Existe-t-il un moyen de déterminer le nombre de cœurs d'une machine en C / C ++ de manière indépendante de la plate-forme? Si une telle chose n'existe pas, qu'en est-il de la déterminer par plate-forme (Windows / * nix / Mac)?

C ++ 11

#include <thread>

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

Référence: std :: thread :: hardware_concurrency

En C ++ avant C ++ 11, il n'y a pas de moyen portable. À la place, vous devrez utiliser une ou plusieurs des méthodes suivantes (protégées par des #ifdeflignes appropriées ):

• Win32

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

• Linux, Solaris, AIX et Mac OS X> = 10,4 (c'est-à-dire Tiger à partir de)

  int numCPU = sysconf(_SC_NPROCESSORS_ONLN);

• FreeBSD, MacOS X, NetBSD, OpenBSD, etc.

  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 ou iOS)

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

Cette fonctionnalité fait partie de la norme C ++ 11.

#include <thread>

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

Pour les compilateurs plus anciens, vous pouvez utiliser la bibliothèque Boost.Thread .

#include <boost/thread.hpp>

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

Dans les deux cas, hardware_concurrency()renvoie le nombre de threads que le matériel est capable d'exécuter simultanément en fonction du nombre de cœurs de processeur et d'unités d'hyper-threading.

OpenMP est pris en charge sur de nombreuses plates-formes (y compris Visual Studio 2005) et il offre un

int omp_get_num_procs();

fonction qui renvoie le nombre de processeurs / cœurs disponibles au moment de l'appel.

Si vous disposez d'un accès en langage assembleur, vous pouvez utiliser l'instruction CPUID pour obtenir toutes sortes d'informations sur le processeur. Il est portable entre les systèmes d'exploitation, mais vous devrez utiliser des informations spécifiques au fabricant pour déterminer comment trouver le nombre de cœurs. Voici un document qui décrit comment le faire sur des puces Intel , et la page 11 de celui-ci décrit la spécification AMD.

(Presque) Fonction indépendante de la plateforme en code 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
}

Sous Linux, vous pouvez lire le fichier / proc / cpuinfo et compter les cœurs.

Notez que "nombre de cœurs" peut ne pas être un nombre particulièrement utile, vous devrez peut-être le qualifier un peu plus. Comment voulez-vous compter les processeurs multithread tels que Intel HT, IBM Power5 et Power6, et surtout, les Niagara / UltraSparc T1 et T2 de Sun? Ou encore plus intéressant, le MIPS 1004k avec ses deux niveaux de threading matériel (superviseur ET niveau utilisateur) ... Sans parler de ce qui se passe lorsque vous passez dans des systèmes supportés par hyperviseur où le matériel peut avoir des dizaines de CPU mais votre OS particulier n'en voit que quelques-uns.

Le mieux que vous puissiez espérer est d'indiquer le nombre d'unités de traitement logique que vous avez dans votre partition OS locale. Oubliez de voir la vraie machine à moins que vous ne soyez un hyperviseur. La seule exception à cette règle est aujourd'hui en terre x86, mais la fin des machines non virtuelles arrive rapidement ...

Encore une recette Windows: utilisez la variable d'environnement à l'échelle du système NUMBER_OF_PROCESSORS:

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

Vous ne pourrez probablement pas l'obtenir de manière indépendante de la plate-forme. Windows vous obtenez un certain nombre de processeurs.

Informations système Win32

Windows (x64 et Win32) et C ++ 11

Nombre de groupes de processeurs logiques partageant un seul cœur de processeur. (À l'aide de GetLogicalProcessorInformationEx , consultez également 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;
}

Notez que la mise en œuvre de NumberOfPhysicalCoresest à mon humble avis loin d'être triviale (c'est-à-dire "utiliser GetLogicalProcessorInformationou GetLogicalProcessorInformationEx"). Au lieu de cela, il est plutôt subtil si on lit la documentation (explicitement présente pour GetLogicalProcessorInformationet implicitement présente pour GetLogicalProcessorInformationEx) sur MSDN.

Le nombre de processeurs logiques. (Utilisation de 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);
}

Notez que les deux méthodes peuvent facilement être converties en C / C ++ 98 / C ++ 03.

Plus sur OS X: sysconf(_SC_NPROCESSORS_ONLN)est disponible uniquement les versions> = 10.5, pas 10.4.

Une alternative est le HW_AVAILCPU/sysctl()code BSD qui est disponible sur les versions> = 10.2.

Windows Server 2003 et versions ultérieures vous permettent de tirer parti de la fonction GetLogicalProcessorInformation

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

Sans rapport avec C ++, mais sous Linux, je fais habituellement:

grep processor /proc/cpuinfo | wc -l

Pratique pour les langages de script comme bash / perl / python / ruby.

hwloc (http://www.open-mpi.org/projects/hwloc/) mérite d'être examiné. Bien qu'il nécessite une autre intégration de bibliothèque dans votre code mais il peut fournir toutes les informations sur votre processeur (nombre de cœurs, topologie, etc.)

Sous Linux, la meilleure façon de programmation, pour autant que je sache, est d'utiliser

sysconf(_SC_NPROCESSORS_CONF)

ou

sysconf(_SC_NPROCESSORS_ONLN)

Ce ne sont pas standard, mais sont dans ma page de manuel pour Linux.

Sous Linux, il n'est peut-être pas sûr de l'utiliser _SC_NPROCESSORS_ONLNcar il ne fait pas partie de la norme POSIX et le manuel sysconf l' indique autant. Il y a donc une possibilité qui _SC_NPROCESSORS_ONLNpeut ne pas être présente:

 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).

Une approche simple serait de les lire /proc/statou de les /proc/cpuinfocompter:

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

En utilisant /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;
}

La même approche en shell utilisant grep:

grep -c ^processor /proc/cpuinfo

Ou

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

Alternative à OS X: La solution décrite précédemment basée sur [[NSProcessInfo processInfo] processorCount] n'est disponible que sur OS X 10.5.0, selon la documentation. Pour les versions antérieures d'OS X, utilisez la fonction Carbon MPProcessors ().

Si vous êtes un programmeur Cocoa, ne soyez pas paniqué par le fait qu'il s'agit de Carbon. Vous avez juste besoin d'ajouter le framework Carbon à votre projet Xcode et MPProcessors () sera disponible.

Pour Win32:

Alors que GetSystemInfo () vous obtient le nombre de processeurs logiques , utilisez GetLogicalProcessorInformationEx () pour obtenir le nombre de processeurs physiques .

vous pouvez également utiliser WMI dans .net mais vous dépendez alors du service wmi en cours d'exécution, etc. Parfois, cela fonctionne localement, mais échoue lorsque le même code est exécuté sur des serveurs. Je crois que c'est un problème d'espace de noms, lié aux "noms" dont vous lisez les valeurs.

Sous Linux, vous pouvez extraire dmesg et filtrer les lignes où ACPI initialise les CPU, quelque chose comme:

dmesg | grep 'ACPI: Processor"

Une autre possibilité consiste à utiliser dmidecode pour filtrer les informations du processeur.