MARKUS

using System;

using System.Collections;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ProecssAffinityTest

{

    public class test

    {

        static List<long> ProcessorAffinityList = new List<long>();

        static List<item> processItems = new List<item>();

        static string ProcessName = "ProcessAffinityTestProcess.exe";

        [MTAThread]

        static void Main(string[] args)

        {

            var processkill = Process.GetProcessesByName("ProcessAffinityTestProcess");

            foreach (var item in processkill)

            {

                item.Kill();

            }

            Console.Write("input Process Count :");

            var str = Console.ReadLine();

            int count = 10;

            try

            {

                int parseValue = 0;

                if(int.TryParse(str,out parseValue))

                {

                    count = parseValue;

                }

            }

            catch (Exception)

            {

                throw;

            }

            int processCount = Environment.ProcessorCount;

            if (count == 0)

            {

                count = processCount;

            }

            Console.WriteLine($"Check Process Count :{processCount}");

            Console.WriteLine("input any key");

            Console.ReadKey();

            long affinityMask = 0;

            for (int i = count; i > 0; i--)

            {

                BitArray bitArray = new BitArray(processCount);

                if (processCount -1 < i)

                {

                    bitArray = new BitArray(processCount, true);

                }

                else

                {

                    bitArray.Set(i, true);

                }

                var bits = bitArray.Cast<bool>().Select(bit => bit ? 1 : 0);

                affinityMask = System.Convert.ToInt64(string.Join("", bits), 2);

                System.Diagnostics.Debug.WriteLine($"index{string.Format("0#", ProcessorAffinityList.Count())} - {string.Join("", bits)}");

                ProcessorAffinityList.Add(affinityMask);

                Console.WriteLine($"{affinityMask}");

            }

            Console.WriteLine("input any key");

            Console.ReadKey();

            while (true)

            {

                var process = Process.GetProcessesByName("ProcessAffinityTestProcess");

                if (process.Count() < count)

                {

                    Process testProcess = new Process();

                    long currentAffinity = 0;

                    if (ProcessorAffinityList.Count() > 0)

                    {

                        var processAffinity = ProcessorAffinityList.Except(process.Select(x => x.ProcessorAffinity.ToInt64()));

                        if (processAffinity.Count() > 0)

                        {

                            currentAffinity = processAffinity.First();

                            Console.WriteLine($"process currentAffinity set {currentAffinity}");

                        }

                        else

                        {

                            var items = processItems.Where(x => x.AffinityMask > 0).Select(x => x.AffinityMask).Distinct();

                            currentAffinity = items.Min();

                            Console.WriteLine($"process currentAffinity processAffinity.Count() > 0 : {currentAffinity}");

                        }

                        processItems.Add(new item { AffinityMask = currentAffinity});

                    }

                    ProcessStartInfo startInfo = new ProcessStartInfo

                    {

                        UseShellExecute = false,

                        FileName = ProcessName,

                        WindowStyle = ProcessWindowStyle.Hidden,

                        CreateNoWindow = true,

                        ErrorDialog = false,

                        RedirectStandardError = false,

                        Arguments = $"{currentAffinity}"

                    };

                    testProcess.StartInfo = startInfo;

                    testProcess.EnableRaisingEvents = true;

                    if (testProcess.Start())

                    {

                        testProcess.ProcessorAffinity = new IntPtr(currentAffinity);

                    }

                }

                System.Threading.Thread.Sleep(100);

            }

        }

        private static long GetIntFromBitArray(BitArray bitArray)

        {

            var array = new int[bitArray.Length];

            bitArray.CopyTo(array, 0);

            return (uint)array[0] + ((long)(uint)array[1] << bitArray.Length);

        }

    }

    internal class item

    {

        public long AffinityMask { get; set; }

    }

}