megafine 0.1.0

A multithreaded command-line benchmarking tool
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use std::path::PathBuf;

use anyhow::{Context, Result, bail};
use tracing::debug;

use crate::cli::Cli;
use crate::format::TimeUnit;

pub struct Options {
    pub jobs: usize,
    pub warmup: u64,
    pub runs: Option<u64>,
    /// `None` runs commands directly; `Some(path)` runs them through that shell.
    pub shell: Option<PathBuf>,
    pub setup: Option<String>,
    pub prepare: Option<String>,
    pub cleanup: Option<String>,
    pub time_unit: Option<TimeUnit>,
    /// Time only the command's `megafine_start()`/`megafine_stop()` region.
    pub region: bool,
    /// Calibrate the measurement floor against `/bin/true` before timing.
    pub calibrate: bool,
    /// Pin each concurrent job to its own disjoint subset of the allowed CPUs.
    pub pin: bool,
}

fn all_cores() -> usize {
    std::thread::available_parallelism()
        .map(|n| n.into())
        .unwrap_or(1)
}

impl Options {
    pub fn from_cli(cli: &Cli) -> Result<Self> {
        let jobs = match cli.jobs {
            None | Some(0) => all_cores(),
            Some(n) => n,
        };

        let shell = if cli.shell {
            let ppid = unsafe { libc::getppid() };
            let exe = format!("/proc/{ppid}/exe");
            let exe = std::fs::read_link(&exe)
                .with_context(|| format!("could not resolve the current shell via {exe}"))?;
            debug!("Current shell is {}", exe.display());
            Some(exe)
        } else {
            None
        };

        let time_unit = cli
            .time_unit
            .as_deref()
            .map(|s| {
                TimeUnit::parse(s)
                    .with_context(|| format!("invalid time unit '{s}' (use us, ms or s)"))
            })
            .transpose()?;

        if let Some(0) = cli.runs {
            bail!("--runs must be at least 1");
        }

        if cli.command_name.len() > cli.commands.len() {
            bail!(
                "got {} command names but only {} command(s)",
                cli.command_name.len(),
                cli.commands.len()
            );
        }

        Ok(Options {
            jobs,
            warmup: cli.warmup,
            runs: cli.runs,
            shell,
            setup: cli.setup.clone(),
            prepare: cli.prepare.clone(),
            cleanup: cli.cleanup.clone(),
            time_unit,
            region: cli.region,
            calibrate: !cli.region && !cli.no_calibrate,
            pin: !cli.no_pin,
        })
    }
}