Rename PCPMetric files, structures and related internal functions

Simplify names to just Metric in this case as it is not mirroring
core htop naming (which is the norm for that naming convention).

1 files changed, 44 insertions, 44 deletions

diff --git a/pcp/PCPMachine.c b/pcp/PCPMachine.c
index 726218d9..801f3978 100644
--- a/pcp/PCPMachine.c
+++ b/pcp/PCPMachine.c
@@ -25,13 +25,13 @@ in the source distribution for its full text.
 #include "Settings.h"
 #include "XUtils.h"
 
-#include "pcp/PCPMetric.h"
+#include "pcp/Metric.h"
 #include "pcp/PCPProcess.h"
 
 
 static void PCPMachine_updateCPUcount(PCPMachine* this) {
    Machine* super = &this->super;
-   super->activeCPUs = PCPMetric_instanceCount(PCP_PERCPU_SYSTEM);
+   super->activeCPUs = Metric_instanceCount(PCP_PERCPU_SYSTEM);
    unsigned int cpus = Platform_getMaxCPU();
    if (cpus == super->existingCPUs)
       return;
@@ -58,30 +58,30 @@ static void PCPMachine_updateMemoryInfo(Machine* host) {
    host->usedSwap = host->totalSwap = host->sharedMem = 0;
 
    pmAtomValue value;
-   if (PCPMetric_values(PCP_MEM_TOTAL, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_TOTAL, &value, 1, PM_TYPE_U64) != NULL)
       host->totalMem = value.ull;
-   if (PCPMetric_values(PCP_MEM_FREE, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_FREE, &value, 1, PM_TYPE_U64) != NULL)
       freeMem = value.ull;
-   if (PCPMetric_values(PCP_MEM_BUFFERS, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_BUFFERS, &value, 1, PM_TYPE_U64) != NULL)
       host->buffersMem = value.ull;
-   if (PCPMetric_values(PCP_MEM_SRECLAIM, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_SRECLAIM, &value, 1, PM_TYPE_U64) != NULL)
       sreclaimableMem = value.ull;
-   if (PCPMetric_values(PCP_MEM_SHARED, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_SHARED, &value, 1, PM_TYPE_U64) != NULL)
       host->sharedMem = value.ull;
-   if (PCPMetric_values(PCP_MEM_CACHED, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_CACHED, &value, 1, PM_TYPE_U64) != NULL)
       host->cachedMem = value.ull + sreclaimableMem - host->sharedMem;
    const memory_t usedDiff = freeMem + host->cachedMem + sreclaimableMem + host->buffersMem;
    host->usedMem = (host->totalMem >= usedDiff) ?
            host->totalMem - usedDiff : host->totalMem - freeMem;
-   if (PCPMetric_values(PCP_MEM_AVAILABLE, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_AVAILABLE, &value, 1, PM_TYPE_U64) != NULL)
       host->availableMem = MINIMUM(value.ull, host->totalMem);
    else
       host->availableMem = freeMem;
-   if (PCPMetric_values(PCP_MEM_SWAPFREE, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_SWAPFREE, &value, 1, PM_TYPE_U64) != NULL)
       swapFreeMem = value.ull;
-   if (PCPMetric_values(PCP_MEM_SWAPTOTAL, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_SWAPTOTAL, &value, 1, PM_TYPE_U64) != NULL)
       host->totalSwap = value.ull;
-   if (PCPMetric_values(PCP_MEM_SWAPCACHED, &value, 1, PM_TYPE_U64) != NULL)
+   if (Metric_values(PCP_MEM_SWAPCACHED, &value, 1, PM_TYPE_U64) != NULL)
       host->cachedSwap = value.ull;
    host->usedSwap = host->totalSwap - swapFreeMem - host->cachedSwap;
 }
@@ -153,26 +153,26 @@ static void PCPMachine_deriveCPUTime(pmAtomValue* values) {
    PCPMachine_saveCPUTimePeriod(values, CPU_TOTAL_PERIOD, totaltime);
 }
 
-static void PCPMachine_updateAllCPUTime(PCPMachine* this, PCPMetric metric, CPUMetric cpumetric)
+static void PCPMachine_updateAllCPUTime(PCPMachine* this, Metric metric, CPUMetric cpumetric)
 {
    pmAtomValue* value = &this->cpu[cpumetric];
-   if (PCPMetric_values(metric, value, 1, PM_TYPE_U64) == NULL)
+   if (Metric_values(metric, value, 1, PM_TYPE_U64) == NULL)
       memset(value, 0, sizeof(pmAtomValue));
 }
 
-static void PCPMachine_updatePerCPUTime(PCPMachine* this, PCPMetric metric, CPUMetric cpumetric)
+static void PCPMachine_updatePerCPUTime(PCPMachine* this, Metric metric, CPUMetric cpumetric)
 {
    int cpus = this->super.existingCPUs;
-   if (PCPMetric_values(metric, this->values, cpus, PM_TYPE_U64) == NULL)
+   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++)
       this->percpu[i][cpumetric].ull = this->values[i].ull;
 }
 
-static void PCPMachine_updatePerCPUReal(PCPMachine* this, PCPMetric metric, CPUMetric cpumetric)
+static void PCPMachine_updatePerCPUReal(PCPMachine* this, Metric metric, CPUMetric cpumetric)
 {
    int cpus = this->super.existingCPUs;
-   if (PCPMetric_values(metric, this->values, cpus, PM_TYPE_DOUBLE) == NULL)
+   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++)
       this->percpu[i][cpumetric].d = this->values[i].d;
