มีวิธีในการพิจารณาจำนวนคอร์ของเครื่องจาก C / C ++ ในแบบอิสระหรือไม่ หากไม่มีสิ่งดังกล่าวแล้วจะพิจารณาได้อย่างไรต่อแพลตฟอร์ม (Windows / * nix / Mac)

C ++ 11

#include <thread>

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

การอ้างอิง: std :: thread :: hardware_concurrency

ใน C ++ ก่อน C ++ 11 ไม่มีวิธีการพกพา แต่คุณจะต้องใช้วิธีการต่อไปนี้อย่างน้อยหนึ่งวิธี (ป้องกันโดย#ifdefบรรทัดที่เหมาะสม):

• Win32

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

• Linux, Solaris, AIX และ Mac OS X> = 10.4 (เช่น Tiger เป็นต้นไป)

  int numCPU = sysconf(_SC_NPROCESSORS_ONLN);

• FreeBSD, MacOS X, NetBSD, OpenBSD เป็นต้น

  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 หรือ iOS)

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

ฟังก์ชันนี้เป็นส่วนหนึ่งของมาตรฐาน C ++ 11

#include <thread>

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

สำหรับคอมไพเลอร์รุ่นเก่าคุณสามารถใช้ห้องสมุดBoost.Thread

#include <boost/thread.hpp>

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

ในกรณีใดกรณีหนึ่งให้hardware_concurrency()ส่งคืนจำนวนเธรดที่ฮาร์ดแวร์สามารถดำเนินการพร้อมกันตามจำนวนแกนประมวลผล CPU และหน่วยเธรดไฮเปอร์

OpenMPรองรับหลายแพลตฟอร์ม (รวมถึง Visual Studio 2005) และให้บริการ

int omp_get_num_procs();

ฟังก์ชั่นที่คืนค่าจำนวนตัวประมวลผล / คอร์ที่มีในเวลาที่โทร

หากคุณมีการเข้าถึงภาษาแอสเซมบลีคุณสามารถใช้คำสั่ง CPUID เพื่อรับข้อมูลทุกประเภทเกี่ยวกับ CPU เป็นแบบพกพาระหว่างระบบปฏิบัติการแม้ว่าคุณจะต้องใช้ข้อมูลเฉพาะของผู้ผลิตเพื่อกำหนดวิธีการค้นหาจำนวนคอร์ นี่คือเอกสารที่อธิบายวิธีการทำบนชิป Intelและหน้า 11 ของเอกสารนี้อธิบายถึงข้อกำหนดของ AMD

(เกือบ) ฟังก์ชั่นอิสระของแพลตฟอร์มใน 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
}

บน Linux คุณสามารถอ่านไฟล์ / proc / cpuinfo และนับจำนวนแกน

โปรดทราบว่า "จำนวนแกนหลัก" อาจไม่ใช่หมายเลขที่มีประโยชน์โดยเฉพาะคุณอาจต้องผ่านการรับรองอีกเล็กน้อย คุณต้องการนับซีพียูแบบมัลติเธรดเช่น Intel HT, IBM Power5 และ Power6 อย่างไรและโด่งดังที่สุดคือ Niagara / UltraSparc T1 และ T2 ของ Sun หรือน่าสนใจยิ่งขึ้น MIPS 1004k พร้อมเธรดฮาร์ดแวร์สองระดับ (หัวหน้างานและระดับผู้ใช้) ... ไม่ต้องพูดถึงสิ่งที่เกิดขึ้นเมื่อคุณย้ายเข้าสู่ระบบที่รองรับ hypervisor ซึ่งฮาร์ดแวร์อาจมีซีพียูหลายสิบตัว แต่เป็นระบบปฏิบัติการเฉพาะของคุณ เห็นเพียงไม่กี่

สิ่งที่ดีที่สุดที่คุณสามารถคาดหวังได้คือการบอกจำนวนหน่วยการประมวลผลเชิงตรรกะที่คุณมีในพาร์ติชันระบบปฏิบัติการท้องถิ่นของคุณ ลืมเกี่ยวกับการดูเครื่องจริงเว้นแต่คุณจะเป็นไฮเปอร์ไวเซอร์ ข้อยกเว้นสำหรับกฎนี้ในวันนี้คือในที่ดิน x86 แต่จุดสิ้นสุดของเครื่องจักรที่ไม่ใช่เสมือนกำลังมาอย่างรวดเร็ว ...

สูตร Windows อีกหนึ่งตัว: ใช้ตัวแปรสภาพแวดล้อมทั้งระบบNUMBER_OF_PROCESSORS:

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

คุณอาจไม่สามารถรับได้ด้วยวิธีที่เป็นอิสระจากแพลตฟอร์ม Windows คุณจะได้รับจำนวนโปรเซสเซอร์

ข้อมูลระบบ Win32

Windows (x64 และ Win32) และ C ++ 11

