foo.rs

use std::fs::{self, File};
use std::io::prelude::*;
use std::process::Command;
use std::time::{Instant, Duration};

#[derive(Clone)]
struct Data {
    release: bool,
    cgus: usize,
    thinlto: bool,
    dur: Duration,
    fresh: bool,
    build: usize,
}

fn main() {
    let mut data = Vec::new();
    for &release in [true, false].iter() {
        for &cgus in [1, 2, 4, 8, 16, 32, 64].iter() {
            build(release, cgus, false, &mut data);
            if release {
                build(release, cgus, true, &mut data);
            }
        }
    }

    let d = data.iter().filter(|d| d.fresh).cloned().collect::<Vec<_>>();
    println!("| cgus | 1 | 2 | 4 | 8 | 16 | 32 | 64 |");
    println!("|------|---|---|---|---|----|----|----|");
    print("debug", &mut d.iter().filter(|d| !d.release));
    print("release thinlto=no", &mut d.iter().filter(|d| d.release && !d.thinlto));
    print("release thinlto=yes", &mut d.iter().filter(|d| d.release && d.thinlto));

    println!("");

    let d = data.iter().filter(|d| !d.fresh).cloned().collect::<Vec<_>>();
    println!("| cgus | 1 | 2 | 4 | 8 | 16 | 32 | 64 |");
    println!("|------|---|---|---|---|----|----|----|");
    print("debug", &mut d.iter().filter(|d| !d.release));
    print("release thinlto=no", &mut d.iter().filter(|d| d.release && !d.thinlto));
    print("release thinlto=yes", &mut d.iter().filter(|d| d.release && d.thinlto));
}

fn print(header: &str, it: &mut Iterator<Item = &Data>) {
    let mut builds = Vec::new();
    for data in it {
        while builds.len() <= data.build {
            builds.push(Vec::new());
        }
        builds[data.build].push(data);
    }

    for (i, builds) in builds.iter_mut().enumerate() {
        builds.sort_by_key(|b| b.cgus);
        print!("| {} #{} |", header, i);
        let smallest = builds.iter().map(|b| b.dur).min();
        for build in builds {
            let bold = if Some(build.dur) == smallest {
                "**"
            } else {
                ""
            };
            print!(" {}{}.{:03}{} |",
                   bold,
                   build.dur.as_secs(),
                   build.dur.subsec_nanos() / 1_000_000,
                   bold);
        }
        println!("");
    }
}

fn build(release: bool, cgus: usize, thinlto: bool, data: &mut Vec<Data>) {
    let mut lib = String::new();
    File::open("services/positions-api/src/main.rs").unwrap()
        .read_to_string(&mut lib).unwrap();

    for build in 0..2 {
        drop(fs::remove_dir_all("target"));

        let mut cmd = Command::new("cargo");
        cmd.arg("+nightly");
        cmd.arg("build");
        cmd.arg("--frozen");
        cmd.arg("--manifest-path").arg("services/positions-api/Cargo.toml");
        if release {
            cmd.arg("--release");
        }
        let mut flags = format!("-C codegen-units={}", cgus);
        if thinlto {
            flags.push_str(" -Z thinlto");
        }
        cmd.env("RUSTFLAGS", flags);

        let start = Instant::now();
        let status = cmd.status().unwrap();
        let dur = start.elapsed();
        assert!(status.success());

        println!("fresh=true ; release={:5}; cgus={:2}, thinlto={:5}; dur={}.{:03}",
                 release,
                 cgus,
                 thinlto,
                 dur.as_secs(),
                 dur.subsec_nanos() / 1_000_000);
        data.push(Data {
            release,
            cgus,
            thinlto,
            dur,
            fresh: false,
            build,
        });

        File::create("services/positions-api/src/main.rs").unwrap()
            .write_all(lib.as_bytes()).unwrap();

        let start = Instant::now();
        let status = cmd.status().unwrap();
        let dur = start.elapsed();
        assert!(status.success());

        println!("fresh=false; release={:5}; cgus={:2}, thinlto={:5}; dur={}.{:03}",
                 release,
                 cgus,
                 thinlto,
                 dur.as_secs(),
                 dur.subsec_nanos() / 1_000_000);
        data.push(Data {
            release,
            cgus,
            thinlto,
            dur,
            fresh: true,
            build,
        });
    }
}