Method run

src/executor/wall_time/executor.rs:174–235

(
        &mut self,
        execution_context: &ExecutionContext,
        _mongo_tracer: &Option<MongoTracer>,
    )

    }

    async fn run(
        &mut self,
        execution_context: &ExecutionContext,
        _mongo_tracer: &Option<MongoTracer>,
    ) -> Result<()> {
        let _guard = HookScriptsGuard::setup();

        let (_env_file, _script_file, cmd_builder) =
            WallTimeExecutor::walltime_bench_cmd(&execution_context.config, execution_context)?;

        // Resolve the isolation decision once and reuse it for both the scope
        // wrapping here and the privilege wrapping below (or in the profiler).
        let isolate = requires_isolation();
        let cmd_builder = if isolate {
            wrap_isolation_scope(cmd_builder)?
        } else {
            cmd_builder
        };

        // Split-borrow `self` so the closure inside `run_with_profiler` can
        // capture `benchmark_state` while we hold `&mut profiler`.
        let Self {
            profiler,
            benchmark_state,
        } = self;

        let status = match profiler.as_mut() {
            Some(profiler) if execution_context.config.enable_profiler => {
                run_with_profiler(
                    profiler.as_mut(),
                    cmd_builder,
                    &execution_context.config,
                    &execution_context.profile_folder,
                    isolate,
                    benchmark_state,
                )
                .await
            }
            _ => {
                // No profiler: still honor the isolation decision, since the
                // scope (and the sudo it requires) is a property of the run, not
                // of the profiler.
                let cmd_builder = if isolate {
                    wrap_with_sudo(cmd_builder)?
                } else {
                    cmd_builder
                };
                let cmd = cmd_builder.build();
                debug!("cmd: {cmd:?}");
                run_command_with_log_pipe(cmd).await
            }
        };

        let status = status.map_err(|e| anyhow!("failed to execute the benchmark process. {e}"))?;
        debug!("cmd exit status: {status:?}");

        if !status.success() {
            bail!("failed to execute the benchmark process: {status}");