profiling setup

prover/src/lib.rs

@@ -725,7 +725,7 @@
 pub mod tests {
 
     use std::fs::File;
     use std::io::{Read, Write};
 
     use super::*;
 
@@ -750,55 +750,55 @@
 
     pub fn test_e2e_prover<C: SP1ProverComponents>(
         elf: &[u8],
         opts: SP1ProverOpts,
         test_kind: Test,
     ) -> Result<()> {
         tracing::info!("initializing prover");
         let prover: SP1Prover<C> = SP1Prover::<C>::new();
         let context = SP1Context::default();
 
         tracing::info!("setup elf");
         let (pk, vk) = prover.setup(elf);
 
-        tracing::info!("prove core");
-        let stdin = SP1Stdin::new();
-        let core_proof = prover.prove_core(&pk, &stdin, opts, context)?;
-        let public_values = core_proof.public_values.clone();
+        // tracing::info!("prove core");
+        // let stdin = SP1Stdin::new();
+        // let core_proof = prover.prove_core(&pk, &stdin, opts, context)?;
+        // let public_values = core_proof.public_values.clone();
 
-        tracing::info!("verify core");
-        prover.verify(&core_proof.proof, &vk)?;
+        // tracing::info!("verify core");
+        // prover.verify(&core_proof.proof, &vk)?;
 
-        if test_kind == Test::Core {
-            return Ok(());
-        }
+        // if test_kind == Test::Core {
+        //     return Ok(());
+        // }
 
-        tracing::info!("compress");
-        let compressed_proof = prover.compress(&vk, core_proof, vec![], opts)?;
+        // tracing::info!("compress");
+        // let compressed_proof = prover.compress(&vk, core_proof, vec![], opts)?;
 
-        tracing::info!("verify compressed");
-        prover.verify_compressed(&compressed_proof, &vk)?;
+        // tracing::info!("verify compressed");
+        // prover.verify_compressed(&compressed_proof, &vk)?;
 
-        if test_kind == Test::Compress {
-            return Ok(());
-        }
+        // if test_kind == Test::Compress {
+        //     return Ok(());
+        // }
 
-        tracing::info!("shrink");
-        let shrink_proof = prover.shrink(compressed_proof, opts)?;
+        // tracing::info!("shrink");
+        // let shrink_proof = prover.shrink(compressed_proof, opts)?;
 
-        tracing::info!("verify shrink");
-        prover.verify_shrink(&shrink_proof, &vk)?;
+        // tracing::info!("verify shrink");
+        // prover.verify_shrink(&shrink_proof, &vk)?;
 
-        if test_kind == Test::Shrink {
-            return Ok(());
-        }
+        // if test_kind == Test::Shrink {
+        //     return Ok(());
+        // }
 
-        tracing::info!("wrap bn254");
-        let wrapped_bn254_proof = prover.wrap_bn254(shrink_proof, opts)?;
-        let bytes = bincode::serialize(&wrapped_bn254_proof).unwrap();
+        // tracing::info!("wrap bn254");
+        // let wrapped_bn254_proof = prover.wrap_bn254(shrink_proof, opts)?;
+        // let bytes = bincode::serialize(&wrapped_bn254_proof).unwrap();
 
-        // Save the proof.
-        let mut file = File::create("proof-with-pis.bin").unwrap();
-        file.write_all(bytes.as_slice()).unwrap();
+        // // Save the proof.
+        // let mut file = File::create("proof-with-pis.bin").unwrap();
+        // file.write_all(bytes.as_slice()).unwrap();
 
         // Load the proof.
         let mut file = File::open("proof-with-pis.bin").unwrap();
@@ -828,7 +828,7 @@
         let plonk_bn254_proof = prover.wrap_plonk_bn254(wrapped_bn254_proof, &artifacts_dir);
         println!("{:?}", plonk_bn254_proof);
 
-        prover.verify_plonk_bn254(&plonk_bn254_proof, &vk, &public_values, &artifacts_dir)?;
+        // prover.verify_plonk_bn254(&plonk_bn254_proof, &vk, &public_values, &artifacts_dir)?;
 
         Ok(())
     }

recursion/circuit-v2/Cargo.toml

@@ -52,3 +52,7 @@ rand = "0.8.5"
 
 [features]
 native-gnark = ["sp1-recursion-gnark-ffi/native"]
+
+[[bin]]
+name = "circuit-architecture-sweep"
+path = "scripts/circuit_architecture_sweep.rs"

recursion/circuit-v2/scripts/circuit_architecture_sweep.rs

@@ -3,7 +3,7 @@
 use p3_baby_bear::BabyBear;
 
 use sp1_core::{stark::StarkMachine, utils::log2_strict_usize};
 use sp1_recursion_circuit_v2::build_wrap_v2::{machine_with_all_chips, test_machine};
 use sp1_recursion_core::stark::config::BabyBearPoseidon2Outer;
 use sp1_recursion_core_v2::machine::RecursionAir;
 
@@ -18,49 +18,49 @@
 
 fn main() {
     // Test the performance of the full architecture with different degrees.
-    let machine_maker_3 = || machine_with_all_chips::<3>(16, 16, 16);
-    let machine_maker_5 = || machine_with_all_chips::<5>(16, 16, 16);
-    let machine_maker_9 = || machine_with_all_chips::<9>(16, 16, 16);
-    let machine_maker_17 = || machine_with_all_chips::<17>(16, 16, 16);
-    test_machine(machine_maker_3);
-    test_machine(machine_maker_5);
-    test_machine(machine_maker_9);
-    test_machine(machine_maker_17);
+    // let machine_maker_3 = || machine_with_all_chips::<3>(16, 16, 16);
+    // let machine_maker_5 = || machine_with_all_chips::<5>(16, 16, 16);
+    // let machine_maker_9 = || machine_with_all_chips::<9>(16, 16, 16);
+    // let machine_maker_17 = || machine_with_all_chips::<17>(16, 16, 16);
+    // test_machine(machine_maker_3);
+    // test_machine(machine_maker_5);
+    // test_machine(machine_maker_9);
+    // test_machine(machine_maker_17);
 
     // Test the performance of the machine with the full architecture for different numbers of rows
     // in the precompiles. Degree is set to 9.
-    let machine_maker = |i| machine_with_all_chips::<9>(i, i, i);
-    for i in 1..=5 {
-        test_machine(|| machine_maker(i));
-    }
+    // let machine_maker = |i| machine_with_all_chips::<9>(i, i, i);
+    // for i in 1..=5 {
+    //     test_machine(|| machine_maker(i));
+    // }
 
     // Test the performance of the dummy machine for different numbers of columns in the dummy table.
     // Degree is kept fixed at 9.
-    test_machine(|| machine_with_dummy::<9, 1>(16));
-    test_machine(|| machine_with_dummy::<9, 50>(16));
-    test_machine(|| machine_with_dummy::<9, 100>(16));
-    test_machine(|| machine_with_dummy::<9, 150>(16));
-    test_machine(|| machine_with_dummy::<9, 200>(16));
-    test_machine(|| machine_with_dummy::<9, 250>(16));
-    test_machine(|| machine_with_dummy::<9, 300>(16));
-    test_machine(|| machine_with_dummy::<9, 350>(16));
-    test_machine(|| machine_with_dummy::<9, 400>(16));
-    test_machine(|| machine_with_dummy::<9, 450>(16));
-    test_machine(|| machine_with_dummy::<9, 500>(16));
-    test_machine(|| machine_with_dummy::<9, 550>(16));
-    test_machine(|| machine_with_dummy::<9, 600>(16));
-    test_machine(|| machine_with_dummy::<9, 650>(16));
-    test_machine(|| machine_with_dummy::<9, 700>(16));
-    test_machine(|| machine_with_dummy::<9, 750>(16));
+    // test_machine(|| machine_with_dummy::<9, 1>(16));
+    // test_machine(|| machine_with_dummy::<9, 50>(16));
+    // test_machine(|| machine_with_dummy::<9, 100>(16));
+    // test_machine(|| machine_with_dummy::<9, 150>(16));
+    // test_machine(|| machine_with_dummy::<9, 200>(16));
+    // test_machine(|| machine_with_dummy::<9, 250>(16));
+    // test_machine(|| machine_with_dummy::<9, 300>(16));
+    // test_machine(|| machine_with_dummy::<9, 350>(16));
+    // test_machine(|| machine_with_dummy::<9, 400>(16));
+    // test_machine(|| machine_with_dummy::<9, 450>(16));
+    // test_machine(|| machine_with_dummy::<9, 500>(16));
+    // test_machine(|| machine_with_dummy::<9, 550>(16));
+    // test_machine(|| machine_with_dummy::<9, 600>(16));
+    // test_machine(|| machine_with_dummy::<9, 650>(16));
+    // test_machine(|| machine_with_dummy::<9, 700>(16));
+    test_machine(|| machine_with_dummy::<5, 130>(18));
 
     // Test the performance of the dummy machine for different heights of the dummy table.
-    for i in 4..=7 {
-        test_machine(|| machine_with_dummy::<9, 1>(i));
-    }
+    // for i in 4..=7 {
+    //     test_machine(|| machine_with_dummy::<9, 1>(i));
+    // }
 
     // Change the degree for the dummy table, keeping other parameters fixed.
-    test_machine(|| machine_with_dummy::<3, 500>(16));
-    test_machine(|| machine_with_dummy::<5, 500>(16));
-    test_machine(|| machine_with_dummy::<9, 500>(16));
-    test_machine(|| machine_with_dummy::<17, 500>(16));
+    // test_machine(|| machine_with_dummy::<3, 500>(16));
+    // test_machine(|| machine_with_dummy::<5, 500>(16));
+    // test_machine(|| machine_with_dummy::<9, 500>(16));
+    // test_machine(|| machine_with_dummy::<17, 500>(16));
 }

recursion/circuit/src/fri.rs

@@ -60,6 +60,7 @@ pub fn verify_two_adic_pcs<C: Config>(
     challenger: &mut MultiField32ChallengerVariable<C>,
     rounds: Vec<TwoAdicPcsRoundVariable<C>>,
 ) {
+    let mut counter = 0;
     let alpha = challenger.sample_ext(builder);
 
     let fri_challenges =
@@ -129,12 +130,17 @@ pub fn verify_two_adic_pcs<C: Config>(
                     for (z, ps_at_z) in izip!(mat_points, mat_values) {
                         let mut acc: Ext<C::F, C::EF> =
                             builder.eval(SymbolicExt::from_f(C::EF::zero()));
+                        counter += 1;
                         for (p_at_x, &p_at_z) in izip!(mat_opening.clone(), ps_at_z) {
                             let pow = log_height_pow[log_height];
+
                             // Fill in any missing powers of alpha.
                             (alpha_pows.len()..pow + 1).for_each(|_| {
-                                alpha_pows.push(builder.eval(*alpha_pows.last().unwrap() * alpha));
+                                let alpha = builder.eval(*alpha_pows.last().unwrap() * alpha);
+                                builder.operations.push(DslIr::ReduceE(alpha));
+                                alpha_pows.push(alpha);
                             });
+
                             acc = builder.eval(acc + (alpha_pows[pow] * (p_at_z - p_at_x[0])));
                             log_height_pow[log_height] += 1;
                         }
@@ -146,6 +152,8 @@ pub fn verify_two_adic_pcs<C: Config>(
         })
         .collect::<Vec<_>>();
 
+    println!("Counter: {}", counter);
+
     verify_challenges(
         builder,
         config,

recursion/compiler/src/constraints/mod.rs

@@ -358,6 +358,14 @@ impl<C: Config + Debug> ConstraintCompiler<C> {
                         vec![a[3].id()],
                     ],
                 }),
+                DslIr::ReduceF(a) => constraints.push(Constraint {
+                    opcode: ConstraintOpcode::ReduceF,
+                    args: vec![vec![a.id()]],
+                }),
+                DslIr::ReduceE(a) => constraints.push(Constraint {
+                    opcode: ConstraintOpcode::ReduceE,
+                    args: vec![vec![a.id()]],
+                }),
                 _ => panic!("unsupported {:?}", instruction),
             };
         }

