Question

我正在尝试编写一个程序来强调测试C＃系统中的所有逻辑核心（最多72个逻辑核心），无论如何，System.Environment.ProcessorCount()只返回32，无论如何。我在一个拥有40个内核和72个内核的系统上运行它，它只能看到32个内核。

我甚至尝试在核心32（索引0）上运行它，然后它回绕并再次对CPU0 Node0进行压力测试。

任何人都有任何想法如何压力测试所有核心？我正在使用我在本文中找到的逻辑（http://omegacoder.com/?p=94）

All 40 cores shown. Will run up to CPU15 Node1 (32nd Core)

尝试编译为64位但仍然没有。

编辑：添加下面的代码示例：用法:(传入CPU号 - > 31 = CPU12节点1）系统每个物理处理器有20个逻辑核心）

public static void Usage(int cpuToStart) {
            // set cpu 
            int cpu = cpuToStart;
            ThreadProcessor tp = new ThreadProcessor();
            // Spikes CPU 1
            Console.WriteLine("Spike CPU 1");
            tp.SpikeCPU(cpu);

            // ouput error
            if (tp._ex != null) {
                Console.WriteLine(tp._ex.Message);
            }
            // No error
            else {
                // if multiple processors (logical cores)
                if (Environment.ProcessorCount > 1) {
                    while (++cpu < Environment.ProcessorCount) {
                        Thread.Sleep(1000);
                        // Spike each CPU
                        Console.WriteLine("Spike CPU " + (cpu + 1).ToString());
                        tp.SpikeCPU(cpu);

                        if (tp._ex != null) {
                            Console.WriteLine(tp._ex.Message);
                            break;
                        }
                    }

                }
                else // Either a single CPU or hyperthreading not enabled in the OS or the BIOS.
            {
                    Console.WriteLine("This PC does not have two processors available.");
                }
            }

        }

秒杀CPU：

public void SpikeCPU(int targetCPU) {

            // Create a worker thread for the work.
            _worker = new Thread(DoBusyWork);

            // Background is set so not to not prevent the
            // mainprocess from terminating if someone closes it.
            _worker.IsBackground = true;

            _worker.Start((object)targetCPU);
            _worker.Join(); // Wait for it to be done.
        }

DoWork的

public void DoBusyWork(object target) {
            try {
                int processor = (int)target;
                Thread tr = Thread.CurrentThread;

                if (Environment.ProcessorCount > 1) {
                    SetThreadAffinityMask(GetCurrentThread(),
                        new IntPtr(1 << processor));
                }

                CalculatePI.Process(PiSignificantDigits);
            }
            catch (Exception ex) {
                _ex = ex;
            }

        }

也许这会帮助每个人理解。当我将它们加到39（第40个CPU）时，我已经标记了每个CPU： 19 is CPU19 Node0, 20 is CPU0 Node1

Answer 1

如何使用更多核心：

使用更多流程并同时启动它们
手动创建线程（使用新的Thread（）...）直到使用核心计数

Amdahl's law强制基于锁定扩展代码，因此请确保所有计算尽可能并行。

至于我，我想说如果你想工作（更实际）的场景，我会出于其他原因启动多个进程：GC可以冻结所有32个（逻辑）内核来清理内存到时候，如果您想用作Web服务器（或类似的东西），不要冻结所有72个内核的应用程序，因为它们正在等待Full GC（Gen2 GC）发生，那将会很棒。让我们说只有16个核心被冻结而其他3个进程可以回应请求并推进计算，这将是很棒的。

Answer 2

所以我想出了这个问题，正如我所怀疑的，这是在这段代码中：

int processor = (int)target;
Thread tr = Thread.CurrentThread;
if (Environment.ProcessorCount > 1) {
    SetThreadAffinityMask(GetCurrentThread(), new IntPtr(1 << processor));
}

因为int只有32位，所以当它尝试按位移位以将第33个处理器设置为1而所有其他处理器都设置为0时，它将会换行，因为它无处可去。简单地通过一个长期修复这个问题。将不得不为具有72个逻辑核心的系统找出解决方案，但那是明天的问题。

int processor = (int)target;
long shift = 1;
long cpuToTest = shift << processor;
Thread tr = Thread.CurrentThread;

if (Environment.ProcessorCount > 1) {
    SetThreadAffinityMask(GetCurrentThread(), new IntPtr(cpuToTest));
}

CalculatePI.Process(PiSignificantDigits);

在Logical Core 32及更高版本上运行程序

2 个答案: