Separate cpu detection and printing logic

src/detection/cpu/cpu.c

@@ -0,0 +1,22 @@
+#include "cpu.h"
+#include "detection/internal.h"
+
+void ffDetectCPUImpl(FFCPUResult* cpu);
+
+const FFCPUResult* ffDetectCPU()
+{
+    FF_DETECTION_INTERNAL_GUARD(FFCPUResult,
+        ffDetectCPUImpl(&result);
+
+        const char* removeStrings[] = {
+            "(R)", "(r)", "(TM)", "(tm)",
+            " CPU", " FPU", " APU", " Processor",
+            " Dual-Core", " Quad-Core", " Six-Core", " Eight-Core", " Ten-Core",
+            " 2-Core", " 4-Core", " 6-Core", " 8-Core", " 10-Core", " 12-Core", " 14-Core", " 16-Core",
+            " with Radeon Graphics"
+        };
+        ffStrbufRemoveStringsA(&result.name, sizeof(removeStrings) / sizeof(removeStrings[0]), removeStrings);
+        ffStrbufSubstrBeforeFirstC(&result.name, '@'); //Cut the speed output in the name as we append our own
+        ffStrbufTrimRight(&result.name, ' '); //If we removed the @ in previous step there was most likely a space before it
+    );
+}

src/detection/cpu/cpu.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_cpu_cpu
+#define FF_INCLUDED_detection_cpu_cpu
+
+#include "fastfetch.h"
+
+#define FF_CPU_TEMP_UNSET (0/0.0)
+
+typedef struct FFCPUResult
+{
+    FFstrbuf name;
+    FFstrbuf vendor;
+
+    uint16_t coresPhysical;
+    uint16_t coresLogical;
+    uint16_t coresOnline;
+
+    double frequencyMin;
+    double frequencyMax;
+
+    double temperature;
+} FFCPUResult;
+
+const FFCPUResult* ffDetectCPU();
+
+#endif

src/detection/cpu/cpu_apple.c

@@ -0,0 +1,17 @@
+#include "cpu.h"
+
+void ffDetectCPUImpl(FFCPUResult* cpu)
+{
+    ffStrbufInit(&cpu->name);
+    ffStrbufInit(&cpu->vendor);
+
+    cpu->coresPhysical = 0;
+    cpu->coresLogical = 0;
+    cpu->coresOnline = 0;
+
+    cpu->frequencyCurrent = 0.0;
+    cpu->frequencyMin = 0.0;
+    cpu->frequencyMax = 0.0;
+
+    cpu->temperature = FF_CPU_TEMP_UNKNOWN;
+}

src/detection/cpu/cpu_linux.c

@@ -0,0 +1,102 @@
+#include "cpu.h"
+#include "common/io.h"
+#include "common/properties.h"
+#include "detection/temps.h"
+
+#include <stdlib.h>
+#include <unistd.h>
+
+static void parseCpuInfo(FFCPUResult* cpu, FFstrbuf* physicalCoresBuffer)
+{
+    FILE* cpuinfo = fopen("/proc/cpuinfo", "r");
+    if(cpuinfo == NULL)
+        return;
+
+    char* line = NULL;
+    size_t len = 0;
+
+    while(getline(&line, &len, cpuinfo) != -1)
+    {
+        //Stop after the first CPU
+        if(cpu->name.length > 0 && (*line == '\0' || *line == '\n'))
+            break;
+
+        (void)(
+            ffParsePropLine(line, "model name :", &cpu->name) ||
+            ffParsePropLine(line, "vendor_id :", &cpu->vendor) ||
+            ffParsePropLine(line, "cpu cores :", physicalCoresBuffer) ||
+            (cpu->name.length == 0 && ffParsePropLine(line, "Hardware :", &cpu->name)) //For Android devices
+        );
+    }
+
+    if(line != NULL)
+        free(line);
+
+    fclose(cpuinfo);
+}
+
+static double getGHz(const char* file)
+{
+    FFstrbuf content;
+    ffStrbufInit(&content);
+    ffReadFileBuffer(file, &content);
+    double herz = ffStrbufToDouble(&content);
+    ffStrbufDestroy(&content);
+
+    //ffStrbufToDouble failed
+    if(herz != herz)
+        return 0;
+
+    herz /= 1000.0; //to MHz
+    return herz / 1000.0; //to GHz
+}
+
+static double getFrequency(const char* info, const char* scaling)
+{
+    double frequency = getGHz(info);
+    if(frequency > 0.0)
+        return frequency;
+
+    return getGHz(scaling);
+}
+
+static double detectCPUTemp()
+{
+    const FFTempsResult *temps = ffDetectTemps();
+
+    for(uint32_t i = 0; i < temps->values.length; i++)
+    {
+        FFTempValue* value = ffListGet(&temps->values, i);
+
+        if(
+            ffStrbufFirstIndexS(&value->name, "cpu") < value->name.length ||
+            ffStrbufCompS(&value->name, "k10temp") == 0 ||
+            ffStrbufCompS(&value->name, "coretemp") == 0
+        ) return value->value;
+    }
+
+    return FF_CPU_TEMP_UNSET;
+}
+
+void ffDetectCPUImpl(FFCPUResult* cpu)
+{
+    ffStrbufInit(&cpu->name);
+    ffStrbufInit(&cpu->vendor);
+
+    FFstrbuf physicalCoresBuffer;
+    ffStrbufInit(&physicalCoresBuffer);
+
+    parseCpuInfo(cpu, &physicalCoresBuffer);
+
+    cpu->coresPhysical = ffStrbufToUInt16(&physicalCoresBuffer, 1);
+    cpu->coresLogical = (uint16_t) get_nprocs_conf();
+    cpu->coresOnline = (uint16_t) get_nprocs();
+
+    #define BP "/sys/devices/system/cpu/cpufreq/policy0/"
+    cpu->frequencyMin = getFrequency(BP"cpuinfo_min_freq", BP"scaling_min_freq");
+    cpu->frequencyMax = getFrequency(BP"cpuinfo_max_freq", BP"scaling_max_freq");
+
+    cpu->temperature = detectCPUTemp();
+
+    ffStrbufDestroy(&physicalCoresBuffer);
+}

