C'è un modo per determinare quanti core ha una macchina da C / C ++ in modo indipendente dalla piattaforma? Se non esiste nulla del genere, che ne dici di determinarlo per piattaforma (Windows / * nix / Mac)?

C ++ 11

#include <thread>

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

Riferimento: std :: thread :: hardware_concurrency

In C ++ prima di C ++ 11, non esiste un modo portatile. Invece, dovrai usare uno o più dei seguenti metodi (sorvegliati da #ifdeflinee appropriate ):

• Win32

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

• Linux, Solaris, AIX e Mac OS X> = 10.4 (ovvero Tiger in poi)

  int numCPU = sysconf(_SC_NPROCESSORS_ONLN);

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

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

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

Questa funzionalità fa parte dello standard C ++ 11.

#include <thread>

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

Per i compilatori meno recenti , è possibile utilizzare la libreria Boost.Thread .

#include <boost/thread.hpp>

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

In entrambi i casi, hardware_concurrency()restituisce il numero di thread che l'hardware è in grado di eseguire contemporaneamente in base al numero di core della CPU e unità di hyper-threading.

OpenMP è supportato su molte piattaforme (incluso Visual Studio 2005) e offre un

int omp_get_num_procs();

funzione che restituisce il numero di processori / core disponibili al momento della chiamata.

Se si dispone dell'accesso in linguaggio assembly, è possibile utilizzare l'istruzione CPUID per ottenere tutti i tipi di informazioni sulla CPU. È portatile tra i sistemi operativi, sebbene sia necessario utilizzare le informazioni specifiche del produttore per determinare come trovare il numero di core. Ecco un documento che descrive come farlo su chip Intel e la pagina 11 di questo descrive le specifiche AMD.

(Quasi) Funzione indipendente dalla piattaforma in codice 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
}

Su Linux, puoi leggere il file / proc / cpuinfo e contare i core.

Si noti che "numero di core" potrebbe non essere un numero particolarmente utile, potrebbe essere necessario qualificarlo un po 'di più. Come si desidera contare CPU multi-thread come Intel HT, IBM Power5 e Power6 e, soprattutto, Sun's Niagara / UltraSparc T1 e T2? O ancora più interessante, MIPS 1004k con i suoi due livelli di threading hardware (supervisore E livello utente) ... Per non parlare di ciò che accade quando si passa a sistemi supportati da hypervisor in cui l'hardware potrebbe avere decine di CPU ma il proprio sistema operativo specifico ne vede solo alcuni.

Il meglio che puoi sperare è di dire il numero di unità di elaborazione logica che hai nella partizione del sistema operativo locale. Dimentica di vedere la vera macchina se non sei un hypervisor. L'unica eccezione a questa regola oggi è nella terra x86, ma la fine delle macchine non virtuali sta arrivando velocemente ...

Un'altra ricetta per Windows: utilizzare la variabile di ambiente a livello di sistema NUMBER_OF_PROCESSORS:

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

Probabilmente non sarai in grado di ottenerlo in modo indipendente dalla piattaforma. Windows ottieni il numero di processori.

Informazioni sul sistema Win32

Windows (x64 e Win32) e C ++ 11

Il numero di gruppi di processori logici che condividono un singolo core del processore. (Utilizzando GetLogicalProcessorInformationEx , consultare anche 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;
}

Si noti che l'implementazione di NumberOfPhysicalCoresIMHO è tutt'altro che banale (ovvero "uso GetLogicalProcessorInformationo GetLogicalProcessorInformationEx"). Invece è piuttosto sottile se si legge la documentazione (esplicitamente presente GetLogicalProcessorInformatione implicitamente presente GetLogicalProcessorInformationEx) su MSDN.

Il numero di processori logici. (Utilizzo di 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);
}

Si noti che entrambi i metodi possono essere facilmente convertiti in C / C ++ 98 / C ++ 03.

Altro su OS X: sysconf(_SC_NPROCESSORS_ONLN)sono disponibili solo versioni> = 10.5, non 10.4.

Un'alternativa è il HW_AVAILCPU/sysctl()codice BSD che è disponibile nelle versioni> = 10.2.

Windows Server 2003 e versioni successive consentono di sfruttare la funzione GetLogicalProcessorInformation

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

Non correlato al C ++, ma su Linux di solito faccio:

grep processor /proc/cpuinfo | wc -l

Comodo per i linguaggi di scripting come bash / perl / python / ruby.

Vale la pena dare un'occhiata a hwloc (http://www.open-mpi.org/projects/hwloc/). Tuttavia richiede un'altra integrazione della libreria nel codice ma può fornire tutte le informazioni sul processore (numero di core, topologia, ecc.)

Su Linux il miglior modo programmatico per quanto ne so è usare

sysconf(_SC_NPROCESSORS_CONF)

o

sysconf(_SC_NPROCESSORS_ONLN)

Questi non sono standard, ma sono nella mia pagina man per Linux.

Su Linux, potrebbe non essere sicuro da usare _SC_NPROCESSORS_ONLNpoiché non fa parte dello standard POSIX e il manuale di sysconf lo afferma altrettanto. Quindi c'è una possibilità che _SC_NPROCESSORS_ONLNpotrebbe non essere presente:

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

Un approccio semplice sarebbe quello di leggerli /proc/stato /proc/cpuinfocontarli:

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

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

Lo stesso approccio in shell usando grep:

grep -c ^processor /proc/cpuinfo

O

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

Alternativa OS X: la soluzione descritta in precedenza basata su [[NSProcessInfo processInfo] processorCount] è disponibile solo su OS X 10.5.0, secondo i documenti. Per le versioni precedenti di OS X, utilizzare la funzione Carbon MPProcessors ().

Se sei un programmatore di cacao, non essere spaventato dal fatto che questo è Carbon. Devi solo aggiungere il framework Carbon al tuo progetto Xcode e MPProcessors () sarà disponibile.

Per Win32:

Mentre GetSystemInfo () ti fornisce il numero di processori logici , usa GetLogicalProcessorInformationEx () per ottenere il numero di processori fisici .

puoi usare WMI anche in .net ma sei quindi dipendente dal servizio wmi in esecuzione ecc. A volte funziona localmente, ma poi fallisce quando lo stesso codice viene eseguito sui server. Credo che sia un problema di spazio dei nomi, correlato ai "nomi" di cui stai leggendo i valori.

In Linux, puoi controllare dmesg e filtrare le linee in cui ACPI inizializza le CPU, qualcosa del tipo:

dmesg | grep 'ACPI: Processor'

Un'altra possibilità è utilizzare dmidecode per filtrare le informazioni sul processore.