प्रोग्रामेटिक रूप से किसी मशीन पर कोर की संख्या ज्ञात करें

Question

क्या यह निर्धारित करने का एक तरीका है कि प्लेटफ़ॉर्म-स्वतंत्र तरीके से C / C ++ से मशीन में कितने कोर हैं? यदि ऐसी कोई चीज मौजूद नहीं है, तो इसे प्रति-प्लेटफ़ॉर्म (विंडोज / * निक्स / मैक) निर्धारित करने के बारे में क्या?

Comments

यदि आप इसका उपयोग करना चाहते हैं, तो यह पता लगाने के लिए कि कितने धागे शुरू करने के लिए कृपया प्राथमिक माप के रूप में NUMBER_OF_PROCESSORS का उपयोग करें। मैं इसे एक एक्सर्साइज़ के रूप में छोड़ता हूं कि यह क्यों बेहतर है (यदि लोग इसे अधिक उपयोग करेंगे) तो हार्डवेयर कोर का उपयोग करना। आपके कार्यक्रम का कोर कितना पर्यावरणीय मुद्दा है!

— लोथार

ध्यान दें कि std::thread::hardware_concurrencyभौतिक सीपीयू कोर की संख्या लौटाता है, लेकिन nprocलिनक्स में केवल सीपीयू कोर की संख्या दिखाई देती है, जिस पर वर्तमान प्रक्रिया चल सकती है, जिसे नियंत्रित किया जा सकता है sched_setaffinity। मुझे मानक C ++ के बजाय यह प्राप्त करने का कोई तरीका नहीं मिला: पायथन में उदाहरण देखें: stackoverflow.com/questions/1006289/…

— Ciro Santilli 郝海东 to 病 事件 法轮功

Answer 1

सी ++ 11

#include <thread>

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

संदर्भ: एसटीडी :: थ्रेड :: hardware_concurrency

---

