Bir makinenin C / C ++ 'dan kaç tane çekirdeğe sahip olduğunu platformdan bağımsız bir şekilde belirlemenin bir yolu var mı? Böyle bir şey yoksa, platform başına (Windows / * nix / Mac) belirlemeye ne dersiniz?

C ++ 11

#include <thread>

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

Referans: std :: thread :: hardware_concurrency

C ++ 11'den önceki C ++ 'da taşınabilir bir yol yoktur. Bunun yerine, aşağıdaki yöntemlerden birini veya daha fazlasını kullanmanız gerekir (uygun #ifdefçizgilerle korunur ):

• Win32

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

• Linux, Solaris, AIX ve Mac OS X> = 10.4 (yani Tiger'dan sonra)

  int numCPU = sysconf(_SC_NPROCESSORS_ONLN);

• FreeBSD, MacOS X, NetBSD, OpenBSD vb.

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

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

Bu işlevsellik, C ++ 11 standardının bir parçasıdır.

#include <thread>

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

Daha eski derleyiciler için Boost.Thread kütüphanesini kullanabilirsiniz .

#include <boost/thread.hpp>

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

Her iki durumda da, hardware_concurrency()CPU çekirdeği ve hiper iş parçacığı birimlerinin sayısına bağlı olarak donanımın eşzamanlı olarak çalıştırabildiği iş parçacığı sayısını döndürür.

OpenMP birçok platformda (Visual Studio 2005 dahil) desteklenir ve bir

int omp_get_num_procs();

çağrı sırasında kullanılabilen işlemci / çekirdek sayısını döndüren işlev.

Montaj dili erişiminiz varsa, CPU hakkında her türlü bilgiyi almak için CPUID komutunu kullanabilirsiniz. İşletim sistemleri arasında taşınabilir, ancak çekirdek sayısını nasıl bulacağınızı belirlemek için üreticiye özgü bilgileri kullanmanız gerekir. İşte bir Intel çipleri üzerinde nasıl yapılacağını açıklar belge ve sayfa 11 bu bir AMD şartname açıklar.

(Neredeyse) Platform C kodunda bağımsız işlev

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

Linux'ta / proc / cpuinfo dosyasını okuyabilir ve çekirdekleri sayabilirsiniz.

"Çekirdek sayısı" nın özellikle kullanışlı bir sayı olmayabileceğini, biraz daha nitelendirmeniz gerekebileceğini unutmayın. Intel HT, IBM Power5 ve Power6 gibi çok iş parçacıklı CPU'ları ve en ünlüsü Sun'ın Niagara / UltraSparc T1 ve T2'yi nasıl saymak istersiniz? Daha da ilginç olanı, iki donanım iş parçacığı (denetimci ve kullanıcı düzeyi) düzeyiyle MIPS 1004k ... Donanımın onlarca CPU'su olabileceği hipervizör destekli sistemlere geçtiğinizde ne olacağından bahsetmiyorum. sadece birkaç tanesini görür.

Umabileceğiniz en iyi şey, yerel işletim sistemi bölümünüzde bulunan mantıksal işlem birimlerinin sayısını söylemektir. Hipervizör değilseniz gerçek makineyi görmeyi unutun. Bugün bu kuralın tek istisnası x86 ülkesinde, ancak sanal olmayan makinelerin sonu hızla geliyor ...

Bir Windows tarifi daha: sistem genelinde ortam değişkenini kullanın NUMBER_OF_PROCESSORS:

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

Muhtemelen platformdan bağımsız bir şekilde elde edemezsiniz. Windows size işlemci sayısını alırsınız.

Win32 Sistem Bilgileri

Windows (x64 ve Win32) ve C ++ 11

Tek bir işlemci çekirdeğini paylaşan mantıksal işlemci gruplarının sayısı. ( GetLogicalProcessorInformationEx kullanarak , ayrıca bkz. 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;
}

Uygulamasının NumberOfPhysicalCoresIMHO'nun önemsiz olmaktan çok uzak olduğunu unutmayın (yani "kullanım GetLogicalProcessorInformationveya GetLogicalProcessorInformationEx"). Bunun yerine, MSDN'deki belgeleri (açık bir şekilde sunmak GetLogicalProcessorInformationve dolaylı olarak sunmak için GetLogicalProcessorInformationEx) okumak oldukça incedir.

Mantıksal işlemci sayısı. ( GetSystemInfo Kullanılıyor )

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

Her iki yöntemin de kolayca C / C ++ 98 / C ++ 03'e dönüştürülebileceğini unutmayın.

OS X hakkında daha fazla bilgi: sysconf(_SC_NPROCESSORS_ONLN)10.4 sürümünde değil, sadece> 10.5 sürümü mevcuttur.

Alternatif, HW_AVAILCPU/sysctl()> = 10.2 sürümlerinde bulunan BSD kodudur.

Windows Server 2003 ve sonraki sürümler GetLogicalProcessorInformation işlevinden yararlanmanızı sağlar

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

C ++ ile ilgisi yoktur, ancak Linux'ta genellikle şunu yaparım:

grep processor /proc/cpuinfo | wc -l

Bash / perl / python / ruby ​​gibi komut dilleri için kullanışlıdır.

hwloc (http://www.open-mpi.org/projects/hwloc/) göz atmaya değer. Kodunuza başka bir kütüphane entegrasyonu gerektirmesine rağmen, işlemcinizle ilgili tüm bilgileri sağlayabilir (çekirdek sayısı, topoloji, vb.)

Linux'ta bildiğim kadarıyla en iyi programlı yöntem

sysconf(_SC_NPROCESSORS_CONF)

veya

sysconf(_SC_NPROCESSORS_ONLN)

Bunlar standart değil, Linux için man sayfamda.

Linux'ta, _SC_NPROCESSORS_ONLNPOSIX standardının bir parçası olmadığı ve sysconf manuel durumlarının fazla olmadığı için kullanmak güvenli olmayabilir . Yani _SC_NPROCESSORS_ONLNmevcut olmayan bir olasılık var:

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

Basit bir yaklaşım onları okumak /proc/statveya /proc/cpuinfosaymak olacaktır:

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

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

Grep kullanarak kabukta aynı yaklaşım:

grep -c ^processor /proc/cpuinfo

Veya

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

OS X alternatifi: Daha önce [[NSProcessInfo processInfo] işlemciCount] 'a dayalı olarak açıklanan çözüm dokümanlara göre yalnızca OS X 10.5.0'da kullanılabilir. OS X'in önceki sürümleri için, MPProcessors () Karbon işlevini kullanın.

Bir Kakao programcısıysanız, bunun Karbon olduğu gerçeğinden korkmayın. Sadece Xcode projenize Karbon çerçevesini eklemeniz gerekir ve MPProcessors () kullanılabilir olacaktır.

Win32 için:

GetSystemInfo () size mantıksal işlemci sayısını alırken , fiziksel işlemci sayısını almak için GetLogicalProcessorInformationEx () öğesini kullanın .

WMI'yı .net içinde de kullanabilirsiniz, ancak wmi hizmetinin çalışmasına vb. bağımlı olursunuz. Bazen yerel olarak çalışır, ancak sunucularda aynı kod çalıştırıldığında başarısız olur. Bence bu, değerleri okuduğunuz "adlar" ile ilgili bir ad alanı sorunu.

Linux'ta, dmesg'e göz atabilir ve ACPI'nin CPU'ları başlattığı satırları filtreleyebilirsiniz, örneğin:

dmesg | grep 'ACPI: Processor'

Diğer olasılık, işlemci bilgisini filtrelemek için dmidecode kullanmaktır.