Gibt es eine Möglichkeit, plattformunabhängig zu bestimmen, wie viele Kerne eine Maschine aus C / C ++ hat? Wenn es so etwas nicht gibt, wie wäre es dann mit der Ermittlung pro Plattform (Windows / * nix / Mac)?

C ++ 11

#include <thread>

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

Referenz: std :: thread :: hardware_concurrency

In C ++ vor C ++ 11 gibt es keinen portablen Weg. Stattdessen müssen Sie eine oder mehrere der folgenden Methoden verwenden (geschützt durch entsprechende #ifdefZeilen):

• Win32

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

• Linux, Solaris, AIX und Mac OS X> = 10.4 (dh Tiger ab)

  int numCPU = sysconf(_SC_NPROCESSORS_ONLN);

• FreeBSD, MacOS X, NetBSD, OpenBSD usw.

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

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

Diese Funktionalität ist Teil des C ++ 11-Standards.

#include <thread>

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

Für ältere Compiler können Sie die Boost.Thread- Bibliothek verwenden.

#include <boost/thread.hpp>

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

Gibt in beiden Fällen hardware_concurrency()die Anzahl der Threads zurück, die die Hardware gleichzeitig ausführen kann, basierend auf der Anzahl der CPU-Kerne und Hyper-Threading-Einheiten.

OpenMP wird auf vielen Plattformen (einschließlich Visual Studio 2005) unterstützt und bietet eine

int omp_get_num_procs();

Funktion, die die Anzahl der zum Zeitpunkt des Aufrufs verfügbaren Prozessoren / Kerne zurückgibt.

Wenn Sie Zugriff auf Assemblersprache haben, können Sie den CPUID-Befehl verwenden, um alle möglichen Informationen über die CPU abzurufen. Es ist zwischen Betriebssystemen portierbar, obwohl Sie herstellerspezifische Informationen verwenden müssen, um die Anzahl der Kerne zu ermitteln. Hier ist ein Dokument, das beschreibt, wie es auf Intel-Chips gemacht wird , und Seite 11 dieses Dokuments beschreibt die AMD-Spezifikation.

(Fast) Plattformunabhängige Funktion im C-Code

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

Unter Linux können Sie die Datei / proc / cpuinfo lesen und die Kerne zählen.

Beachten Sie, dass "Anzahl der Kerne" möglicherweise keine besonders nützliche Zahl ist. Möglicherweise müssen Sie sie etwas weiter qualifizieren. Wie möchten Sie Multithread-CPUs wie Intel HT, IBM Power5 und Power6 und vor allem Suns Niagara / UltraSparc T1 und T2 zählen? Oder noch interessanter ist das MIPS 1004k mit seinen zwei Hardware-Threading-Ebenen (Supervisor- UND Benutzerebene) ... Ganz zu schweigen davon, was passiert, wenn Sie auf von Hypervisor unterstützte Systeme umsteigen, auf denen die Hardware möglicherweise mehrere zehn CPUs hat, aber Ihr spezielles Betriebssystem sieht nur wenige.

Das Beste, auf das Sie hoffen können, ist, die Anzahl der logischen Verarbeitungseinheiten in Ihrer lokalen Betriebssystempartition anzugeben. Vergessen Sie, die wahre Maschine zu sehen, es sei denn, Sie sind ein Hypervisor. Die einzige Ausnahme von dieser Regel ist heute in x86-Land, aber das Ende nicht virtueller Maschinen kommt schnell ...

Noch ein Windows-Rezept: Verwenden Sie die systemweite Umgebungsvariable NUMBER_OF_PROCESSORS:

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

Sie werden es wahrscheinlich nicht plattformunabhängig bekommen können. Windows erhalten Sie Anzahl der Prozessoren.

Win32-Systeminformationen

Windows (x64 und Win32) und C ++ 11

Die Anzahl der Gruppen logischer Prozessoren, die sich einen einzelnen Prozessorkern teilen. (Verwenden von GetLogicalProcessorInformationEx , siehe auch 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;
}

Beachten Sie, dass die Implementierung von NumberOfPhysicalCoresIMHO alles andere als trivial ist (dh "use GetLogicalProcessorInformationor GetLogicalProcessorInformationEx"). Stattdessen ist es ziemlich subtil, wenn man die Dokumentation (explizit vorhanden für GetLogicalProcessorInformationund implizit vorhanden für GetLogicalProcessorInformationEx) bei MSDN liest .

Die Anzahl der logischen Prozessoren. (Verwenden von 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);
}

