refactor(profiler)!: make TritonProfiler private

Change the interface for using the internal profiler. Most notably,
at most one instance should exist at any given time and per thread.
The already-existing macros like `prof_start!` and `prof_stop!` work
as before, and use the one profiler instance.

This design is less intrusive, as it does not require passing the
profiler as an argument to every function that can or should be
profiled.

triton-vm/benches/cached_vs_jit_trace.rs

@@ -27,8 +27,8 @@ fn prove_fib<const N: u64>(c: &mut Criterion) {
 
     let mut group = c.benchmark_group(format!("prove_fib_{N}"));
     triton_vm::config::overwrite_lde_trace_caching_to(CacheDecision::Cache);
-    group.bench_function("cache", |b| b.iter(|| stark.prove(&claim, &aet, &mut None)));
+    group.bench_function("cache", |b| b.iter(|| stark.prove(&claim, &aet)));
     triton_vm::config::overwrite_lde_trace_caching_to(CacheDecision::NoCache);
-    group.bench_function("jit", |b| b.iter(|| stark.prove(&claim, &aet, &mut None)));
+    group.bench_function("jit", |b| b.iter(|| stark.prove(&claim, &aet)));
     group.finish();
 }

triton-vm/benches/mem_io.rs

@@ -6,8 +6,6 @@ use criterion::Criterion;
 
 use triton_vm::prelude::*;
 use triton_vm::profiler::Report;
