verify_fibair/
verify_fibair.rs

1use std::sync::Arc;
2
3use clap::Parser;
4use eyre::Result;
5use openvm_benchmarks_prove::util::BenchmarkCli;
6#[cfg(feature = "cuda")]
7use openvm_circuit::utils::cpu_proving_ctx_to_gpu;
8use openvm_circuit::{
9    arch::{
10        instructions::exe::VmExe, verify_single, SingleSegmentVmProver,
11        DEFAULT_MAX_NUM_PUBLIC_VALUES,
12    },
13    utils::TestStarkEngine as Poseidon2Engine,
14};
15use openvm_native_circuit::{NativeBuilder, NativeConfig, NATIVE_MAX_TRACE_HEIGHTS};
16use openvm_native_compiler::conversion::CompilerOptions;
17use openvm_native_recursion::testing_utils::inner::build_verification_program;
18use openvm_sdk::{
19    config::{AppConfig, DEFAULT_APP_LOG_BLOWUP, DEFAULT_LEAF_LOG_BLOWUP},
20    keygen::AppProvingKey,
21    prover::vm::new_local_prover,
22};
23use openvm_stark_sdk::{
24    bench::run_with_metric_collection, config::FriParameters,
25    dummy_airs::fib_air::chip::FibonacciChip, engine::StarkFriEngine, openvm_stark_backend::Chip,
26};
27use tracing::info_span;
28
29/// Benchmark of aggregation VM performance.
30/// Proofs:
31/// 1. Prove Fibonacci AIR.
32/// 2. Verify the proof of 1. by execution VM program in STARK VM.
33fn main() -> Result<()> {
34    let args = BenchmarkCli::parse();
35    let app_log_blowup = args.app_log_blowup.unwrap_or(DEFAULT_APP_LOG_BLOWUP);
36    let leaf_log_blowup = args.leaf_log_blowup.unwrap_or(DEFAULT_LEAF_LOG_BLOWUP);
37
38    let n = 1 << 15; // STARK to calculate (2 ** 15)th Fibonacci number.
39    let fib_chip = FibonacciChip::new(0, 1, n);
40    let engine = Poseidon2Engine::new(FriParameters::standard_with_100_bits_security(
41        app_log_blowup,
42    ));
43
44    run_with_metric_collection("OUTPUT_PATH", || -> Result<()> {
45        // run_test tries to setup tracing, but it will be ignored since run_with_metric_collection
46        // already sets it.
47        let (fib_air, fib_ctx) = (
48            vec![fib_chip.air()],
49            vec![fib_chip.generate_proving_ctx(())],
50        );
51        #[cfg(feature = "cuda")]
52        let fib_ctx = fib_ctx.into_iter().map(cpu_proving_ctx_to_gpu).collect();
53        let vdata = engine.run_test(fib_air, fib_ctx).unwrap();
54        // Unlike other apps, this "app" does not have continuations enabled.
55        let app_fri_params = FriParameters::standard_with_100_bits_security(leaf_log_blowup);
56        let mut app_vm_config = NativeConfig::aggregation(
57            DEFAULT_MAX_NUM_PUBLIC_VALUES,
58            app_fri_params.max_constraint_degree().min(7),
59        );
60        app_vm_config.system.profiling = args.profiling;
61        app_vm_config.system.max_constraint_degree = (1 << app_log_blowup) + 1;
62
63        let compiler_options = CompilerOptions::default();
64        let app_config = AppConfig {
65            app_fri_params: app_fri_params.into(),
66            app_vm_config,
67            leaf_fri_params: app_fri_params.into(),
68            compiler_options,
69        };
70        let (program, input_stream) = build_verification_program(vdata, compiler_options);
71        let app_pk = AppProvingKey::keygen(app_config)?;
72        let app_vk = app_pk.get_app_vk();
73        let exe = Arc::new(VmExe::new(program));
74        let mut prover = new_local_prover::<Poseidon2Engine, _>(
75            NativeBuilder::default(),
76            &app_pk.app_vm_pk,
77            exe,
78        )?;
79        let proof = info_span!("verify_fibair", group = "verify_fibair").in_scope(|| {
80            #[cfg(feature = "metrics")]
81            metrics::counter!("fri.log_blowup")
82                .absolute(prover.vm.engine.fri_params().log_blowup as u64);
83            SingleSegmentVmProver::prove(&mut prover, input_stream, NATIVE_MAX_TRACE_HEIGHTS)
84        })?;
85        verify_single(&prover.vm.engine, &app_vk.vk, &proof)?;
86        Ok(())
87    })?;
88    Ok(())
89}