Czy istnieje sposób na określenie liczby rdzeni maszyny w C / C ++ w sposób niezależny od platformy? Jeśli nic takiego nie istnieje, co powiesz na określenie tego na platformę (Windows / * nix / Mac)?

C ++ 11

#include <thread>

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

Odniesienie: std :: thread :: hardware_concurrency

W C ++ przed C ++ 11 nie ma przenośnego sposobu. Zamiast tego musisz użyć jednej lub więcej z następujących metod (strzeżonych odpowiednimi #ifdefliniami):

• Win32

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

• Linux, Solaris, AIX i Mac OS X> = 10,4 (tj. Tiger i nowsze)

  int numCPU = sysconf(_SC_NPROCESSORS_ONLN);

• FreeBSD, MacOS X, NetBSD, OpenBSD itp.

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

• Cel C (Mac OS X> = 10.5 lub iOS)

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

Ta funkcjonalność jest częścią standardu C ++ 11.

#include <thread>

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

W przypadku starszych kompilatorów możesz użyć biblioteki Boost.Thread .

#include <boost/thread.hpp>

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

W obu przypadkach hardware_concurrency()zwraca liczbę wątków, które sprzęt może wykonywać jednocześnie, w oparciu o liczbę rdzeni procesora i jednostek hiperwątkowości.

OpenMP jest obsługiwany na wielu platformach (w tym Visual Studio 2005) i oferuje

int omp_get_num_procs();

funkcja zwracająca liczbę procesorów / rdzeni dostępnych w momencie połączenia.

Jeśli masz dostęp w języku asemblera, możesz użyć instrukcji CPUID, aby uzyskać wszelkiego rodzaju informacje o CPU. Jest przenośny między systemami operacyjnymi, ale musisz użyć informacji specyficznych dla producenta, aby ustalić, jak znaleźć liczbę rdzeni. Oto dokument opisujący, jak to zrobić na układach Intel , a strona 11 tego opisu opisuje specyfikację AMD.

(Prawie) Niezależna od platformy funkcja w kodzie 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
}

W systemie Linux możesz odczytać plik / proc / cpuinfo i policzyć rdzenie.

Zauważ, że „liczba rdzeni” może nie być szczególnie przydatną liczbą, być może będziesz musiał ją jeszcze bardziej zakwalifikować. Jak chcesz policzyć wielowątkowe procesory, takie jak Intel HT, IBM Power5 i Power6, a najbardziej znany, Sun's Niagara / UltraSparc T1 i T2? Lub jeszcze bardziej interesujące, MIPS 1004k z dwoma poziomami wątków sprzętowych (nadzorca ORAZ poziom użytkownika) ... Nie wspominając o tym, co dzieje się, gdy przejdziesz do systemów obsługiwanych przez hypervisor, w których sprzęt może mieć dziesiątki procesorów, ale twój system operacyjny widzi tylko kilka.

Najlepsze, na co możesz liczyć, to podanie liczby jednostek przetwarzania logicznego na lokalnej partycji systemu operacyjnego. Zapomnij o zobaczeniu prawdziwej maszyny, chyba że jesteś hiperwizorem. Jedyny wyjątek od tej reguły jest dzisiaj na ziemi x86, ale koniec maszyn nie-wirtualnych nadchodzi szybko ...

Jeszcze jeden przepis na Windows: użyj ogólnosystemowej zmiennej środowiskowej NUMBER_OF_PROCESSORS:

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

Prawdopodobnie nie będziesz w stanie uzyskać go w sposób niezależny od platformy. Windows dostajesz liczbę procesorów.

Informacje o systemie Win32

Windows (x64 i Win32) oraz C ++ 11

Liczba grup procesorów logicznych współużytkujących jeden rdzeń procesora. (Używając GetLogicalProcessorInformationEx , zobacz także 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;
}

Zauważ, że implementacja NumberOfPhysicalCoresIMHO jest daleka od trywialnej (tj. „Use GetLogicalProcessorInformationor GetLogicalProcessorInformationEx”). Zamiast tego jest raczej subtelne, jeśli czyta się dokumentację (jawnie obecną GetLogicalProcessorInformationi niejawnie obecną GetLogicalProcessorInformationEx) w MSDN.

Liczba procesorów logicznych. (Korzystanie z 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);
}

Zauważ, że obie metody można łatwo przekonwertować na C / C ++ 98 / C ++ 03.

Więcej informacji na temat systemu OS X: sysconf(_SC_NPROCESSORS_ONLN)dostępne są tylko wersje> = 10,5, a nie 10,4.

Alternatywą jest HW_AVAILCPU/sysctl()kod BSD, który jest dostępny w wersjach> = 10.2.

Windows Server 2003 i nowsze wersje umożliwiają wykorzystanie funkcji GetLogicalProcessorInformation

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

Nie jest związany z C ++, ale w Linuksie zwykle robię:

grep processor /proc/cpuinfo | wc -l

Przydatny do języków skryptowych, takich jak bash / perl / python / ruby.

Warto przyjrzeć się hwloc (http://www.open-mpi.org/projects/hwloc/). Chociaż wymaga kolejnej integracji biblioteki z twoim kodem, ale może dostarczyć wszystkich informacji o twoim procesorze (liczba rdzeni, topologia itp.)

Na Linuksie najlepszym sposobem programistycznym, o ile wiem, jest użycie

sysconf(_SC_NPROCESSORS_CONF)

lub

sysconf(_SC_NPROCESSORS_ONLN)

Nie są to standardowe, ale są na mojej stronie podręcznika użytkownika dla systemu Linux.

W Linuksie korzystanie z niego może nie być bezpieczne, _SC_NPROCESSORS_ONLNponieważ nie jest ono częścią standardu POSIX, a instrukcja sysconf podaje tyle samo. Istnieje więc możliwość, że _SC_NPROCESSORS_ONLNmoże nie być obecna:

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

Prostym podejściem byłoby ich przeczytanie /proc/statlub /proc/cpuinfopoliczenie:

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

Używanie /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;
}

To samo podejście w powłoce przy użyciu grep:

grep -c ^processor /proc/cpuinfo

Lub

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

Alternatywa dla OS X: Rozwiązanie opisane wcześniej w oparciu o [[NSProcessInfo processInfo] processCount] jest dostępne tylko w OS X 10.5.0, zgodnie z dokumentacją. W przypadku wcześniejszych wersji OS X użyj funkcji Carbon MPProcessors ().

Jeśli jesteś programistą Cocoa, nie przejmuj się faktem, że jest to Carbon. Musisz tylko dodać platformę Carbon do swojego projektu Xcode, a MPProcessors () będzie dostępny.

Dla Win32:

Podczas gdy GetSystemInfo () uzyskuje liczbę procesorów logicznych , użyj GetLogicalProcessorInformationEx (), aby uzyskać liczbę procesorów fizycznych .

możesz również używać WMI w .net, ale jesteś zależny od działającej usługi wmi itp. Czasami działa ona lokalnie, ale potem kończy się niepowodzeniem, gdy ten sam kod jest uruchamiany na serwerach. Uważam, że jest to problem związany z przestrzenią nazw, związany z „nazwami”, których wartości czytasz.

W systemie Linux możesz pobrać dmesg i filtrować wiersze, w których ACPI inicjuje procesory, na przykład:

dmesg | grep 'ACPI: Processor„

Inną możliwością jest użycie dmidecode do odfiltrowania informacji o procesorze.