C ++ 11 से पहले C ++ में, कोई पोर्टेबल तरीका नहीं है। इसके बजाय, आपको निम्न विधियों में से एक या अधिक का उपयोग करने की आवश्यकता होगी (उपयुक्त #ifdefलाइनों द्वारा संरक्षित ):

• Win32

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

• Linux, Solaris, AIX और Mac OS X> = 10.4 (अर्थात बाद में बाघ)

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

• उद्देश्य-सी (मैक ओएस एक्स> = 10.5 या आईओएस)

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

Comments

@mcandre: यह पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है। यदि मैं लागू कर रहा था, तो मैं शायद खाका-नीति दृष्टिकोण का उपयोग करूंगा जहां नीति को पूर्व-निदेशक निर्देशों में परिभाषित किया गया था। या ... आप बूस्ट थ्रेड :: hardware_concurrency () का उपयोग कर सकते हैं।

— paxos1977

स्पष्टीकरण के एक बिंदु के रूप में Win32 समाधान कोर की कुल संख्या (जो के लिए पूछा गया था) देता है भौतिक सीपीयू की कुल संख्या नहीं।

— एरिक

लिनक्स / सोलारिस / एआईएक्स तरीका फ्रीबीएसडी पर भी काम करता है और कम से कम 2006 से है। इसके अलावा, वह सीपीयू को ऑनलाइन लौटा देगा, अगर कोई सिस्टम बंद करने में सक्षम होता है तो उन्हें गिना नहीं जा सकता है। "_SC_NPROCESSORS_CONF" के साथ sysconf को कॉल करने पर कुल सीपीयू कॉन्फ़िगर हो जाएगा।

— क्रिस एस

कुछ बातों का ध्यान रखना। HW_NCPUOS X पर पदावनत किया जाता है। Windows GetSystemInfoकेवल तभी उपयोगी है जब आपके सिस्टम में 32 लॉजिकल प्रोसेसर हों या कम हों, ऐसे GetLogicalProcessorInformationसिस्टम के लिए उपयोग करें जिनमें 32 से अधिक लॉजिकल प्रोसेसर हों।

@Trejkaz डॉक्यूमेंटेशन में स्पष्ट रूप से "तार्किक" कहा गया है - जो हमेशा HT कोर की गिनती कर रहा है, शब्द "भौतिक" हमेशा BIOS / UEFI द्वारा सूचित कोर को संदर्भित करता है क्योंकि कोर को भी अनुकरण / वर्चुअलाइज्ड किया जा सकता है। आप उदाहरण के लिए GetLogicalProcessorInformation जैसे कार्यों के साथ HT / non-HT कोर के बीच अंतर कर सकते हैं । नोट: HT! = Emulation या वर्चुअलाइजेशन, एक बड़ा अंतर है, HT एक हार्डवेयर अनुकूलन है, इसलिए बोलने के लिए

— specializt

Answer 2

यह कार्यक्षमता 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()थ्रेड्स की संख्या लौटाता है जो हार्डवेयर सीपीयू कोर और हाइपर-थ्रेडिंग इकाइयों की संख्या के आधार पर समवर्ती रूप से निष्पादित करने में सक्षम है।

Comments

दूसरा ... ऊपर नमूना कोड और कुछ पूर्वप्रक्रमक मैक्रोज़ का उपयोग करने के लिए जा रहा था एक समारोह में, लेकिन मेरे लिए कड़ी मेहनत की गई थी।

— jkp

Win32 के लिए, यह GetSystemInfo के लिए एक कॉल है। (संस्करण 1.41.0 को बढ़ावा देने के रूप में) क्या यह निर्धारित करने के लिए सभी जानकारी पर कब्जा है कि कितने कार्यकर्ता धागे प्रभावी होंगे? क्या दोनों को कोर और हाइपर-थ्रेडिंग की संख्या पर विचार करने की आवश्यकता है? अहस्ताक्षरित धागा :: hardware_concurrency () {SYSTEM_INFO जानकारी = {0}; GetSystemInfo (और जानकारी); info.dwNumberOfProcessors; }

— जिवे डैडसन

MSDN के अनुसार, GetSystemInfo () dwNumberOfProcessors में "भौतिक प्रोसेसर" की संख्या देता है, लेकिन यह परिभाषित नहीं करता है कि इसका क्या मतलब है। बूस्ट प्रलेखन का दावा है कि इसमें हाइपरथ्रेडिंग इकाइयां शामिल हैं।

— फेर्रुकियो

देखिए stackoverflow.com/questions/642348/… हाइपरथ्रेडिंग के लिए

— नौगटुर

Answer 3

ओपनएमपी कई प्लेटफार्मों (विजुअल स्टूडियो 2005 सहित) पर समर्थित है और यह एक प्रदान करता है

int omp_get_num_procs();

फ़ंक्शन जो कॉल के समय उपलब्ध प्रोसेसर / कोर की संख्या लौटाता है।

Comments

क्योंकि यह एक गलत उत्तर है। से gcc.gnu.org/bugzilla/show_bug.cgi?id=37586 ( "omp_get_num_procs) केवल सिस्टम CPU की संख्या की तुलना में छोटी संख्या वापस आ जाएगी ऑनलाइन, अगर GOMP_CPU_AFFINITY env var प्रयोग किया जाता है, या यदि बुला प्रक्रिया और / या धागा है CPU आत्मीयता CPUs के सबसेट तक सीमित है ”। इसलिए यदि आप पहले से कॉल करते हैं, तो sched_setaffinityयह काम नहीं करेगा।

— अंगेनर

यह फ़ंक्शन कॉलिंग प्रक्रिया के लिए उपलब्ध सीपीयू की संख्या लौटाता है। वैसे भी यह सबसे आम उपयोग मामला नहीं है? कुछ बेकार रिपोर्टिंग उद्देश्यों के कारण, CPU हार्डवेयर कोर की वास्तविक संख्या आपके लिए प्रासंगिक नहीं है यदि आप अपने कोड में उनका लाभ नहीं उठा सकते हैं।

— मैकिबर्डी

@EvanTeran इस तथ्य के अलावा कि यह प्रश्न का उद्देश्य था, यह निश्चित रूप से उपयोगी हो सकता है। उदाहरण के लिए, धागा संबंध स्थापित करने के उद्देश्य से। कहते हैं, मैं अपनी पहली मशीन पर चार अंतिम सीपीयू कोर के लिए चार धागे चलाना चाहता हूं, बजाय चार कोर के। और इसके अलावा, OpenMP को छोड़कर कोड को समानांतर करने के अन्य तरीके हैं। मैं खुद पैंथ स्पॉन करना चाह सकती हूं। वे निश्चित रूप से उपलब्ध हैं और OpenMP पर्यावरण चर द्वारा प्रतिबंधित नहीं हैं।

— 21

यह तार्किक सीपीयू की संख्या लौटाता है, कोर (भौतिक सीपीयू) जैसे नहीं।

— माइकल Konečný

Answer 4

यदि आपके पास असेंबली-भाषा एक्सेस है, तो आप CPU के बारे में सभी प्रकार की जानकारी प्राप्त करने के लिए CPUID निर्देश का उपयोग कर सकते हैं। यह ऑपरेटिंग सिस्टम के बीच पोर्टेबल है, हालांकि आपको यह निर्धारित करने के लिए निर्माता-विशिष्ट जानकारी का उपयोग करने की आवश्यकता होगी कि कोर की संख्या कैसे ढूंढें। यहाँ एक दस्तावेज का वर्णन करता है कि कैसे इंटेल चिप्स पर यह करने के लिए , और के पेज 11 इस एक एएमडी विनिर्देश वर्णन करता है।

Comments

यह अस्वीकृत हो सकता है क्योंकि प्रश्न को C ++ के रूप में टैग किया गया है और यह जवाब गैर-x86 आर्किटेक्चर (ARM, PPC, आदि) पर C ++ चलाने वाले सिस्टम पर लागू नहीं होता है। मैं यह नहीं कह रहा हूं कि यह एक उत्तर को कम करने का एक अच्छा कारण है, बस एक संभावना है।

— फेर्रुकियो

इस विधि का एक नुकसान यह है कि यदि आप इंटेल प्रोसेसर पर हाइपरथ्रेडिंग का पता लगाने के लिए सीपीयूआईडी का उपयोग कर रहे हैं। मैं अपने लैपटॉप पर इस समस्या में भाग गया: जबकि सीपीयू जो मैंने मशीन में डाला था वह हाइपरथ्रेडिंग का समर्थन करता है (और, निश्चित रूप से, रिपोर्ट है कि यह सीपीयूआईडी के माध्यम से करता है), BIOS नहीं करता है। इसलिए, आपको किसी CPUID पठन से HT क्षमता का उपयोग करने का प्रयास नहीं करना चाहिए। चूँकि आप HT सपोर्ट के बारे में BIOS को क्वेरी नहीं कर सकते हैं (कोई रास्ता नहीं जो मैंने देखा है), OS को तार्किक प्रोसेसर की संख्या प्राप्त करने के लिए क्वियर किया जाना चाहिए।

— चक आर

Answer 5

(लगभग) सी-कोड में प्लेटफ़ॉर्म इंडिपेंडेंट फंक्शन

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

Comments

HW_NCPUOS X स्रोत

Answer 6

लिनक्स पर, आप / proc / cpuinfo फ़ाइल पढ़ सकते हैं और कोर की गणना कर सकते हैं।

Comments

सिवाय इसके कि हाइपरथ्रेडेड या अन्य श्रीमती समाधानों को अधिक कोर के रूप में गिना जाता है ...

— जकोबेंगब्लोम 2

@ प्रारूप: हाइपरथ्रेडिंग सही समानांतर निष्पादन नहीं है, यह संदर्भ स्विचिंग ओवरहेड को कम करने के लिए एक तकनीक है। एक हाइपरथ्रेडेड सीपीयू एक समय में केवल एक थ्रेड को निष्पादित कर सकता है , लेकिन यह एक ही समय में दो थ्रेड्स के आर्किटेक्चरल स्टेट (रजिस्टर मान आदि) को स्टोर कर सकता है। प्रदर्शन विशेषताओं दो कोर होने से बहुत अलग हैं।

— विम कॉइनन जूल

@Wim: यह पूरी तरह से सही नहीं है। हाइपरथ्रेडिंग वाले सीपीयू में आमतौर पर कई एएलयू होते हैं और प्रति चक्र कई निर्देश भेज सकते हैं। यदि डेटा निर्भरता और स्टालों के कारण, सभी ALU को एक धागे से व्यस्त नहीं रखा जा सकता है, तो उन ALU का उपयोग दूसरे हार्डवेयर थ्रेड के एक साथ निष्पादन के लिए किया जाएगा।

— बेन वोइगट

Answer 7

ध्यान दें कि "कोर की संख्या" विशेष रूप से उपयोगी संख्या नहीं हो सकती है, आपको इसे थोड़ा और योग्य बनाना पड़ सकता है। आप मल्टी-थ्रेडेड सीपीयू जैसे इंटेल एचटी, आईबीएम पावर 5 और पावर 6, और सबसे प्रसिद्ध, सन के नियाग्रा / अल्ट्रास्पार्क टी 1 और टी 2 को कैसे गिनना चाहते हैं? या इससे भी अधिक दिलचस्प, MIPS 1004k हार्डवेयर थ्रेडिंग (पर्यवेक्षक और उपयोगकर्ता-स्तर) के अपने दो स्तरों के साथ ... यह उल्लेख करने के लिए नहीं कि हाइपरवाइज़र-समर्थित सिस्टम में जाने पर क्या होता है जहां हार्डवेयर में दसियों CPU हो सकते हैं लेकिन आपका विशेष OS केवल कुछ ही देखता है।

आपके लिए सबसे अच्छी आशा यह हो सकती है कि आप अपने स्थानीय ओएस विभाजन में तार्किक प्रसंस्करण इकाइयों की संख्या बताएं। सच मशीन को देखने के बारे में भूल जाओ जब तक कि आप एक हाइपरवाइजर नहीं हैं। इस नियम का एकमात्र अपवाद आज x86 भूमि में है, लेकिन गैर-आभासी मशीनों का अंत तेजी से हो रहा है ...

Answer 8

एक और विंडोज नुस्खा: सिस्टम-वाइड पर्यावरण चर का उपयोग करें NUMBER_OF_PROCESSORS:

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

Answer 9

आप शायद इसे स्वतंत्र रूप से एक मंच पर लाने में सक्षम नहीं होंगे। विंडोज में आपको प्रोसेसर की संख्या मिलती है।

Win32 सिस्टम जानकारी

Comments

Carefull: हाइपरथ्रेडेड प्रोसेसर कहते हैं कि दो हैं। इसलिए आपको यह भी देखना होगा कि क्या प्रोसेसर हाइपरथ्रेड सक्षम है या नहीं।

— मार्टिन यॉर्क

Answer 10

विंडोज (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;
}

ध्यान दें कि NumberOfPhysicalCoresआईएमएचओ का कार्यान्वयन तुच्छ (यानी "उपयोग GetLogicalProcessorInformationया GetLogicalProcessorInformationEx") से बहुत दूर है । इसके बजाय यह सूक्ष्म है यदि कोई MSDN पर प्रलेखन (स्पष्ट रूप से मौजूद है GetLogicalProcessorInformationऔर इसके लिए निहित रूप से मौजूद है GetLogicalProcessorInformationEx) पढ़ता है ।

तार्किक प्रोसेसर की संख्या। ( 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 में परिवर्तित किया जा सकता है।

Comments

धन्यवाद! मैं इसका GetLogicalProcessorInformationउपयोग विभिन्न बफर आकारों के साथ काम नहीं करने के कारण कर रहा था। संतुष्ट से अधिक! ^ ^

— KeyWeeUsr

@KeyWeeUsr धन्यवाद विंडोज प्रोग्रामिंग तुच्छ और तार्किक से कुछ हद तक दूर है। इस समय के दौरान, मैं कुछ सीढ़ियों के संबंध में स्टैटिक एनालाइजर पीवीएस-स्टूडियो के अनुसार थोड़ा अधिक अपडेटेड C ++ 17 वर्जन का उपयोग करता हूं size_t। (हालाँकि, msvc ++ W4 पर शिकायत नहीं करता है।)

— मथायस

Answer 11

OS X पर अधिक: sysconf(_SC_NPROCESSORS_ONLN)केवल संस्करण> = 10.5 उपलब्ध है, 10.4 नहीं।

एक विकल्प HW_AVAILCPU/sysctl()बीएसडी कोड है जो संस्करणों> = 10.2 पर उपलब्ध है।

Answer 12

Windows Server 2003 और बाद में आपको GetLogicalProcessorInformation फ़ंक्शन का लाभ उठाने देता है

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

Answer 13

C ++ से असंबंधित, लेकिन लिनक्स पर मैं आमतौर पर करता हूं:

grep processor /proc/cpuinfo | wc -l

बैश / पर्ल / अजगर / माणिक जैसी भाषाओं की स्क्रिप्टिंग के लिए आसान।

Comments

अजगर के लिए:import multiprocessing print multiprocessing.cpu_count()

— inगितो

यह एक लंबा समय हो गया है, लेकिन है grepनहीं है -cगिनती प्रविष्टियों के लिए झंडा!

— लापशिन दिमित्री

Answer 14

hwloc (http://www.open-mpi.org/projects/hwloc/) देखने लायक है। हालाँकि आपके कोड में एक और पुस्तकालय एकीकरण की आवश्यकता है लेकिन यह आपके प्रोसेसर (कोर की संख्या, टोपोलॉजी इत्यादि) के बारे में सभी जानकारी प्रदान कर सकता है।

Answer 15

लिनक्स पर जहाँ तक मुझे पता है सबसे अच्छा प्रोग्रामेटिक तरीका है

sysconf(_SC_NPROCESSORS_CONF)

या

sysconf(_SC_NPROCESSORS_ONLN)

ये मानक नहीं हैं, लेकिन लिनक्स के लिए मेरे मैन पेज में हैं।

Answer 16

लिनक्स पर, यह उपयोग करने के लिए सुरक्षित नहीं हो सकता है _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

Answer 17

OS X विकल्प: [[NSProcessInfo processInfo] processorCount] पर आधारित पहले वर्णित समाधान केवल डॉक्स के अनुसार OS X 10.5.0 पर उपलब्ध है। OS X के पुराने संस्करणों के लिए, कार्बन फ़ंक्शन MPProcessors () का उपयोग करें।

यदि आप एक कोको प्रोग्रामर हैं, तो इस तथ्य से विचलित न हों कि यह कार्बन है। आपको अपने Xcode प्रोजेक्ट में कार्बन फ्रेमवर्क जोड़ने की आवश्यकता है और MPProcessors () उपलब्ध होगा।

Answer 18

Win32 के लिए:

जबकि GetSystemInfo () आपको तार्किक प्रोसेसर की संख्या प्राप्त करता है, भौतिक प्रोसेसर की संख्या प्राप्त करने के लिए GetLogicalProcessorInformationEx () का उपयोग करें ।

Answer 19

आप WMI का उपयोग .net में भी कर सकते हैं, लेकिन आप तब चल रहे wmi सेवा पर निर्भर होते हैं आदि। कभी-कभी यह स्थानीय रूप से काम करता है, लेकिन तब विफल रहता है जब सर्वर पर समान कोड चलाया जाता है। मेरा मानना ​​है कि यह एक नाम स्थान का मुद्दा है, "नाम" से संबंधित है जिसके मूल्य आप पढ़ रहे हैं।

Answer 20

लिनक्स में, आप dumsg को चेक कर सकते हैं और उन लाइनों को फ़िल्टर कर सकते हैं जहाँ ACPI CPU को इनिशियलाइज़ करता है, कुछ इस तरह:

dmesg | grep 'ACPI: Processor'

अन्य संभावना प्रोसेसर की जानकारी को फ़िल्टर करने के लिए dmidecode का उपयोग करना है।