mirror of
https://bitbucket.org/smil3y/kde-workspace.git
synced 2025-02-24 10:52:51 +00:00
655 lines
18 KiB
C
655 lines
18 KiB
C
/*
|
|
KSysGuard, the KDE System Guard
|
|
|
|
Copyright (c) 1999 Chris Schlaeger <cs@kde.org>
|
|
Copyright (c) 2010 David Naylor <naylor.b.david@gmail.com>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/resource.h>
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <devstat.h>
|
|
#include <fcntl.h>
|
|
#include <nlist.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "cpuinfo.h"
|
|
#include "Command.h"
|
|
#include "ksysguardd.h"
|
|
|
|
#define FREQ_LEVEL_BUFFER 256
|
|
#define SYSCTL_ID_LEN 35
|
|
|
|
static void get_mmfreq(int, int*, int*);
|
|
|
|
static long percentages(int cnt, long *out, long *new, long *old, long *diffs);
|
|
|
|
static long (*cp_time)[CPUSTATES] = NULL;
|
|
static long (*cp_old)[CPUSTATES] = NULL;
|
|
static long (*cp_diff)[CPUSTATES] = NULL;
|
|
|
|
static int maxcpus = 1;
|
|
static int cpus = 1;
|
|
static int cores = 1;
|
|
static int (*freq)[3] = NULL;
|
|
static int *temp = NULL;
|
|
|
|
static long (*cpu_states)[CPUSTATES] = NULL;
|
|
|
|
void
|
|
initCpuInfo(struct SensorModul* sm)
|
|
{
|
|
size_t len;
|
|
int id;
|
|
char name[SYSCTL_ID_LEN];
|
|
int minfreq, maxfreq;
|
|
|
|
len = sizeof(cpus);
|
|
/* XXX: this is a guess */
|
|
sysctlbyname("kern.smp.active", &cpus, &len, NULL, 0);
|
|
/* NOTE: cpus may be 0, which implies 1 */
|
|
cpus = cpus ? cpus : 1;
|
|
|
|
len = sizeof(cores);
|
|
sysctlbyname("kern.smp.cpus", &cores, &len, NULL, 0);
|
|
|
|
len = sizeof(maxcpus);
|
|
sysctlbyname("kern.smp.maxcpus", &maxcpus, &len, NULL, 0);
|
|
|
|
/* Core/process count */
|
|
registerMonitor("system/processors", "integer", printNumCpus, printNumCpusInfo, sm);
|
|
registerMonitor("system/cores", "integer", printNumCores, printNumCoresInfo, sm);
|
|
|
|
/*
|
|
* CPU Loads
|
|
*/
|
|
if ((cp_time = malloc(sizeof(long) * CPUSTATES * (cores * 4 + 1))) == NULL) {
|
|
log_error("out of memory for cp_time");
|
|
return;
|
|
}
|
|
cp_old = &cp_time[cores];
|
|
cp_diff = &cp_old[cores];
|
|
cpu_states = &cp_diff[cores];
|
|
|
|
/* Total CPU load */
|
|
registerMonitor("cpu/system/user", "float", printCPUUser, printCPUUserInfo, sm);
|
|
registerMonitor("cpu/system/nice", "float", printCPUNice, printCPUNiceInfo, sm);
|
|
registerMonitor("cpu/system/sys", "float", printCPUSys, printCPUSysInfo, sm);
|
|
registerMonitor("cpu/system/TotalLoad", "float", printCPUTotalLoad, printCPUTotalLoadInfo, sm);
|
|
registerMonitor("cpu/system/intr", "float", printCPUIntr, printCPUIntrInfo, sm);
|
|
registerMonitor("cpu/system/idle", "float", printCPUIdle, printCPUIdleInfo, sm);
|
|
|
|
/* Monitor names changed from kde3 => kde4. Remain compatible with legacy requests when possible. */
|
|
registerLegacyMonitor("cpu/user", "float", printCPUUser, printCPUUserInfo, sm);
|
|
registerLegacyMonitor("cpu/nice", "float", printCPUNice, printCPUNiceInfo, sm);
|
|
registerLegacyMonitor("cpu/sys", "float", printCPUSys, printCPUSysInfo, sm);
|
|
registerLegacyMonitor("cpu/idle", "float", printCPUIdle, printCPUIdleInfo, sm);
|
|
|
|
for (id = 0; id < cores; ++id) {
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/user", id);
|
|
registerMonitor(name, "float", printCPUxUser, printCPUxUserInfo, sm);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/nice", id);
|
|
registerMonitor(name, "float", printCPUxNice, printCPUxNiceInfo, sm);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/sys", id);
|
|
registerMonitor(name, "float", printCPUxSys, printCPUxSysInfo, sm);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/TotalLoad", id);
|
|
registerMonitor(name, "float", printCPUxTotalLoad, printCPUxTotalLoadInfo, sm);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/intr", id);
|
|
registerMonitor(name, "float", printCPUxIntr, printCPUxIntrInfo, sm);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/idle", id);
|
|
registerMonitor(name, "float", printCPUxIdle, printCPUxIdleInfo, sm);
|
|
}
|
|
|
|
/*
|
|
* CPU frequencies
|
|
*/
|
|
if ((freq = malloc(sizeof(int) * 3 * (cores + 1))) == NULL) {
|
|
log_error("out of memory for freq");
|
|
return;
|
|
}
|
|
|
|
registerMonitor("cpu/system/AverageClock", "float", printCPUClock, printCPUClockInfo, sm);
|
|
for (id = 0; id < cores; ++id) {
|
|
len = sizeof(int);
|
|
snprintf(name, SYSCTL_ID_LEN, "dev.cpu.%d.freq", id);
|
|
if (!sysctlbyname(name, &freq[id][0], &len, NULL, 0)) {
|
|
get_mmfreq(id, &freq[id][1], &freq[id][2]);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/clock", id);
|
|
registerMonitor(name, "integer", printCPUxClock, printCPUxClockInfo, sm);
|
|
} else {
|
|
freq[id][0] = -1;
|
|
freq[id][1] = 0;
|
|
freq[id][2] = 0;
|
|
}
|
|
}
|
|
|
|
minfreq = freq[0][1];
|
|
maxfreq = freq[0][2];
|
|
for (id = 1; id < cores; ++id)
|
|
if (freq[id][0] != -1) {
|
|
minfreq = minfreq > freq[id][1] ? freq[id][1] : minfreq;
|
|
maxfreq = maxfreq < freq[id][2] ? freq[id][2] : maxfreq;
|
|
}
|
|
freq[cores][1] = minfreq;
|
|
freq[cores][2] = maxfreq;
|
|
|
|
/*
|
|
* CPU temperature
|
|
*/
|
|
if ((temp = malloc(sizeof(int) * (cores + 1))) == NULL) {
|
|
log_error("out of memory for temp");
|
|
return;
|
|
}
|
|
registerMonitor("cpu/system/AverageTemperature", "float", printCPUTemperature, printCPUTemperatureInfo, sm);
|
|
for (id = 0; id < cores; ++id) {
|
|
len = sizeof(int);
|
|
snprintf(name, SYSCTL_ID_LEN, "dev.cpu.%d.temperature", id);
|
|
if (!sysctlbyname(name, &temp[id], &len, NULL, 0)) {
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/temperature", id);
|
|
registerMonitor(name, "float", printCPUxTemperature, printCPUxTemperatureInfo, sm);
|
|
} else
|
|
temp[id] = -1;
|
|
}
|
|
|
|
updateCpuInfo();
|
|
}
|
|
|
|
void
|
|
exitCpuInfo(void)
|
|
{
|
|
int id;
|
|
char name[SYSCTL_ID_LEN];
|
|
|
|
removeMonitor("system/processors");
|
|
removeMonitor("system/cores");
|
|
|
|
if (cp_time != NULL) {
|
|
removeMonitor("cpu/system/user");
|
|
removeMonitor("cpu/system/nice");
|
|
removeMonitor("cpu/system/sys");
|
|
removeMonitor("cpu/system/TotalLoad");
|
|
removeMonitor("cpu/system/intr");
|
|
removeMonitor("cpu/system/idle");
|
|
|
|
/* These were registered as legacy monitors */
|
|
removeMonitor("cpu/user");
|
|
removeMonitor("cpu/nice");
|
|
removeMonitor("cpu/sys");
|
|
removeMonitor("cpu/idle");
|
|
|
|
for (id = 0; id < cores; ++id) {
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/user", id);
|
|
removeMonitor(name);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/nice", id);
|
|
removeMonitor(name);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/sys", id);
|
|
removeMonitor(name);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/TotalLoad", id);
|
|
removeMonitor(name);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/intr", id);
|
|
removeMonitor(name);
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/idle", id);
|
|
removeMonitor(name);
|
|
|
|
if (freq != NULL && freq[id][0] != -1) {
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/clock", id);
|
|
removeMonitor(name);
|
|
}
|
|
if (temp != NULL && temp[id] != -1) {
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/temperature", id);
|
|
removeMonitor(name);
|
|
}
|
|
}
|
|
|
|
free(cp_time);
|
|
cp_time = NULL;
|
|
}
|
|
|
|
if (freq != NULL) {
|
|
removeMonitor("cpu/system/AverageClock");
|
|
for (id = 0; id < cores; ++id)
|
|
if (freq[id][0] != -1) {
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/clock", id);
|
|
removeMonitor(name);
|
|
}
|
|
free(freq);
|
|
freq = NULL;
|
|
}
|
|
|
|
if (temp != NULL) {
|
|
removeMonitor("cpu/system/AverageTemperature");
|
|
for (id = 0; id < cores; ++id)
|
|
if (temp[id] != -1) {
|
|
snprintf(name, SYSCTL_ID_LEN, "cpu/cpu%d/temperature", id);
|
|
removeMonitor(name);
|
|
}
|
|
free(temp);
|
|
temp = NULL;
|
|
}
|
|
|
|
}
|
|
|
|
int
|
|
updateCpuInfo(void)
|
|
{
|
|
int sid, id, tot_freq = 0, tot_temp = 0, freq_count = 0, temp_count = 0;
|
|
char name[SYSCTL_ID_LEN];
|
|
|
|
if (cp_time == NULL || freq == NULL || temp == NULL)
|
|
return (0);
|
|
|
|
size_t len = sizeof(long) * CPUSTATES * cores;
|
|
sysctlbyname("kern.cp_times", cp_time, &len, NULL, 0);
|
|
for (sid = 0; sid < CPUSTATES; ++sid)
|
|
cpu_states[cores][sid] = 0;
|
|
for (id = 0; id < cores; ++id) {
|
|
percentages(CPUSTATES, cpu_states[id], cp_time[id], cp_old[id], cp_diff[id]);
|
|
for (sid = 0; sid < CPUSTATES; ++sid)
|
|
cpu_states[cores][sid] += cpu_states[id][sid];
|
|
}
|
|
for (id = 0; id < cores; ++id) {
|
|
if (freq[id][0] != -1) {
|
|
len = sizeof(int);
|
|
snprintf(name, SYSCTL_ID_LEN, "dev.cpu.%d.freq", id);
|
|
freq[id][0] = 0;
|
|
if (!sysctlbyname(name, &freq[id][0], &len, NULL, 0)) {
|
|
freq_count += 1;
|
|
tot_freq += freq[id][0];
|
|
}
|
|
}
|
|
if (temp[id] != -1) {
|
|
len = sizeof(int);
|
|
snprintf(name, SYSCTL_ID_LEN, "dev.cpu.%d.temperature", id);
|
|
temp[id] = 0.0;
|
|
if (!sysctlbyname(name, &temp[id], &len, NULL, 0)) {
|
|
temp_count += 1;
|
|
tot_temp += temp[id];
|
|
}
|
|
}
|
|
}
|
|
freq[cores][0] = freq_count == 0 ? 0 : tot_freq * 100 / freq_count;
|
|
temp[cores] = temp_count == 0 ? 0.0 : tot_temp * 100 / temp_count;
|
|
|
|
return (0);
|
|
}
|
|
|
|
void
|
|
printCPUUser(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%f\n", cpu_states[cores][CP_USER] / 10.0 / cores);
|
|
}
|
|
|
|
void
|
|
printCPUUserInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU User Load\t0\t100\t%%\n");
|
|
}
|
|
|
|
void
|
|
printCPUNice(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%f\n", cpu_states[cores][CP_NICE] / 10.0 / cores);
|
|
}
|
|
|
|
void
|
|
printCPUNiceInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU Nice Load\t0\t100\t%%\n");
|
|
}
|
|
|
|
void
|
|
printCPUSys(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%f\n", cpu_states[cores][CP_SYS] / 10.0 / cores);
|
|
}
|
|
|
|
void
|
|
printCPUSysInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU System Load\t0\t100\t%%\n");
|
|
}
|
|
|
|
void
|
|
printCPUTotalLoad(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%f\n", (cpu_states[cores][CP_SYS] + cpu_states[cores][CP_USER] +
|
|
cpu_states[cores][CP_NICE] + cpu_states[cores][CP_INTR]) / 10.0 / cores);
|
|
}
|
|
|
|
void
|
|
printCPUTotalLoadInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU Total Load\t0\t100\t%%\n");
|
|
}
|
|
|
|
void
|
|
printCPUIntr(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%f\n", cpu_states[cores][CP_INTR] / 10.0 / cores);
|
|
}
|
|
|
|
void
|
|
printCPUIntrInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU Interrupt Load\t0\t100\t%%\n");
|
|
}
|
|
|
|
void
|
|
printCPUIdle(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%f\n", cpu_states[cores][CP_IDLE] / 10.0 / cores);
|
|
}
|
|
|
|
void
|
|
printCPUIdleInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU Idle Load\t0\t100\t%%\n");
|
|
}
|
|
|
|
void
|
|
printCPUxUser(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "%0.1f\n", cpu_states[id][CP_USER] / 10.0);
|
|
}
|
|
|
|
void
|
|
printCPUxUserInfo(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "CPU%d User Load\t0\t100\t%%\n", id + 1);
|
|
}
|
|
|
|
void
|
|
printCPUxNice(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "%0.1f\n", cpu_states[id][CP_NICE] / 10.0);
|
|
}
|
|
|
|
void
|
|
printCPUxNiceInfo(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "CPU%d Nice Load\t0\t100\t%%\n", id + 1);
|
|
}
|
|
|
|
void
|
|
printCPUxSys(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "%0.1f\n", cpu_states[id][CP_SYS] / 10.0);
|
|
}
|
|
|
|
void
|
|
printCPUxSysInfo(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "CPU%d System Load\t0\t100\t%%\n", id + 1);
|
|
}
|
|
|
|
void
|
|
printCPUxTotalLoad(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "%f\n", (cpu_states[id][CP_SYS] + cpu_states[id][CP_USER] +
|
|
cpu_states[id][CP_NICE] + cpu_states[id][CP_INTR]) / 10.0);
|
|
}
|
|
|
|
void
|
|
printCPUxTotalLoadInfo(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "CPU%d Total Load\t0\t100\t%%\n", id + 1);
|
|
}
|
|
|
|
void
|
|
printCPUxIntr(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "%0.1f\n", cpu_states[id][CP_INTR] / 10.0);
|
|
}
|
|
|
|
void
|
|
printCPUxIntrInfo(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "CPU%d Interrupt Load\t0\t100\t%%\n", id + 1);
|
|
}
|
|
|
|
void
|
|
printCPUxIdle(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "%0.1f\n", cpu_states[id][CP_IDLE] / 10.0);
|
|
}
|
|
|
|
void
|
|
printCPUxIdleInfo(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "CPU%d Idle Load\t0\t100\t%%\n", id + 1);
|
|
}
|
|
|
|
void printCPUxClock(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "%d\n", freq[id][0]);
|
|
}
|
|
|
|
void printCPUxClockInfo(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "CPU%d Clock Frequency\t%d\t%d\tMHz\n", id + 1,
|
|
freq[id][1], freq[id][2]);
|
|
}
|
|
|
|
void printCPUClock(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%f\n", freq[cores][0] / 100.0);
|
|
}
|
|
|
|
void printCPUClockInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU Clock Frequency\t%d\t%d\tMHz\n", freq[cores][1], freq[cores][2]);
|
|
}
|
|
|
|
void printCPUxTemperature(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "%0.1f\n", (temp[id] - 2732) / 10.0);
|
|
}
|
|
|
|
void printCPUxTemperatureInfo(const char* cmd)
|
|
{
|
|
int id;
|
|
|
|
sscanf(cmd + 7, "%d", &id);
|
|
fprintf(CurrentClient, "CPU%d Temperature\t0\t0\tC\n", id + 1);
|
|
}
|
|
|
|
void printCPUTemperature(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%0.3f\n", (temp[cores] - 273200) / 1000.0);
|
|
}
|
|
|
|
void printCPUTemperatureInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "CPU Temperature\t0\t0\tC\n");
|
|
}
|
|
|
|
void printNumCpus(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%d\n", cpus);
|
|
}
|
|
|
|
void printNumCpusInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "Number of physical CPUs\t0\t%d\t\n", maxcpus);
|
|
}
|
|
|
|
void printNumCores(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "%d\n", cores);
|
|
}
|
|
|
|
void printNumCoresInfo(const char* cmd)
|
|
{
|
|
fprintf(CurrentClient, "Total number of processor cores\t0\t%d\t\n", maxcpus);
|
|
}
|
|
|
|
void get_mmfreq(int id, int* minfreq, int* maxfreq)
|
|
{
|
|
char buf[FREQ_LEVEL_BUFFER];
|
|
char mid[SYSCTL_ID_LEN];
|
|
size_t len = FREQ_LEVEL_BUFFER;
|
|
|
|
*minfreq = 0;
|
|
*maxfreq = 0;
|
|
|
|
snprintf(mid, sizeof(mid), "dev.cpu.%d.freq_levels", id);
|
|
if (!sysctlbyname(mid, buf, &len, NULL, 0))
|
|
{
|
|
char *start = buf;
|
|
char *end;
|
|
|
|
/*
|
|
* The string is ([[freq]]/[[num]] )*([[freq]]/[[num]] ), so
|
|
* for each frequency we get we must also skip over another
|
|
* set of numbers
|
|
*/
|
|
while (1)
|
|
{
|
|
/* Get the first number */
|
|
int number = strtol(start, &end, 10);
|
|
if (start == end)
|
|
break;
|
|
if (!*maxfreq)
|
|
*maxfreq = number;
|
|
else
|
|
*minfreq = number;
|
|
if (!*end)
|
|
break;
|
|
start = end + 1;
|
|
|
|
/* Skip over the next number */
|
|
strtol(start, &end, 10);
|
|
if (start == end || !*end)
|
|
break;
|
|
start = end + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* The part ripped from top... */
|
|
/*
|
|
* Top users/processes display for Unix
|
|
* Version 3
|
|
*
|
|
* This program may be freely redistributed,
|
|
* but this entire comment MUST remain intact.
|
|
*
|
|
* Copyright (c) 1984, 1989, William LeFebvre, Rice University
|
|
* Copyright (c) 1989, 1990, 1992, William LeFebvre, Northwestern University
|
|
*/
|
|
|
|
/*
|
|
* percentages(cnt, out, new, old, diffs) - calculate percentage change
|
|
* between array "old" and "new", putting the percentages i "out".
|
|
* "cnt" is size of each array and "diffs" is used for scratch space.
|
|
* The array "old" is updated on each call.
|
|
* The routine assumes modulo arithmetic. This function is especially
|
|
* useful on BSD mchines for calculating cpu state percentages.
|
|
*/
|
|
long percentages(int cnt, long *out, long *new, long *old, long *diffs)
|
|
{
|
|
int i;
|
|
long change;
|
|
long total_change;
|
|
long *dp;
|
|
long half_total;
|
|
|
|
/* initialization */
|
|
total_change = 0;
|
|
dp = diffs;
|
|
|
|
/* calculate changes for each state and the overall change */
|
|
for (i = 0; i < cnt; i++)
|
|
{
|
|
if ((change = *new - *old) < 0)
|
|
{
|
|
/* this only happens when the counter wraps */
|
|
change = (int)
|
|
((unsigned long)*new-(unsigned long)*old);
|
|
}
|
|
total_change += (*dp++ = change);
|
|
*old++ = *new++;
|
|
}
|
|
|
|
/* avoid divide by zero potential */
|
|
if (total_change == 0)
|
|
{
|
|
total_change = 1;
|
|
}
|
|
|
|
/* calculate percentages based on overall change, rounding up */
|
|
half_total = total_change / 2l;
|
|
|
|
/* Do not divide by 0. Causes Floating point exception */
|
|
for (i = 0; i < cnt; i++)
|
|
{
|
|
*out++ = (int)((*diffs++ * 1000 + half_total) / total_change);
|
|
}
|
|
|
|
/* return the total in case the caller wants to use it */
|
|
return(total_change);
|
|
}
|