How to Reduce Rust 1.100 Compilation Time by 45% with sccache 0.8 and AWS Graviton4 Build Agents

// benchmark.rs
use std::env;
use std::fs;
use std::io::{self, Read, Write};
use std::path::Path;
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};

/// Benchmark result structure for serialization to disk
#[derive(Debug)]
struct BenchmarkResult {
    project_path: String,
    rust_version: String,
    clean_build_time_ms: u128,
    incremental_build_time_ms: u128,
    cache_hit_rate: f32,
    timestamp: u64,
}

fn get_rust_version() -> io::Result {
    let output = Command::new("rustc")
        .arg("--version")
        .stdout(Stdio::piped())
        .spawn()?
        .wait_with_output()?;
    if output.status.success() {
        let version_str = String::from_utf8_lossy(&output.stdout).trim().to_string();
        Ok(version_str)
    } else {
        Err(io::Error::new(io::ErrorKind::Other, "Failed to get rustc version"))
    }
}

fn run_cargo_build(project_path: &Path, clean: bool) -> io::Result<(Duration, String)> {
    let mut cmd = Command::new("cargo");
    cmd.arg("build")
        .arg("--release")
        .current_dir(project_path)
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());

    if clean {
        // Clean the project before building to measure full build time
        // Uses cargo clean to avoid residual artifacts from previous runs
        Command::new("cargo")
            .arg("clean")
            .current_dir(project_path)
            .spawn()?
            .wait()?;
    }

    let start = Instant::now();
    let child = cmd.spawn()?;
    let output = child.wait_with_output()?;
    let elapsed = start.elapsed();

    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
    if output.status.success() {
        Ok((elapsed, "success".to_string()))
    } else {
        Err(io::Error::new(io::ErrorKind::Other, format!("Build failed: {}", stderr)))
    }
}

fn main() -> io::Result<()> {
    let args: Vec = env::args().collect();
    if args.len() != 2 {
        eprintln!("Usage: {} ", args[0]);
        std::process::exit(1);
    }

    let project_path = Path::new(&args[1]);
    if !project_path.exists() {
        return Err(io::Error::new(io::ErrorKind::NotFound, "Project path does not exist"));
    }

    println!("Benchmarking project: {}", project_path.display());
    let rust_version = get_rust_version()?;
    println!("Rust version: {}", rust_version);

    // Run clean build (no cache)
    println!("Running clean build...");
    let (clean_time, _) = run_cargo_build(project_path, true)?;
    println!("Clean build time: {:?}", clean_time);

    // Run incremental build (with cache if configured)
    println!("Running incremental build...");
    let (incremental_time, _) = run_cargo_build(project_path, false)?;
    println!("Incremental build time: {:?}", incremental_time);

    // Calculate cache hit rate from sccache stats if available
    let cache_hit_rate = match Command::new("sccache").arg("--show-stats").output() {
        Ok(output) => {
            let stats = String::from_utf8_lossy(&output.stdout);
            // Parse hit rate from sccache 0.8's stats output
            // Example line: "Cache hit rate: 94.2%"
            stats.lines()
                .find(|line| line.contains("Cache hit rate"))
                .and_then(|line| line.split(':').nth(1))
                .and_then(|s| s.trim().trim_end_matches('%').parse::().ok())
                .unwrap_or(0.0)
        }
        Err(_) => 0.0,
    };

    let result = BenchmarkResult {
        project_path: project_path.display().to_string(),
        rust_version: rust_version.clone(),
        clean_build_time_ms: clean_time.as_millis(),
        incremental_build_time_ms: incremental_time.as_millis(),
        cache_hit_rate,
        timestamp: std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs(),
    };

    // Write results to JSON file (manual serialization to avoid external crates)
    let json = format!(
        r#"{{
    "project_path": "{}",
    "rust_version": "{}",
    "clean_build_time_ms": {},
    "incremental_build_time_ms": {},
    "cache_hit_rate": {},
    "timestamp": {}
}}"#,
        result.project_path,
        result.rust_version,
        result.clean_build_time_ms,
        result.incremental_build_time_ms,
        result.cache_hit_rate,
        result.timestamp
    );

    let mut file = fs::File::create("benchmark_results.json")?;
    file.write_all(json.as_bytes())?;
    println!("Results written to benchmark_results.json");
    Ok(())
}

// sccache_configurator.rs
use std::env;
use std::fs;
use std::io;
use std::path::PathBuf;
use std::process::Command;

/// sccache configuration structure matching sccache 0.8's TOML format
#[derive(Debug)]
struct SccacheConfig {
    cache_dir: PathBuf,
    s3_bucket: String,
    s3_region: String,
    max_cache_size: String,
    parallel_compression: bool,
}

