Struct BenchConfig 

pub struct BenchConfig {

    pub model: String,
    pub runs: usize,
    pub concurrency: usize,
    pub workload: Option<String>,
    pub output_format: OutputFormat,
    pub output_path: Option<PathBuf>,
    pub warmup: usize,
    pub save_baseline: bool,
    pub check_regression: bool,
    pub tolerance: f64,
    pub external_frameworks: Vec<ExternalFrameworkConfig>,
    pub external_timeout_secs: u64,
    pub concurrency_sweep: Option<Vec<usize>>,
    pub memory_sample_interval_ms: u64,
    pub suite: Option<TaskSuite>,
    pub baseline_path: PathBuf,
    pub dry_run: bool,
    pub max_cost_usd: Option<f64>,
    pub confirm_cost: bool,
    pub experimental: bool,
}

Top-level benchmark configuration mapped from CLI flags.

Controls all aspects of benchmark execution including iteration count, concurrency, output format, regression detection, and cost guards.

Example

use adk_bench::BenchConfig;

let config = BenchConfig {
    model: "gemini-2.5-flash".to_string(),
    runs: 10,
    concurrency: 4,
    ..Default::default()
};
assert_eq!(config.runs, 10);
assert_eq!(config.warmup, 3);

Fields

model: String

Model identifier (e.g., “gemini-2.5-flash”).

runs: usize

Number of measurement iterations per workload.

concurrency: usize

Agent concurrency level (1 = sequential).

workload: Option<String>

Specific workload to run (None = all built-in).

output_format: OutputFormat

Output format for results.

output_path: Option<PathBuf>

Output file path (None = stdout).

warmup: usize

Warm-up iterations before measurement begins (discarded).

save_baseline: bool

Whether to save results as baseline after the run.

check_regression: bool

Whether to check regression against a saved baseline.

tolerance: f64

Maximum allowed relative degradation (default 0.10 = 10%).

external_frameworks: Vec<ExternalFrameworkConfig>

External framework configurations for comparison.

external_timeout_secs: u64

Timeout for external framework runs in seconds.

concurrency_sweep: Option<Vec<usize>>

Concurrency sweep levels (if sweep mode enabled). When set, the runner tests each level sequentially: e.g., [1, 2, 4, 8, 16, 32, 64].

memory_sample_interval_ms: u64

Memory sampling interval in milliseconds.

suite: Option<TaskSuite>

Task quality suite to run (tau2, bfcl).

baseline_path: PathBuf

Baseline file path for regression detection.

dry_run: bool

Dry-run mode: compute and display estimated cost without executing API calls.

max_cost_usd: Option<f64>

Maximum allowed API cost in USD; abort if estimated cost exceeds this.

confirm_cost: bool

Skip interactive cost confirmation (auto-confirm when estimated cost > $1.00).

experimental: bool

Enable experimental workloads (e.g., multi-agent delegation).

Trait Implementations

impl Clone for BenchConfig

fn clone(&self) -> BenchConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BenchConfig

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

Formats the value using the given formatter.

impl Default for BenchConfig

fn default() -> Self

Creates a BenchConfig with documented defaults:

• model: "gemini-2.5-flash"
• runs: 5
• concurrency: 1 (sequential)
• warmup: 3
• tolerance: 0.10 (10%)
• external_timeout_secs: 300
• memory_sample_interval_ms: 100
• output_format: Table
• baseline_path: .bench-baseline.json
• dry_run: false
• max_cost_usd: None
• confirm_cost: false
• experimental: false

impl<'de> Deserialize<'de> for BenchConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BenchConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.