src/detection/host/host.c

@@ -1,25 +1,11 @@
 #include "host.h"
-
-#include "pthread.h"
+#include "detection/internal.h"
 
 void ffDetectHostImpl(FFHostResult* host);
 
 const FFHostResult* ffDetectHost()
 {
-    static FFHostResult host;
-
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static bool init = false;
-    pthread_mutex_lock(&mutex);
-    if(init)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &host;
-    }
-    init = true;
-
-    ffDetectHostImpl(&host);
-
-    pthread_mutex_unlock(&mutex);
-    return &host;
+    FF_DETECTION_INTERNAL_GUARD(FFHostResult,
+        ffDetectHostImpl(&result)
+    );
 }

src/detection/host/host.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef FF_INCLUDED_DETECTION_HOST_host
-#define FF_INCLUDED_DETECTION_HOST_host
+#ifndef FF_INCLUDED_detection_host_host
+#define FF_INCLUDED_detection_host_host
 
 #include "fastfetch.h"
 

src/detection/internal.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifndef FF_INCLUDED_detection_internal
+#define FF_INCLUDED_detection_internal
+
+#include "pthread.h"
+
+#define FF_DETECTION_INTERNAL_GUARD(ResultType, ...) \
+    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; \
+    static ResultType result; \
+    static bool init = false; \
+    pthread_mutex_lock(&mutex); \
+    if(init) \
+    { \
+        pthread_mutex_unlock(&mutex); \
+        return &result; \
+    } \
+    init = true; \
+    __VA_ARGS__; \
+    pthread_mutex_unlock(&mutex); \
+    return &result; \
+
+#endif

src/detection/os/os.c

@@ -1,24 +1,11 @@
 #include "os.h"
-
-#include <pthread.h>
+#include "detection/internal.h"
 
 void ffDetectOSImpl(FFOSResult* os, const FFinstance* instance);
 
 const FFOSResult* ffDetectOS(const FFinstance* instance)
 {
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-    static FFOSResult result;
-    static bool init = false;
-    pthread_mutex_lock(&mutex);
-    if(init)
-    {
-        pthread_mutex_unlock(&mutex);
-        return &result;
-    }
-    init = true;
-
-    ffDetectOSImpl(&result, instance);
-
-    pthread_mutex_unlock(&mutex);
-    return &result;
+    FF_DETECTION_INTERNAL_GUARD(FFOSResult,
+        ffDetectOSImpl(&result, instance)
+    );
 }

src/detection/os/os.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef FF_INCLUDED_detection_os
-#define FF_INCLUDED_detection_os
+#ifndef FF_INCLUDED_detection_os_os
+#define FF_INCLUDED_detection_os_os
 
 #include "fastfetch.h"