feat: enable tracing_forest as an option

facebook · Jan 30, 2024 · 5a00b61 · 5a00b61
1 parent 9ef238f
commit 5a00b61
Show file tree

Hide file tree

Showing 16 changed files with 281 additions and 245 deletions.
diff --git a/examples/Cargo.toml b/examples/Cargo.toml
@@ -23,6 +23,7 @@ doc = false
 [features]
 concurrent = ["winterfell/concurrent", "std"]
 default = ["std"]
+tree = ["std", "tracing-forest"]
 std = ["core-utils/std", "hex/std", "rand-utils", "winterfell/std"]
 
 [dependencies]
@@ -33,7 +34,7 @@ rand-utils = { version = "0.7", path = "../utils/rand", package = "winter-rand-u
 structopt = { version = "0.3", default-features = false }
 tracing = { version = "0.1", default-features = false }
 tracing-subscriber = { version = "0.3", features = ["std", "env-filter"] }
-tracing-forest = { version = "0.1", features = ["ansi", "smallvec"] }
+tracing-forest = { version = "0.1", features = ["ansi", "smallvec"], optional = true }
 winterfell = { version="0.7", path = "../winterfell", default-features = false }
 
 [dev-dependencies]

diff --git a/examples/src/fibonacci/fib2/mod.rs b/examples/src/fibonacci/fib2/mod.rs
@@ -7,7 +7,7 @@ use super::utils::compute_fib_term;
 use crate::{Blake3_192, Blake3_256, Example, ExampleOptions, HashFunction, Sha3_256};
 use core::marker::PhantomData;
 use std::time::Instant;
-use tracing::{event, info_span, Level};
+use tracing::{field, info_span};
 use winterfell::{
     crypto::{DefaultRandomCoin, ElementHasher},
     math::{fields::f128::BaseElement, FieldElement},
@@ -97,19 +97,36 @@ where
         let prover = FibProver::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!("Generating execution trace").in_scope(|| {
+        let trace = info_span!(
+            "Generated execution trace",
+            registers_num = field::Empty,
+            steps = field::Empty
+        )
+        .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(),
-            );
+            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
+        // });
+
         // generate the proof
         prover.prove(trace).unwrap()
     }

diff --git a/examples/src/fibonacci/fib8/mod.rs b/examples/src/fibonacci/fib8/mod.rs
@@ -7,7 +7,7 @@ use super::utils::compute_fib_term;
 use crate::{Blake3_192, Blake3_256, Example, ExampleOptions, HashFunction, Sha3_256};
 use core::marker::PhantomData;
 use std::time::Instant;
-use tracing::{event, info_span, Level};
+use tracing::{field, info_span};
 use winterfell::{
     crypto::{DefaultRandomCoin, ElementHasher},
     math::{fields::f128::BaseElement, FieldElement},
@@ -97,16 +97,15 @@ where
         let prover = Fib8Prover::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!("Generating execution trace").in_scope(|| {
+        let trace = info_span!(
+            "Generated execution trace",
+            registers_num = field::Empty,
+            steps = field::Empty
+        )
+        .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(),
-            );
+            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
+            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
             trace
         });
 

diff --git a/examples/src/fibonacci/fib_small/mod.rs b/examples/src/fibonacci/fib_small/mod.rs
@@ -7,7 +7,7 @@ use super::utils::compute_fib_term;
 use crate::{Example, ExampleOptions, HashFunction};
 use core::marker::PhantomData;
 use std::time::Instant;
-use tracing::{event, info_span, Level};
+use tracing::{field, info_span};
 use winterfell::{
     crypto::{DefaultRandomCoin, ElementHasher},
     math::{fields::f64::BaseElement, FieldElement},
@@ -112,16 +112,15 @@ where
         let prover = FibSmallProver::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!("Generating execution trace").in_scope(|| {
+        let trace = info_span!(
+            "Generated execution trace",
+            registers_num = field::Empty,
+            steps = field::Empty
+        )
+        .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(),
-            );
+            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
+            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
             trace
         });
 

diff --git a/examples/src/fibonacci/mulfib2/mod.rs b/examples/src/fibonacci/mulfib2/mod.rs
@@ -7,7 +7,7 @@ use super::utils::compute_mulfib_term;
 use crate::{Blake3_192, Blake3_256, Example, ExampleOptions, HashFunction, Sha3_256};
 use core::marker::PhantomData;
 use std::time::Instant;
-use tracing::{event, info_span, Level};
+use tracing::{field, info_span};
 use winterfell::{
     crypto::{DefaultRandomCoin, ElementHasher},
     math::{fields::f128::BaseElement, FieldElement},
@@ -92,16 +92,15 @@ where
         let prover = MulFib2Prover::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!("Generating execution trace").in_scope(|| {
+        let trace = info_span!(
+            "Generated execution trace",
+            registers_num = field::Empty,
+            steps = field::Empty
+        )
+        .in_scope(|| {
             let trace = prover.build_trace(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(),
-            );
+            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
+            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
             trace
         });
 

diff --git a/examples/src/fibonacci/mulfib8/mod.rs b/examples/src/fibonacci/mulfib8/mod.rs
@@ -7,7 +7,7 @@ use super::utils::compute_mulfib_term;
 use crate::{Blake3_192, Blake3_256, Example, ExampleOptions, HashFunction, Sha3_256};
 use core::marker::PhantomData;
 use std::time::Instant;
-use tracing::{event, info_span, Level};
+use tracing::{field, info_span};
 use winterfell::{
     crypto::{DefaultRandomCoin, ElementHasher},
     math::{fields::f128::BaseElement, FieldElement},
@@ -93,16 +93,15 @@ where
         let prover = MulFib8Prover::<H>::new(self.options.clone());
 
         // generate execution trace
-        let trace = info_span!("Generating execution trace").in_scope(|| {
+        let trace = info_span!(
+            "Generated execution trace",
+            registers_num = field::Empty,
+            steps = field::Empty
+        )
+        .in_scope(|| {
             let trace = prover.build_trace(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(),
-            );
+            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
+            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
             trace
         });
 

diff --git a/examples/src/lamport/aggregate/mod.rs b/examples/src/lamport/aggregate/mod.rs
@@ -9,7 +9,7 @@ use super::{
 use crate::{Blake3_192, Blake3_256, ExampleOptions, HashFunction, Sha3_256};
 use core::marker::PhantomData;
 use std::time::Instant;
-use tracing::{event, info_span, Level};
+use tracing::{field, info_span};
 use winterfell::{
     crypto::{DefaultRandomCoin, ElementHasher},
     math::{fields::f128::BaseElement, get_power_series, FieldElement, StarkField},
@@ -122,15 +122,16 @@ where
         let prover =
             LamportAggregateProver::<H>::new(&self.pub_keys, &self.messages, self.options.clone());
 
-        let trace = info_span!("Generating execution trace").in_scope(|| {
+        // 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);
-            let trace_length = trace.length();
-            event!(
-                Level::DEBUG,
-                "Generated execution trace of {} registers and 2^{} steps",
-                trace.width(),
-                trace_length.ilog2(),
-            );
+            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
+            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
             trace
         });
 

diff --git a/examples/src/lamport/threshold/mod.rs b/examples/src/lamport/threshold/mod.rs
@@ -10,7 +10,7 @@ use super::{
 use crate::{Blake3_192, Blake3_256, ExampleOptions, HashFunction, Sha3_256};
 use core::marker::PhantomData;
 use std::time::Instant;
-use tracing::{event, info_span, Level};
+use tracing::{field, info_span};
 use winterfell::{
     crypto::{DefaultRandomCoin, ElementHasher},
     math::{fields::f128::BaseElement, get_power_series, FieldElement, StarkField},
@@ -129,15 +129,15 @@ where
         );
 
         // generate execution trace
-        let trace = info_span!("Generating execution trace").in_scope(|| {
+        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);
-            let trace_length = trace.length();
-            event!(
-                Level::DEBUG,
-                "Generated execution trace of {} registers and 2^{} steps",
-                trace.width(),
-                trace_length.ilog2(),
-            );
+            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
+            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
             trace
         });
 

diff --git a/examples/src/main.rs b/examples/src/main.rs
@@ -6,7 +6,10 @@
 use std::time::Instant;
 use structopt::StructOpt;
 use tracing::info_span;
+#[cfg(feature = "tree")]
 use tracing_forest::ForestLayer;
+#[cfg(not(feature = "tree"))]
+use tracing_subscriber::fmt::format::FmtSpan;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
 use winterfell::StarkProof;
 
@@ -22,11 +25,25 @@ fn main() {
     if std::env::var("WINTER_LOG").is_err() {
         std::env::set_var("WINTER_LOG", "info");
     }
+    let registry =
+        tracing_subscriber::registry::Registry::default().with(EnvFilter::from_env("WINTER_LOG"));
 
-    tracing_subscriber::registry::Registry::default()
-        .with(EnvFilter::from_env("WINTER_LOG"))
-        .with(ForestLayer::default())
-        .init();
+    #[cfg(feature = "tree")]
+    registry.with(ForestLayer::default()).init();
+
+    #[cfg(not(feature = "tree"))]
+    {
+        let format = tracing_subscriber::fmt::layer()
+            .with_level(false)
+            .with_target(false)
+            .with_thread_names(false)
+            .with_span_events(FmtSpan::CLOSE)
+            .with_ansi(false)
+            .with_timer(tracing_subscriber::fmt::time::SystemTime::default())
+            .compact();
+
+        registry.with(format).init();
+    }
 
     // read command-line args
     let options = ExampleOptions::from_args();

diff --git a/examples/src/merkle/mod.rs b/examples/src/merkle/mod.rs
@@ -14,7 +14,7 @@ use crate::{
 use core::marker::PhantomData;
 use rand_utils::{rand_value, rand_vector};
 use std::time::Instant;
-use tracing::{event, info_span, Level};
+use tracing::{field, info_span};
 use winterfell::{
     crypto::{DefaultRandomCoin, Digest, ElementHasher, MerkleTree},
     math::{fields::f128::BaseElement, FieldElement, StarkField},
@@ -116,16 +116,16 @@ where
         // create the prover
         let prover = MerkleProver::<H>::new(self.options.clone());
 
-        // generate the execution trace
-        let trace = info_span!("Generating execution trace").in_scope(|| {
+        // 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);
-            let trace_length = trace.length();
-            event!(
-                Level::DEBUG,
-                "Generated execution trace of {} registers and 2^{} steps",
-                trace.width(),
-                trace_length.ilog2(),
-            );
+            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
+            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
             trace
         });
 

diff --git a/examples/src/rescue/mod.rs b/examples/src/rescue/mod.rs
@@ -6,7 +6,7 @@
 use crate::{Blake3_192, Blake3_256, Example, ExampleOptions, HashFunction, Sha3_256};
 use core::marker::PhantomData;
 use std::time::Instant;
-use tracing::{event, info_span, Level};
+use tracing::{field, info_span};
 use winterfell::{
     crypto::{DefaultRandomCoin, ElementHasher},
     math::{fields::f128::BaseElement, FieldElement},
@@ -101,16 +101,16 @@ where
         // create a prover
         let prover = RescueProver::<H>::new(self.options.clone());
 
-        // generate the execution trace
-        let trace = info_span!("Generating execution trace").in_scope(|| {
+        // 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);
-            let trace_length = trace.length();
-            event!(
-                Level::DEBUG,
-                "Generated execution trace of {} registers and 2^{} steps",
-                trace.width(),
-                trace_length.ilog2(),
-            );
+            tracing::Span::current().record("registers_num", &format!("{}", trace.width()));
+            tracing::Span::current().record("steps", &format!("2^{}", trace.length().ilog2()));
             trace
         });