Apakah ada cara untuk menentukan berapa core yang dimiliki mesin dari C / C ++ dengan cara yang bebas platform? Jika tidak ada hal seperti itu, bagaimana dengan menentukannya per-platform (Windows / * nix / Mac)?

C ++ 11

#include <thread>

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

Referensi: std :: thread :: hardware_concurrency

Di C ++ sebelum C ++ 11, tidak ada cara portabel. Sebagai gantinya, Anda harus menggunakan satu atau lebih metode berikut (dijaga oleh #ifdefbaris yang sesuai ):

• Win32

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

• Linux, Solaris, AIX dan Mac OS X> = 10.4 (yaitu Tiger dan seterusnya)

  int numCPU = sysconf(_SC_NPROCESSORS_ONLN);

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

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

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

Fungsionalitas ini adalah bagian dari standar C ++ 11.

#include <thread>

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

Untuk kompiler lama, Anda bisa menggunakan perpustakaan Boost.Thread .

#include <boost/thread.hpp>

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

Dalam kedua kasus tersebut, hardware_concurrency()kembalikan jumlah utas yang dapat dieksekusi perangkat keras secara bersamaan berdasarkan jumlah inti CPU dan unit hyper-threading.

OpenMP didukung pada banyak platform (termasuk Visual Studio 2005) dan ia menawarkan a

int omp_get_num_procs();

fungsi yang mengembalikan jumlah prosesor / inti yang tersedia pada saat panggilan.

Jika Anda memiliki akses bahasa assembly, Anda dapat menggunakan instruksi CPUID untuk mendapatkan semua jenis informasi tentang CPU. Ini portabel di antara sistem operasi, meskipun Anda harus menggunakan informasi khusus pabrikan untuk menentukan cara menemukan jumlah inti. Berikut adalah dokumen yang menjelaskan cara melakukannya pada chip Intel , dan halaman 11 ini menjelaskan spesifikasi AMD.

(Hampir) Platform Fungsi independen dalam kode-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
}

Di Linux, Anda dapat membaca file / proc / cpuinfo dan menghitung inti.

Perhatikan bahwa "jumlah inti" mungkin bukan angka yang sangat berguna, Anda mungkin harus membuatnya sedikit lebih memenuhi syarat. Bagaimana Anda ingin menghitung CPU multi-threaded seperti Intel HT, IBM Power5 dan Power6, dan yang paling terkenal, Sun's Niagara / UltraSparc T1 dan T2? Atau bahkan lebih menarik, MIPS 1004k dengan dua tingkat threading perangkat keras (pengawas DAN tingkat pengguna) ... Belum lagi apa yang terjadi ketika Anda pindah ke sistem yang didukung hypervisor di mana perangkat keras mungkin memiliki puluhan CPU tetapi OS khusus Anda hanya melihat beberapa.

Yang terbaik yang dapat Anda harapkan adalah memberi tahu jumlah unit pemrosesan logis yang Anda miliki di partisi OS lokal Anda. Lupakan tentang melihat mesin yang sebenarnya kecuali Anda adalah hypervisor. Satu-satunya pengecualian untuk aturan ini hari ini adalah di tanah x86, tetapi akhir dari mesin non-virtual datang dengan cepat ...

Satu lagi resep Windows: gunakan variabel lingkungan sistem-lebar NUMBER_OF_PROCESSORS:

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

Anda mungkin tidak akan bisa mendapatkannya di platform mandiri. Windows Anda mendapatkan sejumlah prosesor.

Informasi Sistem Win32

Windows (x64 dan Win32) dan C ++ 11

Jumlah kelompok prosesor logis yang berbagi inti prosesor tunggal. (Menggunakan GetLogicalProcessorInformationEx , lihat GetLogicalProcessorInformation juga)

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

Perhatikan bahwa implementasi NumberOfPhysicalCoresIMHO jauh dari sepele (yaitu "gunakan GetLogicalProcessorInformationatau GetLogicalProcessorInformationEx"). Sebaliknya itu agak halus jika seseorang membaca dokumentasi (secara eksplisit hadir untuk GetLogicalProcessorInformationdan secara implisit hadir untuk GetLogicalProcessorInformationEx) di MSDN.

Jumlah prosesor logis. (Menggunakan 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);
}

Perhatikan bahwa kedua metode dapat dengan mudah dikonversi ke C / C ++ 98 / C ++ 03.

Lebih lanjut tentang OS X: sysconf(_SC_NPROCESSORS_ONLN)hanya tersedia versi> = 10.5, bukan 10.4.

Alternatifnya adalah HW_AVAILCPU/sysctl()kode BSD yang tersedia pada versi> = 10.2.

Windows Server 2003 dan yang lebih baru memungkinkan Anda memanfaatkan fungsi GetLogicalProcessorInformation

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

Tidak terkait dengan C ++, tetapi di Linux biasanya saya lakukan:

grep processor /proc/cpuinfo | wc -l

Berguna untuk bahasa skrip seperti bash / perl / python / ruby.

hwloc (http://www.open-mpi.org/projects/hwloc/) layak untuk dilihat. Meskipun memerlukan integrasi pustaka lain ke dalam kode Anda, tetapi itu dapat memberikan semua informasi tentang prosesor Anda (jumlah inti, topologi, dll.)

Di linux cara pemrograman terbaik sejauh yang saya tahu adalah menggunakan

sysconf(_SC_NPROCESSORS_CONF)

atau

sysconf(_SC_NPROCESSORS_ONLN)

Ini bukan standar, tetapi ada di halaman manual saya untuk Linux.

Di Linux, ini mungkin tidak aman untuk digunakan _SC_NPROCESSORS_ONLNkarena itu bukan bagian dari standar POSIX dan status manual sysconf . Jadi ada kemungkinan yang _SC_NPROCESSORS_ONLNtidak ada:

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

Pendekatan sederhana adalah membaca /proc/statatau /proc/cpuinfomenghitungnya:

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

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

Pendekatan yang sama di shell menggunakan grep:

grep -c ^processor /proc/cpuinfo

Atau

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

Alternatif OS X: Solusi yang dijelaskan sebelumnya berdasarkan [[NSProcessInfo processInfo] processorCount] hanya tersedia di OS X 10.5.0, menurut dokumen. Untuk versi OS X yang lebih lama, gunakan fungsi Karbon MPProcessors ().

Jika Anda seorang programmer Cocoa, jangan takut dengan kenyataan bahwa ini adalah Carbon. Anda hanya perlu menambahkan kerangka Karbon ke proyek Xcode Anda dan MPProcessor () akan tersedia.

Untuk Win32:

Sementara GetSystemInfo () memberi Anda jumlah prosesor logis , gunakan GetLogicalProcessorInformationEx () untuk mendapatkan jumlah prosesor fisik .

Anda dapat menggunakan WMI di .net juga tetapi Anda kemudian tergantung pada layanan wmi yang berjalan dll. Kadang-kadang bekerja secara lokal, tetapi kemudian gagal ketika kode yang sama dijalankan di server. Saya percaya itu masalah namespace, terkait dengan "nama" yang nilainya Anda baca.

Di Linux, Anda dapat checkout dmesg dan memfilter garis tempat ACPI menginisialisasi CPU, seperti:

dmesg | grep 'ACPI: Processor'

Kemungkinan lain adalah menggunakan dmidecode untuk menyaring informasi prosesor.