Beachten Sie, dass beide Methoden problemlos in C / C ++ 98 / C ++ 03 konvertiert werden können.

Mehr zu OS X: sysconf(_SC_NPROCESSORS_ONLN) ist nur für Versionen> = 10.5 verfügbar, nicht für 10.4.

Eine Alternative ist der HW_AVAILCPU/sysctl()BSD-Code, der in Versionen> = 10.2 verfügbar ist.

Mit Windows Server 2003 und höher können Sie die Funktion GetLogicalProcessorInformation nutzen

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

Nicht mit C ++ verwandt, aber unter Linux mache ich normalerweise:

grep processor /proc/cpuinfo | wc -l

Praktisch für Skriptsprachen wie bash / perl / python / ruby.

hwloc (http://www.open-mpi.org/projects/hwloc/) ist einen Blick wert. Erfordert zwar eine weitere Bibliotheksintegration in Ihren Code, kann jedoch alle Informationen zu Ihrem Prozessor (Anzahl der Kerne, Topologie usw.) bereitstellen.

Unter Linux ist die beste programmatische Methode, soweit ich weiß, die Verwendung

sysconf(_SC_NPROCESSORS_CONF)

oder

sysconf(_SC_NPROCESSORS_ONLN)

Diese sind nicht Standard, befinden sich aber in meiner Manpage für Linux.

Unter Linux ist die Verwendung möglicherweise nicht sicher, _SC_NPROCESSORS_ONLNda es nicht Teil des POSIX-Standards ist und das sysconf- Handbuch dies auch angibt. Es gibt also eine Möglichkeit, die _SC_NPROCESSORS_ONLNmöglicherweise nicht vorhanden ist:

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

Ein einfacher Ansatz wäre, sie zu lesen /proc/statoder zu /proc/cpuinfozählen:

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

Verwenden von /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;
}

Der gleiche Ansatz in der Shell mit grep:

grep -c ^processor /proc/cpuinfo

Oder

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

OS X-Alternative: Die zuvor beschriebene Lösung basierend auf [[NSProcessInfo processInfo] processorCount] ist gemäß den Dokumenten nur unter OS X 10.5.0 verfügbar. Verwenden Sie für frühere Versionen von OS X die Carbon-Funktion MPProcessors ().

Wenn Sie ein Kakao-Programmierer sind, lassen Sie sich nicht von der Tatsache ausflippen, dass dies Carbon ist. Sie müssen lediglich das Carbon-Framework zu Ihrem Xcode-Projekt hinzufügen, und MPProcessors () ist verfügbar.

Für Win32:

Während GetSystemInfo () die Anzahl der logischen Prozessoren ermittelt, verwenden Sie GetLogicalProcessorInformationEx () , um die Anzahl der physischen Prozessoren abzurufen .

Sie können WMI auch in .net verwenden, sind dann aber auf den ausgeführten wmi-Dienst usw. angewiesen. Manchmal funktioniert es lokal, schlägt jedoch fehl, wenn derselbe Code auf Servern ausgeführt wird. Ich glaube, das ist ein Namespace-Problem, das mit den "Namen" zusammenhängt, deren Werte Sie lesen.

Unter Linux können Sie dmesg auschecken und die Zeilen filtern, in denen ACPI die CPUs initialisiert.

dmesg | grep 'ACPI: Processor'

Eine andere Möglichkeit besteht darin, dmidecode zum Herausfiltern der Prozessorinformationen zu verwenden.