mod commands;
use cbtop::config::{ComputeBackend, LoadProfile, WorkloadType};
use cbtop::headless::OutputFormat;
use cbtop::{CbtopApp, CbtopError, Config};
use clap::{Parser, Subcommand};
#[derive(Parser, Debug)]
#[command(name = "aprender-cbtop")]
#[command(author = "Trueno Engineering")]
#[command(version = concat!(env!("CARGO_PKG_VERSION"), " (", env!("APR_GIT_SHA"), ")"))]
#[command(about = "Real-time load testing and hardware monitoring TUI", long_about = None)]
struct Cli {
#[command(subcommand)]
command: Option<Commands>,
#[arg(short, long, default_value = "100")]
refresh: u64,
#[arg(short, long, default_value = "0")]
device: u32,
#[arg(short, long, default_value = "all", value_parser = BACKENDS, ignore_case = true)]
backend: String,
#[arg(short, long, default_value = "idle", value_parser = LOADS, ignore_case = true)]
load: String,
#[arg(short, long, default_value = "gemm", value_parser = WORKLOADS, ignore_case = true)]
workload: String,
#[arg(short, long, default_value = "1048576")]
size: usize,
#[arg(short, long)]
threads: Option<usize>,
#[arg(long)]
deterministic: bool,
#[arg(long)]
show_fps: bool,
#[arg(short, long)]
config: Option<std::path::PathBuf>,
#[arg(long)]
headless: bool,
#[arg(long, default_value = "text", value_parser = FORMATS, ignore_case = true)]
format: String,
#[arg(long, default_value = "5")]
duration: u64,
#[arg(short, long)]
output: Option<std::path::PathBuf>,
}
#[derive(Subcommand, Debug)]
enum Commands {
Bench {
#[arg(short, long, default_value = "simd", value_parser = BACKENDS, ignore_case = true)]
backend: String,
#[arg(short, long, default_value = "gemm", value_parser = WORKLOADS, ignore_case = true)]
workload: String,
#[arg(short, long, default_value = "1048576")]
size: usize,
#[arg(short, long, default_value = "5")]
duration: u64,
#[arg(short, long, default_value = "json", value_parser = FORMATS, ignore_case = true)]
format: String,
#[arg(short, long)]
output: Option<std::path::PathBuf>,
#[arg(long)]
baseline: Option<std::path::PathBuf>,
#[arg(long, default_value = "5.0")]
fail_on_regression: f64,
#[arg(long, value_parser = parse_backend_list)]
compare: Option<String>,
},
Optimize {
#[command(subcommand)]
action: OptimizeAction,
},
}
#[derive(Subcommand, Debug)]
pub(crate) enum OptimizeAction {
Baseline {
#[arg(short, long, default_value = "benchmarks/baseline.json")]
output: std::path::PathBuf,
#[arg(long)]
quick: bool,
#[arg(short, long, default_value = "3")]
duration: u64,
},
Analyze {
#[arg(short, long, default_value = "benchmarks/baseline.json")]
baseline: std::path::PathBuf,
#[arg(short, long, default_value = "text", value_parser = FORMATS)]
format: String,
#[arg(short, long)]
output: Option<std::path::PathBuf>,
},
Check {
#[arg(short, long, default_value = "benchmarks/baseline.json")]
baseline: std::path::PathBuf,
#[arg(short, long, default_value = "5.0")]
threshold: f64,
#[arg(long)]
quick: bool,
#[arg(short, long, default_value = "text", value_parser = FORMATS)]
format: String,
},
}
const BACKENDS: [&str; 4] = ["simd", "wgpu", "cuda", "all"];
const LOADS: [&str; 5] = ["idle", "light", "medium", "heavy", "stress"];
const WORKLOADS: [&str; 8] = [
"gemm",
"conv",
"conv2d",
"attention",
"bandwidth",
"elementwise",
"reduction",
"all",
];
const FORMATS: [&str; 2] = ["text", "json"];
fn parse_backend_list(s: &str) -> Result<String, String> {
for item in s.split(',') {
let item = item.trim().to_lowercase();
if !BACKENDS.contains(&item.as_str()) {
return Err(format!(
"invalid backend '{item}' [possible values: {}]",
BACKENDS.join(", ")
));
}
}
Ok(s.to_string())
}
fn parse_backend(s: &str) -> ComputeBackend {
match s.to_lowercase().as_str() {
"simd" => ComputeBackend::Simd,
"wgpu" => ComputeBackend::Wgpu,
"cuda" => ComputeBackend::Cuda,
_ => ComputeBackend::All,
}
}
fn parse_load_profile(s: &str) -> LoadProfile {
match s.to_lowercase().as_str() {
"light" => LoadProfile::Light,
"medium" => LoadProfile::Medium,
"heavy" => LoadProfile::Heavy,
"stress" => LoadProfile::Stress,
_ => LoadProfile::Idle,
}
}
fn parse_workload(s: &str) -> WorkloadType {
match s.to_lowercase().as_str() {
"conv" | "conv2d" => WorkloadType::Conv2d,
"attention" => WorkloadType::Attention,
"bandwidth" => WorkloadType::Bandwidth,
"elementwise" => WorkloadType::Elementwise,
"reduction" => WorkloadType::Reduction,
"all" => WorkloadType::All,
_ => WorkloadType::Gemm,
}
}
fn parse_output_format(s: &str) -> OutputFormat {
match s.to_lowercase().as_str() {
"json" => OutputFormat::Json,
_ => OutputFormat::Text,
}
}
fn main() -> Result<(), CbtopError> {
let cli = Cli::parse();
match cli.command {
Some(Commands::Bench {
backend,
workload,
size,
duration,
format,
output,
baseline,
fail_on_regression,
compare,
}) => {
return commands::run_bench(
&backend,
&workload,
size,
duration,
&format,
output,
baseline,
fail_on_regression,
compare,
);
}
Some(Commands::Optimize { action }) => {
return commands::run_optimize(action);
}
None => {}
}
if cli.headless {
return commands::run_headless(
&cli.backend,
&cli.workload,
cli.size,
cli.duration,
&cli.format,
cli.output,
);
}
let config = Config {
refresh_ms: cli.refresh,
device_index: cli.device,
backend: parse_backend(&cli.backend),
load_profile: parse_load_profile(&cli.load),
workload: parse_workload(&cli.workload),
problem_size: cli.size,
threads: cli.threads.unwrap_or_else(|| {
std::thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(1)
}),
deterministic: cli.deterministic,
show_fps: cli.show_fps,
config_path: cli.config,
};
let mut app = CbtopApp::new(config)?;
app.run()
}
#[cfg(test)]
mod g13_tests {
use super::Cli;
use clap::{CommandFactory, Parser};
fn rejects(args: &[&str]) -> bool {
Cli::try_parse_from(args).is_err()
}
#[test]
fn g13_name_is_the_target_name() {
assert_eq!(Cli::command().get_name(), "aprender-cbtop");
}
#[test]
fn g13_bogus_enumerated_values_are_usage_errors() {
for bad in [
&["aprender-cbtop", "bench", "--backend", "nosuch"][..],
&["aprender-cbtop", "bench", "--workload", "dot"],
&["aprender-cbtop", "bench", "--format", "nosuch"],
&["aprender-cbtop", "bench", "--compare", "simd,nosuch"],
&["aprender-cbtop", "--load", "nosuch"],
&["aprender-cbtop", "--backend", "nosuch"],
&["aprender-cbtop", "--workload", "nosuch"],
&["aprender-cbtop", "--format", "nosuch"],
&[
"aprender-cbtop",
"optimize",
"analyze",
"--format",
"nosuch",
],
&["aprender-cbtop", "optimize", "check", "--format", "nosuch"],
] {
assert!(rejects(bad), "accepted {bad:?}");
}
}
#[test]
fn g13_valid_values_parse_case_insensitively() {
for ok in [
&["aprender-cbtop", "bench", "--backend", "SIMD"][..],
&["aprender-cbtop", "bench", "--workload", "conv2d"],
&["aprender-cbtop", "bench", "--compare", "simd, all"],
&["aprender-cbtop", "--load", "stress", "--format", "json"],
&["aprender-cbtop", "optimize", "check", "--format", "json"],
] {
assert!(!rejects(ok), "rejected {ok:?}");
}
}
}