c - सी का उपयोग करके लिनक्स में सीपीयू की संख्या कैसे प्राप्त करें?




linux multithreading (5)

क्या Linux में उपलब्ध CPU की संख्या प्राप्त करने के लिए एक API है? मेरा मतलब है, का उपयोग किए बिना / proc / cpuinfo या किसी अन्य sys- नोड फ़ाइल ...

मुझे यह कार्यान्वयन शेड्यूल का उपयोग करके मिला है।

int GetCPUCount()
{
 cpu_set_t cs;
 CPU_ZERO(&cs);
 sched_getaffinity(0, sizeof(cs), &cs);

 int count = 0;
 for (int i = 0; i < 8; i++)
 {
  if (CPU_ISSET(i, &cs))
   count++;
 }
 return count;
}

लेकिन, क्या आम पुस्तकालयों का उपयोग करने के लिए कुछ अधिक उच्च स्तर नहीं है?


एक अन्य विधि स्कैनिंग सीयूपी * निर्देशिका sys फ़ाइल सिस्टम के तहत:

#include<stdio.h>
#include <dirent.h>
#include <errno.h>
#define LINUX_SYS_CPU_DIRECTORY "/sys/devices/system/cpu"

int main() {
   int cpu_count = 0;
   DIR *sys_cpu_dir = opendir(LINUX_SYS_CPU_DIRECTORY);
   if (sys_cpu_dir == NULL) {
       int err = errno;
       printf("Cannot open %s directory, error (%d).\n", LINUX_SYS_CPU_DIRECTORY, strerror(err));
       return -1;
   }
   const struct dirent *cpu_dir;
   while((cpu_dir = readdir(sys_cpu_dir)) != NULL) {
       if (fnmatch("cpu[0-9]*", cpu_dir->d_name, 0) != 0)
       {
          /* Skip the file which does not represent a CPU */
          continue;
       }
       cpu_count++;
   }
   printf("CPU count: %d\n", cpu_count);
   return 0;
}

का उपयोग /proc/cpuinfo सबसे साफ और सबसे पोर्टेबल समाधान है। यदि ओपन फेल होता है, तो आप बस 1 सीपीयू या 2 सीपीयू मान सकते हैं। कोड जो माइक्रो-ऑप्टिमाइज़िंग के अलावा किसी उद्देश्य के लिए cpus की संख्या जानने पर निर्भर करता है (उदाहरण के लिए चलाने के लिए थ्रेड्स की आदर्श संख्या चुनना) लगभग निश्चित रूप से कुछ गूंगा कर रहा है।

_SC_NPROCESSORS_ONLN समाधान एक गैर-मानक ( _SC_NPROCESSORS_ONLN विशिष्ट) sysconf एक्सटेंशन पर निर्भर करता है, जो कि /proc (सभी लिनक्स सिस्टमों के पास /proc तुलना में बहुत बड़ा निर्भरता है, लेकिन कुछ में गैर-glcc libcs ​​या glibc के पुराने संस्करण हैं, _SC_NPROCESSORS_ONLN कमी है) ।


व्यक्तिगत रूप से हालिया इंटेल cpus के लिए मैं इसका उपयोग करता हूं:

int main()
{
unsigned int eax=11,ebx=0,ecx=1,edx=0;

asm volatile("cpuid"
        : "=a" (eax),
          "=b" (ebx),
          "=c" (ecx),
          "=d" (edx)
        : "0" (eax), "2" (ecx)
        : );

printf("Cores: %d\nThreads: %d\nActual thread: %d\n",eax,ebx,edx);
}

आउटपुट:

Cores: 4
Threads: 8
Actual thread: 1

या, अधिक संक्षेप में:

#include <stdio.h>

int main()
{
unsigned int ncores=0,nthreads=0,ht=0;

asm volatile("cpuid": "=a" (ncores), "=b" (nthreads) : "a" (0xb), "c" (0x1) : );

ht=(ncores!=nthreads);

printf("Cores: %d\nThreads: %d\nHyperThreading: %s\n",ncores,nthreads,ht?"Yes":"No");

return 0;
}

आउटपुट:

Cores: 4
Threads: 8
HyperThreading: Yes

sched_affinity() संस्करण जो आप शुरुआत में उल्लेख करते हैं, वह अभी भी /proc/cpuinfo _SC_NPROCESSORS_ONLN और / या _SC_NPROCESSORS_ONLN से _SC_NPROCESSORS_ONLN क्योंकि यह केवल किसी दिए गए प्रक्रिया के लिए उपलब्ध CPU (कुछ को sched_setaffinity() द्वारा अक्षम किया जा सकता है sched_setaffinity() बाहरी प्रक्रिया द्वारा लागू)। केवल परिवर्तन लूप में CPU_ISSET करने के बजाय CPU_COUNT() का उपयोग करेगा।


#include <stdio.h>
#include <sys/sysinfo.h>

int main(int argc, char *argv[])
{
    printf("This system has %d processors configured and "
        "%d processors available.\n",
        get_nprocs_conf(), get_nprocs());
    return 0;
}

https://linux.die.net/man/3/get_nprocs






processor