Added support for Performance / Efficency cores.

Author: FractalFir

collector/src/compile/execute/mod.rs

@@ -129,7 +129,55 @@ pub struct CargoProcess<'a> {
     pub touch_file: Option<String>,
     pub jobserver: Option<jobserver::Client>,
 }
-
+/// Returns an optional list of Performance CPU cores, if the system has P and E cores.
+/// This list *should* be in a format suitable for the `taskset` command.
+#[cfg(target_os = "linux")]
+fn performance_cores() -> Option<&'static String> {
+    use std::sync::LazyLock;
+    static PERFORMANCE_CORES: LazyLock<Option<String>> = LazyLock::new(|| {
+        // Check if /sys/devices/cpu exists - if it does, then this is not a "Performance-hybrid" CPU.
+        if std::fs::exists("/sys/devices/cpu").expect("Could not check the CPU architecture detali: could not check if `/sys/devices/cpu` exists!"){
+		None
+	}
+	// Check if /sys/devices/cpu_core exists - if it does, then this is a "Performance-hybrid" CPU.
+	else if std::fs::exists("/sys/devices/cpu_core").expect("Could not check the CPU architecture detali: could not check if `/sys/devices/cpu_core` exists!") {
+		Some(std::fs::read_to_string("/sys/devices/cpu_core/cpus").unwrap().trim().to_string())
+	}else{
+		// If neither dir exists, then something is wrong - `/sys/devices/cpu` has been in Linux for over a decade.
+		eprintln!("WARNING: neither `/sys/devices/cpu` nor `/sys/devices/cpu_core` present, unable to determine if this CPU has a Performance-Hybrid architecture.");
+		None
+	}
+    });
+    (*PERFORMANCE_CORES).as_ref()
+}
+#[cfg(target_os = "windows")]
+// Windows stub - TODO: implement to add Performance core support to Windows.
+fn performance_cores() -> Option<&'static String>{
+	None 
+}
+#[cfg(target_os = "macos")]
+// To my knoweladge, MacOS does not run on hardware with P/E cores, so this can simply always return None.
+fn performance_cores() -> Option<&'static String>{
+	None 
+}
+#[cfg(not(any(target_os = "windows",target_os = "macos",target_os = "linux")))]
+// I don't think rustc-perf runs on OSs other than Linux, Windows, or Mac, but I'll still leave a stub here just in case.
+fn performance_cores() -> Option<&'static String>{
+	None
+}
+#[cfg(target_os = "linux")]
+/// Makes the benchmark run only on Performance cores.
+fn run_on_p_cores(path:&Path,cpu_list:&str)->Command{
+        	let mut cmd = Command::new("taskset");
+        	cmd.arg("--cpu-list");
+        	cmd.arg(cpu_list);
+        	cmd.arg(path);
+        	cmd
+}
+#[cfg(not(target_os = "linux"))]
+fn run_on_p_cores(path:&Path,cpu_list:&str)->Command{
+	todo!("Can't run comamnds on the P cores on this platofmr")
+}
 impl<'a> CargoProcess<'a> {
     pub fn incremental(mut self, incremental: bool) -> Self {
         self.incremental = incremental;
@@ -148,7 +196,12 @@ impl<'a> CargoProcess<'a> {
     }
 
     fn base_command(&self, cwd: &Path, subcommand: &str) -> Command {
-        let mut cmd = Command::new(Path::new(&self.toolchain.components.cargo));
+        // Processors with P and E cores require special handling
+        let mut cmd = if let Some(p_cores) = performance_cores() {
+        	run_on_p_cores(Path::new(&self.toolchain.components.cargo),p_cores)
+        } else{
+        	Command::new(Path::new(&self.toolchain.components.cargo))
+        };
         cmd
             // Not all cargo invocations (e.g. `cargo clean`) need all of these
             // env vars set, but it doesn't hurt to have them.
@@ -551,7 +604,11 @@ fn process_stat_output(
         let mut parts = line.split(';').map(|s| s.trim());
         let cnt = get!(parts.next());
         let _unit = get!(parts.next());
-        let name = get!(parts.next());
+        let mut name = get!(parts.next());
+        // Map P-core events to normal events
+        if name == "cpu_core/instructions:u/"{
+        	name = "instructions:u".into();
+        }
         let _time = get!(parts.next());
         let pct = get!(parts.next());
         if cnt == "<not supported>" || cnt == "<not counted>" || cnt.is_empty() {