Styjun

I have a program where I measure the consumed CPU time of a process on a specific core (here second CPU core). Sometimes I get values higher than 100%.

What is the reason for this value?
Does the total CPU time changes so fast when accessing the CPU time of the process?
How can I get rid of this inaccuracy?

int main(int argc, char **argv)

 int pid = 1111;

 while (true)
 
 long unsigned int diffCPUTotal, diffUserCPU, diffSysCPU, diffCuCPU, diffCsCPU, procCPUUsage;

 setCPUTotal();
 setProcCPU(pid);

 diffCPUTotal = cpuTotal - prev_cpuTotal;
 diffUserCPU = procUserCPU - prev_procUserCPU;
 diffSysCPU = procSysCPU - prev_procSysCPU;

 diffCuCPU = procCuCPU - prev_procCuCPU;
 diffCsCPU = procCsCPU - prev_procCsCPU;

 // Process CPU usage including child processes
 procCPUUsage = ((diffUserCPU + diffSysCPU + diffCuCPU + diffCsCPU) / (float) diffCPUTotal) * 100;

 printf("Process CPU usage: %lu%%n", procCPUUsage);
 fflush(stdout);

 prev_cpuTotal = cpuTotal;
 prev_procUserCPU = procUserCPU;
 prev_procSysCPU = procSysCPU;

 prev_procCuCPU = procCuCPU;
 prev_procCsCPU = procCsCPU;

 usleep(500000);
 


void setCPUTotal()

 std::ifstream fstat;
 fstat.open("/proc/stat", std::ios_base::in);

 std::string line;

 // Go to desired line
 for (int i = 0; i < 3; ++i)
 std::getline(fstat, line);

 long unsigned int user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice;

 // Get statistics of second cpu core
 sscanf(line.c_str(), "cpu1 %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
 &user, &nice, &system, &idle, &iowait, &irq, &softirq, &steal, &guest, &guest_nice);


 fstat.close();

 // guest and guest_nice are already included user and nice,
 // see http://unix.stackexchange.com/q/178045/20626
 cpuTotal = user + nice + system + idle + iowait + irq + softirq + steal;


void setProcCPU(int pid)

 std::stringstream ss;
 ss << "/proc/" << pid << "/stat";
 std::string procStatPath = ss.str();

 FILE* fpstat = fopen(procStatPath.c_str(), "r");
 fscanf(fpstat, "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %lu"
 "%lu %ld %ld %*d %*d %*d %*d %lu %*u %*d",
 &procUserCPU, &procSysCPU, &procCuCPU, &procCsCPU, &procStartTime);

 fclose(fpstat);

It's reported in terms of a single core.

100% means "all of one core". If your machine has, say, 8 cores, then the maximum possible is 800%.

If hyperthreading is enabled each hyperthread counts as a core.