the test block generator had some garbage appended to it (by mistake)…

…. This was removed. Extend benchmark to also cover compressed blocks (i.e. CLVM backrefs). Extend benchmark to cover tree_hash_from_stream()

Cargo.toml

@@ -15,6 +15,7 @@ readme = "README.md"
 [lib]
 name = "clvmr"
 crate-type = ["rlib"]
+bench = false
 
 [features]
 # when enabling the "counters" features, the CLVM interpreter is instrumented to

benches/deserialize.rs

@@ -1,52 +1,78 @@
 use clvmr::allocator::Allocator;
-use clvmr::serde::node_from_bytes;
-use clvmr::serde::node_from_bytes_backrefs;
-use clvmr::serde::serialized_length_from_bytes;
-use clvmr::serde::serialized_length_from_bytes_trusted;
-use criterion::{criterion_group, criterion_main, Criterion, SamplingMode};
+use clvmr::serde::{
+    node_from_bytes, node_from_bytes_backrefs, node_to_bytes_backrefs,
+    serialized_length_from_bytes, serialized_length_from_bytes_trusted, tree_hash_from_stream,
+};
+use criterion::{criterion_group, criterion_main, Criterion};
 use std::include_bytes;
 use std::time::Instant;
 
 fn deserialize_benchmark(c: &mut Criterion) {
     let block = include_bytes!("block_af9c3d98.bin");
+    let compressed_block = {
+        let mut a = Allocator::new();
+        let input = node_from_bytes(&mut a, block).expect("failed to parse input file");
+        node_to_bytes_backrefs(&a, input).expect("failed to compress generator")
+    };
 
     let mut group = c.benchmark_group("deserialize");
-    group.sample_size(10);
-    group.sampling_mode(SamplingMode::Flat);
 
-    group.bench_function("serialized_length_from_bytes", |b| {
-        b.iter(|| {
-            let start = Instant::now();
-            let _ = serialized_length_from_bytes(block);
-            start.elapsed()
-        })
-    });
+    for (bl, name_suffix) in &[
+        (block as &[u8], ""),
+        (compressed_block.as_ref(), "-compressed"),
+    ] {
+        group.bench_function(format!("serialized_length_from_bytes{name_suffix}"), |b| {
+            b.iter(|| {
+                let start = Instant::now();
+                serialized_length_from_bytes(bl).expect("serialized_length_from_bytes");
+                start.elapsed()
+            })
+        });
 
-    group.bench_function("serialized_length_from_bytes_trusted", |b| {
-        b.iter(|| {
-            let start = Instant::now();
-            let _ = serialized_length_from_bytes_trusted(block);
-            start.elapsed()
-        })
-    });
+        group.bench_function(
+            format!("serialized_length_from_bytes_trusted{name_suffix}"),
+            |b| {
+                b.iter(|| {
+                    let start = Instant::now();
+                    serialized_length_from_bytes_trusted(bl)
+                        .expect("serialized_length_from_bytes_truested");
+                    start.elapsed()
+                })
+            },
+        );
 
-    let mut a = Allocator::new();
-    let iter_checkpoint = a.checkpoint();
+        // we don't support compressed CLVM in tree_hash_from_stream yet
+        if name_suffix.is_empty() {
+            group.bench_function(format!("tree_hash_from_stream{name_suffix}"), |b| {
+                b.iter(|| {
+                    let mut cur = std::io::Cursor::new(*bl);
+                    let start = Instant::now();
+                    tree_hash_from_stream(&mut cur).expect("tree_hash_from_stream");
+                    start.elapsed()
+                })
+            });
+        }
 
-    group.bench_function("node_from_bytes_backrefs", |b| {
-        b.iter(|| {
-            a.restore_checkpoint(&iter_checkpoint);
-            let start = Instant::now();
-            let _ = node_from_bytes_backrefs(&mut a, block);
-            start.elapsed()
-        })
-    });
+        let mut a = Allocator::new();
+        let iter_checkpoint = a.checkpoint();
+
+        group.bench_function(format!("node_from_bytes_backrefs{name_suffix}"), |b| {
+            b.iter(|| {
+                a.restore_checkpoint(&iter_checkpoint);
+                let start = Instant::now();
+                node_from_bytes_backrefs(&mut a, bl).expect("node_from_bytes_backrefs");
+                start.elapsed()
+            })
+        });
+    }
 
+    let mut a = Allocator::new();
+    let iter_checkpoint = a.checkpoint();
     group.bench_function("node_from_bytes", |b| {
         b.iter(|| {
             a.restore_checkpoint(&iter_checkpoint);
             let start = Instant::now();
-            let _ = node_from_bytes(&mut a, block);
+            node_from_bytes(&mut a, block).expect("node_from_bytes");
             start.elapsed()
         })
     });