replace bitvec with faster warm address bits lookup

nits

use direct path to std format

Author: borngraced

crates/context/Cargo.toml

@@ -28,13 +28,13 @@ bytecode.workspace = true
 # misc
 derive-where.workspace = true
 cfg-if.workspace = true
-bitvec.workspace = true
 
 # Optional
 serde = { workspace = true, features = ["derive", "rc"], optional = true }
 
 [dev-dependencies]
 database.workspace = true
+bitvec.workspace = true
 
 [features]
 default = ["std"]
@@ -46,7 +46,6 @@ std = [
 	"database-interface/std",
 	"primitives/std",
 	"state/std",
-	"bitvec/std",
 ]
 serde = [
 	"dep:serde",
@@ -57,7 +56,6 @@ serde = [
 	"database/serde",
 	"database-interface/serde",
 	"derive-where/serde",
-	"bitvec/serde",
 ]
 dev = [
 	"memory_limit",

crates/context/src/journal/warm_addresses.rs

@@ -2,12 +2,42 @@
 //!
 //! It is used to optimize access to precompile addresses.
 
-use bitvec::{bitvec, vec::BitVec};
 use context_interface::journaled_state::JournalLoadError;
 use primitives::{
     short_address, Address, AddressMap, AddressSet, HashSet, StorageKey, SHORT_ADDRESS_CAP,
 };
 
+/// Number of bytes needed to hold SHORT_ADDRESS_CAP bits (300 bits == 38 bytes).
+const PRECOMPILE_SHORT_ADDRESS_BYTES: usize = (SHORT_ADDRESS_CAP + 7) / 8;
+
+#[cfg(feature = "serde")]
+mod fixed_array {
+    use serde::{Deserialize, Deserializer, Serializer};
+
+    pub(super) fn serialize<S: Serializer, const N: usize>(
+        arr: &[u8; N],
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        serializer.serialize_bytes(arr)
+    }
+
+    pub(super) fn deserialize<'de, D: Deserializer<'de>, const N: usize>(
+        deserializer: D,
+    ) -> Result<[u8; N], D::Error> {
+        let bytes: &[u8] = Deserialize::deserialize(deserializer)?;
+        if bytes.len() != N {
+            return Err(serde::de::Error::custom(std::format!(
+                "expected {} bytes, got {}",
+                N,
+                bytes.len()
+            )));
+        }
+        let mut arr = [0u8; N];
+        arr.copy_from_slice(bytes);
+        Ok(arr)
+    }
+}
+
 /// Stores addresses that are warm loaded. Contains precompiles and coinbase address.
 ///
 /// It contains precompiles addresses that are not changed frequently and AccessList that
@@ -22,9 +52,11 @@ use primitives::{
 pub struct WarmAddresses {
     /// Set of warm loaded precompile addresses.
     precompile_set: AddressSet,
-    /// Bit vector of precompile short addresses. If address is shorter than [`SHORT_ADDRESS_CAP`] it
-    /// will be stored in this bit vector for faster access.
-    precompile_short_addresses: BitVec,
+    /// Fixed bitset of precompile short addresses (one bit per possible short address).
+    /// Uses a plain byte array + manual bit ops for fast access in the hot path
+    /// (avoids BitVec overhead, similar to JumpTable optimization).
+    #[cfg_attr(feature = "serde", serde(with = "fixed_array"))]
+    precompile_short_addresses: [u8; PRECOMPILE_SHORT_ADDRESS_BYTES],
     /// `true` if all precompiles are short addresses.
     precompile_all_short_addresses: bool,
     /// Coinbase address.
@@ -45,7 +77,7 @@ impl WarmAddresses {
     pub fn new() -> Self {
         Self {
             precompile_set: AddressSet::default(),
-            precompile_short_addresses: bitvec![0; SHORT_ADDRESS_CAP],
+            precompile_short_addresses: [0u8; PRECOMPILE_SHORT_ADDRESS_BYTES],
             precompile_all_short_addresses: true,
             coinbase: None,
             access_list: AddressMap::default(),
@@ -66,12 +98,12 @@ impl WarmAddresses {
 
     /// Set the precompile addresses and short addresses.
     pub fn set_precompile_addresses(&mut self, addresses: &AddressSet) {
-        self.precompile_short_addresses.fill(false);
+        self.precompile_short_addresses.fill(0);
 
         let mut all_short_addresses = true;
         for address in addresses.iter() {
             if let Some(short_address) = short_address(address) {
-                self.precompile_short_addresses.set(short_address, true);
+                self.set_precompile_short(short_address);
             } else {
                 all_short_addresses = false;
             }
@@ -81,6 +113,31 @@ impl WarmAddresses {
         self.precompile_set.clone_from(addresses);
     }
 
+    /// Set the bit for a short precompile address.
+    ///
+    /// Uses manual bit manipulation on a fixed byte array (instead of `BitVec`)
+    /// to avoid per-access overhead
+    #[inline(always)]
+    fn set_precompile_short(&mut self, idx: usize) {
+        // get the index to the byte in the arr
+        let byte = idx >> 3;
+        // bit position within the byte (0..7)
+        let bit = 1 << (idx & 7);
+        self.precompile_short_addresses[byte] |= bit;
+    }
+
+    /// Returns whether the bit for the given short address index is set.
+    ///
+    /// This is the hot path inside `is_warm`/`is_cold` for short precompile
+    /// addresses. We perform direct byte + bit operations on the fixed array
+    /// instead of going through `BitVec` (same technique I used in `JumpTable::is_valid`).
+    #[inline(always)]
+    pub(crate) fn is_precompile_short(&self, idx: usize) -> bool {
+        let byte = idx >> 3;
+        let bit = 1 << (idx & 7);
+        self.precompile_short_addresses[byte] & bit != 0
+    }
+
     /// Set the coinbase address.
     #[inline]
     pub const fn set_coinbase(&mut self, address: Address) {
@@ -131,7 +188,7 @@ impl WarmAddresses {
 
         // check if it is short precompile address
         if let Some(short_address) = short_address(address) {
-            return self.precompile_short_addresses[short_address];
+            return self.is_precompile_short(short_address);
         }
 
         if !self.precompile_all_short_addresses {
@@ -185,9 +242,12 @@ mod tests {
         assert!(warm_addresses.precompile_set.is_empty());
         assert_eq!(
             warm_addresses.precompile_short_addresses.len(),
-            SHORT_ADDRESS_CAP
+            PRECOMPILE_SHORT_ADDRESS_BYTES
         );
-        assert!(!warm_addresses.precompile_short_addresses.any());
+        assert!(warm_addresses
+            .precompile_short_addresses
+            .iter()
+            .all(|&b| b == 0));
         assert!(warm_addresses.coinbase.is_none());
 
         // Test Default trait
@@ -234,13 +294,13 @@ mod tests {
         assert_eq!(warm_addresses.precompile_set, precompiles);
         assert_eq!(
             warm_addresses.precompile_short_addresses.len(),
-            SHORT_ADDRESS_CAP
+            PRECOMPILE_SHORT_ADDRESS_BYTES
         );
 
-        // Verify bitvec optimization
-        assert!(warm_addresses.precompile_short_addresses[1]);
-        assert!(warm_addresses.precompile_short_addresses[5]);
-        assert!(!warm_addresses.precompile_short_addresses[0]);
+        // Verify optimization (replaces old BitVec)
+        assert!(warm_addresses.is_precompile_short(1));
+        assert!(warm_addresses.is_precompile_short(5));
+        assert!(!warm_addresses.is_precompile_short(0));
 
         // Verify warmth detection
         assert!(warm_addresses.is_warm(&short_addr1));
@@ -272,7 +332,10 @@ mod tests {
 
         // Verify storage
         assert_eq!(warm_addresses.precompile_set, precompiles);
-        assert!(!warm_addresses.precompile_short_addresses.any());
+        assert!(warm_addresses
+            .precompile_short_addresses
+            .iter()
+            .all(|&b| b == 0));
 
         // Verify warmth detection
         assert!(warm_addresses.is_warm(&regular_addr));
@@ -303,8 +366,8 @@ mod tests {
         assert!(warm_addresses.is_warm(&regular_addr));
 
         // Verify short address optimization is used
-        assert!(warm_addresses.precompile_short_addresses[7]);
-        assert!(!warm_addresses.precompile_short_addresses[8]);
+        assert!(warm_addresses.is_precompile_short(7));
+        assert!(!warm_addresses.is_precompile_short(8));
     }
 
     #[test]
@@ -324,6 +387,174 @@ mod tests {
         warm_addresses.set_precompile_addresses(&precompiles);
 
         assert!(warm_addresses.is_warm(&boundary_addr));
-        assert!(warm_addresses.precompile_short_addresses[SHORT_ADDRESS_CAP - 1]);
+        assert!(warm_addresses.is_precompile_short(SHORT_ADDRESS_CAP - 1));
+    }
+}
+
+#[cfg(test)]
+mod bench_is_short_precompile {
+    use super::*;
+    use std::time::Instant;
+
+    use bitvec::{bitvec, vec::BitVec};
+
+    const ITERATIONS: usize = 1_000_000;
+    const TEST_SIZE: usize = SHORT_ADDRESS_CAP;
+
+    /// Legacy BitVec version (for comparison only).
+    #[derive(Clone)]
+    struct ShortAddressesWithBitVec {
+        bits: BitVec,
+    }
+
+    impl ShortAddressesWithBitVec {
+        fn new() -> Self {
+            Self {
+                bits: bitvec![0; SHORT_ADDRESS_CAP],
+            }
+        }
+
+        fn set_many(&mut self, indices: impl IntoIterator<Item = usize>) {
+            for i in indices {
+                if i < SHORT_ADDRESS_CAP {
+                    self.bits.set(i, true);
+                }
+            }
+        }
+
+        /// Old BitVec [] style (for comparison).
+        #[inline]
+        fn is_set(&self, idx: usize) -> bool {
+            self.bits[idx]
+        }
+    }
+
+    fn create_test_data() -> (WarmAddresses, ShortAddressesWithBitVec) {
+        let mut real = WarmAddresses::new();
+        let mut precompile_set = AddressSet::default();
+
+        for i in (0..TEST_SIZE).step_by(3) {
+            let mut bytes = [0u8; 20];
+            bytes[18] = (i >> 8) as u8;
+            bytes[19] = i as u8;
+            precompile_set.insert(Address::from(bytes));
+        }
+        real.set_precompile_addresses(&precompile_set);
+
+        let mut legacy = ShortAddressesWithBitVec::new();
+        legacy.set_many((0..TEST_SIZE).step_by(3));
+
+        (real, legacy)
+    }
+
+    fn benchmark_implementation<F>(name: &str, table: &F, test_fn: impl Fn(&F, usize) -> bool)
+    where
+        F: Clone,
+    {
+        for i in 0..10_000 {
+            std::hint::black_box(test_fn(table, i % TEST_SIZE));
+        }
+
+        let start = Instant::now();
+        let mut count = 0;
+
+        for i in 0..ITERATIONS {
+            if test_fn(table, i % TEST_SIZE) {
+                count += 1;
+            }
+        }
+
+        let duration = start.elapsed();
+        let ns_per_op = duration.as_nanos() as f64 / ITERATIONS as f64;
+        let ops_per_sec = ITERATIONS as f64 / duration.as_secs_f64();
+
+        println!("{name} Performance:");
+        println!("  Time per op: {ns_per_op:.2} ns");
+        println!("  Ops per sec: {ops_per_sec:.0}");
+        println!("  True count: {count}");
+        println!();
+
+        std::hint::black_box(count);
+    }
+
+    #[test]
+    fn bench_is_short_precompile() {
+        println!("\nWarmAddresses short precompile bit test Benchmark Comparison");
+        println!("============================================================");
+
+        let (real_warm, legacy_bitvec) = create_test_data();
+
+        benchmark_implementation(
+            "WarmAddresses (Fixed Array + Manual Bits)",
+            &real_warm,
+            |wa, idx| wa.is_precompile_short(idx),
+        );
+
+        benchmark_implementation("Legacy (BitVec indexing)", &legacy_bitvec, |lb, idx| {
+            lb.is_set(idx)
+        });
+
+        println!("Benchmark completed successfully!\n");
+    }
+
+    #[test]
+    fn bench_different_access_patterns() {
+        let (real_warm, legacy_bitvec) = create_test_data();
+
+        println!("Short Precompile Access Pattern Comparison");
+        println!("==========================================");
+
+        let start = Instant::now();
+        for i in 0..ITERATIONS {
+            std::hint::black_box(real_warm.is_precompile_short(i % TEST_SIZE));
+        }
+        let fixed_sequential = start.elapsed();
+
+        let start = Instant::now();
+        for i in 0..ITERATIONS {
+            std::hint::black_box(legacy_bitvec.is_set(i % TEST_SIZE));
+        }
+        let bitvec_sequential = start.elapsed();
+
+        let start = Instant::now();
+        for i in 0..ITERATIONS {
+            std::hint::black_box(real_warm.is_precompile_short((i * 17) % TEST_SIZE));
+        }
+        let fixed_random = start.elapsed();
+
+        let start = Instant::now();
+        for i in 0..ITERATIONS {
+            std::hint::black_box(legacy_bitvec.is_set((i * 17) % TEST_SIZE));
+        }
+        let bitvec_random = start.elapsed();
+
+        println!("Sequential Access:");
+        println!(
+            "  Fixed Array: {:.2} ns/op",
+            fixed_sequential.as_nanos() as f64 / ITERATIONS as f64
+        );
+        println!(
+            "  BitVec:      {:.2} ns/op",
+            bitvec_sequential.as_nanos() as f64 / ITERATIONS as f64
+        );
+        println!(
+            "  Speedup: {:.1}x",
+            bitvec_sequential.as_nanos() as f64 / fixed_sequential.as_nanos() as f64
+        );
+
+        println!();
+        println!("Random Access:");
+        println!(
+            "  Fixed Array: {:.2} ns/op",
+            fixed_random.as_nanos() as f64 / ITERATIONS as f64
+        );
+        println!(
+            "  BitVec:      {:.2} ns/op",
+            bitvec_random.as_nanos() as f64 / ITERATIONS as f64
+        );
+        println!(
+            "  Speedup: {:.1}x",
+            bitvec_random.as_nanos() as f64 / fixed_random.as_nanos() as f64
+        );
     }
 }