Enum Commands 

pub enum Commands {
    Profile {
        target: ProfileTarget,
    },
    Bench {
        bench: String,
        counters: Option<String>,
        check_regression: bool,
        threshold: f64,
        roofline: bool,
    },
    Roofline {
        target: String,
        kernels: Option<String>,
        export: Option<String>,
        empirical: bool,
    },
    Diff {
        baseline: Option<String>,
        current: Option<String>,
        before: Option<String>,
        after: Option<String>,
    },
    Contract {
        action: ContractAction,
    },
    Trace {
        binary: String,
        duration: Option<String>,
    },
    Explain {
        target: String,
        kernel: Option<String>,
    },
    Tui,
    Baseline {
        save: Option<String>,
        load: Option<String>,
    },
    Doctor,
    Compete {
        workload: String,
        ours: String,
        theirs: Vec<String>,
        label: Option<String>,
    },
}

Top-level cgp subcommands.

Variants

Profile

Profile a kernel or function (runtime execution)

Fields

target: ProfileTarget

Bench

Enhanced criterion benchmarking with hardware counters

Fields

bench: String

Benchmark name

counters: Option<String>

Hardware counters to collect (comma-separated)

check_regression: bool

Check regression against saved baseline

threshold: f64

Regression threshold percentage

roofline: bool

Overlay roofline model

Roofline

Generate roofline model for target hardware

Fields

target: String

Target backend (cuda, avx2, avx512, neon, wgpu)

kernels: Option<String>

Kernels to plot on roofline

export: Option<String>

Export to file

empirical: bool

Use empirical measurement instead of spec values

Diff

Compare two profiles (git integration)

Fields

baseline: Option<String>

Baseline commit or profile path

current: Option<String>

Current commit or profile path

before: Option<String>

Before commit

after: Option<String>

After commit

Contract

Verify performance contracts (CI/CD gate)

Fields

action: ContractAction

Trace

System-wide timeline (wraps nsys)

Fields

binary: String

Binary to trace

duration: Option<String>

Trace duration

Explain

Static code analysis (wraps trueno-explain)

Fields

target: String

Analysis target (ptx, simd, wgsl)

kernel: Option<String>

Kernel name

Tui

Interactive TUI exploration mode

Baseline

Save/load performance baselines

Fields

save: Option<String>

Save current profile as baseline

load: Option<String>

Load baseline from file

Doctor

Check tool availability and hardware capabilities

Compete

Head-to-head competitor comparison

Fields

workload: String

Workload name (e.g., gemm)

ours: String

Our command

theirs: Vec<String>

Competitor commands (can be repeated)

label: Option<String>

Labels for each entry (comma-separated)

Trait Implementations

impl Clone for Commands

fn clone(&self) -> Commands

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Commands

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Commands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Commands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand