How to parse /proc/cpuinfo on any linux distro in C

Question

I am running Ubuntu and I don't understand why it's so hard for me to get the number of cores on my system in C! I've tried parsing /proc/cpuinfo with success on my system running Ubuntu but then I tried on another system running arch linux which would fail because the buffer was too small, and I can't seem to figure out how to make it work on both of my systems.

#include <stdio.h>
#include <stdlib.h>

int main() {
  FILE* fp; 
  char *buffer, *tmp; 
  size_t bytes_read, size; 

  if((fp = fopen("/proc/cpuinfo", "r")) == NULL) {
    perror("open failed");
    exit(EXIT_FAILURE); 
  }
  size = 1024;
  if((buffer = malloc(size)) == NULL) {
    perror("malloc failed");
    free(buffer);
    exit(EXIT_FAILURE);
  }
  while(!feof(fp)) {
    bytes_read = fread(buffer, 1, size, fp);
    if(bytes_read == size) {
      size += 128;
      if((tmp = realloc(buffer, size)) == NULL) {
        perror("realloc failed");
        free(buffer);
        exit(EXIT_FAILURE);
      }else {
        buffer = tmp;
      }
    } 
  }
  fclose(fp); 
  if(bytes_read == 0 || bytes_read == size) {
    perror("read failed or buffer isn't big enough.");
    exit(EXIT_FAILURE); 
  }
  printf("%d bytes read out of %d\n", (int)bytes_read,(int) size);
  buffer[bytes_read] = '\0';

  printf("%s", buffer); 
}

This outputs 572 bytes read out of 1152, but it overwrites the buffer whenever I use fread again. And I can't use sysconf(_SC_NPROCESSORS_ONLN); either because it doesn't work on Ubuntu it seems.

Answer 1

How about using popen(3) to execute cat ^processor /proc/cpuinfo | wc -l to get the count of CPUs and then read the result from the pipe? It's quite easy, and you won't have to maintain complicated code to read and parse the entire file.

Here's an example:

#include <stdio.h>

int ncpus(void) {
    FILE *cmd = popen("grep '^processor' /proc/cpuinfo | wc -l", "r");

    if (cmd == NULL)
        return -1;

    unsigned nprocs;
    size_t n;
    char buff[8];

    if ((n = fread(buff, 1, sizeof(buff)-1, cmd)) <= 0)
        return -1;

    buff[n] = '\0';
    if (sscanf(buff, "%u", &nprocs) != 1)
        return -1;

    pclose(cmd);

    return nprocs;
}

int main(void) {
    int cpus = ncpus();
    if (cpus == -1)
        fprintf(stderr, "Error retrieving number of CPUs\n");
    else
        printf("Number of CPUs: %d\n", cpus);
    return 0;
}

You might want to improve error handling in ncpus() to be a little bit user-friendly (right now, you don't really know what happened if if returns -1).

UPDATE

As mentioned below in the comments, nproc(1) might be a better choice here, at least the command is smaller. It will work either way, we can just replace grep + wc with nproc.

Answer 2

Here's a minimal example of how to get physical cores and virtual threads:

#include <stdio.h>

...

FILE *cpu_info = fopen("/proc/cpuinfo", "r");
unsigned int thread_count, core_count;
while (!fscanf(cpu_info, "siblings\t: %u", &thread_count))
  fscanf(cpu_info, "%*[^s]");
while (!fscanf(cpu_info, "cpu cores\t: %u", &core_count))                   
  fscanf(cpu_info, "%*[^c]");                                                                                          
fclose(cpu_info);

Note that you don't need to check for EOF in this example as fscanf will return EOF if reached. This will cause the loop to stop safely.

Also, this example doesn't contain error checking to see if fopen failed. This should be done however you see fit.

This fscanf technique was derived from here: https://stackoverflow.com/a/43483850

Answer 3

This is old Question ,But if anyone got the same question. This code also works for bigLITTLE processors.

#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include<map>
#include<cstring>
using namespace std;

int main() {
    map <string,int > cpu_count;
    map <string,float > freq_count;
    string line;
    string temp="";
    ifstream finfo("/proc/cpuinfo");
    while(getline(finfo,line)) {
        stringstream str(line);
        string itype;
        string info;
        stringstream str1(line);
        string itype1;
        string info1;
        
        if ( getline( str, itype, ':' ) && getline(str,info) && itype.substr(0,10) == "model name" ) {
            cpu_count[info]++;
            temp=info;  
        }

        if ( getline( str1, itype1, ':' ) && getline(str1,info1) && (itype1.substr(0,7) == "cpu MHz" || itype1.substr(0,8) == "BogoMIPS") ) {
            float freq = stof(info1);
            freq_count[temp]+=freq;
        }
    }

    map<string, int>::iterator it1;
    map<string, float>::iterator it2;
    it2=freq_count.begin();
    for (it1 = cpu_count.begin(); it1 != cpu_count.end(); it1++)
    {
        cout << "CPU Model : "<<it1->first << " | Cores : " << it1->second << " | Average Frequency :  " <<it2->second/it1->second<<endl;
        it2++;
    }
    return 0;
}

Output

CPU Model : Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz | Cores : 12 | Average Frequency : 808.687