zeldon
/
htop
mirror of https://github.com/xzeldon/htop.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rework CPU counting 

Currently htop does not support offline CPUs and hot-swapping, e.g. via
    echo 0 > /sys/devices/system/cpu/cpu2/online

Split the current single cpuCount variable into activeCPUs and
existingCPUs.

Supersedes: #650
Related: #580
This commit is contained in:
Christian Göttsche 2021-06-12 18:17:28 +02:00 committed by Benny Baumann
parent c9abd788b1
commit 41af31be7f
28 changed files with 276 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Action.c
View File

@ -302,7 +302,7 @@ static Htop_Reaction actionSetAffinity(State* st) {
if (Settings_isReadonly())
return HTOP_OK;
if (st->pl->cpuCount == 1)
if (st->pl->activeCPUs == 1)
return HTOP_OK;
#if (defined(HAVE_LIBHWLOC) || defined(HAVE_LINUX_AFFINITY))

4
Affinity.c
View File

@ -59,7 +59,7 @@ Affinity* Affinity_get(const Process* proc, ProcessList* pl) {
if (ok) {
affinity = Affinity_new(pl);
if (hwloc_bitmap_last(cpuset) == -1) {
for (unsigned int i = 0; i < pl->cpuCount; i++) {
for (unsigned int i = 0; i < pl->existingCPUs; i++) {
Affinity_add(affinity, i);
}
} else {
@ -93,7 +93,7 @@ Affinity* Affinity_get(const Process* proc, ProcessList* pl) {
return NULL;
Affinity* affinity = Affinity_new(pl);
for (unsigned int i = 0; i < pl->cpuCount; i++) {
for (unsigned int i = 0; i < pl->existingCPUs; i++) {
if (CPU_ISSET(i, &cpuset)) {
Affinity_add(affinity, i);
}

6
AffinityPanel.c
View File

@ -383,7 +383,8 @@ Panel* AffinityPanel_new(ProcessList* pl, const Affinity* affinity, int* width)
Panel_setHeader(super, "Use CPUs:");
unsigned int curCpu = 0;
for (unsigned int i = 0; i < pl->cpuCount; i++) {
for (unsigned int i = 0; i < pl->existingCPUs; i++) {
/* TODO: skip offline CPUs */
char number[16];
xSnprintf(number, 9, "CPU %d", Settings_cpuId(pl->settings, i));
unsigned cpu_width = 4 + strlen(number);
@ -427,7 +428,8 @@ Affinity* AffinityPanel_getAffinity(Panel* super, ProcessList* pl) {
Affinity_add(affinity, i);
hwloc_bitmap_foreach_end();
#else
for (unsigned int i = 0; i < this->pl->cpuCount; i++) {
for (unsigned int i = 0; i < this->pl->existingCPUs; i++) {
/* TODO: skip offline CPUs */
const MaskItem* item = (const MaskItem*)Vector_get(this->cpuids, i);
if (item->value) {
Affinity_add(affinity, item->cpu);

4
AvailableMetersPanel.c
View File

@ -94,9 +94,9 @@ const PanelClass AvailableMetersPanel_class = {
// Handle (&CPUMeter_class) entries in the AvailableMetersPanel
static void AvailableMetersPanel_addCPUMeters(Panel* super, const MeterClass* type, const ProcessList* pl) {
if (pl->cpuCount > 1) {
if (pl->existingCPUs > 1) {
Panel_add(super, (Object*) ListItem_new("CPU average", 0));
for (unsigned int i = 1; i <= pl->cpuCount; i++) {
for (unsigned int i = 1; i <= pl->existingCPUs; i++) {
char buffer[50];
xSnprintf(buffer, sizeof(buffer), "%s %d", type->uiName, Settings_cpuId(pl->settings, i - 1));
Panel_add(super, (Object*) ListItem_new(buffer, i));

21
CPUMeter.c
View File

@ -43,7 +43,7 @@ static void CPUMeter_init(Meter* this) {
unsigned int cpu = this->param;
if (cpu == 0) {
Meter_setCaption(this, "Avg");
} else if (this->pl->cpuCount > 1) {
} else if (this->pl->activeCPUs > 1) {
char caption[10];
xSnprintf(caption, sizeof(caption), "%3u", Settings_cpuId(this->pl->settings, cpu - 1));
Meter_setCaption(this, caption);
@ -59,21 +59,24 @@ static void CPUMeter_getUiName(const Meter* this, char* buffer, size_t length) {
}
static void CPUMeter_updateValues(Meter* this) {
memset(this->values, 0, sizeof(double) * CPU_METER_ITEMCOUNT);
unsigned int cpu = this->param;
if (cpu > this->pl->cpuCount) {
if (cpu > this->pl->existingCPUs) {
xSnprintf(this->txtBuffer, sizeof(this->txtBuffer), "absent");
for (uint8_t i = 0; i < this->curItems; i++)
this->values[i] = 0;
return;
}
memset(this->values, 0, sizeof(double) * CPU_METER_ITEMCOUNT);
double percent = Platform_setCPUValues(this, cpu);
if (isnan(percent)) {
xSnprintf(this->txtBuffer, sizeof(this->txtBuffer), "offline");
return;
}
char cpuUsageBuffer[8] = { 0 };
char cpuFrequencyBuffer[16] = { 0 };
char cpuTemperatureBuffer[16] = { 0 };
double percent = Platform_setCPUValues(this, cpu);
if (this->pl->settings->showCPUUsage) {
xSnprintf(cpuUsageBuffer, sizeof(cpuUsageBuffer), "%.1f%%", percent);
}
@ -112,7 +115,7 @@ static void CPUMeter_display(const Object* cast, RichString* out) {
int len;
const Meter* this = (const Meter*)cast;
if (this->param > this->pl->cpuCount) {
if (this->param > this->pl->existingCPUs) {
RichString_appendAscii(out, CRT_colors[METER_TEXT], "absent");
return;
}
@ -206,7 +209,7 @@ static void AllCPUsMeter_updateValues(Meter* this) {
}
static void CPUMeterCommonInit(Meter* this, int ncol) {
unsigned int cpus = this->pl->cpuCount;
unsigned int cpus = this->pl->existingCPUs;
CPUMeterData* data = this->meterData;
if (!data) {
data = this->meterData = xMalloc(sizeof(CPUMeterData));

2
CommandLine.c
View File

@ -295,7 +295,7 @@ int CommandLine_run(const char* name, int argc, char** argv) {
Hashtable* dm = DynamicMeters_new();
ProcessList* pl = ProcessList_new(ut, dm, flags.pidMatchList, flags.userId);
Settings* settings = Settings_new(pl->cpuCount);
Settings* settings = Settings_new(pl->activeCPUs);
pl->settings = settings;
Header* header = Header_new(pl, settings, 2);

12
LoadAverageMeter.c
View File

@ -47,12 +47,12 @@ static void LoadAverageMeter_updateValues(Meter* this) {
if (this->values[0] < 1.0) {
this->curAttributes = OK_attributes;
this->total = 1.0;
} else if (this->values[0] < this->pl->cpuCount) {
} else if (this->values[0] < this->pl->activeCPUs) {
this->curAttributes = Medium_attributes;
this->total = this->pl->cpuCount;
this->total = this->pl->activeCPUs;
} else {
this->curAttributes = High_attributes;
this->total = 2 * this->pl->cpuCount;
this->total = 2 * this->pl->activeCPUs;
}
xSnprintf(this->txtBuffer, sizeof(this->txtBuffer), "%.2f/%.2f/%.2f", this->values[0], this->values[1], this->values[2]);
@ -79,12 +79,12 @@ static void LoadMeter_updateValues(Meter* this) {
if (this->values[0] < 1.0) {
this->curAttributes = OK_attributes;
this->total = 1.0;
} else if (this->values[0] < this->pl->cpuCount) {
} else if (this->values[0] < this->pl->activeCPUs) {
this->curAttributes = Medium_attributes;
this->total = this->pl->cpuCount;
this->total = this->pl->activeCPUs;
} else {
this->curAttributes = High_attributes;
this->total = 2 * this->pl->cpuCount;
this->total = 2 * this->pl->activeCPUs;
}
xSnprintf(this->txtBuffer, sizeof(this->txtBuffer), "%.2f", this->values[0]);

2
Process.c
View File

@ -821,7 +821,7 @@ void Process_writeField(const Process* this, RichString* str, ProcessField field
case PERCENT_NORM_CPU: {
float cpuPercentage = this->percent_cpu;
if (field == PERCENT_NORM_CPU) {
cpuPercentage /= this->processList->cpuCount;
cpuPercentage /= this->processList->activeCPUs;
}
if (cpuPercentage > 999.9F) {
xSnprintf(buffer, n, "%4u ", (unsigned int)cpuPercentage);

3
ProcessList.c
View File

@ -34,7 +34,8 @@ ProcessList* ProcessList_init(ProcessList* this, const ObjectClass* klass, Users
this->userId = userId;
// set later by platform-specific code
this->cpuCount = 0;
this->activeCPUs = 0;
this->existingCPUs = 0;
this->monotonicMs = 0;
// always maintain valid realtime timestamps

3
ProcessList.h
View File

@ -83,7 +83,8 @@ typedef struct ProcessList_ {
memory_t usedSwap;
memory_t cachedSwap;
unsigned int cpuCount;
unsigned int activeCPUs;
unsigned int existingCPUs;
} ProcessList;
ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, Hashtable* pidMatchList, uid_t userId);

2
TasksMeter.c
View File

@ -28,7 +28,7 @@ static void TasksMeter_updateValues(Meter* this) {
this->values[0] = pl->kernelThreads;
this->values[1] = pl->userlandThreads;
this->values[2] = pl->totalTasks - pl->kernelThreads - pl->userlandThreads;
this->values[3] = MINIMUM(pl->runningTasks, pl->cpuCount);
this->values[3] = MINIMUM(pl->runningTasks, pl->activeCPUs);
this->total = pl->totalTasks;
xSnprintf(this->txtBuffer, sizeof(this->txtBuffer), "%d/%d", (int) this->values[3], (int) this->total);

8
darwin/DarwinProcessList.c
View File

@ -134,7 +134,9 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
ProcessList_init(&this->super, Class(DarwinProcess), usersTable, dynamicMeters, pidMatchList, userId);
/* Initialize the CPU information */
this->super.cpuCount = ProcessList_allocateCPULoadInfo(&this->prev_load);
this->super.activeCPUs = ProcessList_allocateCPULoadInfo(&this->prev_load);
// TODO: support offline CPUs and hot swapping
this->super.existingCPUs = this->super.activeCPUs;
ProcessList_getHostInfo(&this->host_info);
ProcessList_allocateCPULoadInfo(&this->curr_load);
@ -184,13 +186,13 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
/* Get the time difference */
dpl->global_diff = 0;
for (unsigned int i = 0; i < dpl->super.cpuCount; ++i) {
for (unsigned int i = 0; i < dpl->super.existingCPUs; ++i) {
for (size_t j = 0; j < CPU_STATE_MAX; ++j) {
dpl->global_diff += dpl->curr_load[i].cpu_ticks[j] - dpl->prev_load[i].cpu_ticks[j];
}
}
const double time_interval = ticksToNanoseconds(dpl->global_diff) / (double) dpl->super.cpuCount;
const double time_interval = ticksToNanoseconds(dpl->global_diff) / (double) dpl->super.activeCPUs;
/* Clear the thread counts */
super->kernelThreads = 0;

12
darwin/Platform.c
View File

@ -186,21 +186,21 @@ int Platform_getMaxPid() {
static double Platform_setCPUAverageValues(Meter* mtr) {
const ProcessList* dpl = mtr->pl;
unsigned int cpus = dpl->cpuCount;
unsigned int activeCPUs = dpl->activeCPUs;
double sumNice = 0.0;
double sumNormal = 0.0;
double sumKernel = 0.0;
double sumPercent = 0.0;
for (unsigned int i = 1; i <= cpus; i++) {
for (unsigned int i = 1; i <= dpl->existingCPUs; i++) {
sumPercent += Platform_setCPUValues(mtr, i);
sumNice += mtr->values[CPU_METER_NICE];
sumNormal += mtr->values[CPU_METER_NORMAL];
sumKernel += mtr->values[CPU_METER_KERNEL];
}
mtr->values[CPU_METER_NICE] = sumNice / cpus;
mtr->values[CPU_METER_NORMAL] = sumNormal / cpus;
mtr->values[CPU_METER_KERNEL] = sumKernel / cpus;
return sumPercent / cpus;
mtr->values[CPU_METER_NICE] = sumNice / activeCPUs;
mtr->values[CPU_METER_NORMAL] = sumNormal / activeCPUs;
mtr->values[CPU_METER_KERNEL] = sumKernel / activeCPUs;
return sumPercent / activeCPUs;
}
double Platform_setCPUValues(Meter* mtr, unsigned int cpu) {

8
dragonflybsd/DragonFlyBSDProcessList.c
View File

@ -95,13 +95,15 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
sysctl(MIB_kern_cp_times, 2, dfpl->cp_times_o, &len, NULL, 0);
}
pl->cpuCount = MAXIMUM(cpus, 1);
pl->existingCPUs = MAXIMUM(cpus, 1);
// TODO: support offline CPUs and hot swapping
pl->activeCPUs = pl->existingCPUs;
if (cpus == 1 ) {
dfpl->cpus = xRealloc(dfpl->cpus, sizeof(CPUData));
} else {
// on smp we need CPUs + 1 to store averages too (as kernel kindly provides that as well)
dfpl->cpus = xRealloc(dfpl->cpus, (pl->cpuCount + 1) * sizeof(CPUData));
dfpl->cpus = xRealloc(dfpl->cpus, (pl->existingCPUs + 1) * sizeof(CPUData));
}
len = sizeof(kernelFScale);
@ -140,7 +142,7 @@ void ProcessList_delete(ProcessList* this) {
static inline void DragonFlyBSDProcessList_scanCPUTime(ProcessList* pl) {
const DragonFlyBSDProcessList* dfpl = (DragonFlyBSDProcessList*) pl;
unsigned int cpus = pl->cpuCount; // actual CPU count
unsigned int cpus = pl->existingCPUs; // actual CPU count
unsigned int maxcpu = cpus; // max iteration (in case we have average + smp)
int cp_times_offset;

2
dragonflybsd/Platform.c
View File

@ -159,7 +159,7 @@ int Platform_getMaxPid() {
double Platform_setCPUValues(Meter* this, unsigned int cpu) {
const DragonFlyBSDProcessList* fpl = (const DragonFlyBSDProcessList*) this->pl;
unsigned int cpus = this->pl->cpuCount;
unsigned int cpus = this->pl->activeCPUs;
const CPUData* cpuData;
if (cpus == 1) {

8
freebsd/FreeBSDProcessList.c
View File

@ -125,13 +125,15 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
sysctl(MIB_kern_cp_times, 2, fpl->cp_times_o, &len, NULL, 0);
}
pl->cpuCount = MAXIMUM(cpus, 1);
pl->existingCPUs = MAXIMUM(cpus, 1);
// TODO: support offline CPUs and hot swapping
pl->activeCPUs = pl->existingCPUs;
if (cpus == 1 ) {
fpl->cpus = xRealloc(fpl->cpus, sizeof(CPUData));
} else {
// on smp we need CPUs + 1 to store averages too (as kernel kindly provides that as well)
fpl->cpus = xRealloc(fpl->cpus, (pl->cpuCount + 1) * sizeof(CPUData));
fpl->cpus = xRealloc(fpl->cpus, (pl->existingCPUs + 1) * sizeof(CPUData));
}
@ -169,7 +171,7 @@ void ProcessList_delete(ProcessList* this) {
static inline void FreeBSDProcessList_scanCPU(ProcessList* pl) {
const FreeBSDProcessList* fpl = (FreeBSDProcessList*) pl;
unsigned int cpus = pl->cpuCount; // actual CPU count
unsigned int cpus = pl->existingCPUs; // actual CPU count
unsigned int maxcpu = cpus; // max iteration (in case we have average + smp)
int cp_times_offset;

2
freebsd/Platform.c
View File

@ -181,7 +181,7 @@ int Platform_getMaxPid() {
double Platform_setCPUValues(Meter* this, unsigned int cpu) {
const FreeBSDProcessList* fpl = (const FreeBSDProcessList*) this->pl;
unsigned int cpus = this->pl->cpuCount;
unsigned int cpus = this->pl->activeCPUs;
const CPUData* cpuData;
if (cpus == 1) {

44
linux/LibSensors.c
View File

@ -32,10 +32,10 @@ static void* dlopenHandle = NULL;
#endif /* BUILD_STATIC */
int LibSensors_init(FILE* input) {
int LibSensors_init(void) {
#ifdef BUILD_STATIC
return sym_sensors_init(input);
return sym_sensors_init(NULL);
#else
@ -69,7 +69,7 @@ int LibSensors_init(FILE* input) {
#undef resolve
}
return sym_sensors_init(input);
return sym_sensors_init(NULL);
dlfailure:
@ -99,6 +99,18 @@ void LibSensors_cleanup(void) {
#endif /* BUILD_STATIC */
}
int LibSensors_reload(void) {
#ifndef BUILD_STATIC
if (!dlopenHandle) {
errno = ENOTSUP;
return -1;
}
#endif /* !BUILD_STATIC */
sym_sensors_cleanup();
return sym_sensors_init(NULL);
}
static int tempDriverPriority(const sensors_chip_name* chip) {
static const struct TempDriverDefs {
const char* prefix;
@ -120,10 +132,10 @@ static int tempDriverPriority(const sensors_chip_name* chip) {
return -1;
}
void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount) {
assert(cpuCount > 0 && cpuCount < 16384);
double data[cpuCount + 1];
for (size_t i = 0; i < cpuCount + 1; i++)
void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int existingCPUs, unsigned int activeCPUs) {
assert(existingCPUs > 0 && existingCPUs < 16384);
double data[existingCPUs + 1];
for (size_t i = 0; i < existingCPUs + 1; i++)
data[i] = NAN;
#ifndef BUILD_STATIC
@ -145,7 +157,7 @@ void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount) {
if (priority < topPriority) {
/* Clear data from lower priority sensor */
for (size_t i = 0; i < cpuCount + 1; i++)
for (size_t i = 0; i < existingCPUs + 1; i++)
data[i] = NAN;
}
@ -166,7 +178,7 @@ void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount) {
/* Feature name IDs start at 1, adjust to start at 0 to match data indices */
tempID--;
if (tempID > cpuCount)
if (tempID > existingCPUs)
continue;
const sensors_subfeature* subFeature = sym_sensors_get_subfeature(chip, feature, SENSORS_SUBFEATURE_TEMP_INPUT);
@ -190,8 +202,8 @@ void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount) {
}
/* Adjust data for chips not providing a platform temperature */
if (coreTempCount + 1 == cpuCount || coreTempCount + 1 == cpuCount / 2) {
memmove(&data[1], &data[0], cpuCount * sizeof(*data));
if (coreTempCount + 1 == activeCPUs || coreTempCount + 1 == activeCPUs / 2) {
memmove(&data[1], &data[0], existingCPUs * sizeof(*data));
data[0] = NAN;
coreTempCount++;
@ -200,7 +212,7 @@ void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount) {
/* Only package temperature - copy to all cores */
if (coreTempCount == 0 && !isnan(data[0])) {
for (unsigned int i = 1; i <= cpuCount; i++)
for (unsigned int i = 1; i <= existingCPUs; i++)
data[i] = data[0];
/* No further adjustments */
@ -210,7 +222,7 @@ void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount) {
/* No package temperature - set to max core temperature */
if (isnan(data[0]) && coreTempCount != 0) {
double maxTemp = NAN;
for (unsigned int i = 1; i <= cpuCount; i++) {
for (unsigned int i = 1; i <= existingCPUs; i++) {
if (isnan(data[i]))
continue;
@ -224,7 +236,7 @@ void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount) {
/* Only temperature for core 0, maybe Ryzen - copy to all other cores */
if (coreTempCount == 1 && !isnan(data[1])) {
for (unsigned int i = 2; i <= cpuCount; i++)
for (unsigned int i = 2; i <= existingCPUs; i++)
data[i] = data[1];
/* No further adjustments */
@ -232,7 +244,7 @@ void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount) {
}
/* Half the temperatures, probably HT/SMT - copy to second half */
const unsigned int delta = cpuCount / 2;
const unsigned int delta = activeCPUs / 2;
if (coreTempCount == delta) {
memcpy(&data[delta + 1], &data[1], delta * sizeof(*data));
@ -241,7 +253,7 @@ void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount) {
}
out:
for (unsigned int i = 0; i <= cpuCount; i++)
for (unsigned int i = 0; i <= existingCPUs; i++)
cpus[i].temperature = data[i];
}

5
linux/LibSensors.h
View File

@ -8,9 +8,10 @@
#include "linux/LinuxProcessList.h"
int LibSensors_init(FILE* input);
int LibSensors_init(void);
void LibSensors_cleanup(void);
int LibSensors_reload(void);
void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int cpuCount);
void LibSensors_getCPUTemperatures(CPUData* cpus, unsigned int existingCPUs, unsigned int activeCPUs);
#endif /* HEADER_LibSensors */

170
linux/LinuxProcessList.c
View File

@ -158,30 +158,85 @@ static void LinuxProcessList_initNetlinkSocket(LinuxProcessList* this) {
#endif
static void LinuxProcessList_updateCPUcount(ProcessList* super, FILE* stream) {
static void LinuxProcessList_updateCPUcount(ProcessList* super) {
/* Similiar to get_nprocs_conf(3) / _SC_NPROCESSORS_CONF
* https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/getsysstats.c;hb=HEAD
*/
LinuxProcessList* this = (LinuxProcessList*) super;
unsigned int existing = 0, active = 0;
unsigned int cpus = 0;
char buffer[PROC_LINE_LENGTH + 1];
while (fgets(buffer, sizeof(buffer), stream)) {
if (String_startsWith(buffer, "cpu")) {
cpus++;
}
DIR* dir = opendir("/sys/devices/system/cpu");
if (!dir) {
super->activeCPUs = 1;
super->existingCPUs = 1;
this->cpuData = xReallocArray(this->cpuData, 2, sizeof(CPUData));
this->cpuData[0].online = true;
this->cpuData[1].online = true;
return;
}
if (cpus == 0)
CRT_fatalError("No cpu entry in " PROCSTATFILE);
if (cpus == 1)
CRT_fatalError("No cpu aggregate or cpuN entry in " PROCSTATFILE);
unsigned int currExisting = super->existingCPUs;
/* Subtract aggregate cpu entry */
cpus--;
const struct dirent* entry;
while ((entry = readdir(dir)) != NULL) {
if (entry->d_type != DT_DIR)
continue;
if (cpus != super->cpuCount || !this->cpus) {
super->cpuCount = MAXIMUM(cpus, 1);
free(this->cpus);
this->cpus = xCalloc(cpus + 1, sizeof(CPUData));
if (!String_startsWith(entry->d_name, "cpu"))
continue;
char *endp;
unsigned long int id = strtoul(entry->d_name + 3, &endp, 10);
if (id == ULONG_MAX || endp == entry->d_name + 3 || *endp != '\0')
continue;
#ifdef HAVE_OPENAT
int cpuDirFd = openat(dirfd(dir), entry->d_name, O_DIRECTORY | O_PATH | O_NOFOLLOW);
if (cpuDirFd < 0)
continue;
#else
char cpuDirFd[4096];
xSnprintf(cpuDirFd, sizeof(cpuDirFd), "/sys/devices/system/cpu/%s", entry->d_name);
#endif
existing++;
/* readdir() iterates with no specific order */
unsigned int max = MAXIMUM(existing, id + 1);
if (max > currExisting) {
this->cpuData = xReallocArray(this->cpuData, max + /* aggregate */ 1, sizeof(CPUData));
for (unsigned int j = currExisting; j < max; j++) {
this->cpuData[j].online = false;
}
currExisting = max;
}
char buffer[8];
ssize_t res = xReadfileat(cpuDirFd, "online", buffer, sizeof(buffer));
/* If the file "online" does not exist or on failure count as active */
if (res < 1 || buffer[0] != '0') {
active++;
this->cpuData[id + 1].online = true;
} else {
this->cpuData[id + 1].online = false;
}
Compat_openatArgClose(cpuDirFd);
}
closedir(dir);
#ifdef HAVE_SENSORS_SENSORS_H
/* When started with offline CPUs, libsensors does not monitor those,
* even when they become online. */
if (super->existingCPUs != 0 && (active > super->activeCPUs || currExisting > super->existingCPUs))
LibSensors_reload();
#endif
super->activeCPUs = active;
assert(existing == currExisting);
super->existingCPUs = currExisting;
}
ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, Hashtable* pidMatchList, uid_t userId) {
@ -220,15 +275,13 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
CRT_fatalError("Failed to parse btime from " PROCSTATFILE);
}
fclose(statfile);
if (btime == -1)
CRT_fatalError("No btime in " PROCSTATFILE);
rewind(statfile);
// Initialize CPU count
LinuxProcessList_updateCPUcount(pl, statfile);
fclose(statfile);
LinuxProcessList_updateCPUcount(pl);
return pl;
}
@ -236,7 +289,7 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
void ProcessList_delete(ProcessList* pl) {
LinuxProcessList* this = (LinuxProcessList*) pl;
ProcessList_done(pl);
free(this->cpus);
free(this->cpuData);
if (this->ttyDrivers) {
for (int i = 0; this->ttyDrivers[i].path; i++) {
free(this->ttyDrivers[i].path);
@ -1270,9 +1323,9 @@ static bool LinuxProcessList_recurseProcTree(LinuxProcessList* this, openat_arg_
return false;
}
unsigned int cpus = pl->cpuCount;
bool hideKernelThreads = settings->hideKernelThreads;
bool hideUserlandThreads = settings->hideUserlandThreads;
const unsigned int activeCPUs = pl->activeCPUs;
const bool hideKernelThreads = settings->hideKernelThreads;
const bool hideUserlandThreads = settings->hideUserlandThreads;
while ((entry = readdir(dir)) != NULL) {
const char* name = entry->d_name;
@ -1407,7 +1460,7 @@ static bool LinuxProcessList_recurseProcTree(LinuxProcessList* this, openat_arg_
/* period might be 0 after system sleep */
float percent_cpu = (period < 1E-6) ? 0.0F : ((lp->utime + lp->stime - lasttimes) / period * 100.0);
proc->percent_cpu = CLAMP(percent_cpu, 0.0F, cpus * 100.0F);
proc->percent_cpu = CLAMP(percent_cpu, 0.0F, activeCPUs * 100.0F);
proc->percent_mem = proc->m_resident / (double)(pl->totalMem) * 100.0;
if (! LinuxProcessList_updateUser(pl, proc, procFd))
@ -1771,33 +1824,50 @@ static inline void LinuxProcessList_scanZfsArcstats(LinuxProcessList* lpl) {
static inline double LinuxProcessList_scanCPUTime(ProcessList* super) {
LinuxProcessList* this = (LinuxProcessList*) super;
LinuxProcessList_updateCPUcount(super);
FILE* file = fopen(PROCSTATFILE, "r");
if (!file)
CRT_fatalError("Cannot open " PROCSTATFILE);
LinuxProcessList_updateCPUcount(super, file);
unsigned int existingCPUs = super->existingCPUs;
unsigned int lastAdjCpuId = 0;
rewind(file);
unsigned int cpus = super->cpuCount;
for (unsigned int i = 0; i <= cpus; i++) {
for (unsigned int i = 0; i <= existingCPUs; i++) {
char buffer[PROC_LINE_LENGTH + 1];
unsigned long long int usertime, nicetime, systemtime, idletime;
unsigned long long int ioWait = 0, irq = 0, softIrq = 0, steal = 0, guest = 0, guestnice = 0;
// Depending on your kernel version,
// 5, 7, 8 or 9 of these fields will be set.
// The rest will remain at zero.
const char* ok = fgets(buffer, sizeof(buffer), file);
if (!ok)
break;
// cpu fields are sorted first
if (!String_startsWith(buffer, "cpu"))
break;
// Depending on your kernel version,
// 5, 7, 8 or 9 of these fields will be set.
// The rest will remain at zero.
unsigned int adjCpuId;
if (i == 0) {
(void) sscanf(buffer, "cpu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu", &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest, &guestnice);
adjCpuId = 0;
} else {
unsigned int cpuid;
(void) sscanf(buffer, "cpu%4u %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu %16llu", &cpuid, &usertime, &nicetime, &systemtime, &idletime, &ioWait, &irq, &softIrq, &steal, &guest, &guestnice);
assert(cpuid == i - 1);
adjCpuId = cpuid + 1;
}
if (adjCpuId > super->existingCPUs)
break;
for (unsigned int j = lastAdjCpuId + 1; j < adjCpuId; j++) {
// Skipped an ID, but /proc/stat is ordered => got offline CPU
memset(&(this->cpuData[j]), '\0', sizeof(CPUData));
}
lastAdjCpuId = adjCpuId;
// Guest time is already accounted in usertime
usertime -= guest;
nicetime -= guestnice;
@ -1807,7 +1877,7 @@ static inline double LinuxProcessList_scanCPUTime(ProcessList* super) {
unsigned long long int systemalltime = systemtime + irq + softIrq;
unsigned long long int virtalltime = guest + guestnice;
unsigned long long int totaltime = usertime + nicetime + systemalltime + idlealltime + steal + virtalltime;
CPUData* cpuData = &(this->cpus[i]);
CPUData* cpuData = &(this->cpuData[adjCpuId]);
// Since we do a subtraction (usertime - guest) and cputime64_to_clock_t()
// used in /proc/stat rounds down numbers, it can lead to a case where the
// integer overflow.
@ -1837,7 +1907,7 @@ static inline double LinuxProcessList_scanCPUTime(ProcessList* super) {
cpuData->totalTime = totaltime;
}
double period = (double)this->cpus[0].totalPeriod / cpus;
double period = (double)this->cpuData[0].totalPeriod / super->activeCPUs;
char buffer[PROC_LINE_LENGTH + 1];
while (fgets(buffer, sizeof(buffer), file)) {
@ -1853,7 +1923,7 @@ static inline double LinuxProcessList_scanCPUTime(ProcessList* super) {
}
static int scanCPUFreqencyFromSysCPUFreq(LinuxProcessList* this) {
unsigned int cpus = this->super.cpuCount;
unsigned int existingCPUs = this->super.existingCPUs;
int numCPUsWithFrequency = 0;
unsigned long totalFrequency = 0;
@ -1871,7 +1941,7 @@ static int scanCPUFreqencyFromSysCPUFreq(LinuxProcessList* this) {
return -1;
}
for (unsigned int i = 0; i < cpus; ++i) {
for (unsigned int i = 0; i < existingCPUs; ++i) {
char pathBuffer[64];
xSnprintf(pathBuffer, sizeof(pathBuffer), "/sys/devices/system/cpu/cpu%u/cpufreq/scaling_cur_freq", i);
@ -1887,7 +1957,7 @@ static int scanCPUFreqencyFromSysCPUFreq(LinuxProcessList* this) {
if (fscanf(file, "%lu", &frequency) == 1) {
/* convert kHz to MHz */
frequency = frequency / 1000;
this->cpus[i + 1].frequency = frequency;
this->cpuData[i + 1].frequency = frequency;
numCPUsWithFrequency++;
totalFrequency += frequency;
}
@ -1907,7 +1977,7 @@ static int scanCPUFreqencyFromSysCPUFreq(LinuxProcessList* this) {
}
if (numCPUsWithFrequency > 0)
this->cpus[0].frequency = (double)totalFrequency / numCPUsWithFrequency;
this->cpuData[0].frequency = (double)totalFrequency / numCPUsWithFrequency;
return 0;
}
@ -1917,7 +1987,7 @@ static void scanCPUFreqencyFromCPUinfo(LinuxProcessList* this) {
if (file == NULL)
return;
unsigned int cpus = this->super.cpuCount;
unsigned int existingCPUs = this->super.existingCPUs;
int numCPUsWithFrequency = 0;
double totalFrequency = 0;
int cpuid = -1;
@ -1940,11 +2010,11 @@ static void scanCPUFreqencyFromCPUinfo(LinuxProcessList* this) {
(sscanf(buffer, "clock : %lfMHz", &frequency) == 1) ||
(sscanf(buffer, "clock: %lfMHz", &frequency) == 1)
) {
if (cpuid < 0 || (unsigned int)cpuid > (cpus - 1)) {
if (cpuid < 0 || (unsigned int)cpuid > (existingCPUs - 1)) {
continue;
}
CPUData* cpuData = &(this->cpus[cpuid + 1]);
CPUData* cpuData = &(this->cpuData[cpuid + 1]);
/* do not override sysfs data */
if (isnan(cpuData->frequency)) {
cpuData->frequency = frequency;
@ -1958,15 +2028,15 @@ static void scanCPUFreqencyFromCPUinfo(LinuxProcessList* this) {
fclose(file);
if (numCPUsWithFrequency > 0) {
this->cpus[0].frequency = totalFrequency / numCPUsWithFrequency;
this->cpuData[0].frequency = totalFrequency / numCPUsWithFrequency;
}
}
static void LinuxProcessList_scanCPUFrequency(LinuxProcessList* this) {
unsigned int cpus = this->super.cpuCount;
unsigned int existingCPUs = this->super.existingCPUs;
for (unsigned int i = 0; i <= cpus; i++) {
this->cpus[i].frequency = NAN;
for (unsigned int i = 0; i <= existingCPUs; i++) {
this->cpuData[i].frequency = NAN;
}
if (scanCPUFreqencyFromSysCPUFreq(this) == 0) {
@ -1993,7 +2063,7 @@ void ProcessList_goThroughEntries(ProcessList* super, bool pauseProcessUpdate) {
#ifdef HAVE_SENSORS_SENSORS_H
if (settings->showCPUTemperature)
LibSensors_getCPUTemperatures(this->cpus, this->super.cpuCount);
LibSensors_getCPUTemperatures(this->cpuData, this->super.existingCPUs, this->super.activeCPUs);
#endif
// in pause mode only gather global data for meters (CPU/memory/...)

5
linux/LinuxProcessList.h
View File

@ -53,6 +53,8 @@ typedef struct CPUData_ {
#ifdef HAVE_SENSORS_SENSORS_H
double temperature;
#endif
bool online;
} CPUData;
typedef struct TtyDriver_ {
@ -65,7 +67,8 @@ typedef struct TtyDriver_ {
typedef struct LinuxProcessList_ {
ProcessList super;
CPUData* cpus;
CPUData* cpuData;
TtyDriver* ttyDrivers;
bool haveSmapsRollup;

10
linux/Platform.c
View File

@ -246,10 +246,16 @@ int Platform_getMaxPid() {
double Platform_setCPUValues(Meter* this, unsigned int cpu) {
const LinuxProcessList* pl = (const LinuxProcessList*) this->pl;
const CPUData* cpuData = &(pl->cpus[cpu]);
const CPUData* cpuData = &(pl->cpuData[cpu]);
double total = (double) ( cpuData->totalPeriod == 0 ? 1 : cpuData->totalPeriod);
double percent;
double* v = this->values;
if (!cpuData->online) {
this->curItems = 0;
return NAN;
}
v[CPU_METER_NICE] = cpuData->nicePeriod / total * 100.0;
v[CPU_METER_NORMAL] = cpuData->userPeriod / total * 100.0;
if (this->pl->settings->detailedCPUTime) {
@ -1000,7 +1006,7 @@ void Platform_init(void) {
}
#ifdef HAVE_SENSORS_SENSORS_H
LibSensors_init(NULL);
LibSensors_init();
#endif
}

29
openbsd/OpenBSDProcessList.c
View File

@ -42,7 +42,6 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
const int fmib[] = { CTL_KERN, KERN_FSCALE };
int r;
unsigned int cpu_index_c = 0;
unsigned int ncpu;
size_t size;
char errbuf[_POSIX2_LINE_MAX];
@ -50,17 +49,19 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
ProcessList* pl = (ProcessList*) opl;
ProcessList_init(pl, Class(OpenBSDProcess), usersTable, dynamicMeters, pidMatchList, userId);
size = sizeof(pl->cpuCount);
r = sysctl(mib, 2, &pl->cpuCount, &size, NULL, 0);
if (r < 0 || pl->cpuCount < 1) {
pl->cpuCount = 1;
// TODO: test offline CPUs and hot swapping
size = sizeof(pl->activeCPUs);
r = sysctl(mib, 2, &pl->activeCPUs, &size, NULL, 0);
if (r < 0 || pl->activeCPUs < 1) {
pl->activeCPUs = 1;
}
opl->cpus = xCalloc(pl->cpuCount + 1, sizeof(CPUData));
opl->cpus = xCalloc(pl->activeCPUs + 1, sizeof(CPUData));
size = sizeof(int);
r = sysctl(nmib, 2, &ncpu, &size, NULL, 0);
r = sysctl(nmib, 2, &pl->existingCPUs, &size, NULL, 0);
if (r < 0) {
ncpu = pl->cpuCount;
pl->existingCPUs = pl->activeCPUs;
}
size = sizeof(fscale);
@ -72,7 +73,7 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
CRT_fatalError("pagesize sysconf call failed");
pageSizeKB = pageSize / ONE_K;
for (unsigned int i = 0; i <= pl->cpuCount; i++) {
for (unsigned int i = 0; i <= pl->activeCPUs; i++) {
CPUData* d = opl->cpus + i;
d->totalTime = 1;
d->totalPeriod = 1;
@ -85,7 +86,7 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
opl->cpuSpeed = -1;
for (unsigned int i = 0; i < ncpu; i++) {
for (unsigned int i = 0; i < pl->existingCPUs; i++) {
const int ncmib[] = { CTL_KERN, KERN_CPUSTATS, i };
struct cpustats cpu_stats;
@ -98,7 +99,7 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
cpu_index_c++;
}
if (cpu_index_c == pl->cpuCount)
if (cpu_index_c == pl->activeCPUs)
break;
}
@ -312,7 +313,7 @@ static void OpenBSDProcessList_scanProcs(OpenBSDProcessList* this) {
proc->m_virt = kproc->p_vm_dsize * pageSizeKB;
proc->m_resident = kproc->p_vm_rssize * pageSizeKB;
proc->percent_mem = proc->m_resident / (float)this->super.totalMem * 100.0F;
proc->percent_cpu = CLAMP(getpcpu(kproc), 0.0F, this->super.cpuCount * 100.0F);
proc->percent_cpu = CLAMP(getpcpu(kproc), 0.0F, this->super.activeCPUs * 100.0F);
proc->nice = kproc->p_nice - 20;
proc->time = 100 * (kproc->p_rtime_sec + ((kproc->p_rtime_usec + 500000) / 1000000));
proc->priority = kproc->p_priority - PZERO;
@ -400,7 +401,7 @@ static void OpenBSDProcessList_scanCPUTime(OpenBSDProcessList* this) {
u_int64_t kernelTimes[CPUSTATES] = {0};
u_int64_t avg[CPUSTATES] = {0};
for (unsigned int i = 0; i < this->super.cpuCount; i++) {
for (unsigned int i = 0; i < this->super.activeCPUs; i++) {
getKernelCPUTimes(this->cpus[i].cpuIndex, kernelTimes);
CPUData* cpu = this->cpus + i + 1;
kernelCPUTimesToHtop(kernelTimes, cpu);
@ -416,7 +417,7 @@ static void OpenBSDProcessList_scanCPUTime(OpenBSDProcessList* this) {
}
for (int i = 0; i < CPUSTATES; i++) {
avg[i] /= this->super.cpuCount;
avg[i] /= this->super.activeCPUs;
}
kernelCPUTimesToHtop(avg, this->cpus);

18
openbsd/Platform.c
View File

@ -169,11 +169,25 @@ int Platform_getMaxPid() {
double Platform_setCPUValues(Meter* this, unsigned int cpu) {
const OpenBSDProcessList* pl = (const OpenBSDProcessList*) this->pl;
const CPUData* cpuData = &(pl->cpus[cpu]);
double total = cpuData->totalPeriod == 0 ? 1 : cpuData->totalPeriod;
const CPUData* cpuData = NULL;
double total;
double totalPercent;
double* v = this->values;
for (unsigned int i = 0; i < pl->super.activeCPUs; i++) {
if (pl->cpus[i].cpuIndex == cpu) {
cpuData = &(pl->cpus[i]);
break;
}
}
if (!cpuData) {
this->curItems = 0;
return NAN;
}
total = cpuData->totalPeriod == 0 ? 1 : cpuData->totalPeriod;
v[CPU_METER_NICE] = cpuData->nicePeriod / total * 100.0;
v[CPU_METER_NORMAL] = cpuData->userPeriod / total * 100.0;
if (this->pl->settings->detailedCPUTime) {

19
pcp/PCPProcessList.c
View File

@ -33,10 +33,13 @@ static int PCPProcessList_computeCPUcount(void) {
static void PCPProcessList_updateCPUcount(PCPProcessList* this) {
ProcessList* pl = &(this->super);
unsigned int cpus = PCPProcessList_computeCPUcount();
if (cpus == pl->cpuCount)
if (cpus == pl->existingCPUs)
return;
pl->cpuCount = cpus;
pl->existingCPUs = cpus;
// TODO: support offline CPUs and hot swapping
pl->activeCPUs = pl->existingCPUs;
free(this->percpu);
free(this->values);
@ -79,7 +82,7 @@ void ProcessList_delete(ProcessList* pl) {
PCPProcessList* this = (PCPProcessList*) pl;
ProcessList_done(pl);
free(this->values);
for (unsigned int i = 0; i < pl->cpuCount; i++)
for (unsigned int i = 0; i < pl->existingCPUs; i++)
free(this->percpu[i]);
free(this->percpu);
free(this->cpu);
@ -371,7 +374,7 @@ static bool PCPProcessList_updateProcesses(PCPProcessList* this, double period,
float percent_cpu = (pp->utime + pp->stime - lasttimes) / period * 100.0;
proc->percent_cpu = isnan(percent_cpu) ?
0.0 : CLAMP(percent_cpu, 0.0, pl->cpuCount * 100.0);
0.0 : CLAMP(percent_cpu, 0.0, pl->activeCPUs * 100.0);
proc->percent_mem = proc->m_resident / (double)pl->totalMem * 100.0;
PCPProcessList_updateUsername(proc, pid, offset, pl->usersTable);
@ -539,7 +542,7 @@ static void PCPProcessList_updateAllCPUTime(PCPProcessList* this, Metric metric,
static void PCPProcessList_updatePerCPUTime(PCPProcessList* this, Metric metric, CPUMetric cpumetric)
{
int cpus = this->super.cpuCount;
int cpus = this->super.existingCPUs;
if (Metric_values(metric, this->values, cpus, PM_TYPE_U64) == NULL)
memset(this->values, 0, cpus * sizeof(pmAtomValue));
for (int i = 0; i < cpus; i++)
@ -548,7 +551,7 @@ static void PCPProcessList_updatePerCPUTime(PCPProcessList* this, Metric metric,
static void PCPProcessList_updatePerCPUReal(PCPProcessList* this, Metric metric, CPUMetric cpumetric)
{
int cpus = this->super.cpuCount;
int cpus = this->super.existingCPUs;
if (Metric_values(metric, this->values, cpus, PM_TYPE_DOUBLE) == NULL)
memset(this->values, 0, cpus * sizeof(pmAtomValue));
for (int i = 0; i < cpus; i++)
@ -608,7 +611,7 @@ static void PCPProcessList_updateHeader(ProcessList* super, const Settings* sett
PCPProcessList_updateAllCPUTime(this, PCP_CPU_GUEST, CPU_GUEST_TIME);
PCPProcessList_deriveCPUTime(this->cpu);
for (unsigned int i = 0; i < super->cpuCount; i++)
for (unsigned int i = 0; i < super->existingCPUs; i++)
PCPProcessList_backupCPUTime(this->percpu[i]);
PCPProcessList_updatePerCPUTime(this, PCP_PERCPU_USER, CPU_USER_TIME);
PCPProcessList_updatePerCPUTime(this, PCP_PERCPU_NICE, CPU_NICE_TIME);
@ -619,7 +622,7 @@ static void PCPProcessList_updateHeader(ProcessList* super, const Settings* sett
PCPProcessList_updatePerCPUTime(this, PCP_PERCPU_SOFTIRQ, CPU_SOFTIRQ_TIME);
PCPProcessList_updatePerCPUTime(this, PCP_PERCPU_STEAL, CPU_STEAL_TIME);
PCPProcessList_updatePerCPUTime(this, PCP_PERCPU_GUEST, CPU_GUEST_TIME);
for (unsigned int i = 0; i < super->cpuCount; i++)
for (unsigned int i = 0; i < super->existingCPUs; i++)
PCPProcessList_deriveCPUTime(this->percpu[i]);
if (settings->showCPUFrequency)

2
solaris/Platform.c
View File

@ -184,7 +184,7 @@ int Platform_getMaxPid() {
double Platform_setCPUValues(Meter* this, unsigned int cpu) {
const SolarisProcessList* spl = (const SolarisProcessList*) this->pl;
unsigned int cpus = this->pl->cpuCount;
unsigned int cpus = this->pl->activeCPUs;
const CPUData* cpuData = NULL;
if (cpus == 1) {

14
solaris/SolarisProcessList.c
View File

@ -59,20 +59,24 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
CRT_fatalError("Cannot get pagesize by sysconf(_SC_PAGESIZE)");
pageSizeKB = pageSize / 1024;
pl->cpuCount = sysconf(_SC_NPROCESSORS_ONLN);
if (pl->cpuCount == (unsigned int)-1)
pl->activeCPUs = sysconf(_SC_NPROCESSORS_ONLN);
if (pl->activeCPUs == (unsigned int)-1)
CRT_fatalError("Cannot get CPU count by sysconf(_SC_NPROCESSORS_ONLN)");
else if (pl->cpuCount == 1)
else if (pl->activeCPUs == 1)
spl->cpus = xRealloc(spl->cpus, sizeof(CPUData));
else
spl->cpus = xRealloc(spl->cpus, (pl->cpuCount + 1) * sizeof(CPUData));
spl->cpus = xRealloc(spl->cpus, (pl->activeCPUs + 1) * sizeof(CPUData));
/* TODO: support offline CPUs and hot swapping
* pl->existingCPUs = sysconf(_SC_NPROCESSORS_CONF) */
pl->existingCPUs = pl->activeCPUs;
return pl;
}
static inline void SolarisProcessList_scanCPUTime(ProcessList* pl) {
const SolarisProcessList* spl = (SolarisProcessList*) pl;
unsigned int cpus = pl->cpuCount;
unsigned int cpus = pl->existingCPUs;
kstat_t* cpuinfo = NULL;
kstat_named_t* idletime = NULL;
kstat_named_t* intrtime = NULL;

3
unsupported/UnsupportedProcessList.c
View File

@ -18,7 +18,8 @@ ProcessList* ProcessList_new(UsersTable* usersTable, Hashtable* dynamicMeters, H
ProcessList* this = xCalloc(1, sizeof(ProcessList));
ProcessList_init(this, Class(Process), usersTable, dynamicMeters, pidMatchList, userId);
this->cpuCount = 1;
this->existingCPUs = 1;
this->activeCPUs = 1;
return this;
}