fix: only set PYTHONPERFSUPPORT for exec-harness benchmarks

Setting PYTHONPERFSUPPORT=1 in every mode (#577) activates CPython's perf
trampoline in all Python processes the runner starts. pytest-codspeed
crashes with it enabled and the run exits with status 139.

Remove it from the shared runner env and set it only in exec-harness,
which needs the perf map to name Python frames in its profiles.

exec-harness now exposes runtime_env::env(), which apply() uses. The
memtrack interpreter tests use it as a dev-dependency instead of copying
the env and the node wrapper flags by hand.

Author: not-matthias

Cargo.lock

@@ -5,7 +5,7 @@ use std::io::{self, BufRead};
 pub mod analysis;
 pub mod constants;
 pub mod prelude;
-mod runtime_env;
+pub mod runtime_env;
 mod uri;
 pub mod walltime;
 

crates/exec-harness/src/lib.rs

@@ -1,23 +1,37 @@
 //! Runtime env for benchmark processes started by exec-harness: the shared
-//! [`runner_shared::runtime_env::env`] vars plus the `node` wrapper on `PATH`.
+//! [`runner_shared::runtime_env::env`] vars, `PYTHONPERFSUPPORT`, and the
+//! `node` wrapper on `PATH`.
 
 use crate::MeasurementMode;
+use std::ffi::OsString;
 
 mod node;
 
-const PATH_ENV: &str = "PATH";
+/// Env vars to set on benchmark processes for `mode`.
+pub fn env(mode: MeasurementMode) -> anyhow::Result<Vec<(&'static str, OsString)>> {
+    let mut env: Vec<(&'static str, OsString)> = runner_shared::runtime_env::env(mode)
+        .into_iter()
+        .map(|(key, value)| (key, value.into()))
+        .collect();
+    // Makes CPython write `/tmp/perf-<pid>.map` (or jitdump when
+    // `PYTHON_PERF_JIT_SUPPORT=1`) so profiles can name Python frames. Only set
+    // for exec-harness: integrations with their own harness (pytest-codspeed)
+    // crash with the perf trampoline enabled.
+    env.push(("PYTHONPERFSUPPORT", "1".into()));
+    let path = std::env::var_os("PATH").unwrap_or_default();
+    env.push(("PATH", node::path_with_node_wrapper(&path)?));
+    Ok(env)
+}
 
-/// Applies the runtime env and the node wrapper to the current process, so
-/// every child inherits them. Existing values are overwritten: `mode` may come
-/// from a CLI flag that differs from an inherited `CODSPEED_RUNNER_MODE`.
+/// Applies [`env`] to the current process, so every child inherits it.
+/// Existing values are overwritten: `mode` may come from a CLI flag that
+/// differs from an inherited `CODSPEED_RUNNER_MODE`.
 ///
 /// # Safety
 /// Must be called while the process is single-threaded.
 pub(crate) unsafe fn apply(mode: MeasurementMode) -> anyhow::Result<()> {
-    for (key, value) in runner_shared::runtime_env::env(mode) {
+    for (key, value) in env(mode)? {
         unsafe { std::env::set_var(key, value) };
     }
-    let path = std::env::var_os(PATH_ENV).unwrap_or_default();
-    unsafe { std::env::set_var(PATH_ENV, node::path_with_node_wrapper(&path)?) };
     Ok(())
 }

crates/exec-harness/src/runtime_env/mod.rs

@@ -49,6 +49,7 @@ bindgen = "0.72"
 
 [dev-dependencies]
 tempfile = { workspace = true }
+exec-harness = { path = "../exec-harness" }
 rstest = { workspace = true }
 test-log = { workspace = true }
 insta = { workspace = true, features = ["json", "redactions"] }

crates/memtrack/Cargo.toml

@@ -4,24 +4,16 @@ mod shared;
 use memtrack::TrackerOptions;
 use runner_shared::artifacts::{MemtrackEvent, MemtrackEventKind};
 use runner_shared::measurement_mode::MeasurementMode;
-use runner_shared::runtime_env;
 use std::path::Path;
 use std::process::Command;
 
 const ALLOCATION_SIZE: u64 = 2_000_001;
-const NODE_PROGRAM: &str = "node";
-/// Writes /tmp/perf-<pid>.map.
-const NODE_PERF_MAP_FLAG: &str = "--perf-basic-prof";
 
-/// Applies the memory-mode runtime env the runner injects, and makes Node
-/// emit its perf map like exec-harness's `node` wrapper does in memory mode.
+/// Runs `program` with the env exec-harness sets for memory-mode benchmarks.
 fn memory_mode_command(program: &str, fixture_path: &str) -> anyhow::Result<Command> {
     let mut command = Command::new(program);
-    if program == NODE_PROGRAM {
-        command.arg(NODE_PERF_MAP_FLAG);
-    }
     command.arg(fixture_path);
-    command.envs(runtime_env::env(MeasurementMode::Memory));
+    command.envs(exec_harness::runtime_env::env(MeasurementMode::Memory)?);
     Ok(command)
 }
 
@@ -87,7 +79,7 @@ fn test_python_allocation_has_jit_symbol() -> anyhow::Result<()> {
 #[test_with::env(GITHUB_ACTIONS)]
 #[test_log::test]
 fn test_node_allocation_has_jit_symbol() -> anyhow::Result<()> {
-    let command = memory_mode_command(NODE_PROGRAM, &fixture("node_alloc.js"))?;
+    let command = memory_mode_command("node", &fixture("node_alloc.js"))?;
     let (events, thread_handle) = shared::track_command(command, stack_capture())?;
 
     assert_perf_map_symbol(allocation_pid(&events), "JS:~allocation ");

crates/memtrack/tests/interpreter_tests.rs

@@ -2,21 +2,17 @@ use crate::measurement_mode::MeasurementMode;
 
 const PYTHONHASHSEED: &str = "PYTHONHASHSEED";
 const PYTHON_PERF_JIT_SUPPORT: &str = "PYTHON_PERF_JIT_SUPPORT";
-const PYTHONPERFSUPPORT: &str = "PYTHONPERFSUPPORT";
 
 /// Python env:
 /// - `PYTHONHASHSEED=0`: deterministic hashing in every mode.
 /// - `PYTHON_PERF_JIT_SUPPORT`: perf jitdump for walltime profiles.
 ///   FIXME(COD-2645): Keep this disabled on macOS. Enabling it causes
 ///   many unresolved addresses on the stack when profiling with samply.
-/// - `PYTHONPERFSUPPORT=1`: `/tmp/perf-<pid>.map` so valgrind and memory flamegraphs can
-///   name Python frames. When `PYTHON_PERF_JIT_SUPPORT=1` is also set, CPython uses jitdump.
 pub(super) fn env(mode: MeasurementMode) -> Vec<(&'static str, String)> {
     let perf_jit = mode == MeasurementMode::Walltime && !cfg!(target_os = "macos");
     let perf_jit_value = if perf_jit { "1" } else { "0" };
     vec![
         (PYTHONHASHSEED, "0".to_owned()),
         (PYTHON_PERF_JIT_SUPPORT, perf_jit_value.to_owned()),
-        (PYTHONPERFSUPPORT, "1".to_owned()),
     ]
 }