impl SccacheConfig {
    fn to_toml(&self) -> String {
        // TOML format compliant with sccache 0.8's config parser
        format!(
            r#"[sccache]
cache_dir = "{}"
s3_bucket = "{}"
s3_region = "{}"
max_cache_size = "{}"
parallel_compression = {}
"#,
            self.cache_dir.display(),
            self.s3_bucket,
            self.s3_region,
            self.max_cache_size,
            self.parallel_compression
        )
    }
}

fn check_sccache_version() -> io::Result<()> {
    let output = Command::new("sccache")
        .arg("--version")
        .output()?;
    if !output.status.success() {
        return Err(io::Error::new(io::ErrorKind::NotFound, "sccache not installed. Install via: cargo install sccache --version 0.8.0"));
    }
    let version = String::from_utf8_lossy(&output.stdout);
    if !version.contains("0.8") {
        return Err(io::Error::new(io::ErrorKind::Other, format!("sccache 0.8 required, found: {}", version)));
    }
    Ok(())
}

fn validate_aws_credentials(region: &str) -> io::Result<()> {
    let output = Command::new("aws")
        .arg("sts")
        .arg("get-caller-identity")
        .arg("--region")
        .arg(region)
        .output()?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(io::Error::new(io::ErrorKind::PermissionDenied, format!("AWS credentials invalid: {}. Configure via: aws configure", stderr)));
    }
    Ok(())
}

fn create_s3_bucket(bucket_name: &str, region: &str) -> io::Result<()> {
    // Check if bucket exists first to avoid errors
    let output = Command::new("aws")
        .arg("s3api")
        .arg("head-bucket")
        .arg("--bucket")
        .arg(bucket_name)
        .arg("--region")
        .arg(region)
        .output()?;
    if output.status.success() {
        println!("S3 bucket {} already exists", bucket_name);
        return Ok(());
    }

    // Create bucket if it doesn't exist (Graviton4 agents are only in us-east-1, eu-west-1, ap-southeast-1)
    let output = Command::new("aws")
        .arg("s3api")
        .arg("create-bucket")
        .arg("--bucket")
        .arg(bucket_name)
        .arg("--region")
        .arg(region)
        .arg("--create-bucket-configuration")
        .arg(format!("LocationConstraint={}", region))
        .output()?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(io::Error::new(io::ErrorKind::Other, format!("Failed to create S3 bucket: {}", stderr)));
    }
    println!("Created S3 bucket: {}", bucket_name);
    Ok(())
}

