How can I set processor affinity to a thread or a Task in .NET?

Process and ProcessThread objects have a ProcessorAffinity property of IntPtr type that can be directly manipulated to read/change affinity for up to 64 processors:

using System.Diagnostics; 

Process proc = Process.GetCurrentProcess(); long affinityMask = 0x000F; // use only any of the first 4 available processors proc.ProcessorAffinity = (IntPtr)affinityMask; ProcessThread thread = proc.Threads[0]; affinityMask = 0x0002; // use only the second processor, despite availability thread.ProcessorAffinity = (IntPtr)affinityMask; 

You can also use the thread's IdealProcessor property to allow the scheduler to prefer running the thread on a specified processor (without guarantee).

Yes, it's that easy :)

Reference: ProcessThread.ProcessorAffinity Property

Actually, .NET Framework and Windows manage the threads pretty well, distributing them evenly on every processor. However, the distribution of threads can be manipulated manually using Process and ProcessThread.

using System; using System.Diagnostics; using System.Threading; namespace ThreadTest { class Program { static void Main(string[] args) { //Get the our application's process. Process process = Process.GetCurrentProcess(); //Get the processor count of our machine. int cpuCount = Environment.ProcessorCount; Console.WriteLine("CPU Count : {0}", cpuCount); //Since the application starts with a few threads, we have to //record the offset. int offset = process.Threads.Count; Thread[] threads = new Thread[cpuCount]; Console.WriteLine(process.Threads.Count); LogThreadIds(process); //Create and start a number of threads that equals to //our processor count. for (int i = 0; i < cpuCount; ++i) { Thread t = new Thread(new ThreadStart(Calculation)) { IsBackground = true }; t.Start(); } //Refresh the process information in order to get the newest //thread list. process.Refresh(); Console.WriteLine(process.Threads.Count); LogThreadIds(process); //Set the affinity of newly created threads. for (int i = 0; i < cpuCount; ++i) { //process.Threads[i + offset].ProcessorAffinity = (IntPtr)(1L << i); //The code above distributes threads evenly on all processors. //But now we are making a test, so let's bind all the threads to the //second processor. process.Threads[i + offset].ProcessorAffinity = (IntPtr)(1L << 1); } Console.ReadLine(); } static void Calculation() { //some extreme loads. while (true) { Random rand = new Random(); double a = rand.NextDouble(); a = Math.Sin(Math.Sin(a)); } } static void LogThreadIds(Process proc) { //This will log out all the thread id binded to the process. //It is used to test whether newly added threads are the latest elements //in the collection. Console.WriteLine("===Thread Ids==="); for (int i = 0; i < proc.Threads.Count; ++i) { Console.WriteLine(proc.Threads[i].Id); } Console.WriteLine("===End of Thread Ids==="); } } } 

Now check the task manager, we can see that that the second processor is taking all the work loads. The task manager window

Process.GetCurrentProcess().ProcessorAffinity = (System.IntPtr)2; 

Actually OS is capable of load balancing your cores/processors but if you want to do it explicitly use mentioned via PInvoke. You pass id of thread (not managed one!) and mask - the bit array of cores.

The following example from MSDN shows how to set the ProcessorAffinity property for an instance of Notepad to the first processor.

using System; using System.Diagnostics; namespace ProcessThreadIdealProcessor { class Program { static void Main(string[] args) { // Make sure there is an instance of notepad running. Process[] notepads = Process.GetProcessesByName("notepad"); if (notepads.Length == 0) Process.Start("notepad"); ProcessThreadCollection threads; //Process[] notepads; // Retrieve the Notepad processes. notepads = Process.GetProcessesByName("Notepad"); // Get the ProcessThread collection for the first instance threads = notepads[0].Threads; // Set the properties on the first ProcessThread in the collection threads[0].IdealProcessor = 0; threads[0].ProcessorAffinity = (IntPtr)1; } } } 

I want to share this code, showing how to do it with TPL.

With threads,

 using System; using System.Diagnostics; using System.Threading; static void Fibonacci(int n) { int a = 0, b = 1, c = 0; for (int i = 0; i < n; i++) { c = a + b; a = b; b = c; } Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId}: Fibonacci({n}) = {c}"); } int processorCount = Environment.ProcessorCount; for (int i = 0; i < processorCount; i++) { int processorNum = i; Thread thread = new Thread(() => Fibonacci(processorNum * 10)); // Set processor affinity for each thread thread.ProcessorAffinity = (IntPtr)(1 << processorNum); thread.Start(); } 

With TPL (Below code will not work, just a failed attempt),

 using System; using System.Diagnostics; using System.Threading.Tasks; int processorCount = Environment.ProcessorCount; Task[] tasks = new Task[processorCount]; for (int i = 0; i < processorCount; i++) { int processorNum = i; tasks[i] = Task.Factory.StartNew(() => Fibonacci(processorNum * 10), TaskCreationOptions.LongRunning); } // Set processor affinity for each task ProcessThreadCollection currentThreads = Process.GetCurrentProcess().Threads; for (int i = 0; i < processorCount; i++) { ProcessThread assignedThread = null; foreach (ProcessThread thread in currentThreads) { # Problem here: Is possible to find out TPL task's thread ID, after it started? And then assign processor affinity after startNew? if (thread.Id == tasks[i].Id) { assignedThread = thread; break; } } if (assignedThread != null) { int processorNum = i; assignedThread.ProcessorAffinity = (IntPtr)(1 << processorNum); } } Task.WaitAll(tasks); Console.ReadLine();