有没有一种方法可以以平台无关的方式确定C / C ++中一台计算机有多少个内核？如果不存在这样的问题，那么如何在每个平台上确定它（Windows / * nix / Mac）？

C ++ 11

#include <thread>

//may return 0 when not able to detect
const auto processor_count = std::thread::hardware_concurrency();

参考：std :: thread :: hardware_concurrency

在C ++ 11之前的C ++中，没有可移植的方法。相反，您将需要使用以下一种或多种方法（由适当的#ifdef行保护）：

• Win32的

  SYSTEM_INFO sysinfo;
  GetSystemInfo(&sysinfo);
  int numCPU = sysinfo.dwNumberOfProcessors;

• Linux，Solaris，AIX和Mac OS X> = 10.4（即从Tiger起）

  int numCPU = sysconf(_SC_NPROCESSORS_ONLN);

• FreeBSD，MacOS X，NetBSD，OpenBSD等

  int mib[4];
  int numCPU;
  std::size_t len = sizeof(numCPU); 
  
  /* set the mib for hw.ncpu */
  mib[0] = CTL_HW;
  mib[1] = HW_AVAILCPU;  // alternatively, try HW_NCPU;
  
  /* get the number of CPUs from the system */
  sysctl(mib, 2, &numCPU, &len, NULL, 0);
  
  if (numCPU < 1) 
  {
      mib[1] = HW_NCPU;
      sysctl(mib, 2, &numCPU, &len, NULL, 0);
      if (numCPU < 1)
          numCPU = 1;
  }

• 惠普

  int numCPU = mpctl(MPC_GETNUMSPUS, NULL, NULL);

• 虹膜

  int numCPU = sysconf(_SC_NPROC_ONLN);

• Objective-C（Mac OS X> = 10.5或iOS）

  NSUInteger a = [[NSProcessInfo processInfo] processorCount];
  NSUInteger b = [[NSProcessInfo processInfo] activeProcessorCount];

此功能是C ++ 11标准的一部分。

#include <thread>

unsigned int nthreads = std::thread::hardware_concurrency();

对于较早的编译器，可以使用Boost.Thread库。

#include <boost/thread.hpp>

unsigned int nthreads = boost::thread::hardware_concurrency();

无论哪种情况，都hardware_concurrency()根据CPU内核和超线程单元的数量返回硬件能够同时执行的线程数。

许多平台（包括Visual Studio 2005）都支持OpenMP，并且它提供了

int omp_get_num_procs();

该函数返回调用时可用的处理器/内核数。

如果您具有汇编语言访问权限，则可以使用CPUID指令来获取有关CPU的各种信息。它在操作系统之间是可移植的，尽管您需要使用制造商特定的信息来确定如何找到内核数。下面是描述如何做到这一点英特尔芯片的文档，以及第11页这一个介绍AMD规范。

（几乎）C代码中与平台无关的功能

#ifdef _WIN32
#include <windows.h>
#elif MACOS
#include <sys/param.h>
#include <sys/sysctl.h>
#else
#include <unistd.h>
#endif

int getNumCores() {
#ifdef WIN32
    SYSTEM_INFO sysinfo;
    GetSystemInfo(&sysinfo);
    return sysinfo.dwNumberOfProcessors;
#elif MACOS
    int nm[2];
    size_t len = 4;
    uint32_t count;

    nm[0] = CTL_HW; nm[1] = HW_AVAILCPU;
    sysctl(nm, 2, &count, &len, NULL, 0);

    if(count < 1) {
        nm[1] = HW_NCPU;
        sysctl(nm, 2, &count, &len, NULL, 0);
        if(count < 1) { count = 1; }
    }
    return count;
#else
    return sysconf(_SC_NPROCESSORS_ONLN);
#endif
}

在Linux上，您可以读取/ proc / cpuinfo文件并计算内核数。

请注意，“核心数”可能不是一个特别有用的数字，您可能需要对其进行更多限定。您想如何计算多线程CPU，例如Intel HT，IBM Power5和Power6，以及最著名的Sun的Niagara / UltraSparc T1和T2？甚至更有趣的是，MIPS 1004k具有两个级别的硬件线程（管理程序和用户级别）...更不用说当您进入支持虚拟机管理程序的系统时，硬件可能具有数十个CPU但您的特定操作系统会发生什么只看到一些。

最好的办法是告诉您本地OS分区中逻辑处理单元的数量。除非您是虚拟机监控程序，否则不要再看真实的机器了。今天，此规则的唯一例外是在x86领域，但是非虚拟机的终结日趋迅速。

Windows的另一个秘诀：使用系统范围的环境变量NUMBER_OF_PROCESSORS：

printf("%d\n", atoi(getenv("NUMBER_OF_PROCESSORS")));

您可能无法以独立于平台的方式获得它。在Windows中，您可以获得处理器数量。

Win32系统信息

Windows（x64和Win32）和C ++ 11

共享一个处理器核心的逻辑处理器的组数。（使用GetLogicalProcessorInformationEx，也请参阅GetLogicalProcessorInformation）