จำนวนกลุ่มของตัวประมวลผลเชิงตรรกะที่แบ่งใช้ตัวประมวลผลหลักเดียว (ใช้GetLogicalProcessorInformationExดู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;
}

โปรดทราบว่าการดำเนินการของNumberOfPhysicalCoresIMHO นั้นห่างไกลจากเรื่องเล็กน้อย (เช่น "ใช้GetLogicalProcessorInformationหรือGetLogicalProcessorInformationEx") แต่มันค่อนข้างบอบบางถ้ามีคนอ่านเอกสาร (นำเสนออย่างชัดเจนGetLogicalProcessorInformationและโดยปริยายสำหรับGetLogicalProcessorInformationEx) ที่ MSDN

จำนวนตัวประมวลผลเชิงตรรกะ (ใช้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);
}

โปรดทราบว่าทั้งสองวิธีสามารถแปลงเป็น C / C ++ 98 / C ++ 03 ได้อย่างง่ายดาย

เพิ่มเติมเกี่ยวกับ OS X: sysconf(_SC_NPROCESSORS_ONLN)มีเฉพาะรุ่น> = 10.5 ไม่ใช่ 10.4

อีกทางเลือกหนึ่งคือHW_AVAILCPU/sysctl()รหัส BSD ซึ่งมีอยู่ในรุ่น> = 10.2

Windows Server 2003 และใหม่กว่าให้คุณใช้ประโยชน์จากฟังก์ชัน GetLogicalProcessorInformation

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

ไม่เกี่ยวข้องกับ C ++ แต่บน Linux ฉันมักจะทำ:

grep processor /proc/cpuinfo | wc -l

มีประโยชน์สำหรับภาษาสคริปต์เช่น bash / perl / python / ruby

hwloc (http://www.open-mpi.org/projects/hwloc/) มีมูลค่าการดู แม้ว่าต้องมีการรวมไลบรารีอื่นในรหัสของคุณ แต่สามารถให้ข้อมูลทั้งหมดเกี่ยวกับโปรเซสเซอร์ของคุณ (จำนวนคอร์โทโพโลยีและอื่น ๆ )

บน linux วิธีการเขียนโปรแกรมที่ดีที่สุดเท่าที่ฉันรู้คือการใช้

sysconf(_SC_NPROCESSORS_CONF)

หรือ

sysconf(_SC_NPROCESSORS_ONLN)

สิ่งเหล่านี้ไม่ได้มาตรฐาน แต่อยู่ใน man page ของฉันสำหรับ Linux

บน Linux อาจไม่ปลอดภัยที่จะใช้_SC_NPROCESSORS_ONLNเนื่องจากไม่ใช่ส่วนหนึ่งของมาตรฐาน POSIX และสถานะsysconfด้วยตนเองมาก ดังนั้นจึงมีความเป็นไปได้ที่_SC_NPROCESSORS_ONLNอาจไม่มีอยู่:

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

วิธีง่าย ๆ คือการอ่าน/proc/statหรือ/proc/cpuinfoนับพวกเขา:

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

การใช้/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:

grep -c ^processor /proc/cpuinfo

หรือ

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

ทางเลือก OS X: วิธีการแก้ปัญหาที่อธิบายไว้ก่อนหน้านี้อิงตาม [[NSProcessInfo processInfo] ตัวประมวลผลจำนวน] ใช้ได้เฉพาะใน OS X 10.5.0 ตามเอกสาร สำหรับ OS X เวอร์ชั่นก่อนหน้าให้ใช้ฟังก์ชั่น Carbon MPProcessors ()

หากคุณเป็นโปรแกรมเมอร์โกโก้ไม่ต้องกลัวว่ามันจะเป็นคาร์บอน คุณเพียงแค่ต้องเพิ่ม Carbon framework ในโครงการ Xcode ของคุณและ MPProcessors () จะพร้อมใช้งาน

สำหรับ Win32:

ในขณะที่ GetSystemInfo ให้จำนวนตัวประมวลผลเชิงตรรกะแก่คุณให้ใช้ GetLogicalProcessorInformationEx () เพื่อรับจำนวนตัวประมวลผลทางกายภาพ

คุณสามารถใช้ WMI ใน. net ได้เช่นกัน แต่ขึ้นอยู่กับบริการ wmi ที่ใช้งาน ฯลฯ บางครั้งก็ทำงานได้ภายในเครื่อง แต่ก็ล้มเหลวเมื่อมีการเรียกใช้รหัสเดียวกันบนเซิร์ฟเวอร์ ฉันเชื่อว่าเป็นปัญหาเกี่ยวกับเนมสเปซซึ่งเกี่ยวข้องกับ "ชื่อ" ที่คุณกำลังอ่าน

ใน Linux คุณสามารถชำระเงิน dmesg และกรองบรรทัดที่ ACPI เริ่มต้น CPU ได้ดังนี้:

dmesg | grep 'ACPI: Processor'

ความเป็นไปได้อื่น ๆ คือการใช้ dmidecode เพื่อกรองข้อมูลโปรเซสเซอร์