fastfetch-cli/fastfetch
1
0
Fork 0
mirror of https://github.com/fastfetch-cli/fastfetch.git synced 2026-10-29 00:03:58 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Chore: run clang-format

Browse Source 
```bash
find . -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" -o -name "*.hpp" \) ! -path "src/3rdparty/*" -print0 | xargs -0 clang-format -i
```
This commit is contained in:
李通洲
2026-03-29 09:28:49 +08:00
parent cdd4cee968
commit e0eba8ce21
690 changed files with 28093 additions and 30062 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/detection/cpuusage/cpuusage.c
+27 -25
View File
@@ -7,50 +7,53 @@
static FFlist cpuTimes1;
static uint64_t startTime;
void ffPrepareCPUUsage(void)
{
if (cpuTimes1.elementSize != 0) return; // Already prepared
void ffPrepareCPUUsage(void) {
if (cpuTimes1.elementSize != 0) {
return; // Already prepared
}
ffListInit(&cpuTimes1, sizeof(FFCpuUsageInfo));
ffGetCpuUsageInfo(&cpuTimes1);
startTime = ffTimeGetNow();
}
const char* ffGetCpuUsageResult(FFCPUUsageOptions* options, FFlist* result)
{
const char* ffGetCpuUsageResult(FFCPUUsageOptions* options, FFlist* result) {
const char* error = NULL;
if(cpuTimes1.elementSize == 0)
{
if (cpuTimes1.elementSize == 0) {
ffListInit(&cpuTimes1, sizeof(FFCpuUsageInfo));
error = ffGetCpuUsageInfo(&cpuTimes1);
if(error) return error;
if (error) {
return error;
}
ffTimeSleep(options->waitTime);
}
else
{
} else {
uint64_t elapsedTime = ffTimeGetNow() - startTime;
if (elapsedTime < options->waitTime)
ffTimeSleep(options->waitTime - (uint32_t)elapsedTime);
if (elapsedTime < options->waitTime) {
ffTimeSleep(options->waitTime - (uint32_t) elapsedTime);
}
}
if(cpuTimes1.length == 0) return "No CPU cores found";
if (cpuTimes1.length == 0) {
return "No CPU cores found";
}
FF_LIST_AUTO_DESTROY cpuTimes2 = ffListCreate(sizeof(FFCpuUsageInfo));
uint32_t retryCount = 0;
retry:
error = ffGetCpuUsageInfo(&cpuTimes2);
if(error) return error;
if(cpuTimes1.length != cpuTimes2.length) return "Unexpected CPU usage result";
if (error) {
return error;
}
if (cpuTimes1.length != cpuTimes2.length) {
return "Unexpected CPU usage result";
}
for (uint32_t i = 0; i < cpuTimes1.length; ++i)
{
for (uint32_t i = 0; i < cpuTimes1.length; ++i) {
FFCpuUsageInfo* cpuTime1 = FF_LIST_GET(FFCpuUsageInfo, cpuTimes1, i);
FFCpuUsageInfo* cpuTime2 = FF_LIST_GET(FFCpuUsageInfo, cpuTimes2, i);
if (cpuTime2->totalAll <= cpuTime1->totalAll)
{
if (++retryCount <= 3)
{
if (cpuTime2->totalAll <= cpuTime1->totalAll) {
if (++retryCount <= 3) {
ffListClear(&cpuTimes2);
ffTimeSleep(options->waitTime);
goto retry;
@@ -59,11 +62,10 @@ retry:
}
}
for (uint32_t i = 0; i < cpuTimes1.length; ++i)
{
for (uint32_t i = 0; i < cpuTimes1.length; ++i) {
FFCpuUsageInfo* cpuTime1 = FF_LIST_GET(FFCpuUsageInfo, cpuTimes1, i);
FFCpuUsageInfo* cpuTime2 = FF_LIST_GET(FFCpuUsageInfo, cpuTimes2, i);
*(double*) ffListAdd(result) = (double)(cpuTime2->inUseAll - cpuTime1->inUseAll) / (double)(cpuTime2->totalAll - cpuTime1->totalAll) * 100;
*(double*) ffListAdd(result) = (double) (cpuTime2->inUseAll - cpuTime1->inUseAll) / (double) (cpuTime2->totalAll - cpuTime1->totalAll) * 100;
cpuTime1->inUseAll = cpuTime2->inUseAll;
cpuTime1->totalAll = cpuTime2->totalAll;
}
src/detection/cpuusage/cpuusage_apple.c
+9 -11
View File
@@ -5,28 +5,26 @@
#include <mach/mach_host.h>
#include <mach/vm_map.h>
const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
{
const char* ffGetCpuUsageInfo(FFlist* cpuTimes) {
natural_t numCPUs = 0U;
processor_info_array_t cpuInfo;
mach_msg_type_number_t numCpuInfo;
if (host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &numCPUs, &cpuInfo, &numCpuInfo) != KERN_SUCCESS)
if (host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &numCPUs, &cpuInfo, &numCpuInfo) != KERN_SUCCESS) {
return "host_processor_info() failed";
if (numCPUs * CPU_STATE_MAX != numCpuInfo)
}
if (numCPUs * CPU_STATE_MAX != numCpuInfo) {
return "Unexpected host_processor_info() result";
}
for (natural_t i = 0U; i < numCPUs; ++i)
{
integer_t inUse = cpuInfo[CPU_STATE_MAX * i + CPU_STATE_USER]
+ cpuInfo[CPU_STATE_MAX * i + CPU_STATE_SYSTEM]
+ cpuInfo[CPU_STATE_MAX * i + CPU_STATE_NICE];
for (natural_t i = 0U; i < numCPUs; ++i) {
integer_t inUse = cpuInfo[CPU_STATE_MAX * i + CPU_STATE_USER] + cpuInfo[CPU_STATE_MAX * i + CPU_STATE_SYSTEM] + cpuInfo[CPU_STATE_MAX * i + CPU_STATE_NICE];
integer_t total = inUse + cpuInfo[CPU_STATE_MAX * i + CPU_STATE_IDLE];
FFCpuUsageInfo* info = (FFCpuUsageInfo*) ffListAdd(cpuTimes);
*info = (FFCpuUsageInfo) {
.inUseAll = (uint64_t)inUse,
.totalAll = (uint64_t)total,
.inUseAll = (uint64_t) inUse,
.totalAll = (uint64_t) total,
};
}
src/detection/cpuusage/cpuusage_bsd.c
+17 -15
View File
@@ -7,23 +7,24 @@
#include <stdlib.h>
#if __OpenBSD__ || __NetBSD__
#include <sys/sched.h>
# include <sys/sched.h>
#endif
const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
{
const char* ffGetCpuUsageInfo(FFlist* cpuTimes) {
size_t neededLength = 0;
#if __OpenBSD__|| __NetBSD__
#ifdef KERN_CPTIME
int ctls[] = {CTL_KERN, KERN_CPTIME};
#else
int ctls[] = {CTL_KERN, KERN_CP_TIME};
#endif
if (sysctl(ctls, 2, NULL, &neededLength, NULL, 0) != 0)
#if __OpenBSD__ || __NetBSD__
# ifdef KERN_CPTIME
int ctls[] = {CTL_KERN, KERN_CPTIME};
# else
int ctls[] = {CTL_KERN, KERN_CP_TIME};
# endif
if (sysctl(ctls, 2, NULL, &neededLength, NULL, 0) != 0) {
return "sysctl({CTL_KERN, KERN_CPTIME}, 2, NULL) failed";
}
#else
if(sysctlbyname("kern.cp_times", NULL, &neededLength, NULL, 0) != 0)
if (sysctlbyname("kern.cp_times", NULL, &neededLength, NULL, 0) != 0) {
return "sysctlbyname(kern.cp_times, NULL) failed";
}
#endif
uint32_t coreCount = (uint32_t) (neededLength / (CPUSTATES * sizeof(uint64_t)));
@@ -32,15 +33,16 @@ const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
FF_AUTO_FREE uint64_t (*cpTimes)[CPUSTATES] = malloc(neededLength);
#if __OpenBSD__ || __NetBSD__
if (sysctl(ctls, 2, cpTimes, &neededLength, NULL, 0) != 0)
if (sysctl(ctls, 2, cpTimes, &neededLength, NULL, 0) != 0) {
return "sysctl({CTL_KERN, KERN_CPTIME}, 2, NULL) failed";
}
#else
if(sysctlbyname("kern.cp_times", cpTimes, &neededLength, NULL, 0) != 0)
if (sysctlbyname("kern.cp_times", cpTimes, &neededLength, NULL, 0) != 0) {
return "sysctlbyname(kern.cp_times, cpTime) failed";
}
#endif
for (uint32_t i = 0; i < coreCount; ++i)
{
for (uint32_t i = 0; i < coreCount; ++i) {
uint64_t* cpTime = cpTimes[i];
uint64_t inUse = cpTime[CP_USER] + cpTime[CP_NICE] + cpTime[CP_SYS] + cpTime[CP_INTR];
uint64_t total = inUse + cpTime[CP_IDLE];
src/detection/cpuusage/cpuusage_haiku.c
+6 -6
View File
@@ -4,20 +4,20 @@
#include <OS.h>
const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
{
const char* ffGetCpuUsageInfo(FFlist* cpuTimes) {
system_info sysInfo;
if (get_system_info(&sysInfo) != B_OK)
if (get_system_info(&sysInfo) != B_OK) {
return "get_system_info() failed";
}
FF_AUTO_FREE cpu_info* cpuInfo = malloc(sizeof(*cpuInfo) * sysInfo.cpu_count);
if (get_cpu_info(0, sysInfo.cpu_count, cpuInfo) != B_OK)
if (get_cpu_info(0, sysInfo.cpu_count, cpuInfo) != B_OK) {
return "get_cpu_info() failed";
}
uint64_t uptime = (uint64_t) system_time();
for (uint32_t i = 0; i < sysInfo.cpu_count; ++i)
{
for (uint32_t i = 0; i < sysInfo.cpu_count; ++i) {
FFCpuUsageInfo* info = (FFCpuUsageInfo*) ffListAdd(cpuTimes);
info->inUseAll = (uint64_t) cpuInfo[i].active_time;
info->totalAll = uptime;
src/detection/cpuusage/cpuusage_linux.c
+13 -16
View File
@@ -5,32 +5,29 @@
#include <stdio.h>
#include <inttypes.h>
const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
{
const char* ffGetCpuUsageInfo(FFlist* cpuTimes) {
char buf[PROC_FILE_BUFFSIZ];
ssize_t nRead = ffReadFileData("/proc/stat", ARRAY_SIZE(buf) - 1, buf);
if(nRead < 0)
{
#ifdef __ANDROID__
if (nRead < 0) {
#ifdef __ANDROID__
return "Accessing \"/proc/stat\" is restricted on Android O+";
#else
#else
return "ffReadFileData(\"/proc/stat\", ARRAY_SIZE(buf) - 1, buf) failed";
#endif
#endif
}
buf[nRead] = '\0';
// Skip first line
char *start = NULL;
if((start = strchr(buf, '\n')) == NULL)
char* start = NULL;
if ((start = strchr(buf, '\n')) == NULL) {
return "skip first line failed";
}
++start;
uint64_t user = 0, nice = 0, system = 0, idle = 0, iowait = 0, irq = 0, softirq = 0;
char *token = NULL;
while ((token = strchr(start, '\n')))
{
if(sscanf(start, "cpu%*d%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%*[^\n]\n", &user, &nice, &system, &idle, &iowait, &irq, &softirq) == 7)
{
char* token = NULL;
while ((token = strchr(start, '\n'))) {
if (sscanf(start, "cpu%*d%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%" PRIu64 "%*[^\n]\n", &user, &nice, &system, &idle, &iowait, &irq, &softirq) == 7) {
uint64_t inUse = user + nice + system + irq + softirq;
uint64_t total = inUse + idle + iowait;
@@ -39,9 +36,9 @@ const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
.inUseAll = inUse,
.totalAll = total,
};
}
else
} else {
break;
}
start = token + 1;
}
src/detection/cpuusage/cpuusage_nosupport.c
+1 -2
View File
@@ -1,7 +1,6 @@
#include "fastfetch.h"
#include "detection/cpuusage/cpuusage.h"
const char* ffGetCpuUsageInfo(FF_MAYBE_UNUSED FFlist* cpuTimes)
{
const char* ffGetCpuUsageInfo(FF_MAYBE_UNUSED FFlist* cpuTimes) {
return "Not support on this platform";
}
src/detection/cpuusage/cpuusage_sunos.c
+9 -9
View File
@@ -4,26 +4,26 @@
#include <kstat.h>
#include <sys/sysinfo.h>
static inline void kstatFreeWrap(kstat_ctl_t** pkc)
{
static inline void kstatFreeWrap(kstat_ctl_t** pkc) {
assert(pkc);
if (*pkc)
if (*pkc) {
kstat_close(*pkc);
}
}
const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
{
const char* ffGetCpuUsageInfo(FFlist* cpuTimes) {
__attribute__((__cleanup__(kstatFreeWrap))) kstat_ctl_t* kc = kstat_open();
if (!kc)
if (!kc) {
return "kstat_open() failed";
}
for (int i = 0;; ++i)
{
for (int i = 0;; ++i) {
kstat_t* ks = kstat_lookup(kc, "cpu_stat", i, NULL);
cpu_stat_t cs;
if (!ks || kstat_read(kc, ks, &cs) < 0)
if (!ks || kstat_read(kc, ks, &cs) < 0) {
break;
}
uint64_t inUse = cs.cpu_sysinfo.cpu[CPU_USER] + cs.cpu_sysinfo.cpu[CPU_KERNEL];
uint64_t total = inUse + cs.cpu_sysinfo.cpu[CPU_IDLE] + cs.cpu_sysinfo.cpu[CPU_WAIT];
src/detection/cpuusage/cpuusage_windows.c
+57 -58
View File
@@ -8,25 +8,25 @@
#include "common/windows/perflib_.h"
#include "common/windows/nt.h"
static const char* getInfoByNqsi(FFlist* cpuTimes)
{
static const char* getInfoByNqsi(FFlist* cpuTimes) {
ULONG size = 0;
if(NtQuerySystemInformation(SystemProcessorPerformanceInformation, NULL, 0, &size) != STATUS_INFO_LENGTH_MISMATCH)
if (NtQuerySystemInformation(SystemProcessorPerformanceInformation, NULL, 0, &size) != STATUS_INFO_LENGTH_MISMATCH) {
return "NtQuerySystemInformation(SystemProcessorPerformanceInformation, NULL) failed";
}
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* FF_AUTO_FREE pinfo = (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION*)malloc(size);
if(!NT_SUCCESS(NtQuerySystemInformation(SystemProcessorPerformanceInformation, pinfo, size, &size)))
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* FF_AUTO_FREE pinfo = (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION*) malloc(size);
if (!NT_SUCCESS(NtQuerySystemInformation(SystemProcessorPerformanceInformation, pinfo, size, &size))) {
return "NtQuerySystemInformation(SystemProcessorPerformanceInformation, size) failed";
}
for (uint32_t i = 0; i < size / sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION); ++i)
{
for (uint32_t i = 0; i < size / sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION); ++i) {
SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION* coreInfo = pinfo + i;
// KernelTime includes IdleTime and DpcTime.
coreInfo->KernelTime.QuadPart -= coreInfo->IdleTime.QuadPart;
uint64_t inUse = (uint64_t) (coreInfo->UserTime.QuadPart + coreInfo->KernelTime.QuadPart);
uint64_t total = inUse + (uint64_t)coreInfo->IdleTime.QuadPart;
uint64_t total = inUse + (uint64_t) coreInfo->IdleTime.QuadPart;
FFCpuUsageInfo* info = (FFCpuUsageInfo*) ffListAdd(cpuTimes);
*info = (FFCpuUsageInfo) {
@@ -38,21 +38,18 @@ static const char* getInfoByNqsi(FFlist* cpuTimes)
return NULL;
}
static const char* getInfoByPerflib(FFlist* cpuTimes)
{
static const char* getInfoByPerflib(FFlist* cpuTimes) {
static HANDLE hQuery = NULL;
if (hQuery == NULL)
{
struct FFPerfQuerySpec
{
if (hQuery == NULL) {
struct FFPerfQuerySpec {
PERF_COUNTER_IDENTIFIER Identifier;
WCHAR Name[16];
} querySpec = {
.Identifier = {
// Processor Information GUID
// HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\_V2Providers\{383487a6-3676-4870-a4e7-d45b30c35629}\{b4fc721a-0378-476f-89ba-a5a79f810b36}
.CounterSetGuid = { 0xb4fc721a, 0x0378, 0x476f, {0x89, 0xba, 0xa5, 0xa7, 0x9f, 0x81, 0x0b, 0x36} },
.CounterSetGuid = {0xb4fc721a, 0x0378, 0x476f, {0x89, 0xba, 0xa5, 0xa7, 0x9f, 0x81, 0x0b, 0x36}},
.Size = sizeof(querySpec),
.CounterId = PERF_WILDCARD_COUNTER, // https://learn.microsoft.com/en-us/windows/win32/perfctrs/using-the-perflib-functions-to-consume-counter-data
.InstanceId = PERF_WILDCARD_COUNTER,
@@ -60,84 +57,86 @@ static const char* getInfoByPerflib(FFlist* cpuTimes)
.Name = PERF_WILDCARD_INSTANCE,
};
if (PerfOpenQueryHandle(NULL, &hQuery) != ERROR_SUCCESS)
{
if (PerfOpenQueryHandle(NULL, &hQuery) != ERROR_SUCCESS) {
PerfCloseQueryHandle(hQuery);
hQuery = INVALID_HANDLE_VALUE;
return "PerfOpenQueryHandle() failed";
}
if (PerfAddCounters(hQuery, &querySpec.Identifier, sizeof(querySpec)) != ERROR_SUCCESS)
{
if (PerfAddCounters(hQuery, &querySpec.Identifier, sizeof(querySpec)) != ERROR_SUCCESS) {
PerfCloseQueryHandle(hQuery);
hQuery = INVALID_HANDLE_VALUE;
return "PerfAddCounters() failed";
}
if (querySpec.Identifier.Status != ERROR_SUCCESS)
{
if (querySpec.Identifier.Status != ERROR_SUCCESS) {
PerfCloseQueryHandle(hQuery);
hQuery = INVALID_HANDLE_VALUE;
return "PerfAddCounters() reports invalid identifier";
}
}
if (hQuery == INVALID_HANDLE_VALUE)
if (hQuery == INVALID_HANDLE_VALUE) {
return "Init hQuery failed";
}
DWORD dataSize = 0;
if (PerfQueryCounterData(hQuery, NULL, 0, &dataSize) != ERROR_NOT_ENOUGH_MEMORY)
if (PerfQueryCounterData(hQuery, NULL, 0, &dataSize) != ERROR_NOT_ENOUGH_MEMORY) {
return "PerfQueryCounterData(NULL) failed";
}
if (dataSize <= sizeof(PERF_DATA_HEADER) + sizeof(PERF_COUNTER_HEADER))
if (dataSize <= sizeof(PERF_DATA_HEADER) + sizeof(PERF_COUNTER_HEADER)) {
return "instance doesn't exist";
}
FF_AUTO_FREE PERF_DATA_HEADER* const pDataHeader = (PERF_DATA_HEADER*)malloc(dataSize);
if (PerfQueryCounterData(hQuery, pDataHeader, dataSize, &dataSize) != ERROR_SUCCESS)
FF_AUTO_FREE PERF_DATA_HEADER* const pDataHeader = (PERF_DATA_HEADER*) malloc(dataSize);
if (PerfQueryCounterData(hQuery, pDataHeader, dataSize, &dataSize) != ERROR_SUCCESS) {
return "PerfQueryCounterData(pDataHeader) failed";
}
PERF_COUNTER_HEADER* pCounterHeader = (PERF_COUNTER_HEADER*)(pDataHeader + 1);
if (pCounterHeader->dwType != PERF_COUNTERSET)
PERF_COUNTER_HEADER* pCounterHeader = (PERF_COUNTER_HEADER*) (pDataHeader + 1);
if (pCounterHeader->dwType != PERF_COUNTERSET) {
return "Invalid counter type";
}
PERF_MULTI_COUNTERS* pMultiCounters = (PERF_MULTI_COUNTERS*)(pCounterHeader + 1);
if (pMultiCounters->dwCounters == 0)
PERF_MULTI_COUNTERS* pMultiCounters = (PERF_MULTI_COUNTERS*) (pCounterHeader + 1);
if (pMultiCounters->dwCounters == 0) {
return "No CPU counters found";
}
PERF_MULTI_INSTANCES* pMultiInstances = (PERF_MULTI_INSTANCES*)((BYTE*)pMultiCounters + pMultiCounters->dwSize);
if (pMultiInstances->dwInstances == 0)
PERF_MULTI_INSTANCES* pMultiInstances = (PERF_MULTI_INSTANCES*) ((BYTE*) pMultiCounters + pMultiCounters->dwSize);
if (pMultiInstances->dwInstances == 0) {
return "No CPU instances found";
}
PERF_INSTANCE_HEADER* pInstanceHeader = (PERF_INSTANCE_HEADER*)(pMultiInstances + 1);
for (DWORD iInstance = 0; iInstance < pMultiInstances->dwInstances; ++iInstance)
{
const wchar_t* instanceName = (const wchar_t*)((BYTE*)pInstanceHeader + sizeof(*pInstanceHeader));
PERF_INSTANCE_HEADER* pInstanceHeader = (PERF_INSTANCE_HEADER*) (pMultiInstances + 1);
for (DWORD iInstance = 0; iInstance < pMultiInstances->dwInstances; ++iInstance) {
const wchar_t* instanceName = (const wchar_t*) ((BYTE*) pInstanceHeader + sizeof(*pInstanceHeader));
PERF_COUNTER_DATA* pCounterData = (PERF_COUNTER_DATA*)((BYTE*)pInstanceHeader + pInstanceHeader->Size);
PERF_COUNTER_DATA* pCounterData = (PERF_COUNTER_DATA*) ((BYTE*) pInstanceHeader + pInstanceHeader->Size);
uint64_t processorUtility = UINT64_MAX, utilityBase = UINT64_MAX;
for (ULONG iCounter = 0; iCounter != pMultiCounters->dwCounters; iCounter++)
{
DWORD* pCounterIds = (DWORD*)(pMultiCounters + 1);
for (ULONG iCounter = 0; iCounter != pMultiCounters->dwCounters; iCounter++) {
DWORD* pCounterIds = (DWORD*) (pMultiCounters + 1);
// https://learn.microsoft.com/en-us/windows/win32/perfctrs/using-the-perflib-functions-to-consume-counter-data
switch (pCounterIds[iCounter]) {
case 26: // % Processor Utility (#26, Type=PERF_AVERAGE_BULK)
assert(pCounterData->dwDataSize == sizeof(uint64_t));
processorUtility = *(uint64_t*)(pCounterData + 1);
break;
case 27: // % Utility Base (#27, Type=PERF_AVERAGE_BASE)
assert(pCounterData->dwDataSize == sizeof(uint32_t));
utilityBase = *(uint32_t*)(pCounterData + 1) * 100LLU;
break;
case 26: // % Processor Utility (#26, Type=PERF_AVERAGE_BULK)
assert(pCounterData->dwDataSize == sizeof(uint64_t));
processorUtility = *(uint64_t*) (pCounterData + 1);
break;
case 27: // % Utility Base (#27, Type=PERF_AVERAGE_BASE)
assert(pCounterData->dwDataSize == sizeof(uint32_t));
utilityBase = *(uint32_t*) (pCounterData + 1) * 100LLU;
break;
}
pCounterData = (PERF_COUNTER_DATA*)((BYTE*)pCounterData + pCounterData->dwSize);
pCounterData = (PERF_COUNTER_DATA*) ((BYTE*) pCounterData + pCounterData->dwSize);
}
if (wcschr(instanceName, L'_') == NULL /* ignore `_Total` */)
{
if (processorUtility == UINT64_MAX)
if (wcschr(instanceName, L'_') == NULL /* ignore `_Total` */) {
if (processorUtility == UINT64_MAX) {
return "Counter \"% Processor Utility\" are not supported";
}
FFCpuUsageInfo* info = (FFCpuUsageInfo*) ffListAdd(cpuTimes);
*info = (FFCpuUsageInfo) {
@@ -146,21 +145,21 @@ static const char* getInfoByPerflib(FFlist* cpuTimes)
};
}
pInstanceHeader = (PERF_INSTANCE_HEADER*)pCounterData;
pInstanceHeader = (PERF_INSTANCE_HEADER*) pCounterData;
}
return NULL;
}
const char* ffGetCpuUsageInfo(FFlist* cpuTimes)
{
const char* ffGetCpuUsageInfo(FFlist* cpuTimes) {
const char* error = NULL;
if (ffIsWindows10OrGreater())
{
if (ffIsWindows10OrGreater()) {
error = getInfoByPerflib(cpuTimes);
FF_DEBUG("Get CPU usage info by Perflib: %s", error ?: "success");
if (!error) return NULL;
if (!error) {
return NULL;
}
ffListClear(cpuTimes);
}