refactor: change spans creation, change fields to be logged

facebook · Feb 2, 2024 · dfe4ecb · dfe4ecb
1 parent fa4eb3e
commit dfe4ecb
Show file tree

Hide file tree

Showing 21 changed files with 231 additions and 285 deletions.
diff --git a/examples/Cargo.toml b/examples/Cargo.toml
@@ -23,7 +23,6 @@ doc = false
 [features]
 concurrent = ["winterfell/concurrent", "std"]
 default = ["std"]
-tree = ["std", "tracing-forest"]
 std = ["core-utils/std", "hex/std", "rand-utils", "winterfell/std"]
 
 [dependencies]

diff --git a/examples/src/fibonacci/fib2/mod.rs b/examples/src/fibonacci/fib2/mod.rs
@@ -97,35 +97,13 @@ where
         let prover = FibProver::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(self.sequence_length);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
-
-        // let span = info_span!("Generating execution trace", registers_num = field::Empty, steps = field::Empty);
-        // let trace = prover.build_trace(self.sequence_length);
-        // span.record("registers_num", &format!("{}", trace.width()));
-        // span.record("steps", &format!("2^{} steps", trace.length().ilog2()));
-
-        // let trace = info_span!("Generating execution trace").in_scope(|| {
-        //     let trace = prover.build_trace(self.sequence_length);
-        //     let trace_width = trace.width();
-        //     let trace_length = trace.length();
-        //     event!(
-        //         Level::DEBUG,
-        //         "Generated execution trace of {} registers and 2^{} steps",
-        //         trace_width,
-        //         trace_length.ilog2(),
-        //     );
-        //     trace
-        // });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(self.sequence_length);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()

diff --git a/examples/src/fibonacci/fib8/mod.rs b/examples/src/fibonacci/fib8/mod.rs
@@ -97,17 +97,13 @@ where
         let prover = Fib8Prover::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(self.sequence_length);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(self.sequence_length);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()

diff --git a/examples/src/fibonacci/fib_small/mod.rs b/examples/src/fibonacci/fib_small/mod.rs
@@ -112,17 +112,13 @@ where
         let prover = FibSmallProver::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(self.sequence_length);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(self.sequence_length);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()
