Есть ли способ определить, сколько ядер у машины от 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 ++ до 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];

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

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

int omp_get_num_procs();

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

Если у вас есть доступ к языку ассемблера, вы можете использовать инструкцию CPUID для получения всевозможной информации о процессоре. Он переносим между операционными системами, хотя вам нужно будет использовать информацию от производителя, чтобы определить, как найти количество ядер. Вот документ, который описывает, как это сделать на чипах Intel , и на странице 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 и подсчитать количество ядер.

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

Лучшее, на что вы можете надеяться, - это указать количество логических процессоров, которые есть в вашем локальном разделе ОС. Забудьте о том, чтобы увидеть настоящую машину, если вы не являетесь гипервизором. Единственное исключение из этого правила сегодня на земле 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 далеко не тривиальна (то есть «использовать 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.

Больше на 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 ().

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

Для Win32:

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

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

В Linux вы можете извлекать dmesg и фильтровать строки, в которых ACPI инициализирует процессоры, что-то вроде:

dmesg | grep 'ACPI: Processor'

Другая возможность - использовать dmidecode для фильтрации информации о процессоре.