-use triton_vm::profiler::TritonProfiler;
-use triton_vm::table::master_table::TableId;
 
 criterion_main!(benches);
 criterion_group!(
@@ -68,27 +66,22 @@ impl MemIOBench {
     }
 
     fn timing_report(&self) -> Report {
-        let mut profiler = TritonProfiler::new("Memory I/O");
-        profiler.start("generate AET", Some("gen".into()));
         let (aet, output) = self
             .program
             .trace_execution(self.public_input.clone(), self.secret_input.clone())
             .unwrap();
-        profiler.stop("generate AET");
-
         let claim = Claim::about_program(&self.program).with_output(output);
 
         let stark = Stark::default();
-        let mut profiler = Some(profiler);
-        let proof = stark.prove(&claim, &aet, &mut profiler).unwrap();
-        let mut profiler = profiler.unwrap();
+        triton_vm::profiler::start("Memory I/O");
+        let proof = stark.prove(&claim, &aet).unwrap();
+        let report = triton_vm::profiler::finish();
 
-        let trace_len = aet.height_of_table(TableId::OpStack);
+        let trace_len = aet.height().height;
         let padded_height = proof.padded_height().unwrap();
         let fri = stark.derive_fri(padded_height).unwrap();
 
-        profiler
-            .report()
+        report
             .with_cycle_count(trace_len)
             .with_padded_height(padded_height)
             .with_fri_domain_len(fri.domain.length)

triton-vm/benches/prove_fib.rs

@@ -7,7 +7,6 @@ use triton_vm::aet::AlgebraicExecutionTrace;
 use triton_vm::example_programs::FIBONACCI_SEQUENCE;
 use triton_vm::prelude::*;
 use triton_vm::profiler::Report;
-use triton_vm::profiler::TritonProfiler;
 
 const FIBONACCI_INDEX: BFieldElement = BFieldElement::new(100);
 
@@ -27,23 +26,20 @@ fn fib_benchmark_group(criterion: &mut Criterion, claim: &Claim, aet: &Algebraic
     let mut group = criterion.benchmark_group(bench_group_name);
 
     let stark = Stark::default();
-    group.bench_function(bench_id, |bencher| {
-        bencher.iter(|| stark.prove(claim, aet, &mut None))
-    });
+    group.bench_function(bench_id, |bencher| bencher.iter(|| stark.prove(claim, aet)));
     group.finish();
 }
 
 fn prover_timing_report(claim: &Claim, aet: &AlgebraicExecutionTrace) -> Report {
     let profile_name = format!("Prove Fibonacci {FIBONACCI_INDEX}");
+    triton_vm::profiler::start(profile_name);
     let stark = Stark::default();
-    let mut profiler = Some(TritonProfiler::new(profile_name));
-    let proof = stark.prove(claim, aet, &mut profiler).unwrap();
-    let mut profiler = profiler.unwrap();
+    let proof = stark.prove(claim, aet).unwrap();
+    let report = triton_vm::profiler::finish();
 
     let padded_height = proof.padded_height().unwrap();
     let fri = stark.derive_fri(padded_height).unwrap();
-    profiler
-        .report()
+    report
         .with_cycle_count(aet.processor_trace.nrows())
         .with_padded_height(padded_height)
         .with_fri_domain_len(fri.domain.length)

triton-vm/benches/prove_halt.rs

@@ -3,9 +3,9 @@ use criterion::criterion_main;
 use criterion::BenchmarkId;
 use criterion::Criterion;
 
-use triton_vm::profiler::TritonProfiler;
 use triton_vm::proof::Claim;
 use triton_vm::stark::Stark;
+use triton_vm::table::master_table::TableId;
 use triton_vm::triton_program;
 
 /// cargo criterion --bench prove_halt
@@ -15,26 +15,24 @@ fn prove_halt(criterion: &mut Criterion) {
 
     let stark = Stark::default();
     let claim = Claim::about_program(&program).with_output(output);
-    let mut profiler = Some(TritonProfiler::new("Prove Halt"));
-    let proof = stark.prove(&claim, &aet, &mut profiler).unwrap();
-    let mut profiler = profiler.unwrap();
-    profiler.finish();
+    triton_vm::profiler::start("Prove Halt");
+    let proof = stark.prove(&claim, &aet).unwrap();
+    let report = triton_vm::profiler::finish();
 
     let bench_id = BenchmarkId::new("ProveHalt", 0);
     let mut group = criterion.benchmark_group("prove_halt");
     group.sample_size(10);
     group.bench_function(bench_id, |bencher| {
         bencher.iter(|| {
-            let _proof = stark.prove(&claim, &aet, &mut None);
+            let _proof = stark.prove(&claim, &aet);
         });
     });
     group.finish();
 
     let padded_height = proof.padded_height().unwrap();
     let fri = stark.derive_fri(padded_height).unwrap();
-    let report = profiler
-        .report()
-        .with_cycle_count(aet.processor_trace.nrows())
+    let report = report
+        .with_cycle_count(aet.height_of_table(TableId::Processor))
         .with_padded_height(padded_height)
         .with_fri_domain_len(fri.domain.length);
     eprintln!("{report}");

triton-vm/benches/verify_halt.rs

@@ -3,7 +3,6 @@ use criterion::criterion_main;
 use criterion::BenchmarkId;
 use criterion::Criterion;
 
-use triton_vm::profiler::TritonProfiler;
 use triton_vm::proof::Claim;
 use triton_vm::stark::Stark;
 use triton_vm::triton_program;
@@ -16,17 +15,15 @@ fn verify_halt(criterion: &mut Criterion) {
     let claim = Claim::about_program(&program);
 
     let (aet, _) = program.trace_execution([].into(), [].into()).unwrap();
-    let proof = stark.prove(&claim, &aet, &mut None).unwrap();
+    let proof = stark.prove(&claim, &aet).unwrap();
 
-    let mut profiler = Some(TritonProfiler::new("Verify Halt"));
-    stark.verify(&claim, &proof, &mut profiler).unwrap();
+    triton_vm::profiler::start("Verify Halt");
+    stark.verify(&claim, &proof).unwrap();
+    let report = triton_vm::profiler::finish();
 
-    let mut profiler = profiler.unwrap();
-    profiler.finish();
     let padded_height = proof.padded_height().unwrap();
     let fri = stark.derive_fri(padded_height).unwrap();
-    let report = profiler
-        .report()
+    let report = report
         .with_cycle_count(aet.processor_trace.nrows())
         .with_padded_height(padded_height)
         .with_fri_domain_len(fri.domain.length);
@@ -36,7 +33,7 @@ fn verify_halt(criterion: &mut Criterion) {
     group.sample_size(10);
     group.bench_function(bench_id, |bencher| {
         bencher.iter(|| {
-            let _ = stark.verify(&claim, &proof, &mut None);
+            let _ = stark.verify(&claim, &proof);
         });
     });
     group.finish();

triton-vm/src/config.rs

@@ -73,7 +73,6 @@ mod tests {
 
     use crate::example_programs::FIBONACCI_SEQUENCE;
     use crate::prelude::*;
-    use crate::profiler::TritonProfiler;
     use crate::shared_tests::prove_with_low_security_level;
 
     use super::*;
@@ -94,13 +93,12 @@ mod tests {
         let stdin = PublicInput::from(bfe_array![100]);
         let secret_in = NonDeterminism::default();
 
-        let mut profiler = Some(TritonProfiler::new("Prove Fib 100"));
+        crate::profiler::start("Prove Fib 100");
         let (stark, claim, proof) =
-            prove_with_low_security_level(&FIBONACCI_SEQUENCE, stdin, secret_in, &mut profiler);
-        assert!(let Ok(()) = stark.verify(&claim, &proof, &mut None));
+            prove_with_low_security_level(&FIBONACCI_SEQUENCE, stdin, secret_in);
+        assert!(let Ok(()) = stark.verify(&claim, &proof));
 
-        let mut profiler = profiler.unwrap();
-        let report = profiler.report();
+        let report = crate::profiler::finish();
         println!("{report}");
     }
 }

triton-vm/src/fri.rs

@@ -14,7 +14,6 @@ use crate::error::FriValidationError;
 use crate::error::FriValidationError::*;
 use crate::profiler::prof_start;
 use crate::profiler::prof_stop;
-use crate::profiler::TritonProfiler;
 use crate::proof_item::FriResponse;
 use crate::proof_item::ProofItem;
 use crate::proof_stream::ProofStream;
@@ -584,20 +583,19 @@ impl<H: AlgebraicHasher> Fri<H> {
     pub fn verify(
         &self,
         proof_stream: &mut ProofStream,
-        maybe_profiler: &mut Option<TritonProfiler>,
     ) -> VerifierResult<Vec<(usize, XFieldElement)>> {
-        prof_start!(maybe_profiler, "init");
+        prof_start!("init");
         let mut verifier = self.verifier(proof_stream);
         verifier.initialize()?;
-        prof_stop!(maybe_profiler, "init");
+        prof_stop!("init");
 
-        prof_start!(maybe_profiler, "fold all rounds");
+        prof_start!("fold all rounds");
         verifier.compute_last_round_folded_partial_codeword()?;
-        prof_stop!(maybe_profiler, "fold all rounds");
+        prof_stop!("fold all rounds");
 
-        prof_start!(maybe_profiler, "authenticate last round codeword");
+        prof_start!("authenticate last round codeword");
         verifier.authenticate_last_round_codeword()?;
-        prof_stop!(maybe_profiler, "authenticate last round codeword");
+        prof_stop!("authenticate last round codeword");
 
         Ok(verifier.first_round_partially_revealed_codeword())
     }
@@ -780,7 +778,7 @@ mod tests {
         fri.prove(&codeword, &mut proof_stream).unwrap();
 
         let mut proof_stream = prepare_proof_stream_for_verification(proof_stream);
-        let verdict = fri.verify(&mut proof_stream, &mut None);
+        let verdict = fri.verify(&mut proof_stream);
         prop_assert!(verdict.is_ok());
     }
 
@@ -796,7 +794,7 @@ mod tests {
         fri.prove(&codeword, &mut proof_stream).unwrap();
 
         let mut proof_stream = prepare_proof_stream_for_verification(proof_stream);
-        let verdict = fri.verify(&mut proof_stream, &mut None);
+        let verdict = fri.verify(&mut proof_stream);
         prop_assert!(verdict.is_ok());
     }
 
@@ -813,7 +811,7 @@ mod tests {
         fri.prove(&codeword, &mut proof_stream).unwrap();
 
         let mut proof_stream = prepare_proof_stream_for_verification(proof_stream);
-        let verdict = fri.verify(&mut proof_stream, &mut None);
+        let verdict = fri.verify(&mut proof_stream);
         prop_assert!(verdict.is_err());
     }
 
@@ -911,7 +909,7 @@ mod tests {
         let mut proof_stream =
             modify_last_round_codeword_in_proof_stream_using_seed(proof_stream, rng_seed);
 
-        let verdict = fri.verify(&mut proof_stream, &mut None);
+        let verdict = fri.verify(&mut proof_stream);
         let err = verdict.unwrap_err();
         let FriValidationError::BadMerkleRootForLastCodeword = err else {
             return Err(TestCaseError::Fail("validation must fail".into()));
@@ -962,7 +960,7 @@ mod tests {
         let mut proof_stream =
             change_size_of_some_fri_response_in_proof_stream_using_seed(proof_stream, rng_seed);
 
-        let verdict = fri.verify(&mut proof_stream, &mut None);
+        let verdict = fri.verify(&mut proof_stream);
         let err = verdict.unwrap_err();
         let FriValidationError::IncorrectNumberOfRevealedLeaves = err else {
             return Err(TestCaseError::Fail("validation must fail".into()));
@@ -1016,7 +1014,7 @@ mod tests {
         let mut proof_stream =
             modify_some_auth_structure_in_proof_stream_using_seed(proof_stream, rng_seed);
 
-        let verdict = fri.verify(&mut proof_stream, &mut None);
+        let verdict = fri.verify(&mut proof_stream);
         let_assert!(Err(err) = verdict);
         assert!(let BadMerkleAuthenticationPath = err);
     }
@@ -1069,7 +1067,7 @@ mod tests {
             }
         });
 
-        let verdict = fri.verify(&mut proof_stream, &mut None);
+        let verdict = fri.verify(&mut proof_stream);
         let_assert!(Err(err) = verdict);
         assert!(let LastRoundPolynomialEvaluationMismatch = err);
     }
@@ -1086,7 +1084,7 @@ mod tests {
         fri.prove(&codeword, &mut proof_stream).unwrap();
 
         let mut proof_stream = prepare_proof_stream_for_verification(proof_stream);
-        let verdict = fri.verify(&mut proof_stream, &mut None);
+        let verdict = fri.verify(&mut proof_stream);
         let_assert!(Err(err) = verdict);
         assert!(let LastRoundPolynomialHasTooHighDegree = err);
     }
@@ -1096,7 +1094,7 @@ mod tests {
         #[strategy(arbitrary_fri())] fri: Fri<Tip5>,
         #[strategy(arb())] mut proof_stream: ProofStream,
     ) {
-        let _verdict = fri.verify(&mut proof_stream, &mut None);
+        let _verdict = fri.verify(&mut proof_stream);
     }
 
     #[proptest]

triton-vm/src/lib.rs

@@ -531,7 +531,7 @@ pub fn prove_program(
     let stark = Stark::default();
 
     // Generate the proof.
-    let proof = stark.prove(&claim, &aet, &mut None)?;
+    let proof = stark.prove(&claim, &aet)?;
 
     Ok((stark, claim, proof))
 }
@@ -553,15 +553,15 @@ pub fn prove(
         return Err(ProvingError::PublicOutputMismatch);
     }
 
-    stark.prove(claim, &aet, &mut None)
+    stark.prove(claim, &aet)
 }
 
 /// Verify a proof generated by [`prove`] or [`prove_program`].
 ///
 /// Use [`Stark::verify`] for more verbose verification failures.
 #[must_use]
 pub fn verify(stark: Stark, claim: &Claim, proof: &Proof) -> bool {
-    stark.verify(claim, proof, &mut None).is_ok()
+    stark.verify(claim, proof).is_ok()
 }
 
 #[cfg(test)]
@@ -699,7 +699,6 @@ mod tests {
         implements_auto_traits::<op_stack::NumberOfWords>();
         implements_auto_traits::<parser::ParseError>();
         implements_auto_traits::<parser::InstructionToken>();
-        implements_auto_traits::<profiler::TritonProfiler>();
         implements_auto_traits::<profiler::Report>();
         implements_auto_traits::<program::InstructionIter>();
         implements_auto_traits::<program::ProfileLine>();