[v1.05][X86] Hygon logo and uarch detection (#244)

Makefile

@@ -13,23 +13,17 @@ COMMON_HDR = $(SRC_COMMON)ascii.h $(SRC_COMMON)cpu.h $(SRC_COMMON)udev.h $(SRC_C
 ifneq ($(OS),Windows_NT)
 	GIT_VERSION := "$(shell git describe --abbrev=4 --dirty --always --tags)"
 	arch := $(shell uname -m)
-	os := $(shell uname -s)
-
-	ifeq ($(os), Linux)
-		COMMON_SRC += $(SRC_COMMON)freq.c
-		COMMON_HDR += $(SRC_COMMON)freq.h
-	endif
-
 	ifeq ($(arch), $(filter $(arch), x86_64 amd64 i386 i486 i586 i686))
 		SRC_DIR=src/x86/
 		SOURCE += $(COMMON_SRC) $(SRC_DIR)cpuid.c $(SRC_DIR)apic.c $(SRC_DIR)cpuid_asm.c $(SRC_DIR)uarch.c
 		HEADERS += $(COMMON_HDR) $(SRC_DIR)cpuid.h $(SRC_DIR)apic.h $(SRC_DIR)cpuid_asm.h $(SRC_DIR)uarch.h $(SRC_DIR)freq/freq.h
 
-		ifeq ($(os), Linux)
+                os := $(shell uname -s)
+                ifeq ($(os), Linux)
 			SOURCE += $(SRC_DIR)freq/freq.c freq_nov.o freq_avx.o freq_avx512.o
 			HEADERS += $(SRC_DIR)freq/freq.h
 			CFLAGS += -pthread
-		endif
+                endif
 		CFLAGS += -DARCH_X86 -std=c99 -fstack-protector-all
 	else ifeq ($(arch), $(filter $(arch), ppc64le ppc64 ppcle ppc))
 		SRC_DIR=src/ppc/
@@ -38,25 +32,20 @@ ifneq ($(OS),Windows_NT)
 		CFLAGS += -DARCH_PPC -std=gnu99 -fstack-protector-all -Wno-language-extension-token
 	else ifeq ($(arch), $(filter $(arch), arm aarch64_be aarch64 arm64 armv8b armv8l armv7l armv6l))
 		SRC_DIR=src/arm/
-		SOURCE += $(COMMON_SRC) $(SRC_DIR)midr.c $(SRC_DIR)uarch.c $(SRC_COMMON)soc.c $(SRC_DIR)soc.c $(SRC_COMMON)pci.c $(SRC_DIR)udev.c sve.o
+		SOURCE += $(COMMON_SRC) $(SRC_DIR)midr.c $(SRC_DIR)uarch.c $(SRC_COMMON)soc.c $(SRC_DIR)soc.c $(SRC_COMMON)pci.c $(SRC_DIR)udev.c
 		HEADERS += $(COMMON_HDR) $(SRC_DIR)midr.h $(SRC_DIR)uarch.h  $(SRC_COMMON)soc.h $(SRC_DIR)soc.h $(SRC_COMMON)pci.h $(SRC_DIR)udev.c $(SRC_DIR)socs.h
 		CFLAGS += -DARCH_ARM -Wno-unused-parameter -std=c99 -fstack-protector-all
 
-		# Check if the compiler supports -march=armv8-a+sve. We will use it (if supported) to compile SVE detection code later
+		os := $(shell uname -s)
-		is_sve_flag_supported := $(shell $(CC) -march=armv8-a+sve -c $(SRC_DIR)sve.c -o sve_test.o 2> /dev/null && echo 'yes'; rm -f sve_test.o)
-		ifeq ($(is_sve_flag_supported), yes)
-			SVE_FLAGS += -march=armv8-a+sve
-		endif
-
 		ifeq ($(os), Darwin)
-			SOURCE += $(SRC_COMMON)sysctl.c
+			SOURCE += $(SRC_DIR)sysctl.c
-			HEADERS += $(SRC_COMMON)sysctl.h
+			HEADERS += $(SRC_DIR)sysctl.h
 		endif
-	else ifeq ($(arch), $(filter $(arch), riscv64 riscv32))
+        else ifeq ($(arch), $(filter $(arch), riscv64 riscv32))
-		SRC_DIR=src/riscv/
+                SRC_DIR=src/riscv/
-		SOURCE += $(COMMON_SRC) $(SRC_DIR)riscv.c $(SRC_DIR)uarch.c $(SRC_COMMON)soc.c $(SRC_DIR)soc.c $(SRC_DIR)udev.c
+                SOURCE += $(COMMON_SRC) $(SRC_DIR)riscv.c $(SRC_DIR)uarch.c $(SRC_COMMON)soc.c $(SRC_DIR)soc.c $(SRC_DIR)udev.c
-		HEADERS += $(COMMON_HDR) $(SRC_DIR)riscv.h $(SRC_DIR)uarch.h $(SRC_COMMON)soc.h $(SRC_DIR)soc.h $(SRC_DIR)udev.h $(SRC_DIR)socs.h
+                HEADERS += $(COMMON_HDR) $(SRC_DIR)riscv.h $(SRC_DIR)uarch.h $(SRC_COMMON)soc.h $(SRC_DIR)soc.h $(SRC_DIR)udev.h $(SRC_DIR)socs.h
-		CFLAGS += -DARCH_RISCV -Wno-unused-parameter -std=c99 -fstack-protector-all
+                CFLAGS += -DARCH_RISCV -Wno-unused-parameter -std=c99 -fstack-protector-all
 	else
 		# Error lines should not be tabulated because Makefile complains about it
 $(warning Unsupported arch detected: $(arch). See https://github.com/Dr-Noob/cpufetch#1-support)
@@ -97,9 +86,6 @@ freq_avx.o: Makefile $(SRC_DIR)freq/freq_avx.c $(SRC_DIR)freq/freq_avx.h $(SRC_D
 freq_avx512.o: Makefile $(SRC_DIR)freq/freq_avx512.c $(SRC_DIR)freq/freq_avx512.h $(SRC_DIR)freq/freq.h
 	$(CC) $(CFLAGS) $(SANITY_FLAGS) -c -mavx512f -pthread $(SRC_DIR)freq/freq_avx512.c -o $@
 
-sve.o: Makefile $(SRC_DIR)sve.c $(SRC_DIR)sve.h
-	$(CC) $(CFLAGS) $(SANITY_FLAGS) $(SVE_FLAGS) -c $(SRC_DIR)sve.c -o $@
-
 $(OUTPUT): Makefile $(SOURCE) $(HEADERS)
 ifeq ($(GIT_VERSION),"")
 	$(CC) $(CFLAGS) $(SANITY_FLAGS) $(SOURCE) -o $(OUTPUT)

README.md

@@ -45,7 +45,6 @@ cpufetch is a command-line tool written in C that displays the CPU information i
   - [3.1 x86_64](#31-x86_64)
   - [3.2 ARM](#32-arm)
   - [3.3 PowerPC](#33-powerpc)
-  - [3.4 RISC-V](#34-risc-v)
 - [4. Colors](#4-colors)
   - [4.1 Specifying a name](#41-specifying-a-name)
   - [4.2 Specifying the colors in RGB format](#42-specifying-the-colors-in-rgb-format)
@@ -121,11 +120,6 @@ make
 <p align="center"><img width=90% src="pictures/ibm.png"></p>
 <p align="center">Talos II</p>
 
-## 3.4 RISC-V
-
-<p align="center"><img width=80% src="pictures/starfive.png"></p>
-<p align="center">StarFive VisionFive 2</p>
-
 ## 4. Colors
 By default, `cpufetch` will print the CPU logo with the system colorscheme. However, you can set a custom color scheme in two different ways:
 
@@ -181,7 +175,6 @@ Thanks to the fellow contributors and interested people in the project. Special
 - [mdoksa76](https://github.com/mdoksa76) and [exkc](https://github.com/exkc): Excellent ideas and feedback for supporting Allwinner SoCs.
 - [Sakura286](https://github.com/Sakura286), [exkc](https://github.com/exkc) and [Patola](https://github.com/Patola): Helped with RISC-V port with ssh access, ideas, testing, etc.
 - [ThomasKaiser](https://github.com/ThomasKaiser): Very valuable feedback on improving ARM SoC detection (Apple, Allwinner, Rockchip).
-- [zerkerX](https://github.com/zerkerX): Helped with feedback for supporting old (e.g., Pentium III) Intel CPUs.
 
 ## 8. cpufetch for GPUs (gpufetch)
 See [gpufetch](https://github.com/Dr-Noob/gpufetch) project!

src/arm/midr.c

@@ -8,18 +8,15 @@
 #ifdef __linux__
   #include <sys/auxv.h>
   #include <asm/hwcap.h>
-  #include "../common/freq.h"
 #elif defined __APPLE__ || __MACH__
-  #include "../common/sysctl.h"
+  #include "sysctl.h"
 #endif
 
 #include "../common/global.h"
 #include "../common/soc.h"
-#include "../common/args.h"
 #include "udev.h"
 #include "midr.h"
 #include "uarch.h"
-#include "sve.h"
 
 bool cores_are_equal(int c1pos, int c2pos, uint32_t* midr_array, int32_t* freq_array) {
   return midr_array[c1pos] == midr_array[c2pos] && freq_array[c1pos] == freq_array[c2pos];
@@ -42,17 +39,8 @@ struct cache* get_cache_info(struct cpuInfo* cpu) {
 struct frequency* get_frequency_info(uint32_t core) {
   struct frequency* freq = emalloc(sizeof(struct frequency));
 
-  freq->measured = false;
   freq->base = UNKNOWN_DATA;
   freq->max = get_max_freq_from_file(core);
-  #ifdef __linux__
-    if (freq->max == UNKNOWN_DATA || measure_max_frequency_flag()) {
-      if (freq->max == UNKNOWN_DATA)
-        printWarn("Unable to find max frequency from udev, measuring CPU frequency");
-      freq->max = measure_max_frequency(core);
-      freq->measured = true;
-    }
-  #endif
 
   return freq;
 }
@@ -169,15 +157,6 @@ struct features* get_features_info(void) {
     feat->SHA1 = hwcaps & HWCAP_SHA1;
     feat->SHA2 = hwcaps & HWCAP_SHA2;
     feat->NEON = hwcaps & HWCAP_ASIMD;
-    feat->SVE = hwcaps & HWCAP_SVE;
-
-    hwcaps = getauxval(AT_HWCAP2);
-    if (errno == ENOENT) {
-      printWarn("Unable to retrieve AT_HWCAP2 using getauxval");
-    }
-    else {
-      feat->SVE2 = hwcaps & HWCAP2_SVE2;
-    }
   }
 #else
   else {
@@ -193,8 +172,6 @@ struct features* get_features_info(void) {
     feat->CRC32 = hwcaps & HWCAP2_CRC32;
     feat->SHA1 = hwcaps & HWCAP2_SHA1;
     feat->SHA2 = hwcaps & HWCAP2_SHA2;
-    feat->SVE = false;
-    feat->SVE2 = false;
   }
 #endif // ifdef __aarch64__
 #elif defined __APPLE__ || __MACH__
@@ -204,14 +181,8 @@ struct features* get_features_info(void) {
   feat->SHA1 = true;
   feat->SHA2 = true;
   feat->NEON = true;
-  feat->SVE = false;
-  feat->SVE2 = false;
 #endif  // ifdef __linux__
 
-  if (feat->SVE || feat->SVE2) {
-    feat->cntb = sve_cntb();
-  }
-
   return feat;
 }
 
@@ -448,7 +419,7 @@ char* get_str_topology(struct cpuInfo* cpu, struct topology* topo, bool dual_soc
 
 char* get_str_features(struct cpuInfo* cpu) {
   struct features* feat = cpu->feat;
-  uint32_t max_len = strlen("NEON,SHA1,SHA2,AES,CRC32,SVE,SVE2") + 1;
+  uint32_t max_len = strlen("NEON,SHA1,SHA2,AES,CRC32,") + 1;
   uint32_t len = 0;
   char* string = ecalloc(max_len, sizeof(char));
 
@@ -456,14 +427,6 @@ char* get_str_features(struct cpuInfo* cpu) {
     strcat(string, "NEON,");
     len += 5;
   }
-  if(feat->SVE) {
-    strcat(string, "SVE,");
-    len += 4;
-  }
-  if(feat->SVE2) {
-    strcat(string, "SVE2,");
-    len += 5;
-  }
   if(feat->SHA1) {
     strcat(string, "SHA1,");
     len += 5;
@@ -513,10 +476,6 @@ void print_debug(struct cpuInfo* cpu) {
     }
   }
 
-  if (cpu->feat->SVE || cpu->feat->SVE2) {
-    printf("- cntb: %d\n", (int) cpu->feat->cntb);
-  }
-
   #if defined(__APPLE__) || defined(__MACH__)
     printf("hw.cpufamily: 0x%.8X\n", get_sys_info_by_name("hw.cpufamily"));
     printf("hw.cpusubfamily: 0x%.8X\n", get_sys_info_by_name("hw.cpusubfamily"));

src/arm/soc.c

@@ -11,7 +11,7 @@
 #include "../common/pci.h"
 
 #if defined(__APPLE__) || defined(__MACH__)
-  #include "../common/sysctl.h"
+  #include "sysctl.h"
 #endif
 
 #define NA -1
@@ -167,13 +167,11 @@ bool match_google(char* soc_name, struct system_on_chip* soc) {
 
 // https://www.techinsights.com/
 // https://datasheetspdf.com/pdf-file/1316605/HiSilicon/Hi3660/1
-// https://github.com/Dr-Noob/cpufetch/issues/259
 bool match_hisilicon(char* soc_name, struct system_on_chip* soc) {
   char* tmp;
 
-  if((tmp = strstr(soc_name, "hi")) != NULL);
+  if((tmp = strstr(soc_name, "hi")) == NULL)
-  else if((tmp = strstr(soc_name, "kirin")) != NULL);
+    return false;
-  else return false;
 
   soc->soc_vendor = SOC_VENDOR_KIRIN;
 
@@ -206,7 +204,6 @@ bool match_hisilicon(char* soc_name, struct system_on_chip* soc) {
   SOC_EQ(tmp, "hi3680",     "980",   SOC_HISILICON_3680, soc,  7)
   //SOC_EQ(tmp, "?",        "985",   SOC_KIRIN, soc,  7)
   SOC_EQ(tmp, "hi3690",     "990",   SOC_HISILICON_3690, soc,  7)
-  SOC_EQ(tmp, "kirin9000s", "9000s", SOC_HISILICON_9000S,soc,  7)
   SOC_END
 }
 
@@ -424,9 +421,6 @@ bool match_mediatek(char* soc_name, struct system_on_chip* soc) {
 }
 
 /*
- * Good sources:
- * https://www.geektopia.es/es/products/company/qualcomm/socs/
- *
  * APQ: Application Processor Qualcomm
  * MSM: Mobile Station Modem
  * In a APQXXXX or MSMXXXX, the second digit represents:
@@ -584,25 +578,6 @@ bool match_qualcomm(char* soc_name, struct system_on_chip* soc) {
   SOC_EQ(tmp, "SM8250-AB",      "865+",      SOC_SNAPD_SM8250_AB,      soc,  7)
   SOC_EQ(tmp, "SM8350",         "888",       SOC_SNAPD_SM8350,         soc,  5)
   SOC_EQ(tmp, "SM8350-AC",      "888+",      SOC_SNAPD_SM8350,         soc,  5)
-  // Snapdragon Gen 4 //
-  SOC_EQ(tmp, "SM4375",         "4 Gen 1",   SOC_SNAPD_SM4375,         soc,  6)
-  SOC_EQ(tmp, "SM4450",         "4 Gen 2",   SOC_SNAPD_SM4450,         soc,  4)
-  SOC_EQ(tmp, "SM4635",         "4s Gen 2",  SOC_SNAPD_SM4635,         soc,  4)
-  // Snapdragon Gen 6 //
-  SOC_EQ(tmp, "SM6375-AC",      "6s Gen 3",  SOC_SNAPD_SM6375_AC,      soc,  6)
-  SOC_EQ(tmp, "SM6450",         "6 Gen 1",   SOC_SNAPD_SM6450,         soc,  4)
-  // Snapdragon Gen 7 //
-  SOC_EQ(tmp, "SM7435-AB",      "7s Gen 2",  SOC_SNAPD_SM7435_AB,      soc,  4)
-  SOC_EQ(tmp, "SM7450",         "7 Gen 1",   SOC_SNAPD_SM7450,         soc,  4)
-  SOC_EQ(tmp, "SM7475",         "7+ Gen 2",  SOC_SNAPD_SM7475,         soc,  4)
-  SOC_EQ(tmp, "SM7550-AB",      "7 Gen 3",   SOC_SNAPD_SM7550_AB,      soc,  4)
-  SOC_EQ(tmp, "SM7675-AB",      "7+ Gen 3",  SOC_SNAPD_SM7675_AB,      soc,  4)
-  // Snapdragon Gen 8 //
-  SOC_EQ(tmp, "SM8450",         "8 Gen 1",   SOC_SNAPD_SM8450,         soc,  4)
-  SOC_EQ(tmp, "SM8475",         "8+ Gen 1",  SOC_SNAPD_SM8475,         soc,  4)
-  SOC_EQ(tmp, "SM8550-AB",      "8 Gen 2",   SOC_SNAPD_SM8550_AB,      soc,  4)
-  SOC_EQ(tmp, "SM8635",         "8s Gen 3",  SOC_SNAPD_SM8635,         soc,  4)
-  SOC_EQ(tmp, "SM8650-AB",      "8 Gen 3",   SOC_SNAPD_SM8650_AB,      soc,  4)
   SOC_END
 }
 
@@ -649,37 +624,12 @@ bool match_special(char* soc_name, struct system_on_chip* soc) {
     return true;
   }
 
-  // New Snapdragon SoCs codenames
+  // Snapdragon 8 Gen 1 reported as "taro"
-  // https://github.com/sm8450-mainline/fdt?tab=readme-ov-file#chipsets
-  // https://github.com/Dr-Noob/cpufetch/issues/253
-  if (strcmp(soc_name, "cape") == 0) {
-    fill_soc(soc, "8+ Gen 1", SOC_SNAPD_SM8475, 4);
-    return true;
-  }
-
   if(strcmp(soc_name, "taro") == 0) {
     fill_soc(soc, "8 Gen 1", SOC_SNAPD_SM8450, 4);
     return true;
   }
 
-  if(strcmp(soc_name, "ukee") == 0) {
-    fill_soc(soc, "7+ Gen 2", SOC_SNAPD_SM7475, 4);
-    return true;
-  }
-
-  if(strcmp(soc_name, "diwali") == 0) {
-    fill_soc(soc, "7 Gen 1", SOC_SNAPD_SM7450, 4);
-    return true;
-  }
-
-  // parrot can be either SM7435 or SM6450, we need more data
-  // to distingish between those two
-
-  if(strcmp(soc_name, "ravelin") == 0) {
-    fill_soc(soc, "4 Gen 2", SOC_SNAPD_SM4450, 4);
-    return true;
-  }
-
   // Google Pixel 6
   // https://github.com/Dr-Noob/cpufetch/issues/134
   if(strcmp(soc_name, "oriole") == 0) {
@@ -752,16 +702,6 @@ struct system_on_chip* guess_soc_from_android(struct system_on_chip* soc) {
     else return soc;
   }
 
-  // https://github.com/Dr-Noob/cpufetch/issues/253
-  // ro.soc.model might be more reliable than ro.product.board or
-  // ro.board.platform, so try with it first
-  property_len = android_property_get("ro.soc.model", (char *) &tmp);
-  if(property_len > 0) {
-    try_parse_soc_from_string(soc, property_len, tmp);
-    if(soc->soc_vendor == SOC_VENDOR_UNKNOWN) printWarn("SoC detection failed using Android property ro.soc.model: %s", tmp);
-    else return soc;
-  }
-
   property_len = android_property_get("ro.product.board", (char *) &tmp);
   if(property_len > 0) {
     try_parse_soc_from_string(soc, property_len, tmp);

src/arm/socs.h

@@ -29,7 +29,6 @@ enum {
   SOC_HISILICON_3670,
   SOC_HISILICON_3680,
   SOC_HISILICON_3690,
-  SOC_HISILICON_9000S,
   // Kunpeng //
   SOC_KUNPENG_920,
   SOC_KUNPENG_930,
@@ -271,16 +270,11 @@ enum {
   SOC_SNAPD_SDM660,
   SOC_SNAPD_SM6115,
   SOC_SNAPD_SM6125,
-  SOC_SNAPD_SM6375_AC,
-  SOC_SNAPD_SM6450,
   SOC_SNAPD_SDM670,
   SOC_SNAPD_SM6150,
   SOC_SNAPD_SM6350,
   SOC_SNAPD_SDM710,
   SOC_SNAPD_SDM712,
-  SOC_SNAPD_SM4375,
-  SOC_SNAPD_SM4450,
-  SOC_SNAPD_SM4635,
   SOC_SNAPD_SM7125,
   SOC_SNAPD_SM7150_AA,
   SOC_SNAPD_SM7150_AB,
@@ -289,11 +283,6 @@ enum {
   SOC_SNAPD_SM7250_AA,
   SOC_SNAPD_SM7250_AB,
   SOC_SNAPD_SM7250_AC,
-  SOC_SNAPD_SM7435_AB,
-  SOC_SNAPD_SM7450,
-  SOC_SNAPD_SM7475,
-  SOC_SNAPD_SM7550_AB,
-  SOC_SNAPD_SM7675_AB,
   SOC_SNAPD_MSM8974AA,
   SOC_SNAPD_MSM8974AB,
   SOC_SNAPD_MSM8974AC,
@@ -314,10 +303,6 @@ enum {
   SOC_SNAPD_SM8250_AB,
   SOC_SNAPD_SM8350,
   SOC_SNAPD_SM8450,
-  SOC_SNAPD_SM8475,
-  SOC_SNAPD_SM8550_AB,
-  SOC_SNAPD_SM8635,
-  SOC_SNAPD_SM8650_AB,
   // APPLE
   SOC_APPLE_M1,
   SOC_APPLE_M1_PRO,
@@ -386,11 +371,11 @@ enum {
 
 inline static VENDOR get_soc_vendor_from_soc(SOC soc) {
   if(soc >= SOC_BCM_2835 && soc <= SOC_BCM_2712) return SOC_VENDOR_BROADCOM;
-  else if(soc >= SOC_HISILICON_3620 && soc <= SOC_HISILICON_9000S) return SOC_VENDOR_KIRIN;
+  else if(soc >= SOC_HISILICON_3620 && soc <= SOC_HISILICON_3690) return SOC_VENDOR_KIRIN;
   else if(soc >= SOC_KUNPENG_920 && soc <= SOC_KUNPENG_930) return SOC_VENDOR_KUNPENG;
   else if(soc >= SOC_EXYNOS_3475 && soc <= SOC_EXYNOS_880) return SOC_VENDOR_EXYNOS;
   else if(soc >= SOC_MTK_MT6893 && soc <= SOC_MTK_MT8783) return SOC_VENDOR_MEDIATEK;
-  else if(soc >= SOC_SNAPD_QSD8650 && soc <= SOC_SNAPD_SM8650_AB) return SOC_VENDOR_SNAPDRAGON;
+  else if(soc >= SOC_SNAPD_QSD8650 && soc <= SOC_SNAPD_SM8450) return SOC_VENDOR_SNAPDRAGON;
   else if(soc >= SOC_APPLE_M1 && soc <= SOC_APPLE_M3_MAX) return SOC_VENDOR_APPLE;
   else if(soc >= SOC_ALLWINNER_A10 && soc <= SOC_ALLWINNER_R328) return SOC_VENDOR_ALLWINNER;
   else if(soc >= SOC_ROCKCHIP_3288 && soc <= SOC_ROCKCHIP_3588) return SOC_VENDOR_ROCKCHIP;

src/arm/sve.c

@@ -1,15 +0,0 @@
-#include <stdint.h>
-#include "../common/global.h"
-
-// https://learn.arm.com/learning-paths/servers-and-cloud-computing/sve/sve_basics/#:~:text=Using%20a%20text%20editor%20of%20your%20choice%2C%20copy,svcntb%28%29%29%3B%20%7D%20This%20program%20prints%20the%20vector%20length
-uint64_t sve_cntb(void) {
-  #ifdef __ARM_FEATURE_SVE
-    uint64_t x0 = 0;
-    __asm volatile("cntb %0"
-         : "=r"(x0));
-    return x0;
-  #else
-    printWarn("sve_cntb: Hardware supports SVE, but it was not enabled by the compiler");
-    return 0;
-  #endif
-}

src/arm/sve.h

@@ -1,6 +0,0 @@
-#ifndef __SVE_DETECTION__
-#define __SVE_DETECTION__
-
-uint64_t sve_cntb(void);
-
-#endif

src/arm/sysctl.c

@@ -4,8 +4,8 @@
 #include <string.h>
 #include <errno.h>
 
-#include "global.h"
+#include "../common/global.h"
-#include "cpu.h"
+#include "../common/cpu.h"
 
 uint32_t get_sys_info_by_name(char* name) {
   size_t size = 0;

src/arm/uarch.c

@@ -75,7 +75,6 @@ static const ISA isas_uarch[] = {
   [UARCH_THUNDERX]     = ISA_ARMv8_A,
   [UARCH_THUNDERX2]    = ISA_ARMv8_1_A,
   [UARCH_TAISHAN_V110] = ISA_ARMv8_2_A,
-  [UARCH_TAISHAN_V120] = ISA_ARMv8_2_A, // Not confirmed
   [UARCH_TAISHAN_V200] = ISA_ARMv8_2_A, // Not confirmed
   [UARCH_DENVER]       = ISA_ARMv8_A,
   [UARCH_DENVER2]      = ISA_ARMv8_A,
@@ -203,10 +202,8 @@ struct uarch* get_uarch_from_midr(uint32_t midr, struct cpuInfo* cpu) {
   CHECK_UARCH(arch, cpu, 'C', 0x0AF, NA, NA, "ThunderX2 99XX",        UARCH_THUNDERX2,    CPU_VENDOR_CAVIUM)
 
   CHECK_UARCH(arch, cpu, 'H', 0xD01, NA, NA, "TaiShan v110",          UARCH_TAISHAN_V110, CPU_VENDOR_HUAWEI) // Kunpeng 920 series
-  CHECK_UARCH(arch, cpu, 'H', 0xD02,  2,  2, "TaiShan v120",          UARCH_TAISHAN_V120, CPU_VENDOR_HUAWEI) // Kiring 9000S Big cores (https://github.com/Dr-Noob/cpufetch/issues/259)
   CHECK_UARCH(arch, cpu, 'H', 0xD02, NA, NA, "TaiShan v200",          UARCH_TAISHAN_V200, CPU_VENDOR_HUAWEI) // Kunpeng 930 series (found in openeuler: https://mailweb.openeuler.org/hyperkitty/list/kernel@openeuler.org/message/XQCV7NX2UKRIUWUFKRF4PO3QENCOUFR3)
   CHECK_UARCH(arch, cpu, 'H', 0xD40, NA, NA, "Cortex-A76",            UARCH_CORTEX_A76,   CPU_VENDOR_ARM)    // Kirin 980 Big/Medium cores -> Cortex-A76
-  CHECK_UARCH(arch, cpu, 'H', 0xD42, NA, NA, "TaiShan v120",          UARCH_TAISHAN_V120, CPU_VENDOR_HUAWEI) // Kiring 9000S Small Cores (https://github.com/Dr-Noob/cpufetch/issues/259)
 
   CHECK_UARCH(arch, cpu, 'N', 0x000, NA, NA, "Denver",                UARCH_DENVER,       CPU_VENDOR_NVIDIA)
   CHECK_UARCH(arch, cpu, 'N', 0x003, NA, NA, "Denver2",               UARCH_DENVER2,      CPU_VENDOR_NVIDIA)
@@ -294,10 +291,7 @@ int get_vpus_width(struct cpuInfo* cpu) {
     case UARCH_NEOVERSE_V1:
       return 256;
     default:
-      if (cpu->feat->SVE && cpu->feat->cntb > 0) {
+      if(cpu->feat->NEON) {
-        return cpu->feat->cntb * 8;
-      }
-      else if (cpu->feat->NEON) {
         if(is_ARMv8_or_newer(cpu)) {
           return 128;
         }
@@ -331,7 +325,6 @@ int get_number_of_vpus(struct cpuInfo* cpu) {
     case UARCH_ICESTORM:    // [https://dougallj.github.io/applecpu/icestorm-simd.html]
     case UARCH_BLIZZARD:    // [https://en.wikipedia.org/wiki/Comparison_of_ARM_processors]
     case UARCH_TAISHAN_V110:// [https://www-file.huawei.com/-/media/corp2020/pdf/publications/huawei-research/2022/huawei-research-issue1-en.pdf]: "128-bit x 2 for single precision"
-    case UARCH_TAISHAN_V120:// Not confirmed, asssuming same as v110
     case UARCH_TAISHAN_V200:// Not confirmed, asssuming same as v110
     case UARCH_CORTEX_A57:  // [https://www.anandtech.com/show/8718/the-samsung-galaxy-note-4-exynos-review/5]
     case UARCH_CORTEX_A72:  // [https://www.anandtech.com/show/10347/arm-cortex-a73-artemis-unveiled/2]

src/arm/uarch.h

@@ -83,9 +83,7 @@ enum {
   UARCH_BRAHMA_B15,
   UARCH_BRAHMA_B53,
   UARCH_XGENE,        // Applied Micro X-Gene.
-  // HUAWEI
   UARCH_TAISHAN_V110, // HiSilicon TaiShan v110
-  UARCH_TAISHAN_V120, // HiSilicon TaiShan v120
   UARCH_TAISHAN_V200, // HiSilicon TaiShan v200
   // PHYTIUM
   UARCH_XIAOMI,       // Not to be confused with Xiaomi Inc

src/common/args.c

@@ -28,7 +28,6 @@ struct args_struct {
   bool help_flag;
   bool raw_flag;
   bool accurate_pp;
-  bool measure_max_frequency_flag;
   bool full_cpu_name_flag;
   bool logo_long;
   bool logo_short;
@@ -41,37 +40,35 @@ struct args_struct {
 };
 
 const char args_chr[] = {
-  /* [ARG_STYLE]            = */ 's',
+  /* [ARG_STYLE]          = */ 's',
-  /* [ARG_COLOR]            = */ 'c',
+  /* [ARG_COLOR]          = */ 'c',
-  /* [ARG_HELP]             = */ 'h',
+  /* [ARG_HELP]           = */ 'h',
-  /* [ARG_RAW]              = */ 'r',
+  /* [ARG_RAW]            = */ 'r',
-  /* [ARG_FULLCPUNAME]      = */ 'F',
+  /* [ARG_FULLCPUNAME]    = */ 'F',
-  /* [ARG_LOGO_LONG]        = */ 1,
+  /* [ARG_LOGO_LONG]      = */ 1,
-  /* [ARG_LOGO_SHORT]       = */ 2,
+  /* [ARG_LOGO_SHORT]     = */ 2,
-  /* [ARG_LOGO_INTEL_NEW]   = */ 3,
+  /* [ARG_LOGO_INTEL_NEW] = */ 3,
-  /* [ARG_LOGO_INTEL_OLD]   = */ 4,
+  /* [ARG_LOGO_INTEL_OLD] = */ 4,
-  /* [ARG_ACCURATE_PP]      = */ 5,
+  /* [ARG_ACCURATE_PP]    = */ 5,
-  /* [ARG_MEASURE_MAX_FREQ] = */ 6,
+  /* [ARG_DEBUG]          = */ 'd',
-  /* [ARG_DEBUG]            = */ 'd',
+  /* [ARG_VERBOSE]        = */ 'v',
-  /* [ARG_VERBOSE]          = */ 'v',
+  /* [ARG_VERSION]        = */ 'V',
-  /* [ARG_VERSION]          = */ 'V',
 };
 
 const char *args_str[] = {
-  /* [ARG_STYLE]            = */ "style",
+  /* [ARG_STYLE]          = */ "style",
-  /* [ARG_COLOR]            = */ "color",
+  /* [ARG_COLOR]          = */ "color",
-  /* [ARG_HELP]             = */ "help",
+  /* [ARG_HELP]           = */ "help",
-  /* [ARG_RAW]              = */ "raw",
+  /* [ARG_RAW]            = */ "raw",
-  /* [ARG_FULLCPUNAME]      = */ "full-cpu-name",
+  /* [ARG_FULLCPUNAME]    = */ "full-cpu-name",
-  /* [ARG_LOGO_LONG]        = */ "logo-long",
+  /* [ARG_LOGO_LONG]      = */ "logo-long",
-  /* [ARG_LOGO_SHORT]       = */ "logo-short",
+  /* [ARG_LOGO_SHORT]     = */ "logo-short",
-  /* [ARG_LOGO_INTEL_NEW]   = */ "logo-intel-new",
+  /* [ARG_LOGO_INTEL_NEW] = */ "logo-intel-new",
-  /* [ARG_LOGO_INTEL_OLD]   = */ "logo-intel-old",
+  /* [ARG_LOGO_INTEL_OLD] = */ "logo-intel-old",
-  /* [ARG_ACCURATE_PP]      = */ "accurate-pp",
+  /* [ARG_ACCURATE_PP]    = */ "accurate-pp",
-  /* [ARG_MEASURE_MAX_FREQ] = */ "measure-max-freq",
+  /* [ARG_DEBUG]          = */ "debug",
-  /* [ARG_DEBUG]            = */ "debug",
+  /* [ARG_VERBOSE]        = */ "verbose",
-  /* [ARG_VERBOSE]          = */ "verbose",
+  /* [ARG_VERSION]        = */ "version",
-  /* [ARG_VERSION]          = */ "version",
 };
 
 static struct args_struct args;
@@ -104,10 +101,6 @@ bool accurate_pp(void) {
   return args.accurate_pp;
 }
 
-bool measure_max_frequency_flag(void) {
-  return args.measure_max_frequency_flag;
-}
-
 bool show_full_cpu_name(void) {
   return args.full_cpu_name_flag;
 }
@@ -229,20 +222,12 @@ char* build_short_options(void) {
   memset(str, 0, sizeof(char) * (len*2 + 1));
 
 #ifdef ARCH_X86
-  sprintf(str, "%c:%c:%c%c%c%c%c%c%c%c%c%c%c%c",
+  sprintf(str, "%c:%c:%c%c%c%c%c%c%c%c%c%c%c",
   c[ARG_STYLE], c[ARG_COLOR], c[ARG_HELP],
   c[ARG_RAW], c[ARG_FULLCPUNAME],
   c[ARG_LOGO_SHORT], c[ARG_LOGO_LONG],
   c[ARG_LOGO_INTEL_NEW], c[ARG_LOGO_INTEL_OLD],
-  c[ARG_ACCURATE_PP], c[ARG_MEASURE_MAX_FREQ],
+  c[ARG_ACCURATE_PP], c[ARG_DEBUG], c[ARG_VERBOSE],
-  c[ARG_DEBUG], c[ARG_VERBOSE],
-  c[ARG_VERSION]);
-#elif ARCH_ARM
-  sprintf(str, "%c:%c:%c%c%c%c%c%c%c",
-  c[ARG_STYLE], c[ARG_COLOR], c[ARG_HELP],
-  c[ARG_LOGO_SHORT], c[ARG_LOGO_LONG],
-  c[ARG_MEASURE_MAX_FREQ],
-  c[ARG_DEBUG], c[ARG_VERBOSE],
   c[ARG_VERSION]);
 #else
   sprintf(str, "%c:%c:%c%c%c%c%c%c",
@@ -278,24 +263,21 @@ bool parse_args(int argc, char* argv[]) {
   set_log_level(true);
 
   const struct option long_options[] = {
-    {args_str[ARG_STYLE],            required_argument, 0, args_chr[ARG_STYLE]            },
+    {args_str[ARG_STYLE],          required_argument, 0, args_chr[ARG_STYLE]          },
-    {args_str[ARG_COLOR],            required_argument, 0, args_chr[ARG_COLOR]            },
+    {args_str[ARG_COLOR],          required_argument, 0, args_chr[ARG_COLOR]          },
-    {args_str[ARG_HELP],             no_argument,       0, args_chr[ARG_HELP]             },
+    {args_str[ARG_HELP],           no_argument,       0, args_chr[ARG_HELP]           },
 #ifdef ARCH_X86
-    {args_str[ARG_LOGO_INTEL_NEW],   no_argument,       0, args_chr[ARG_LOGO_INTEL_NEW]   },
+    {args_str[ARG_LOGO_INTEL_NEW], no_argument,       0, args_chr[ARG_LOGO_INTEL_NEW] },
-    {args_str[ARG_LOGO_INTEL_OLD],   no_argument,       0, args_chr[ARG_LOGO_INTEL_OLD]   },
+    {args_str[ARG_LOGO_INTEL_OLD], no_argument,       0, args_chr[ARG_LOGO_INTEL_OLD] },
-    {args_str[ARG_ACCURATE_PP],      no_argument,       0, args_chr[ARG_ACCURATE_PP]      },
+    {args_str[ARG_ACCURATE_PP],    no_argument,       0, args_chr[ARG_ACCURATE_PP]    },
-    {args_str[ARG_MEASURE_MAX_FREQ], no_argument,       0, args_chr[ARG_MEASURE_MAX_FREQ] },
+    {args_str[ARG_FULLCPUNAME],    no_argument,       0, args_chr[ARG_FULLCPUNAME]    },
-    {args_str[ARG_FULLCPUNAME],      no_argument,       0, args_chr[ARG_FULLCPUNAME]      },
+    {args_str[ARG_RAW],            no_argument,       0, args_chr[ARG_RAW]            },
-    {args_str[ARG_RAW],              no_argument,       0, args_chr[ARG_RAW]              },
-#elif ARCH_ARM
-    {args_str[ARG_MEASURE_MAX_FREQ], no_argument,       0, args_chr[ARG_MEASURE_MAX_FREQ] },
 #endif
-    {args_str[ARG_LOGO_SHORT],       no_argument,       0, args_chr[ARG_LOGO_SHORT]       },
+    {args_str[ARG_LOGO_SHORT],     no_argument,       0, args_chr[ARG_LOGO_SHORT]     },
-    {args_str[ARG_LOGO_LONG],        no_argument,       0, args_chr[ARG_LOGO_LONG]        },
+    {args_str[ARG_LOGO_LONG],      no_argument,       0, args_chr[ARG_LOGO_LONG]      },
-    {args_str[ARG_DEBUG],            no_argument,       0, args_chr[ARG_DEBUG]            },
+    {args_str[ARG_DEBUG],          no_argument,       0, args_chr[ARG_DEBUG]          },
-    {args_str[ARG_VERBOSE],          no_argument,       0, args_chr[ARG_VERBOSE]          },
+    {args_str[ARG_VERBOSE],        no_argument,       0, args_chr[ARG_VERBOSE]        },
-    {args_str[ARG_VERSION],          no_argument,       0, args_chr[ARG_VERSION]          },
+    {args_str[ARG_VERSION],        no_argument,       0, args_chr[ARG_VERSION]        },
     {0, 0, 0, 0}
   };
 
@@ -331,9 +313,6 @@ bool parse_args(int argc, char* argv[]) {
     else if(opt == args_chr[ARG_ACCURATE_PP]) {
        args.accurate_pp = true;
     }
-    else if(opt == args_chr[ARG_MEASURE_MAX_FREQ]) {
-       args.measure_max_frequency_flag = true;
-    }
     else if(opt == args_chr[ARG_FULLCPUNAME]) {
        args.full_cpu_name_flag = true;
     }

src/common/args.h

@@ -29,7 +29,6 @@ enum {
   ARG_LOGO_INTEL_NEW,
   ARG_LOGO_INTEL_OLD,
   ARG_ACCURATE_PP,
-  ARG_MEASURE_MAX_FREQ,
   ARG_DEBUG,
   ARG_VERBOSE,
   ARG_VERSION
@@ -44,7 +43,6 @@ int max_arg_str_length(void);
 bool parse_args(int argc, char* argv[]);
 bool show_help(void);
 bool accurate_pp(void);
-bool measure_max_frequency_flag(void);
 bool show_full_cpu_name(void);
 bool show_logo_long(void);
 bool show_logo_short(void);

src/common/cpu.c

@@ -145,25 +145,17 @@ char* get_str_l3(struct cache* cach) {
 
 char* get_str_freq(struct frequency* freq) {
   //Max 3 digits and 3 for '(M/G)Hz' plus 1 for '\0'
-  uint32_t size = (1+5+1+3+1);
+  uint32_t size = (5+1+3+1);
   assert(strlen(STRING_UNKNOWN)+1 <= size);
-  char* string = ecalloc(size, sizeof(char));
+  char* string = emalloc(sizeof(char)*size);
+  memset(string, 0, sizeof(char)*size);
 
-  if(freq->max == UNKNOWN_DATA || freq->max < 0) {
+  if(freq->max == UNKNOWN_DATA || freq->max < 0)
     snprintf(string,strlen(STRING_UNKNOWN)+1,STRING_UNKNOWN);
-  }
+  else if(freq->max >= 1000)
-  else if(freq->max >= 1000) {
+    snprintf(string,size,"%.3f "STRING_GIGAHERZ,(float)(freq->max)/1000);
-    if (freq->measured)
+  else
-      snprintf(string,size,"~%.3f "STRING_GIGAHERZ,(float)(freq->max)/1000);
+    snprintf(string,size,"%d "STRING_MEGAHERZ,freq->max);
-    else
-      snprintf(string,size,"%.3f "STRING_GIGAHERZ,(float)(freq->max)/1000);
-  }
-  else {
-    if (freq->measured)
-      snprintf(string,size,"~%d "STRING_MEGAHERZ,freq->max);
-    else
-      snprintf(string,size,"%d "STRING_MEGAHERZ,freq->max);
-  }
 
   return string;
 }

src/common/cpu.h

@@ -58,8 +58,6 @@ typedef int32_t VENDOR;
 struct frequency {
   int32_t base;
   int32_t max;
-  // Indicates if max frequency was measured
-  bool measured;
 };
 
 struct hypervisor {
@@ -124,9 +122,6 @@ struct features {
   bool SHA1;
   bool SHA2;
   bool CRC32;
-  bool SVE;
-  bool SVE2;
-  uint64_t cntb;
 #endif  
 };
 

src/common/freq.c

@@ -1,195 +0,0 @@
-#ifdef __linux__
-
-#define _GNU_SOURCE
-
-#include <time.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-#include <errno.h>
-#include <unistd.h>
-#include <asm/unistd.h>
-#include <sys/ioctl.h>
-#include <linux/perf_event.h>
-
-#include "global.h"
-#include "cpu.h"
-
-static long
-perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
-                int cpu, int group_fd, unsigned long flags) {
-    int ret;
-    ret = syscall(__NR_perf_event_open, hw_event, pid, cpu,
-                    group_fd, flags);
-    return ret;
-}
-
-#define INSERT_ASM_ONCE __asm volatile("nop");
-#define INSERT_ASM_10_TIMES \
-    INSERT_ASM_ONCE         \
-    INSERT_ASM_ONCE         \
-    INSERT_ASM_ONCE         \
-    INSERT_ASM_ONCE         \
-    INSERT_ASM_ONCE         \
-    INSERT_ASM_ONCE         \
-    INSERT_ASM_ONCE         \
-    INSERT_ASM_ONCE         \
-    INSERT_ASM_ONCE         \
-    INSERT_ASM_ONCE         \
-
-#define INSERT_ASM_100_TIMES \
-    INSERT_ASM_10_TIMES      \
-    INSERT_ASM_10_TIMES      \
-    INSERT_ASM_10_TIMES      \
-    INSERT_ASM_10_TIMES      \
-    INSERT_ASM_10_TIMES      \
-    INSERT_ASM_10_TIMES      \
-    INSERT_ASM_10_TIMES      \
-    INSERT_ASM_10_TIMES      \
-    INSERT_ASM_10_TIMES      \
-    INSERT_ASM_10_TIMES
-
-#define INSERT_ASM_1000_TIMES \
-    INSERT_ASM_100_TIMES     \
-    INSERT_ASM_100_TIMES     \
-    INSERT_ASM_100_TIMES     \
-    INSERT_ASM_100_TIMES     \
-    INSERT_ASM_100_TIMES     \
-    INSERT_ASM_100_TIMES     \
-    INSERT_ASM_100_TIMES     \
-    INSERT_ASM_100_TIMES     \
-    INSERT_ASM_100_TIMES     \
-    INSERT_ASM_100_TIMES     \
-
-void nop_function(uint64_t iters) {
-  for (uint64_t i = 0; i < iters; i++) {
-    INSERT_ASM_1000_TIMES
-    INSERT_ASM_1000_TIMES
-    INSERT_ASM_1000_TIMES
-    INSERT_ASM_1000_TIMES
-  }
-}
-
-// Run the nop_function with the number of iterations specified and
-// measure both the time and number of cycles
-int measure_freq_iters(uint64_t iters, uint32_t core, double* freq) {
-  clockid_t clock = CLOCK_PROCESS_CPUTIME_ID;
-  struct timespec start, end;
-  struct perf_event_attr pe;
-  uint64_t cycles;
-  int fd;
-  int pid = 0;
-  memset(&pe, 0, sizeof(struct perf_event_attr));
-  pe.type = PERF_TYPE_HARDWARE;
-  pe.size = sizeof(struct perf_event_attr);
-  pe.config = PERF_COUNT_HW_CPU_CYCLES;
-  pe.disabled = 1;
-  pe.exclude_kernel = 1;
-  pe.exclude_hv = 1;
-
-  fd = perf_event_open(&pe, pid, core, -1, 0);
-  if (fd == -1) {
-    perror("perf_event_open");
-    if (errno == EPERM || errno == EACCES) {
-      printErr("You may not have permission to collect stats.\n"\
-      "Consider tweaking /proc/sys/kernel/perf_event_paranoid or running as root");
-    }
-    return -1;
-  }
-
-  if (clock_gettime(clock, &start) == -1) {
-    perror("clock_gettime");
-    return -1;
-  }
-  if(ioctl(fd, PERF_EVENT_IOC_RESET, 0) == -1) {
-    perror("ioctl");
-    return -1;
-  }
-  if(ioctl(fd, PERF_EVENT_IOC_ENABLE, 0) == -1) {
-    perror("ioctl");
-    return -1;
-  }
-
-  nop_function(iters);
-
-  ssize_t ret = read(fd, &cycles, sizeof(uint64_t));
-  if (ret == -1) {
-    perror("read");
-    return -1;
-  }
-  if (ret != sizeof(uint64_t)) {
-    printErr("Read returned %d, expected %d", ret, sizeof(uint64_t));
-    return -1;
-  }
-  if(ioctl(fd, PERF_EVENT_IOC_DISABLE, 0) == -1) {
-    perror("ioctl");
-    return -1;
-  }
-  if (clock_gettime(clock, &end) == -1) {
-    perror("clock_gettime");
-    return -1;
-  }
-
-  uint64_t nsecs = (end.tv_sec*1e9 + end.tv_nsec) - (start.tv_sec*1e9 + start.tv_nsec);
-  uint64_t usecs = nsecs/1000;  
-  *freq = cycles/((double)usecs);
-  return 0;
-}
-
-// Return a good number of iterations to run the nop_function in
-// order to get a precise measurement of the frequency without taking
-// too much time.
-uint64_t get_num_iters_from_freq(double frequency) {
-  // Truncate to reduce variability
-  uint64_t freq_trunc = ((uint64_t) frequency / 100) * 100;
-  uint64_t osp_per_iter = 4 * 1000;
-
-  return freq_trunc * 1e7 * 1/osp_per_iter;
-}
-
-// Differences between x86 measure_frequency and this measure_max_frequency:
-// - measure_frequency employs all cores simultaneously whereas
-//   measure_max_frequency only employs 1.
-// - measure_frequency runs the computation and checks /proc/cpuinfo whereas
-//   measure_max_frequency does not rely on /proc/cpuinfo and simply
-//   counts cpu cycles to measure frequency.
-// - measure_frequency uses actual computation while measuring the frequency
-//   whereas measure_max_frequency uses nop instructions. This makes the former
-//   x86 dependant whereas the latter is architecture independant.
-int64_t measure_max_frequency(uint32_t core) {
-  if (!bind_to_cpu(core)) {
-    printErr("Failed binding the process to CPU %d", core);
-    return UNKNOWN_DATA;
-  }
-
-  // First, get very rough estimation of clock cycle to
-  // compute a reasonable value for the iterations
-  double estimation_freq, frequency;
-  uint64_t iters = 100000;
-  if (measure_freq_iters(iters, core, &estimation_freq) == -1)
-    return UNKNOWN_DATA;
-
-  if (estimation_freq <= 0.0) {
-    printErr("First frequency measurement yielded an invalid value: %f", estimation_freq);
-    return UNKNOWN_DATA;
-  }
-  iters = get_num_iters_from_freq(estimation_freq);
-  printWarn("Running frequency measurement with %ld iterations on core %d...", iters, core);
-
-  // Now perform actual measurement
-  const char* frequency_banner = "cpufetch is measuring the max frequency...";
-  printf("%s", frequency_banner);
-  fflush(stdout);
-
-  if (measure_freq_iters(iters, core, &frequency) == -1)
-    return UNKNOWN_DATA;
-  
-  // Clean screen once measurement is finished
-  printf("\r%*c\r", (int) strlen(frequency_banner), ' ');
-  
-  // Discard last digit in the frequency, which should help providing
-  // more reliable and predictable values.
-  return (((int) frequency + 5)/10) * 10;
-}
-
-#endif // #ifdef __linux__

src/common/freq.h

@@ -1,6 +0,0 @@
-#ifndef __COMMON_FREQ__
-#define __COMMON_FREQ__
-
-int64_t measure_max_frequency(uint32_t core);
-
-#endif

src/common/global.c

@@ -1,14 +1,3 @@
-#ifdef _WIN32
-  #define NOMINMAX
-  #include <windows.h>
-#elif defined __linux__
-  #define _GNU_SOURCE
-  #include <sched.h>
-#elif defined __FreeBSD__
-  #include <sys/param.h>
-  #include <sys/cpuset.h>
-#endif
-
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -62,7 +51,7 @@
 #endif
 
 #ifndef GIT_FULL_VERSION
-  static const char* VERSION = "1.06";
+  static const char* VERSION = "1.05";
 #endif
 
 enum {
@@ -210,34 +199,6 @@ void* erealloc(void *ptr, size_t size) {
   return newptr;
 }
 
-#ifndef __APPLE__
-bool bind_to_cpu(int cpu_id) {
-  #ifdef _WIN32
-    HANDLE process = GetCurrentProcess();
-    DWORD_PTR processAffinityMask = 1 << cpu_id;
-    return SetProcessAffinityMask(process, processAffinityMask);
-  #elif defined __linux__
-    cpu_set_t currentCPU;
-    CPU_ZERO(&currentCPU);
-    CPU_SET(cpu_id, &currentCPU);
-    if (sched_setaffinity (0, sizeof(currentCPU), &currentCPU) == -1) {
-      printWarn("sched_setaffinity: %s", strerror(errno));
-      return false;
-    }
-    return true;
-  #elif defined __FreeBSD__
-    cpuset_t currentCPU;
-    CPU_ZERO(&currentCPU);
-    CPU_SET(cpu_id, &currentCPU);
-    if(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(cpuset_t), &currentCPU) == -1) {
-      printWarn("cpuset_setaffinity: %s", strerror(errno));
-      return false;
-    }
-    return true;
-  #endif
-}
-#endif
-
 void print_version(FILE *restrict stream) {
 #ifdef GIT_FULL_VERSION
   fprintf(stream, "cpufetch %s (%s %s)\n", GIT_FULL_VERSION, OS_STR, ARCH_STR);

src/common/global.h

@@ -19,9 +19,6 @@ char *strremove(char *str, const char *sub);
 void* emalloc(size_t size);
 void* ecalloc(size_t nmemb, size_t size);
 void* erealloc(void *ptr, size_t size);
-#ifndef __APPLE__
-bool bind_to_cpu(int cpu_id);
-#endif
 void print_version(FILE *restrict stream);
 
 #endif

src/common/main.c

@@ -30,17 +30,11 @@ void print_help(char *argv[]) {
 #ifdef ARCH_X86
 #ifdef __linux__
   printf("      --%s %*s Compute the peak performance accurately (measure the CPU frequency instead of using the maximum)\n", t[ARG_ACCURATE_PP], (int) (max_len-strlen(t[ARG_ACCURATE_PP])), "");
-  printf("      --%s %*s Measure the max CPU frequency instead of reading it\n", t[ARG_MEASURE_MAX_FREQ], (int) (max_len-strlen(t[ARG_MEASURE_MAX_FREQ])), "");
+#endif
-#endif // __linux__
   printf("      --%s %*s Show the old Intel logo\n", t[ARG_LOGO_INTEL_OLD], (int) (max_len-strlen(t[ARG_LOGO_INTEL_OLD])), "");
   printf("      --%s %*s Show the new Intel logo\n", t[ARG_LOGO_INTEL_NEW], (int) (max_len-strlen(t[ARG_LOGO_INTEL_NEW])), "");
   printf("  -%c, --%s %*s Show the full CPU name (do not abbreviate it)\n", c[ARG_FULLCPUNAME], t[ARG_FULLCPUNAME], (int) (max_len-strlen(t[ARG_FULLCPUNAME])), "");
   printf("  -%c, --%s %*s Print raw cpuid data (debug purposes)\n", c[ARG_RAW], t[ARG_RAW], (int) (max_len-strlen(t[ARG_RAW])), "");
-#endif // ARCH_X86
-#ifdef ARCH_ARM
-#ifdef __linux__
-  printf("      --%s %*s Measure the max CPU frequency instead of reading it\n", t[ARG_MEASURE_MAX_FREQ], (int) (max_len-strlen(t[ARG_MEASURE_MAX_FREQ])), "");
-#endif
 #endif
   printf("  -%c, --%s %*s Print this help and exit\n", c[ARG_HELP], t[ARG_HELP], (int) (max_len-strlen(t[ARG_HELP])), "");
   printf("  -%c, --%s %*s Print cpufetch version and exit\n", c[ARG_VERSION], t[ARG_VERSION], (int) (max_len-strlen(t[ARG_VERSION])), "");
@@ -51,7 +45,7 @@ void print_help(char *argv[]) {
   printf("  * \"amd\":       Use AMD color scheme \n");
   printf("  * \"ibm\",       Use IBM color scheme \n");
   printf("  * \"arm\":       Use ARM color scheme \n");
-  printf("  * \"rockchip\":  Use Rockchip color scheme \n");
+  printf("  * \"rockchip\":  Use ARM color scheme \n");
   printf("  * \"sifive\":    Use SiFive color scheme \n");
   printf("  * custom:      If the argument of --color does not match any of the previous strings, a custom scheme can be specified.\n");
   printf("                 5 colors must be given in RGB with the format: R,G,B:R,G,B:...\n");
@@ -86,11 +80,6 @@ void print_help(char *argv[]) {
   printf("    --accurate-pp option, which will measure the AVX frequency and show a more precise estimation\n");
   printf("    (this option is only available in x86 architectures).\n");
   printf("    To precisely measure peak performance, see: https://github.com/Dr-Noob/peakperf\n");
-  printf("\n");
-  printf("    Both --accurate-pp and --measure-max-freq measure the actual frequency of the CPU. However,\n");
-  printf("    they differ slightly. The former measures the max frequency while running vectorized SSE/AVX\n");
-  printf("    instructions and it is thus x86 only, whereas the latter simply measures the max clock cycle\n");
-  printf("    and is architecture independent.\n");
 }
 
 int main(int argc, char* argv[]) {

src/common/printer.c

@@ -61,7 +61,6 @@ enum {
   ATTRIBUTE_NCORES,
   ATTRIBUTE_NCORES_DUAL,
 #ifdef ARCH_X86
-  ATTRIBUTE_SSE,
   ATTRIBUTE_AVX,
   ATTRIBUTE_FMA,
 #elif ARCH_PPC
@@ -97,7 +96,6 @@ static const char* ATTRIBUTE_FIELDS [] = {
   "Cores:",
   "Cores (Total):",
 #ifdef ARCH_X86
-  "SSE:",
   "AVX:",
   "FMA:",
 #elif ARCH_PPC
@@ -133,7 +131,6 @@ static const char* ATTRIBUTE_FIELDS_SHORT [] = {
   "Cores:",
   "Cores (Total):",
 #ifdef ARCH_X86
-  "SSE:",
   "AVX:",
   "FMA:",
 #elif ARCH_PPC
@@ -597,7 +594,6 @@ bool print_cpufetch_x86(struct cpuInfo* cpu, STYLE s, struct color** cs, struct
   for(int i = 0; i < cpu->num_cpus; ptr = ptr->next_cpu, i++) {
     char* max_frequency = get_str_freq(ptr->freq);
     char* avx = get_str_avx(ptr);
-    char* sse = get_str_sse(ptr);
     char* fma = get_str_fma(ptr);
     char* cpu_num = emalloc(sizeof(char) * 9);
 
@@ -632,18 +628,8 @@ bool print_cpufetch_x86(struct cpuInfo* cpu, STYLE s, struct color** cs, struct
         setAttribute(art, ATTRIBUTE_NCORES, n_cores);
       }
     }
-
+    setAttribute(art, ATTRIBUTE_AVX, avx);
-    // Show the most modern vector instructions.
+    setAttribute(art, ATTRIBUTE_FMA, fma);
-    if (strcmp(avx, "No") == 0) {
-      if (strcmp(sse, "No") != 0) {
-        setAttribute(art, ATTRIBUTE_SSE, sse);
-      }
-    }
-    else {
-      setAttribute(art, ATTRIBUTE_AVX, avx);
-      setAttribute(art, ATTRIBUTE_FMA, fma);
-    }
-
     if(l1i != NULL) setAttribute(art, ATTRIBUTE_L1i, l1i);
     if(l1d != NULL) setAttribute(art, ATTRIBUTE_L1d, l1d);
     if(l2 != NULL) setAttribute(art, ATTRIBUTE_L2, l2);

src/ppc/ppc.c

@@ -146,7 +146,6 @@ struct uarch* get_cpu_uarch(struct cpuInfo* cpu) {
 struct frequency* get_frequency_info(void) {
   struct frequency* freq = emalloc(sizeof(struct frequency));
 
-  freq->measured = false;
   freq->max = get_max_freq_from_file(0);
   freq->base = get_min_freq_from_file(0);
 

src/riscv/riscv.c

@@ -19,7 +19,6 @@
 struct frequency* get_frequency_info(uint32_t core) {
   struct frequency* freq = emalloc(sizeof(struct frequency));
 
-  freq->measured = false;
   freq->base = UNKNOWN_DATA;
   freq->max = get_max_freq_from_file(core);
 

src/x86/apic.c

@@ -72,6 +72,34 @@ uint32_t get_apic_id(bool x2apic_id) {
   }
 }
 
+#ifndef __APPLE__
+bool bind_to_cpu(int cpu_id) {
+  #ifdef _WIN32
+    HANDLE process = GetCurrentProcess();
+    DWORD_PTR processAffinityMask = 1 << cpu_id;
+    return SetProcessAffinityMask(process, processAffinityMask);
+  #elif defined __linux__
+    cpu_set_t currentCPU;
+    CPU_ZERO(&currentCPU);
+    CPU_SET(cpu_id, &currentCPU);
+    if (sched_setaffinity (0, sizeof(currentCPU), &currentCPU) == -1) {
+      printWarn("sched_setaffinity: %s", strerror(errno));
+      return false;
+    }
+    return true;
+  #elif defined __FreeBSD__
+    cpuset_t currentCPU;
+    CPU_ZERO(&currentCPU);
+    CPU_SET(cpu_id, &currentCPU);
+    if(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(cpuset_t), &currentCPU) == -1) {
+      printWarn("cpuset_setaffinity: %s", strerror(errno));
+      return false;
+    }
+    return true;
+  #endif
+}
+#endif
+
 #ifdef __linux__
 int get_total_cores_module(int total_cores, int module) {
   int total_modules = 2;
@@ -369,11 +397,6 @@ bool fill_apic_ids(uint32_t* apic_ids, int first_core, int n, bool x2apic_id) {
 }
 
 bool get_topology_from_apic(struct cpuInfo* cpu, struct topology* topo) {
-  if (topo->cach == NULL) {
-    printWarn("get_topology_from_apic: cach is NULL");
-    return false;
-  }
-
   uint32_t apic_id;
   uint32_t* apic_ids = emalloc(sizeof(uint32_t) * topo->total_cores_module);
   uint32_t* apic_pkg = emalloc(sizeof(uint32_t) * topo->total_cores_module);

src/x86/apic.h

@@ -17,6 +17,10 @@ struct apic {
 bool get_topology_from_apic(struct cpuInfo* cpu, struct topology* topo);
 uint32_t is_smt_enabled_amd(struct topology* topo);
 
+#ifndef __APPLE__
+bool bind_to_cpu(int cpu_id);
+#endif
+
 #ifdef __linux__
 int get_total_cores_module(int total_cores, int module);
 #endif

src/x86/cpuid.c

@@ -6,10 +6,6 @@
   #include <unistd.h>
 #endif
 
-#ifdef __linux__
-  #include "../common/freq.h"
-#endif
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -223,7 +219,7 @@ int64_t get_peak_performance(struct cpuInfo* cpu, bool accurate_pp) {
   #endif
 
     //First, check we have consistent data
-    if(freq == UNKNOWN_DATA || topo == NULL || topo->logical_cores == UNKNOWN_DATA) {
+    if(freq == UNKNOWN_DATA || topo->logical_cores == UNKNOWN_DATA) {
       return -1;
     }
 
@@ -456,7 +452,7 @@ struct cpuInfo* get_cpu_info(void) {
   cpu->cach = NULL;
   cpu->feat = NULL;
 
-  cpu->num_cpus = 1;
+  uint32_t modules = 1;
   uint32_t eax = 0;
   uint32_t ebx = 0;
   uint32_t ecx = 0;
@@ -514,12 +510,12 @@ struct cpuInfo* get_cpu_info(void) {
     cpu->hybrid_flag = (edx >> 15) & 0x1;
   }
 
-  if(cpu->hybrid_flag) cpu->num_cpus = 2;
+  if(cpu->hybrid_flag) modules = 2;
 
   struct cpuInfo* ptr = cpu;
-  for(uint32_t i=0; i < cpu->num_cpus; i++) {
+  for(uint32_t i=0; i < modules; i++) {
     int32_t first_core;
-    set_cpu_module(i, cpu->num_cpus, &first_core);
+    set_cpu_module(i, modules, &first_core);
 
     if(i > 0) {
       ptr->next_cpu = emalloc(sizeof(struct cpuInfo));
@@ -554,7 +550,11 @@ struct cpuInfo* get_cpu_info(void) {
       cpu->cpu_name = infer_cpu_name_from_uarch(cpu->arch);
     }
 
+    // If any field of the struct is NULL,
+    // return early, as next functions
+    // require non NULL fields in cach and topo
     ptr->cach = get_cache_info(ptr);
+    if(ptr->cach == NULL) return cpu;
 
     if(cpu->hybrid_flag) {
       ptr->topo = get_topology_info(ptr, ptr->cach, i);
@@ -562,23 +562,16 @@ struct cpuInfo* get_cpu_info(void) {
     else {
       ptr->topo = get_topology_info(ptr, ptr->cach, -1);
     }
-
+    if(cpu->topo == NULL) return cpu;
-    // If topo is NULL, return early, as get_peak_performance
-    // requries non-NULL topology.
-    if(ptr->topo == NULL) return cpu;
   }
 
+  cpu->num_cpus = modules;
   cpu->peak_performance = get_peak_performance(cpu, accurate_pp());
 
   return cpu;
 }
 
 bool get_cache_topology_amd(struct cpuInfo* cpu, struct topology* topo) {
-  if (topo->cach == NULL) {
-    printWarn("get_cache_topology_amd: cach is NULL");
-    return false;
-  }
-
   if(cpu->maxExtendedLevels >= 0x8000001D && cpu->topology_extensions) {
     uint32_t i, eax, ebx, ecx, edx, num_sharing_cache, cache_type, cache_level;
 
@@ -654,17 +647,10 @@ bool get_cache_topology_amd(struct cpuInfo* cpu, struct topology* topo) {
 
 #ifdef __linux__
 void get_topology_from_udev(struct topology* topo) {
-  topo->total_cores = get_ncores_from_cpuinfo();
   // TODO: To be improved in the future
-  if (topo->total_cores == 1) {
+  topo->total_cores = get_ncores_from_cpuinfo();
-    // We can assume it's a single core CPU
+  topo->logical_cores = topo->total_cores;
-    topo->logical_cores = topo->total_cores;
+  topo->physical_cores = topo->total_cores;
-    topo->physical_cores = topo->total_cores;
-  }
-  else {
-    topo->logical_cores = UNKNOWN_DATA;
-    topo->physical_cores = UNKNOWN_DATA;
-  }
   topo->smt_available = 1;
   topo->smt_supported = 1;
   topo->sockets = 1;
@@ -709,27 +695,29 @@ struct topology* get_topology_info(struct cpuInfo* cpu, struct cache* cach, int
     topo->total_cores_module = topo->total_cores;
   }
 
-  bool toporet = false;
   switch(cpu->cpu_vendor) {
     case CPU_VENDOR_INTEL:
       if (cpu->maxLevels >= 0x00000004) {
-        toporet = get_topology_from_apic(cpu, topo);
+        bool toporet = get_topology_from_apic(cpu, topo);
+        if(!toporet) {
+          #ifdef __linux__
+            printWarn("Failed to retrieve topology from APIC, using udev...\n");
+            get_topology_from_udev(topo);
+          #else
+            printErr("Failed to retrieve topology from APIC, assumming default values...\n");
+            topo->logical_cores = UNKNOWN_DATA;
+            topo->physical_cores = UNKNOWN_DATA;
+            topo->smt_available = 1;
+            topo->smt_supported = 1;
+          #endif
+        }
       }
       else {
-        printWarn("Can't read topology information from cpuid (needed level is 0x%.8X, max is 0x%.8X)", 0x00000004, cpu->maxLevels);
+        printWarn("Can't read topology information from cpuid (needed level is 0x%.8X, max is 0x%.8X)", 0x00000001, cpu->maxLevels);
-      }
+        topo->physical_cores = 1;
-      if(!toporet) {
+        topo->logical_cores = 1;
-        #ifdef __linux__
+        topo->smt_available = 1;
-          printWarn("Failed to retrieve topology from APIC, using udev...");
+        topo->smt_supported = 1;
-          get_topology_from_udev(topo);
-        #else
-          if (cpu->maxLevels >= 0x00000004)
-            printErr("Failed to retrieve topology from APIC, assumming default values...");
-          topo->logical_cores = UNKNOWN_DATA;
-          topo->physical_cores = UNKNOWN_DATA;
-          topo->smt_available = 1;
-          topo->smt_supported = 1;
-        #endif
       }
       break;
     case CPU_VENDOR_AMD:
@@ -750,15 +738,10 @@ struct topology* get_topology_info(struct cpuInfo* cpu, struct cache* cach, int
         }
       }
       else {
-        #ifdef __linux__
+        printWarn("Can't read topology information from cpuid (needed extended level is 0x%.8X, max is 0x%.8X)", 0x80000008, cpu->maxExtendedLevels);
-          printWarn("Can't read topology information from cpuid (needed extended level is 0x%.8X, max is 0x%.8X), using udev...", 0x80000008, cpu->maxExtendedLevels);
+        topo->physical_cores = 1;
-          get_topology_from_udev(topo);
+        topo->logical_cores = 1;
-        #else
+        topo->smt_supported = 1;
-          printWarn("Can't read topology information from cpuid (needed extended level is 0x%.8X, max is 0x%.8X)", 0x80000008, cpu->maxExtendedLevels);
-          topo->physical_cores = 1;
-          topo->logical_cores = 1;
-          topo->smt_supported = 1;
-        #endif
       }
 
       if (cpu->maxLevels >= 0x00000001) {
@@ -935,7 +918,6 @@ struct cache* get_cache_info(struct cpuInfo* cpu) {
 
 struct frequency* get_frequency_info(struct cpuInfo* cpu) {
   struct frequency* freq = emalloc(sizeof(struct frequency));
-  freq->measured = false;
 
   if(cpu->maxLevels < 0x00000016) {
     #if defined (_WIN32) || defined (__APPLE__)
@@ -945,7 +927,7 @@ struct frequency* get_frequency_info(struct cpuInfo* cpu) {
     #else
       printWarn("Can't read frequency information from cpuid (needed level is 0x%.8X, max is 0x%.8X). Using udev", 0x00000016, cpu->maxLevels);
       freq->base = UNKNOWN_DATA;
-      freq->max = get_max_freq_from_file(cpu->first_core_id);
+      freq->max = get_max_freq_from_file(0);
 
       if(freq->max == 0) {
         printWarn("Read max CPU frequency from udev and got 0 MHz");
@@ -972,7 +954,7 @@ struct frequency* get_frequency_info(struct cpuInfo* cpu) {
       printWarn("Read max CPU frequency from CPUID and got 0 MHz");
       #ifdef __linux__
         printWarn("Using udev to detect frequency");
-        freq->max = get_max_freq_from_file(cpu->first_core_id);
+        freq->max = get_max_freq_from_file(0);
 
         if(freq->max == 0) {
           printWarn("Read max CPU frequency from udev and got 0 MHz");
@@ -984,15 +966,6 @@ struct frequency* get_frequency_info(struct cpuInfo* cpu) {
     }
   }
 
-  #ifdef __linux__
-    if (freq->max == UNKNOWN_DATA || measure_max_frequency_flag()) {
-      if (freq->max == UNKNOWN_DATA)
-        printWarn("All previous methods failed, measuring CPU frequency");
-      freq->max = measure_max_frequency(cpu->first_core_id);
-      freq->measured = true;
-    }
-  #endif
-
   return freq;
 }
 
@@ -1014,34 +987,25 @@ char* get_str_topology(struct cpuInfo* cpu, struct topology* topo, bool dual_soc
     string = emalloc(sizeof(char) * (strlen(STRING_UNKNOWN) + 1));
     strcpy(string, STRING_UNKNOWN);
   }
-  else {
+  else if(topo->smt_supported > 1) {
-    char cores_str[6];
+    // 4 for digits, 21 for ' cores (SMT disabled)' which is the longest possible output
-    memset(cores_str, 0, sizeof(char) * 6);
+    uint32_t max_size = 4+21+1;
-    if (topo->physical_cores * topo_sockets > 1)
+    string = emalloc(sizeof(char) * max_size);
-      strcpy(cores_str, "cores");
-    else
-      strcpy(cores_str, "core");
 
-    if(topo->smt_supported > 1) {
+    if(topo->smt_available > 1)
-      // 4 for digits, 21 for ' cores (SMT disabled)' which is the longest possible output
+      snprintf(string, max_size, "%d cores (%d threads)", topo->physical_cores * topo_sockets, topo->logical_cores * topo_sockets);
-      uint32_t max_size = 4+21+1;
-      string = emalloc(sizeof(char) * max_size);
-
-      if(topo->smt_available > 1)
-        snprintf(string, max_size, "%d %s (%d threads)", topo->physical_cores * topo_sockets, cores_str, topo->logical_cores * topo_sockets);
-      else {
-        if(cpu->cpu_vendor == CPU_VENDOR_AMD)
-          snprintf(string, max_size, "%d %s (SMT disabled)", topo->physical_cores * topo_sockets, cores_str);
-        else
-          snprintf(string, max_size, "%d %s (HT disabled)", topo->physical_cores * topo_sockets, cores_str);
-      }
-    }
     else {
-      uint32_t max_size = 4+7+1;
+      if(cpu->cpu_vendor == CPU_VENDOR_AMD)
-      string = emalloc(sizeof(char) * max_size);
+        snprintf(string, max_size, "%d cores (SMT disabled)", topo->physical_cores * topo_sockets);
-      snprintf(string, max_size, "%d %s",topo->physical_cores * topo_sockets, cores_str);
+      else
+        snprintf(string, max_size, "%d cores (HT disabled)", topo->physical_cores * topo_sockets);
     }
   }
+  else {
+    uint32_t max_size = 4+7+1;
+    string = emalloc(sizeof(char) * max_size);
+    snprintf(string, max_size, "%d cores",topo->physical_cores * topo_sockets);
+  }
 
   return string;
 }
@@ -1101,14 +1065,8 @@ char* get_str_sse(struct cpuInfo* cpu) {
       last+=SSE4_2_sl;
   }
 
-  if (last == 0) {
+  //Purge last comma
-    snprintf(string, 2+1, "No");
+  string[last-1] = '\0';
-  }
-  else {
-    //Purge last comma
-    string[last-1] = '\0';
-  }
-
   return string;
 }