cpu_information: report turbo/boost state, hardware peak, and P/E class

The existing per-CPU line printed only the kernel governor's scaling
window via scaling_min_freq / scaling_max_freq. On a system with
boost disabled, or on hybrid CPUs where different cores have
different boost ceilings, that window is the same number on every
core and conveys nothing about whether the CPU can actually run
faster than displayed.

Add three signals so the benchmark banner reflects what the silicon
can do:

1. Turbo/boost state -- a single global line. Reads
   /sys/devices/system/cpu/cpufreq/boost first (AMD CPB,
   acpi-cpufreq, amd-pstate); falls back to
   /sys/devices/system/cpu/intel_pstate/no_turbo (intel_pstate,
   inverse-sense). Reported as on/off; the line is omitted when
   neither file is readable.

2. Hardware peak frequency -- per CPU, when it exceeds the
   scaling cap. Reads amd_pstate_max_freq first (the per-core
   boost ceiling reported by amd-pstate; differs across cores on
   AMD hybrid parts), then cpuinfo_max_freq (Intel turbo cap).
   Suppressed when equal to scaling_max_freq so the line stays
   short on non-hybrid / boost-on systems.

3. P-core / E-core label -- per CPU. Resolved from
   /sys/devices/cpu_core/cpus (P) and /sys/devices/cpu_atom/cpus
   (E), the Intel hybrid PMU sysfs. Empty on non-hybrid Intel and
   on AMD (where the hardware-peak value already exposes the
   split, e.g. 5090 MHz Zen 5 vs 3506 MHz Zen 5c on a Ryzen AI
   7 PRO 350).

Sample on the AMD Ryzen AI 7 PRO 350 (boost disabled,
2 GHz scaling cap):

  CPU information:
      CPUs allowed: 0-1,4-5
      Turbo/boost: off
      CPU0, scaling [623MHz .. 2000MHz], hw peak 5090MHz
      CPU1, scaling [623MHz .. 2000MHz], hw peak 3506MHz
      CPU4, scaling [623MHz .. 2000MHz], hw peak 5090MHz
      CPU5, scaling [623MHz .. 2000MHz], hw peak 3506MHz

Incidental cleanup: the scaling range now prints [min .. max]
(was [max .. min]) since "scaling ... hw peak X" only reads
naturally with an ascending range.

API shape: cpu_scaling_min_freq / cpu_scaling_max_freq collapse
into a single cpu_info_for(cpu) returning a struct (scaling
min/max, hw peak, core class). cpu_boost_enabled() returns
std::optional<bool>.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: rantala

src/sortstring.cpp

@@ -521,16 +521,26 @@ cpu_information(void)
 	std::printf("CPU information:\n");
 	if (!cpus_al.empty())
 		std::printf("    CPUs allowed: %s\n", cpus_al.c_str());
+	if (auto boost = cpu_boost_enabled())
+		std::printf("    Turbo/boost: %s\n", *boost ? "on" : "off");
 	for (int i=0; i < maxcpu; ++i) {
-		if (CPU_ISSET_S(i, cpus_setsize, cpus)) {
-			std::printf("    CPU%d", i);
-			auto min_freq = cpu_scaling_min_freq(i);
-			auto max_freq = cpu_scaling_max_freq(i);
-			if (min_freq && max_freq)
-				std::printf(", scaling frequencies: [%dMHz .. %dMHz]",
-						*max_freq/1000, *min_freq/1000);
-			std::puts("");
+		if (!CPU_ISSET_S(i, cpus_setsize, cpus))
+			continue;
+		const cpu_info info = cpu_info_for(i);
+		std::printf("    CPU%d", i);
+		switch (info.klass) {
+		case cpu_info::core_class::performance: std::printf(" (P-core)"); break;
+		case cpu_info::core_class::efficiency:  std::printf(" (E-core)"); break;
+		case cpu_info::core_class::unknown: break;
 		}
+		if (info.scaling_min_khz && info.scaling_max_khz)
+			std::printf(", scaling [%dMHz .. %dMHz]",
+					*info.scaling_min_khz/1000,
+					*info.scaling_max_khz/1000);
+		if (info.hw_max_khz && info.scaling_max_khz &&
+		    *info.hw_max_khz > *info.scaling_max_khz)
+			std::printf(", hw peak %dMHz", *info.hw_max_khz/1000);
+		std::puts("");
 	}
 	std::putchar('\n');
 	if (cpus)

src/util/cpus_allowed.cpp

@@ -115,6 +115,36 @@ read_int_file(const std::string &path)
 	return v;
 }
 