size_t NumberOfPhysicalCores() noexcept {

    DWORD length = 0;
    const BOOL result_first = GetLogicalProcessorInformationEx(RelationProcessorCore, nullptr, &length);
    assert(GetLastError() == ERROR_INSUFFICIENT_BUFFER);

    std::unique_ptr< uint8_t[] > buffer(new uint8_t[length]);
    const PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX info = 
            reinterpret_cast< PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX >(buffer.get());

    const BOOL result_second = GetLogicalProcessorInformationEx(RelationProcessorCore, info, &length);
    assert(result_second != FALSE);

    size_t nb_physical_cores = 0;
    size_t offset = 0;
    do {
        const PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX current_info =
            reinterpret_cast< PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX >(buffer.get() + offset);
        offset += current_info->Size;
        ++nb_physical_cores;
    } while (offset < length);

    return nb_physical_cores;
}

请注意，NumberOfPhysicalCoresIMHO 的实现远非琐碎（即“ use GetLogicalProcessorInformation或GetLogicalProcessorInformationEx”）。相反，如果人们阅读了MSDN上的文档（显式存在GetLogicalProcessorInformation和隐式存在GetLogicalProcessorInformationEx），那将是相当微妙的。

逻辑处理器的数量。（使用GetSystemInfo）

size_t NumberOfSystemCores() noexcept {
    SYSTEM_INFO system_info;
    ZeroMemory(&system_info, sizeof(system_info));

    GetSystemInfo(&system_info);

    return static_cast< size_t >(system_info.dwNumberOfProcessors);
}

请注意，两种方法都可以轻松转换为C / C ++ 98 / C ++ 03。

有关OS X的更多信息：sysconf(_SC_NPROCESSORS_ONLN)仅在> = 10.5，而不是10.4上可用。

另一种选择是HW_AVAILCPU/sysctl()BSD代码，该代码在版本> = 10.2上可用。

Windows Server 2003和更高版本允许您利用GetLogicalProcessorInformation函数

http://msdn.microsoft.com/en-us/library/ms683194.aspx

与C ++无关，但是在Linux上我通常这样做：

grep processor /proc/cpuinfo | wc -l

适用于bash / perl / python / ruby​​等脚本语言。

hwloc（http://www.open-mpi.org/projects/hwloc/）值得一看。尽管需要将另一个库集成到您的代码中，但是它可以提供有关处理器的所有信息（内核数，拓扑等）。

据我所知，在Linux上，最好的编程方式是使用

sysconf(_SC_NPROCESSORS_CONF)

要么

sysconf(_SC_NPROCESSORS_ONLN)

这些不是标准的，但是在我的Linux手册页中。

在Linux上，使用它可能并不安全，_SC_NPROCESSORS_ONLN因为它不是POSIX标准的一部分，并且sysconf手册对此进行了说明。因此，有_SC_NPROCESSORS_ONLN可能不存在：

 These values also exist, but may not be standard.

     [...]     

     - _SC_NPROCESSORS_CONF
              The number of processors configured.   
     - _SC_NPROCESSORS_ONLN
              The number of processors currently online (available).

一种简单的方法是读取/proc/stat或/proc/cpuinfo计数它们：

#include<unistd.h>
#include<stdio.h>

int main(void)
{
char str[256];
int procCount = -1; // to offset for the first entry
FILE *fp;

if( (fp = fopen("/proc/stat", "r")) )
{
  while(fgets(str, sizeof str, fp))
  if( !memcmp(str, "cpu", 3) ) procCount++;
}

if ( procCount == -1) 
{ 
printf("Unable to get proc count. Defaulting to 2");
procCount=2;
}

printf("Proc Count:%d\n", procCount);
return 0;
}

使用/proc/cpuinfo：

#include<unistd.h>
#include<stdio.h>

int main(void)
{
char str[256];
int procCount = 0;
FILE *fp;

if( (fp = fopen("/proc/cpuinfo", "r")) )
{
  while(fgets(str, sizeof str, fp))
  if( !memcmp(str, "processor", 9) ) procCount++;
}

if ( !procCount ) 
{ 
printf("Unable to get proc count. Defaulting to 2");
procCount=2;
}

printf("Proc Count:%d\n", procCount);
return 0;
}

在外壳中使用grep的相同方法：

grep -c ^processor /proc/cpuinfo

要么

grep -c ^cpu /proc/stat # subtract 1 from the result

OS X替代方案：根据文档，上述基于[[NSProcessInfo processInfo] processorCount]的解决方案仅在OS X 10.5.0上可用。对于OS X的早期版本，请使用Carbon函数MPProcessors（）。

如果您是Cocoa程序员，请不要害怕这是Carbon。您只需要向Xcode项目添加Carbon框架，即可使用MPProcessors（）。

对于Win32：

虽然GetSystemInfo（）获取逻辑处理器的数量，但是使用 GetLogicalProcessorInformationEx（） 获取物理处理器的数量。

您也可以在.net中使用WMI，但是您依赖于运行的wmi服务等。有时它可以在本地运行，但是当在服务器上运行相同的代码时失败。我认为这是一个名称空间问题，与您正在读取其值的“名称”有关。

在Linux中，您可以检出dmesg并过滤ACPI初始化CPU的行，例如：

dmesg | grep 'ACPI: Processor'

其他可能性是使用dmidecode过滤掉处理器信息。