Windows Server 2003 и более поздние версии позволяют использовать функцию GetLogicalProcessorInformation.

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

В Linux вы можете прочитать файл / proc / cpuinfo и подсчитать количество ядер.

Вы, вероятно, не сможете получить его независимым от платформы способом. Windows вы получаете количество процессоров.

Информация о системе Win32

Эта функциональность является частью стандарта 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() возвращает количество потоков, которые аппаратное обеспечение способно выполнять одновременно, в зависимости от количества ядер ЦП и блоков гиперпоточности.

Насколько я знаю, в Linux лучший программный способ - использовать

sysconf(_SC_NPROCESSORS_CONF)

или же

sysconf(_SC_NPROCESSORS_ONLN)

Они не стандартные, но есть на моей странице руководства для Linux.

Если у вас есть доступ к языку ассемблера, вы можете использовать инструкцию CPUID для получения всевозможной информации о процессоре. Он переносится между операционными системами, хотя вам нужно будет использовать информацию производителя, чтобы определить, как определить количество ядер. Здесь документ, описывающий, как это сделать на чипах Intel, а страница 11 Вот этот описывает спецификацию AMD.

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++ до C++ 11 нет переносимого способа. Вместо этого вам нужно будет использовать один или несколько из следующих методов (защищенных соответствующими строками #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;
  }
  

• HPUX

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

• IRIX

  int numCPU = sysconf(_SC_NPROC_ONLN);
  

• Objective-C (Mac OS X> = 10.5 или iOS)

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

Обратите внимание, что «количество ядер» может быть не особенно полезным числом, вам, возможно, придется уточнить его немного больше. Как вы хотите считать многопоточные процессоры, такие как Intel HT, IBM Power5 и Power6, и, что наиболее известно, Sun Niagara / UltraSparc T1 и T2? Или, что еще интереснее, MIPS 1004k с двумя уровнями аппаратной обработки потоков (супервизор И уровень пользователя) ... Не говоря уже о том, что происходит, когда вы переходите в системы с поддержкой гипервизора, где оборудование может иметь десятки процессоров, но ваша конкретная ОС видит только несколько.

Лучшее, на что вы можете надеяться, - это указать количество логических процессоров, которые есть в вашем локальном разделе ОС. Забудьте о том, чтобы видеть настоящую машину, если вы не гипервизор. Единственное исключение из этого правила сегодня - страна x86, но конец невиртуальных машин приближается ...

OpenMP поддерживается на многих платформах (включая Visual Studio 2005) и предлагает

int omp_get_num_procs();

функция, которая возвращает количество процессоров / ядер, доступных на момент вызова.

Еще один рецепт Windows: используйте общесистемную переменную среды NUMBER_OF_PROCESSORS:

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

вы также можете использовать WMI в .net, но тогда вы зависите от запущенной службы wmi и т.д. Иногда он работает локально, но затем не работает, когда тот же код запускается на серверах. Я считаю, что это проблема пространства имен, связанная с «именами», значения которых вы читаете.

Альтернатива OS X: описанное ранее решение на основе [[NSProcessInfo processInfo] processorCount] доступно только в OS X 10.5.0, согласно документации. Для более ранних версий OS X используйте функцию Carbon MPProcessors ().

Если вы программист на Cocoa, не пугайтесь того факта, что это Carbon. Вам просто нужно добавить фреймворк Carbon в ваш проект Xcode, и MPProcessors () будет доступен.

(Почти) независимая от платформы функция в 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
}

Не имеет отношения к C++, но в Linux я обычно делаю:

grep processor /proc/cpuinfo | wc -l

Удобно для таких языков сценариев, как bash / perl / python / ruby.

hwloc (http://www.open-mpi.org/projects/hwloc/) заслуживает внимания. Хотя требуется интеграция другой библиотеки в ваш код, но она может предоставить всю информацию о вашем процессоре (количество ядер, топология и т. д.)

Подробнее об OS X: sysconf(_SC_NPROCESSORS_ONLN) доступен только в версиях> = 10.5, но не 10.4.

Альтернативой является код BSD HW_AVAILCPU/sysctl(), который доступен в версиях> = 10.2.

В 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

Для Win32:

Пока GetSystemInfo () дает вам количество процессоров логичный, используйте GetLogicalProcessorInformationEx () чтобы получить количество процессоров физический.

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

Обратите внимание, что реализация NumberOfPhysicalCores, IMHO, далеко не тривиальна (например, «используйте GetLogicalProcessorInformation или GetLogicalProcessorInformationEx»). Вместо этого это будет довольно тонко, если вы прочитаете документацию (явно присутствующую для GetLogicalProcessorInformation и неявную для GetLogicalProcessorInformationEx) в MSDN.

Количество логических процессоров. (с использованием 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.