Merge pull request #556 from Chia-Network/new-serialize-benchmark

Add two new serializer benchmark trees

Author: arvidn

benches/3.generator

@@ -1,6 +1,7 @@
 use clvmr::allocator::Allocator;
 use clvmr::serde::{
-    node_from_bytes, node_from_bytes_backrefs, node_to_bytes, node_to_bytes_backrefs, Serializer,
+    node_from_bytes, node_from_bytes_backrefs, node_to_bytes_backrefs, node_to_bytes_limit,
+    Serializer,
 };
 use criterion::black_box;
 use criterion::{criterion_group, criterion_main, Criterion};
@@ -14,15 +15,28 @@ fn serialize_benchmark(c: &mut Criterion) {
     let block0: &[u8] = include_bytes!("0.generator");
     let block1: &[u8] = include_bytes!("1.generator");
     let block2: &[u8] = include_bytes!("2.generator");
+    let block3: &[u8] = include_bytes!("3.generator");
+    let block4: &[u8] = include_bytes!("4.generator");
 
     let mut group = c.benchmark_group("serialize");
 
-    for (block, name) in [(&block0, "0"), (&block1, "1"), (&block2, "2")] {
+    for (block, name) in [
+        (&block0, "0"),
+        (&block1, "1"),
+        (&block2, "2"),
+        (&block3, "3"),
+        (&block4, "4"),
+    ] {
         let mut a = Allocator::new();
         let node = node_from_bytes_backrefs(&mut a, block).expect("node_from_bytes_backrefs");
-        let inflated = node_to_bytes(&a, node).expect("node_to_bytes");
-        let mut a = Allocator::new();
-        let node = node_from_bytes(&mut a, inflated.as_slice()).expect("node_from_bytes");
+
+        // if the inflated form takes too much space, just run the benchmark on the compact form
+        let node = if let Ok(inflated) = node_to_bytes_limit(&a, node, 2000000) {
+            a = Allocator::new();
+            node_from_bytes(&mut a, inflated.as_slice()).expect("node_from_bytes")
+        } else {
+            node
+        };
 
         group.bench_function(format!("node_to_bytes_backrefs {name}"), |b| {
             b.iter(|| {

benches/4.generator

@@ -95,7 +95,7 @@ const MODPOW_COST_PER_BYTE_EXPONENT: Cost = 3;
 const MODPOW_COST_PER_BYTE_MOD: Cost = 21;
 
 fn limbs_for_int(v: &Number) -> usize {
-    ((v.bits() + 7) / 8) as usize
+    v.bits().div_ceil(8) as usize
 }
 
 #[cfg(test)]

benches/serialize.rs

@@ -27,7 +27,7 @@ pub fn atom_length_bits(num_bits: u64) -> Option<u64> {
     if num_bits < 8 {
         return Some(1);
     }
-    let num_bytes = (num_bits + 7) / 8;
+    let num_bytes = num_bits.div_ceil(8);
     match num_bytes {
         1..0x40 => Some(1 + num_bytes),
         0x40..0x2000 => Some(2 + num_bytes),
@@ -84,9 +84,9 @@ mod tests {
     #[case(505, Some(2+64))]
     #[case(0xfff8, Some(2+0x1fff))]
     #[case(0xfff9, Some(3+0x2000))]
-    #[case(0x3ffffff8, Some(4 + (0x3ffffff8 + 7) / 8))]
-    #[case(0x3ffffff9, Some(5 + (0x3ffffff9 + 7) / 8))]
-    #[case(0x1ffffffff8, Some(5 + (0x1ffffffff8 + 7) / 8))]
+    #[case(0x3ffffff8, Some(4 + 0x3ffffff8_u64.div_ceil(8)))]
+    #[case(0x3ffffff9, Some(5 + 0x3ffffff9_u64.div_ceil(8)))]
+    #[case(0x1ffffffff8, Some(5 + 0x1ffffffff8_u64.div_ceil(8)))]
     #[case(0x1ffffffff9, None)]
     fn test_atom_length_bits(#[case] num_bits: u64, #[case] expect: Option<u64>) {
         assert_eq!(atom_length_bits(num_bits), expect);

src/more_ops.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::useless_conversion)]
 use std::io;
 
 use super::lazy_node::LazyNode;