recursion/compiler/src/constraints/opcodes.rs

@@ -47,4 +47,6 @@ pub enum ConstraintOpcode {
     CommitCommitedValuesDigest,
     CircuitFelts2Ext,
     PermuteBabyBear,
+    ReduceF,
+    ReduceE,
 }

recursion/compiler/src/ir/instructions.rs

@@ -17,6 +17,10 @@ pub enum DslIr<C: Config> {
     /// Assigns an ext field immediate to an extension field element (ext = ext field imm).
     ImmE(Ext<C::F, C::EF>, C::EF),
 
+    /// Force the reduction of an extension field element.
+    ReduceF(Felt<C::F>),
+    ReduceE(Ext<C::F, C::EF>),
+
     // Additions.
     /// Add two variables (var = var + var).
     AddV(Var<C::N>, Var<C::N>, Var<C::N>),

recursion/compiler/src/ir/types.rs

@@ -1041,6 +1041,11 @@ impl<F: Field, EF: ExtensionField<F>> Ext<F, EF> {
                 (SymbolicExt::Val(lhs, _), SymbolicExt::Val(rhs, _)) => {
                     builder.push(DslIr::SubE(*self, *lhs, *rhs));
                 }
+                (SymbolicExt::Val(lhs, _), SymbolicExt::Base(rhs, _)) => {
+                    let sym: SymbolicFelt<_> = rhs.as_ref().clone();
+                    let rhs: Felt<_> = builder.eval(sym);
+                    builder.push(DslIr::SubEF(*self, *lhs, rhs));
+                }
                 (SymbolicExt::Val(lhs, _), rhs) => {
                     let rhs_value = Self::uninit(builder);
                     rhs_value.assign_with_caches(rhs.clone(), builder, ext_cache, base_cache);

recursion/gnark-ffi/go/main.go

@@ -18,11 +18,8 @@ import (
 
 	"github.com/consensys/gnark-crypto/ecc"
 	"github.com/consensys/gnark/backend/groth16"
-	"github.com/consensys/gnark/backend/plonk"
 	"github.com/consensys/gnark/frontend"
 	"github.com/consensys/gnark/frontend/cs/r1cs"
-	"github.com/consensys/gnark/frontend/cs/scs"
-	"github.com/consensys/gnark/test/unsafekzg"
 	"github.com/succinctlabs/sp1-recursion-gnark/sp1"
 	"github.com/succinctlabs/sp1-recursion-gnark/sp1/babybear"
 	"github.com/succinctlabs/sp1-recursion-gnark/sp1/poseidon2"
@@ -112,36 +109,37 @@ func TestMain() error {
 
 	// Compile the circuit.
 	circuit := sp1.NewCircuit(inputs)
-	builder := scs.NewBuilder
-	scs, err := frontend.Compile(ecc.BN254.ScalarField(), builder, &circuit)
-	if err != nil {
-		return err
-	}
-	fmt.Println("[sp1] gnark verifier constraints:", scs.GetNbConstraints())
-
-	// Run the dummy setup.
-	srs, srsLagrange, err := unsafekzg.NewSRS(scs)
-	if err != nil {
-		return err
-	}
-	var pk plonk.ProvingKey
-	pk, _, err = plonk.Setup(scs, srs, srsLagrange)
-	if err != nil {
-		return err
-	}
-
-	// Generate witness.
-	assignment := sp1.NewCircuit(inputs)
-	witness, err := frontend.NewWitness(&assignment, ecc.BN254.ScalarField())
-	if err != nil {
-		return err
-	}
-
-	// Generate the proof.
-	_, err = plonk.Prove(scs, pk, witness)
+	// builder := scs.NewBuilder
+	// Compile the circuit.
+	r1cs, err := frontend.Compile(ecc.BN254.ScalarField(), r1cs.NewBuilder, &circuit)
 	if err != nil {
-		return err
-	}
+		panic(err)
+	}
+	fmt.Println("Groth16 Constraints:", r1cs.GetNbConstraints())
+
+	// // Run the dummy setup.
+	// srs, srsLagrange, err := unsafekzg.NewSRS(scs)
+	// if err != nil {
+	// 	return err
+	// }
+	// var pk plonk.ProvingKey
+	// pk, _, err = plonk.Setup(scs, srs, srsLagrange)
+	// if err != nil {
+	// 	return err
+	// }
+
+	// // Generate witness.
+	// assignment := sp1.NewCircuit(inputs)
+	// witness, err := frontend.NewWitness(&assignment, ecc.BN254.ScalarField())
+	// if err != nil {
+	// 	return err
+	// }
+
+	// // Generate the proof.
+	// _, err = plonk.Prove(scs, pk, witness)
+	// if err != nil {
+	// 	return err
+	// }
 
 	return nil
 }