Struct Cli 

pub struct Cli {

    pub command: Option<Commands>,
    pub filter: String,
    pub format: String,
    pub output: Option<PathBuf>,
    pub baseline: Option<PathBuf>,
    pub dry_run: bool,
    pub threshold: Option<f64>,
    pub group: Option<String>,
    pub tag: Option<String>,
    pub skip_tag: Option<String>,
    pub warmup: u64,
    pub measurement: u64,
    pub samples: Option<u64>,
    pub min_iterations: Option<u64>,
    pub max_iterations: Option<u64>,
    pub verbose: bool,
    pub isolated: bool,
    pub one_shot: bool,
    pub worker_timeout: u64,
    pub jobs: usize,
    pub threads: usize,
    pub flux_worker: bool,
    pub save_baseline: Option<Option<PathBuf>>,
    pub bench: bool,
}

FluxBench CLI arguments

Fields

command: Option<Commands>

Optional subcommand (List, Run, Compare); defaults to Run

filter: String

Filter benchmarks by regex pattern

format: String

Output format: json, github-summary, csv, html, human

output: Option<PathBuf>

Output file (stdout if not specified)

baseline: Option<PathBuf>

Load baseline for comparison

dry_run: bool

Dry run - list benchmarks without executing

threshold: Option<f64>

Regression threshold percentage

group: Option<String>

Run benchmarks for this group only

tag: Option<String>

Filter by tag

skip_tag: Option<String>

Skip benchmarks with this tag

warmup: u64

Warmup time in seconds

measurement: u64

Measurement time in seconds

samples: Option<u64>

Fixed sample count mode: skip warmup, run exactly N iterations Each iteration becomes one sample. Overrides warmup/measurement/min/max.

min_iterations: Option<u64>

Minimum number of iterations

max_iterations: Option<u64>

Maximum number of iterations

verbose: bool

Verbose output

isolated: bool

Run benchmarks in isolated worker processes (default: true) Use –isolated=false to disable and run in-process

one_shot: bool

Use fresh worker process for each benchmark (One-Shot mode) Default is Persistent mode: reuse worker for safe Rust code

worker_timeout: u64

Worker timeout in seconds

jobs: usize

Number of parallel isolated workers

threads: usize

Number of threads for parallel statistics computation 0 = use all available cores (default), 1 = single-threaded

flux_worker: bool

Internal: Run as worker process (used by supervisor)

save_baseline: Option<Option<PathBuf>>

Save benchmark results as baseline JSON Optionally specify a path; defaults to config or target/fluxbench/baseline.json

bench: bool

Internal: Absorb cargo bench’s –bench flag

Trait Implementations

impl Args for Cli

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

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

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

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

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

impl CommandFactory for Cli

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for Cli

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

Formats the value using the given formatter.

impl FromArgMatches for Cli

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( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Cli

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.