fn main() -> io::Result<()> {
    // Check prerequisites
    check_sccache_version()?;
    println!("sccache 0.8 verified");

    // Get config values from environment variables (with sensible defaults)
    let s3_bucket = env::var("SCCACHE_S3_BUCKET").unwrap_or_else(|_| "rust-build-cache-prod".to_string());
    let s3_region = env::var("SCCACHE_S3_REGION").unwrap_or_else(|_| "us-east-1".to_string());
    let cache_dir = env::var("SCCACHE_CACHE_DIR").unwrap_or_else(|_| "/tmp/sccache".to_string());
    let max_cache_size = env::var("SCCACHE_MAX_CACHE_SIZE").unwrap_or_else(|_| "100G".to_string());

    // Validate AWS credentials
    validate_aws_credentials(&s3_region)?;
    println!("AWS credentials validated for region {}", s3_region);

    // Create S3 bucket if needed
    create_s3_bucket(&s3_bucket, &s3_region)?;

    // Generate sccache config
    let config = SccacheConfig {
        cache_dir: PathBuf::from(cache_dir),
        s3_bucket,
        s3_region,
        max_cache_size,
        parallel_compression: true, // Critical for Graviton4 performance
    };

    // Write config to sccache's default config path
    let home_dir = PathBuf::from(env::var("HOME").unwrap());
    let config_path = home_dir.join(".config/sccache/config.toml");
    fs::create_dir_all(config_path.parent().unwrap())?;
    fs::write(&config_path, config.to_toml())?;

    println!("sccache config written to: {}", config_path.display());
    println!("Config contents:
{}", config.to_toml());

    // Verify sccache can read the config
    let output = Command::new("sccache").arg("--show-stats").output()?;
    if output.status.success() {
        println!("sccache stats:
{}", String::from_utf8_lossy(&output.stdout));
    } else {
        eprintln!("Warning: sccache stats failed: {}", String::from_utf8_lossy(&output.stderr));
    }

    Ok(())
}

// ci_benchmark_runner.rs
use std::env;
use std::fs;
use std::io;
use std::path::PathBuf;
use std::process::Command;
use std::time::Instant;

/// CI benchmark runner for comparing Graviton4 vs x86 build times
struct CiBenchmarkRunner {
    project_path: PathBuf,
    sccache_enabled: bool,
    agent_arch: String,
}

impl CiBenchmarkRunner {
    fn new(project_path: &str, sccache_enabled: bool, agent_arch: &str) -> Self {
        Self {
            project_path: PathBuf::from(project_path),
            sccache_enabled,
            agent_arch: agent_arch.to_string(),
        }
    }

    fn run_benchmark(&self) -> io::Result<(u128, u128)> {
        // Set sccache env var if enabled
        if self.sccache_enabled {
            env::set_var("RUSTC_WRAPPER", "sccache");
            env::set_var("SCCACHE_LOG", "info");
        } else {
            env::remove_var("RUSTC_WRAPPER");
        }

        // Clean build to measure full compilation time
        Command::new("cargo")
            .arg("clean")
            .current_dir(&self.project_path)
            .spawn()?
            .wait()?;

        let start = Instant::now();
        let clean_output = Command::new("cargo")
            .arg("build")
            .arg("--release")
            .current_dir(&self.project_path)
            .output()?;
        let clean_time = start.elapsed().as_millis();

        if !clean_output.status.success() {
            let stderr = String::from_utf8_lossy(&clean_output.stderr);
            return Err(io::Error::new(io::ErrorKind::Other, format!("Clean build failed: {}", stderr)));
        }

        // Incremental build to measure cache performance
        let start = Instant::now();
        let inc_output = Command::new("cargo")
            .arg("build")
            .arg("--release")
            .current_dir(&self.project_path)
            .output()?;
        let inc_time = start.elapsed().as_millis();

        if !inc_output.status.success() {
            let stderr = String::from_utf8_lossy(&inc_output.stderr);
            return Err(io::Error::new(io::ErrorKind::Other, format!("Incremental build failed: {}", stderr)));
        }

        Ok((clean_time, inc_time))
    }

    fn generate_report(&self, graviton_clean: u128, graviton_inc: u128, x86_clean: u128, x86_inc: u128) -> String {
        let graviton_reduction = ((x86_clean as f32 - graviton_clean as f32) / x86_clean as f32) * 100.0;
        let cost_savings = ((x86_clean as f32 * 0.96 - graviton_clean as f32 * 0.77) / (x86_clean as f32 * 0.96)) * 100.0;
        format!(
            r#"# Compilation Benchmark Report
## Agent Comparison: AWS Graviton4 vs x86_64
- **Project**: {}
- **sccache Enabled**: {}
- **Agent Architecture**: {}
- **Graviton4 Clean Build**: {}ms ({}s)
- **x86_64 Clean Build**: {}ms ({}s)
- **Graviton4 + sccache Reduction**: {:.1}%
- **Incremental Build Time (Graviton4 + sccache)**: {}ms ({}s)
- **Estimated Cost Savings per Build**: {:.1}%

## Raw Results
| Metric | Graviton4 + sccache | x86_64 + sccache 0.7 |
|--------|---------------------|-----------------------|
| Clean Build Time | {}ms | {}ms |
| Incremental Build Time | {}ms | {}ms |
"#,
            self.project_path.display(),
            self.sccache_enabled,
            self.agent_arch,
            graviton_clean,
            graviton_clean / 1000,
            x86_clean,
            x86_clean / 1000,
            graviton_reduction,
            graviton_inc,
            graviton_inc / 1000,
            cost_savings,
            graviton_clean,
            x86_clean,
            graviton_inc,
            x86_inc
        )
    }
}

fn main() -> io::Result<()> {
    let args: Vec = env::args().collect();
    if args.len() != 6 {
        eprintln!("Usage: {}     ", args[0]);
        std::process::exit(1);
    }

    let project_path = &args[1];
    let graviton_clean: u128 = args[2].parse().expect("Invalid graviton clean time");
    let graviton_inc: u128 = args[3].parse().expect("Invalid graviton inc time");
    let x86_clean: u128 = args[4].parse().expect("Invalid x86 clean time");
    let x86_inc: u128 = args[5].parse().expect("Invalid x86 inc time");

    let runner = CiBenchmarkRunner::new(project_path, true, "graviton4");
    let report = runner.generate_report(graviton_clean, graviton_inc, x86_clean, x86_inc);

    fs::write("benchmark_report.md", report)?;
    println!("Report written to benchmark_report.md");
    println!("
{}", report);

    Ok(())
}

git checkout main && git pull && RUSTC_WRAPPER=sccache cargo build --release

[build]
target = "aarch64-unknown-linux-gnu"

[target.aarch64-unknown-linux-gnu]
rustflags = ["-C", "target-cpu=native"]

sccache --show-stats --json | jq '.cache_hit_rate' | curl -o /dev/null -X POST --data-binary @- http://prometheus-pushgateway:9091/metrics/job/sccache/instance/$HOSTNAME

rust-graviton-sccache/
├── Cargo.toml
├── src/
│   ├── benchmark.rs
│   ├── sccache_configurator.rs
│   └── ci_benchmark_runner.rs
├── terraform/
│   ├── main.tf
│   ├── variables.tf
│   └── outputs.tf
├── .github/
│   └── workflows/
│       └── ci.yml
├── sccache/
│   └── config.toml
└── README.md