बेंचमार्किंग

adk-bench crate और cargo adk bench command ADK-Rust agents के लिए वास्तविक-LLM बेंचमार्किंग प्रदान करते हैं। सिंथेटिक माइक्रोबेंचमार्क के विपरीत, adk-bench लाइव मॉडल कॉल के साथ वास्तविक एंड-टू-एंड प्रदर्शन को मापता है, जो framework overhead को provider latency से अलग करता है।

यह क्या मापता है

त्वरित शुरुआत

# Run all benchmarks with default settings
cargo adk bench

# Run a specific workload
cargo adk bench --workload simple_tool_call

# Dry run (no LLM calls, validates config only)
cargo adk bench --dry-run

CLI संदर्भ

cargo adk bench [OPTIONS]

OPTIONS:
    --workload <NAME>          Run a specific workload (simple_tool_call,
                               multi_step_reasoning, parallel_tool_invocation)
    --iterations <N>           Number of iterations per workload [default: 10]
    --warmup <N>               Warmup iterations before measurement [default: 2]
    --provider <NAME>          LLM provider to benchmark [default: gemini]
    --model <MODEL>            Model ID to use [default: gemini-2.5-flash]
    --output <FORMAT>          Output format: table, json, csv [default: table]
    --output-file <PATH>       Write results to file instead of stdout

    # Cost control
    --dry-run                  Validate configuration without making LLM calls
    --max-cost-usd <AMOUNT>    Abort if estimated cost exceeds this amount
    --confirm-cost             Prompt for confirmation before running

    # Regression detection
    --save-baseline <NAME>     Save results as a named baseline
    --check-regression <NAME>  Compare against a saved baseline
    --tolerance <PERCENT>      Regression threshold percentage [default: 10]

    # External comparison
    --ebp                      Enable External Benchmark Protocol output
    --harness <PATH>           Path to external framework harness config

लागत नियंत्रण

बेंचमार्क वास्तविक LLM कॉल करते हैं। अप्रत्याशित बिलों से बचने के लिए इन फ़्लैग का उपयोग करें:

# Preview what would run without spending anything
cargo adk bench --dry-run

# Set a hard cost ceiling
cargo adk bench --max-cost-usd 5.00

# Require manual confirmation after cost estimate
cargo adk bench --confirm-cost

लागत अनुमानक पिछले रन से टोकन गणना (या वर्कलोड परिभाषा से अनुमान) का उपयोग करता है, जिसे प्रदाता के प्रकाशित प्रति-टोकन मूल्य निर्धारण से गुणा किया जाता है।

रिग्रेशन डिटेक्शन

रिलीज़ भर में प्रदर्शन को ट्रैक करें:

# Establish a baseline after a release
cargo adk bench --save-baseline v1.0.0

# On the next change, check for regressions
cargo adk bench --check-regression v1.0.0 --tolerance 10

# Tighter tolerance for critical paths
cargo adk bench --workload simple_tool_call --check-regression v1.0.0 --tolerance 5

एग्जिट कोड:

• 0 — कोई रिग्रेशन नहीं मिला
• 1 — कम से कम एक मीट्रिक सहनशीलता से परे बिगड़ गया
• 2 — कॉन्फ़िगरेशन या रनटाइम त्रुटि

बेसलाइन .adk-bench/baselines/ में JSON फ़ाइलों के रूप में संग्रहीत हैं।

बाहरी फ़्रेमवर्क तुलना (EBP)

एक्सटर्नल बेंचमार्क प्रोटोकॉल (EBP) अन्य एजेंट फ़्रेमवर्क के साथ सीधी तुलना को सक्षम बनाता है। EBP एक मानक वर्कलोड प्रारूप और माप प्रोटोकॉल को परिभाषित करता है ताकि परिणाम विभिन्न कार्यान्वयनों में तुलनीय हों।

# Output EBP-compatible results
cargo adk bench --ebp --output json > results.json

# Run against an external harness (e.g., LangGraph, Python SDK)
cargo adk bench --harness harnesses/langraph.toml

हार्नेस कॉन्फ़िगरेशन फ़ाइलें परिभाषित करती हैं कि समान वर्कलोड के साथ बाहरी फ़्रेमवर्क को कैसे आह्वान किया जाए और समान कार्यप्रणाली का उपयोग करके उनके परिणामों को कैसे मापा जाए।

बेंचमार्क परिणाम

प्रकाशित परिणाम ADK-Rust की अन्य फ़्रेमवर्क (नियतात्मक कॉन्फ़िग, समान मॉडल, समान वर्कलोड) के विरुद्ध तुलना करते हुए:

कार्यप्रणाली:

• वास्तविक Gemini 2.5 Flash कॉल (मॉक नहीं किए गए)
• नियतात्मक कॉन्फ़िग: temperature=0, निश्चित सीड
• 2 वार्मअप रन के बाद 10 पुनरावृत्तियाँ
• ओवरहेड अलगाव: कुल समय माइनस मापी गई LLM लेटेंसी
• सभी फ्रेमवर्क में समान टूल परिभाषाएँ और प्रॉम्प्ट

वर्कलोड

simple_tool_call

एकल उपयोगकर्ता संदेश → एक टूल कॉल → एक प्रतिक्रिया। न्यूनतम राउंड-ट्रिप ओवरहेड को मापता है।

multi_step_reasoning

बहु-मोड़ वाली बातचीत जिसमें प्रत्येक के बीच तर्क के साथ 3-5 अनुक्रमिक टूल कॉल की आवश्यकता होती है। निरंतर लूप प्रदर्शन को मापता है।

parallel_tool_invocation

एकल उपयोगकर्ता संदेश जो 3 समानांतर टूल कॉल को ट्रिगर करता है। समवर्ती प्रेषण ओवरहेड को मापता है।

प्रोग्रामेटिक उपयोग

use adk_bench::{BenchmarkSuite, BenchConfig, Workload};

let config = BenchConfig::builder()
    .iterations(10)
    .warmup(2)
    .provider("gemini")
    .model("gemini-2.5-flash")
    .build()?;

let suite = BenchmarkSuite::new(config);
let results = suite.run_all().await?;

for result in &results {
    println!("{}: cold_start={}ms overhead={}μs",
        result.workload,
        result.cold_start_ms,
        result.loop_overhead_us,
    );
}

आगे पढ़ें

इसके लिए adk-bench/README.md देखें:

• कस्टम वर्कलोड परिभाषाएँ
• हार्नेस ऑथरिंग गाइड
• CI एकीकरण पैटर्न
• ऐतिहासिक परिणाम ट्रैकिंग

---

पिछला: ← कोड निष्पादन | अगला: ACP टूल्स →