+/* Parse a Linux cpulist string ("0-3,5,7-9") and report whether `cpu`
+ * is a member. Returns std::nullopt if the file cannot be read; false
+ * if the file is readable but `cpu` is not listed. */
+std::optional<bool>
+cpu_in_cpulist_file(int cpu, const std::string &path)
+{
+	std::ifstream f(path);
+	if (!f) return std::nullopt;
+	std::string list;
+	std::getline(f, list);
+	std::stringstream ss(list);
+	std::string tok;
+	while (std::getline(ss, tok, ',')) {
+		auto dash = tok.find('-');
+		int lo, hi;
+		try {
+			if (dash == std::string::npos) {
+				lo = hi = std::stoi(tok);
+			} else {
+				lo = std::stoi(tok.substr(0, dash));
+				hi = std::stoi(tok.substr(dash + 1));
+			}
+		} catch (...) {
+			continue;
+		}
+		if (cpu >= lo && cpu <= hi) return true;
+	}
+	return false;
+}
+
 } // namespace
 
 std::string
@@ -141,18 +171,39 @@ cpus_allowed()
 	return info;
 }
 
-std::optional<int>
-cpu_scaling_min_freq(int cpu)
+cpu_info
+cpu_info_for(int cpu)
 {
-	std::ostringstream path;
-	path << "/sys/devices/system/cpu/cpu" << cpu << "/cpufreq/scaling_min_freq";
-	return read_int_file(path.str());
+	std::ostringstream base;
+	base << "/sys/devices/system/cpu/cpu" << cpu << "/cpufreq/";
+	const std::string b = base.str();
+
+	cpu_info info;
+	info.scaling_min_khz = read_int_file(b + "scaling_min_freq");
+	info.scaling_max_khz = read_int_file(b + "scaling_max_freq");
+	/* Hardware peak (boost-capable) frequency:
+	 *  - AMD pstate: amd_pstate_max_freq is the per-core boost cap;
+	 *    cpuinfo_max_freq tracks scaling_max_freq when boost is off.
+	 *  - Intel:      cpuinfo_max_freq is the turbo cap. */
+	info.hw_max_khz = read_int_file(b + "amd_pstate_max_freq");
+	if (!info.hw_max_khz)
+		info.hw_max_khz = read_int_file(b + "cpuinfo_max_freq");
+	/* Intel hybrid topology: cpu_core PMU lists P-cores, cpu_atom E-cores. */
+	if (cpu_in_cpulist_file(cpu, "/sys/devices/cpu_core/cpus").value_or(false))
+		info.klass = cpu_info::core_class::performance;
+	else if (cpu_in_cpulist_file(cpu, "/sys/devices/cpu_atom/cpus").value_or(false))
+		info.klass = cpu_info::core_class::efficiency;
+	return info;
 }
 
-std::optional<int>
-cpu_scaling_max_freq(int cpu)
+/* Turbo/boost state, reported as the inverse-sense pair the kernel
+ * exposes for each driver family. */
+std::optional<bool>
+cpu_boost_enabled()
 {
-	std::ostringstream path;
-	path << "/sys/devices/system/cpu/cpu" << cpu << "/cpufreq/scaling_max_freq";
-	return read_int_file(path.str());
+	if (auto v = read_int_file("/sys/devices/system/cpu/cpufreq/boost"))
+		return *v != 0;
+	if (auto v = read_int_file("/sys/devices/system/cpu/intel_pstate/no_turbo"))
+		return *v == 0;
+	return std::nullopt;
 }

src/util/cpus_allowed.h

@@ -35,9 +35,21 @@ struct cpus_info {
 	int        maxcpu  = 0;
 };
 
+struct cpu_info {
+	enum class core_class {
+		unknown,
+		performance, // Intel P-core (cpu_core PMU)
+		efficiency,  // Intel E-core (cpu_atom PMU)
+	};
+	std::optional<int> scaling_min_khz;
+	std::optional<int> scaling_max_khz;
+	std::optional<int> hw_max_khz; // amd_pstate_max_freq or cpuinfo_max_freq
+	core_class         klass = core_class::unknown;
+};
+
 [[nodiscard]] std::string cpus_allowed_list();
 [[nodiscard]] cpus_info cpus_allowed();
-[[nodiscard]] std::optional<int> cpu_scaling_max_freq(int cpu);
-[[nodiscard]] std::optional<int> cpu_scaling_min_freq(int cpu);
+[[nodiscard]] cpu_info cpu_info_for(int cpu);
+[[nodiscard]] std::optional<bool> cpu_boost_enabled();
 
 #endif /* CPUS_ALLOWED_H */