c# - una - ¿Cómo puedo establecer la afinidad del procesador en.NET?

establecer prioridad fortnite

Question

¿Podemos establecer dos subprocesos o dos tareas para ejecutar con una afinidad de procesador diferente en una aplicación C #?

He leído sobre SetThreadAffinityMask pero no he encontrado ningún ejemplo de cómo se debe usar.

Alternativamente, ¿hay alguna forma para que TPL (Task Parallel Library) ejecute dos subprocesos / tareas con alta prioridad para usar el 100% de la CPU?

Answer 1

El siguiente ejemplo de MSDN muestra cómo configurar la propiedad ProcessorAffinity para una instancia de Notepad de Notepad en el primer procesador.

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;
        }
    }
}

Answer 2

En realidad, .NET Framework y Windows administran los subprocesos bastante bien, distribuyéndolos uniformemente en cada procesador. Sin embargo, la distribución de subprocesos se puede manipular manualmente utilizando Process y 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===");
        }
    }
}

Ahora verifique el administrador de tareas, podemos ver que el segundo procesador está tomando todas las cargas de trabajo. La ventana del administrador de tareas

Answer 3

En realidad, el sistema operativo es capaz de equilibrar la carga de sus núcleos / procesadores, pero si desea hacerlo explícitamente use el uso mencionado a través de PInvoke . Pasa el ID de hilo (no administrado uno) y la máscara - la matriz de bits de los núcleos.

Answer 4

ProcessThread objetos Process y ProcessThread tienen una propiedad ProcessorAffinity del tipo IntPtr que se puede manipular directamente para leer / cambiar la afinidad para hasta 64 procesadores:

using System.Diagnostics;
...
  Process Proc = Process.GetCurrentProcess();
  long AffinityMask = (long)Proc.ProcessorAffinity;
  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;
...

También puede usar la propiedad IdealProcessor del IdealProcessor para permitir que el programador prefiera ejecutar el subproceso en un procesador específico (sin garantía).

Sí, es así de fácil :)

Referencia: MSDN ProcessThread.ProcessorAffinity Property