Program.cs

using System.Diagnostics;
#if WINDOWS
using System.Management;
#endif

if (args.Length < 1)
{
    Console.Error.WriteLine("Usage: ThreadAffinityProgram <process>");
    return;
}

string processName = Path.GetFileNameWithoutExtension(args[0]);

// build affinity mask, if we change disableCpuCount we can disable more processors
// defaults to disabling cpu 0 and 1..
nint affinity = BuildAffinityMask(disableCpuCount: 2);

LogStartup(processName, affinity);

ApplyAffinityToExistingProcesses(processName, affinity);

#if WINDOWS
Console.WriteLine("Using Windows WMI process watcher");
StartWindowsWatcher(processName, affinity);
#else
Console.WriteLine("Using cross-platform polling loop");
StartPollingLoop(processName, affinity);
#endif

Thread.Sleep(Timeout.Infinite);
return;

static nint BuildAffinityMask(int disableCpuCount)
{
    int cpuCount = Environment.ProcessorCount;
    return ((1 << cpuCount) - 1) & ~((1 << disableCpuCount) - 1);
}

static void LogStartup(string processName, nint affinity)
{
    const int alignment = -13;
    Console.WriteLine($"{"Processors", alignment}: {Environment.ProcessorCount}");
    Console.WriteLine($"{"Affinity mask", alignment}: {affinity}");
    Console.WriteLine($"{"Target", alignment}: {processName}");
}

static void ApplyAffinityToExistingProcesses(string name, nint affinity)
{
    foreach (var process in Process.GetProcessesByName(name))
    {
        TrySetAffinity(process, affinity);
    }
}

static void StartPollingLoop(string name, nint affinity)
{
    var thread = new Thread(() =>
    {
        while (true)
        {
            foreach (var process in Process.GetProcessesByName(name))
            {
                TrySetAffinity(process, affinity);
            }

            Thread.Sleep(1000);
        }
    })
    {
        IsBackground = true,
        Name = "AffinityPollingLoop",
    };

    thread.Start();
}

static void TrySetAffinity(Process process, nint affinity)
{
    try
    {
        if (process.HasExited)
            return;

        if (process.ProcessorAffinity != affinity)
        {
            process.ProcessorAffinity = affinity;
            Console.WriteLine(
                $"[{DateTime.Now:HH:mm:ss}] Set affinity for {process.ProcessName} (PID {process.Id})"
            );
        }
        else
        {
            Console.WriteLine(
                $"[{DateTime.Now:HH:mm:ss}] Affinity already set for {process.ProcessName} (PID {process.Id})"
            );
        }
    }
    catch (Exception ex)
    {
        Console.Error.WriteLine($"PID {process.Id}: {ex.Message}");
    }
}

#if WINDOWS
static void StartWindowsWatcher(string processName, nint affinity)
{
    processName = EnsureExeSuffix(processName);

    string query = $"SELECT * FROM Win32_ProcessStartTrace WHERE ProcessName = '{processName}'";

    var watcher = new ManagementEventWatcher(new WqlEventQuery(query));

    watcher.EventArrived += (_, e) =>
    {
        try
        {
            uint pid = (uint)e.NewEvent["ProcessID"];
            var process = Process.GetProcessById((int)pid);

            // Avoid early-start race conditions
            Thread.Sleep(200);

            TrySetAffinity(process, affinity);
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"WMI event error: {ex.Message}");
        }
    };

    watcher.Start();
}

static string EnsureExeSuffix(string processName) =>
    processName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)
        ? processName
        : processName + ".exe";
#endif