Wie erhalte ich die Anzahl der CPUs in Linux mit C?

Gibt es eine API, um die Anzahl der in Linux verfügbaren CPUs abzurufen? Ich meine, ohne /proc/cpuinfo oder eine andere Sys-Node-Datei zu verwenden …

Ich habe diese Implementierung mit sched.h gefunden:

int GetCPUCount()
{
 cpu_set_t cs;
 CPU_ZERO(&cs);
 sched_getaffinity(0, sizeof(cs), &cs);

 int count = 0;
 for (int i = 0; i < 64; i++)
 {
  if (CPU_ISSET(i, &cs))
   count++;
  else
   break;
 }
 return count;
}

Aber gibt es nicht etwas Höheres, das gemeinsame Bibliotheken verwendet?

#include <unistd.h>
long number_of_processors = sysconf(_SC_NPROCESSORS_ONLN);

#include <stdio.h>
#include <sys/sysinfo.h>

int main(int argc, char *argv[])
{
    printf("This system has %d processors configured and "
        "%d processors available.\n",
        get_nprocs_conf(), get_nprocs());
    return 0;
}

https://linux.die.net/man/3/get_nprocs

Dieser Code (gezeichnet aus hier) sollte sowohl auf Windows- als auch auf *NIX-Plattformen funktionieren.

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#else
#include <unistd.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>


int main() {
  long nprocs = -1;
  long nprocs_max = -1;
#ifdef _WIN32
#ifndef _SC_NPROCESSORS_ONLN
SYSTEM_INFO info;
GetSystemInfo(&info);
#define sysconf(a) info.dwNumberOfProcessors
#define _SC_NPROCESSORS_ONLN
#endif
#endif
#ifdef _SC_NPROCESSORS_ONLN
  nprocs = sysconf(_SC_NPROCESSORS_ONLN);
  if (nprocs < 1)
  {
    fprintf(stderr, "Could not determine number of CPUs online:\n%s\n", 
strerror (errno));
    exit (EXIT_FAILURE);
  }
  nprocs_max = sysconf(_SC_NPROCESSORS_CONF);
  if (nprocs_max < 1)
  {
    fprintf(stderr, "Could not determine number of CPUs configured:\n%s\n", 
strerror (errno));
    exit (EXIT_FAILURE);
  }
  printf ("%ld of %ld processors online\n",nprocs, nprocs_max);
  exit (EXIT_SUCCESS);
#else
  fprintf(stderr, "Could not determine number of CPUs");
  exit (EXIT_FAILURE);
#endif
}

Verwenden /proc/cpuinfo ist die sauberste und tragbarste Lösung. Falls das Öffnen fehlschlägt, können Sie einfach von 1 CPU oder 2 CPUs ausgehen. Code, der davon abhängt, die Anzahl der CPUs für einen anderen Zweck als die Mikrooptimierung zu kennen (z. B. die Auswahl der idealen Anzahl von auszuführenden Threads), macht mit ziemlicher Sicherheit etwas Dummes.

Das _SC_NPROCESSORS_ONLN Lösung hängt von einem Nicht-Standard ab (glibc-spezifisch) sysconf Erweiterung, die eine viel größere Abhängigkeit als ist /proc (Alle Linux-Systeme haben /procaber einige haben nicht-glibc-libcs ​​oder ältere glibc-Versionen, die fehlen _SC_NPROCESSORS_ONLN).

sched_affinity() Version, die Sie am Anfang erwähnen, ist immer noch besser als /proc/cpuinfo und/oder _SC_NPROCESSORS_ONLN da es nur CPUs zählt, die für einen bestimmten Prozess verfügbar sind (einige können durch deaktiviert werden sched_setaffinity() von einem externen Prozess aufgerufen). Die einzige Änderung wäre die Verwendung CPU_COUNT() statt zu tun CPU_ISSET in einer Schleife.

Persönlich für neuere Intel-CPUs (allgemein nicht x86, nur Intel) Ich benutze die EAX=0Bh cpuid Blatt. Sehen Wikipedia für einige Details darüber, welche Informationen Sie über die Kerne im aktuellen Socket-Aka-Paket erhalten. Auf einem Multi-Socket-System kann dies die Hälfte oder ein Viertel der systemweiten Anzahl physischer/logischer Kerne sein. Intel hat ein Whitepaper zum Aufzählen von CPUs mit Details darüber, was bei Multi-Socket-Systemen zu überprüfen ist. Dieser Code macht das nicht, er prüft nur ein Unterblatt (ECX=1).

int main()
{
unsigned int eax=11,ebx=0,ecx=1,edx=0;

asm volatile("cpuid"
        : "=a" (eax),
          "=b" (ebx),
          "=c" (ecx),
          "=d" (edx)
        : "0" (eax), "2" (ecx)
        : );
            
printf("Cores: %d\nThreads: %d\nActual thread: %d\n",eax,ebx,edx);
}

Ausgabe:

Cores: 4
Threads: 8
Actual thread: 1

Oder kürzer:

#include <stdio.h>

int main()
{
unsigned int ncores=0,nthreads=0,ht=0;

asm volatile("cpuid": "=a" (ncores), "=b" (nthreads) : "a" (0xb), "c" (0x1) : );

ht=(ncores!=nthreads);

printf("Cores: %d\nThreads: %d\nHyperThreading: %s\n",ncores,nthreads,ht?"Yes":"No");

return 0;
}

Ausgabe:

Cores: 4
Threads: 8
HyperThreading: Yes

Keine der Antworten, die beinhalten sysconf(...) oder get_nprocs() sind korrekt, um die Anzahl der Prozessoren zu berücksichtigen, die durch die CPU-Affinität auf eine Aufgabe beschränkt sind.

Sie brauchen so etwas, um die Anzahl der für eine Aufgabe verfügbaren Prozessoren zu erhalten:

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>

int nprocs()
{
  cpu_set_t cs;
  CPU_ZERO(&cs);
  sched_getaffinity(0, sizeof(cs), &cs);
  return CPU_COUNT(&cs);
}

int main()
{
  printf("procs=%d\n", nprocs());
  return 0;
}