@@ -131,6 +127,7 @@ where
     fn verify(&self, proof: StarkProof) -> Result<(), VerifierError> {
         let acceptable_options =
             winterfell::AcceptableOptions::OptionSet(vec![proof.options().clone()]);
+
         winterfell::verify::<FibSmall, H, DefaultRandomCoin<H>>(
             proof,
             self.result,

diff --git a/examples/src/fibonacci/mulfib2/air.rs b/examples/src/fibonacci/mulfib2/air.rs
@@ -3,6 +3,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
+use super::TRACE_WIDTH;
 use crate::utils::are_equal;
 use winterfell::{
     math::{fields::f128::BaseElement, FieldElement},
@@ -13,8 +14,6 @@ use winterfell::{
 // FIBONACCI AIR
 // ================================================================================================
 
-const TRACE_WIDTH: usize = 2;
-
 pub struct MulFib2Air {
     context: AirContext<BaseElement>,
     result: BaseElement,

diff --git a/examples/src/fibonacci/mulfib2/mod.rs b/examples/src/fibonacci/mulfib2/mod.rs
@@ -23,6 +23,11 @@ use prover::MulFib2Prover;
 #[cfg(test)]
 mod tests;
 
+// CONSTANTS
+// ================================================================================================
+
+const TRACE_WIDTH: usize = 2;
+
 // FIBONACCI EXAMPLE
 // ================================================================================================
 
@@ -92,17 +97,13 @@ where
         let prover = MulFib2Prover::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(sequence_length);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(sequence_length);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()

diff --git a/examples/src/fibonacci/mulfib8/air.rs b/examples/src/fibonacci/mulfib8/air.rs
@@ -3,6 +3,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
+use super::TRACE_WIDTH;
 use crate::utils::are_equal;
 use winterfell::{
     math::{fields::f128::BaseElement, FieldElement},
@@ -13,8 +14,6 @@ use winterfell::{
 // FIBONACCI AIR
 // ================================================================================================
 
-const TRACE_WIDTH: usize = 8;
-
 pub struct MulFib8Air {
     context: AirContext<BaseElement>,
     result: BaseElement,

diff --git a/examples/src/fibonacci/mulfib8/mod.rs b/examples/src/fibonacci/mulfib8/mod.rs
@@ -23,6 +23,11 @@ use prover::MulFib8Prover;
 #[cfg(test)]
 mod tests;
 
+// CONSTANTS
+// ================================================================================================
+
+const TRACE_WIDTH: usize = 8;
+
 // FIBONACCI EXAMPLE
 // ================================================================================================
 
@@ -93,17 +98,13 @@ where
         let prover = MulFib8Prover::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(sequence_length);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(sequence_length);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()

diff --git a/examples/src/lamport/aggregate/mod.rs b/examples/src/lamport/aggregate/mod.rs
@@ -123,17 +123,13 @@ where
             LamportAggregateProver::<H>::new(&self.pub_keys, &self.messages, self.options.clone());
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(&self.messages, &self.signatures);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(&self.messages, &self.signatures);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()

diff --git a/examples/src/lamport/threshold/mod.rs b/examples/src/lamport/threshold/mod.rs
@@ -129,17 +129,13 @@ where
         );
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(&self.pub_key, self.message, &self.signatures);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(&self.pub_key, self.message, &self.signatures);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()

diff --git a/examples/src/main.rs b/examples/src/main.rs
@@ -6,9 +6,9 @@
 use std::time::Instant;
 use structopt::StructOpt;
 use tracing::info_span;
-#[cfg(feature = "tree")]
+#[cfg(feature = "tracing-forest")]
 use tracing_forest::ForestLayer;
-#[cfg(not(feature = "tree"))]
+#[cfg(not(feature = "tracing-forest"))]
 use tracing_subscriber::fmt::format::FmtSpan;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
 use winterfell::StarkProof;
@@ -28,10 +28,10 @@ fn main() {
     let registry =
         tracing_subscriber::registry::Registry::default().with(EnvFilter::from_env("WINTER_LOG"));
 
-    #[cfg(feature = "tree")]
+    #[cfg(feature = "tracing-forest")]
     registry.with(ForestLayer::default()).init();
 
-    #[cfg(not(feature = "tree"))]
+    #[cfg(not(feature = "tracing-forest"))]
     {
         let format = tracing_subscriber::fmt::layer()
             .with_level(false)
@@ -87,7 +87,7 @@ fn main() {
 
     // generate proof
     let now = Instant::now();
-    let proof = info_span!("Generating proof").in_scope(|| example.as_ref().prove());
+    let proof = info_span!("generate_proof").in_scope(|| example.as_ref().prove());
     println!("---------------------\nProof generated in {} ms", now.elapsed().as_millis());
 
     let proof_bytes = proof.to_bytes();

diff --git a/examples/src/merkle/mod.rs b/examples/src/merkle/mod.rs
@@ -117,17 +117,13 @@ where
         let prover = MerkleProver::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(self.value, &self.path, self.index);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(self.value, &self.path, self.index);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()

diff --git a/examples/src/rescue/mod.rs b/examples/src/rescue/mod.rs
@@ -102,17 +102,13 @@ where
         let prover = RescueProver::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(self.seed, self.chain_length);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(self.seed, self.chain_length);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()

diff --git a/examples/src/rescue_raps/mod.rs b/examples/src/rescue_raps/mod.rs
@@ -115,17 +115,13 @@ where
         let prover = RescueRapsProver::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!(
-            "Generated execution trace",
-            registers_num = field::Empty,
-            steps = field::Empty
-        )
-        .in_scope(|| {
-            let trace = prover.build_trace(&self.seeds, &self.permuted_seeds, self.result);
-            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
-            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
-            trace
-        });
+        let trace =
+            info_span!("generate_execution_trace", num_cols = TRACE_WIDTH, steps = field::Empty)
+                .in_scope(|| {
+                    let trace = prover.build_trace(&self.seeds, &self.permuted_seeds, self.result);
+                    tracing::Span::current().record("steps", trace.length());
+                    trace
+                });
 
         // generate the proof
         prover.prove(trace).unwrap()

diff --git a/examples/src/vdf/exempt/air.rs b/examples/src/vdf/exempt/air.rs
@@ -3,7 +3,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the root directory of this source tree.
 
-use super::{BaseElement, FieldElement, ProofOptions, ALPHA, FORTY_TWO};
+use super::{BaseElement, FieldElement, ProofOptions, ALPHA, FORTY_TWO, TRACE_WIDTH};
 use winterfell::{
     math::ToElements, Air, AirContext, Assertion, EvaluationFrame, TraceInfo,
     TransitionConstraintDegree,
@@ -39,6 +39,7 @@ impl Air for VdfAir {
 
     fn new(trace_info: TraceInfo, pub_inputs: VdfInputs, options: ProofOptions) -> Self {
         let degrees = vec![TransitionConstraintDegree::new(3)];
+        assert_eq!(TRACE_WIDTH, trace_info.width());
         // make sure the last two rows are excluded from transition constraints as we populate
         // values in the last row with garbage
         let context =