@@ -185,29 +185,29 @@ static inline void PCPMachine_scanZfsArcstats(PCPMachine* this) {
    pmAtomValue value;
 
    memset(&this->zfs, 0, sizeof(ZfsArcStats));
-   if (PCPMetric_values(PCP_ZFS_ARC_ANON_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_ANON_SIZE, &value, 1, PM_TYPE_U64))
       this->zfs.anon = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_C_MIN, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_C_MIN, &value, 1, PM_TYPE_U64))
       this->zfs.min = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_C_MAX, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_C_MAX, &value, 1, PM_TYPE_U64))
       this->zfs.max = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_BONUS_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_BONUS_SIZE, &value, 1, PM_TYPE_U64))
       bonusSize = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_DBUF_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_DBUF_SIZE, &value, 1, PM_TYPE_U64))
       dbufSize = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_DNODE_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_DNODE_SIZE, &value, 1, PM_TYPE_U64))
       dnodeSize = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_COMPRESSED_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_COMPRESSED_SIZE, &value, 1, PM_TYPE_U64))
       this->zfs.compressed = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_UNCOMPRESSED_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_UNCOMPRESSED_SIZE, &value, 1, PM_TYPE_U64))
       this->zfs.uncompressed = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_HDR_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_HDR_SIZE, &value, 1, PM_TYPE_U64))
       this->zfs.header = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_MFU_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_MFU_SIZE, &value, 1, PM_TYPE_U64))
       this->zfs.MFU = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_MRU_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_MRU_SIZE, &value, 1, PM_TYPE_U64))
       this->zfs.MRU = value.ull / ONE_K;
-   if (PCPMetric_values(PCP_ZFS_ARC_SIZE, &value, 1, PM_TYPE_U64))
+   if (Metric_values(PCP_ZFS_ARC_SIZE, &value, 1, PM_TYPE_U64))
       this->zfs.size = value.ull / ONE_K;
 
    this->zfs.other = (dbufSize + dnodeSize + bonusSize) / ONE_K;
@@ -260,31 +260,31 @@ void Machine_scan(Machine* super) {
    bool flagged;
 
    for (int metric = PCP_PROC_PID; metric < PCP_METRIC_COUNT; metric++)
-      PCPMetric_enable(metric, true);
+      Metric_enable(metric, true);
 
    flagged = settings->showCPUFrequency;
-   PCPMetric_enable(PCP_HINV_CPUCLOCK, flagged);
+   Metric_enable(PCP_HINV_CPUCLOCK, flagged);
    flagged = flags & PROCESS_FLAG_LINUX_CGROUP;
-   PCPMetric_enable(PCP_PROC_CGROUPS, flagged);
+   Metric_enable(PCP_PROC_CGROUPS, flagged);
    flagged = flags & PROCESS_FLAG_LINUX_OOM;
-   PCPMetric_enable(PCP_PROC_OOMSCORE, flagged);
+   Metric_enable(PCP_PROC_OOMSCORE, flagged);
    flagged = flags & PROCESS_FLAG_LINUX_CTXT;
-   PCPMetric_enable(PCP_PROC_VCTXSW, flagged);
-   PCPMetric_enable(PCP_PROC_NVCTXSW, flagged);
+   Metric_enable(PCP_PROC_VCTXSW, flagged);
+   Metric_enable(PCP_PROC_NVCTXSW, flagged);
    flagged = flags & PROCESS_FLAG_LINUX_SECATTR;
-   PCPMetric_enable(PCP_PROC_LABELS, flagged);
+   Metric_enable(PCP_PROC_LABELS, flagged);
    flagged = flags & PROCESS_FLAG_LINUX_AUTOGROUP;
-   PCPMetric_enable(PCP_PROC_AUTOGROUP_ID, flagged);
-   PCPMetric_enable(PCP_PROC_AUTOGROUP_NICE, flagged);
+   Metric_enable(PCP_PROC_AUTOGROUP_ID, flagged);
+   Metric_enable(PCP_PROC_AUTOGROUP_NICE, flagged);
 
    /* Sample smaps metrics on every second pass to improve performance */
    host->smaps_flag = !!host->smaps_flag;
-   PCPMetric_enable(PCP_PROC_SMAPS_PSS, host->smaps_flag);
-   PCPMetric_enable(PCP_PROC_SMAPS_SWAP, host->smaps_flag);
-   PCPMetric_enable(PCP_PROC_SMAPS_SWAPPSS, host->smaps_flag);
+   Metric_enable(PCP_PROC_SMAPS_PSS, host->smaps_flag);
+   Metric_enable(PCP_PROC_SMAPS_SWAP, host->smaps_flag);
+   Metric_enable(PCP_PROC_SMAPS_SWAPPSS, host->smaps_flag);
 
    struct timeval timestamp;
-   if (PCPMetric_fetch(&timestamp) != true)
+   if (Metric_fetch(&timestamp) != true)
       return;
 
    double sample = host->timestamp;
@@ -328,7 +328,7 @@ bool Machine_isCPUonline(const Machine* host, unsigned int id) {
    (void) host;
 
    pmAtomValue value;
-   if (PCPMetric_instance(PCP_PERCPU_SYSTEM, id, id, &value, PM_TYPE_U32))
+   if (Metric_instance(PCP_PERCPU_SYSTEM, id, id, &value, PM_TYPE_U32))
       return true;
    return false;
 }