switch gossip to bitvec crate for better low-level API

Author: alexpyattaev

Cargo.lock

@@ -291,6 +291,7 @@ backoff = "0.4.0"
 base64 = "0.22.1"
 bincode = "1.3.3"
 bitflags = { version = "2.8.0" }
+bitvec = "1.0.1"
 blake3 = "1.5.5"
 borsh = { version = "1.5.5", features = ["derive", "unstable__schema"] }
 borsh0-10 = { package = "borsh", version = "0.10.3" }

Cargo.toml

@@ -12,6 +12,7 @@ edition = { workspace = true }
 [dependencies]
 assert_matches = { workspace = true }
 bincode = { workspace = true }
+bitvec = { workspace = true, features = ["serde"] }
 bv = { workspace = true, features = ["serde"] }
 clap = { workspace = true }
 crossbeam-channel = { workspace = true }

gossip/Cargo.toml

@@ -4,7 +4,7 @@ use {
         protocol::MAX_CRDS_OBJECT_SIZE,
     },
     bincode::serialized_size,
-    bv::BitVec,
+    bitvec::prelude::BitVec,
     flate2::{Compress, Compression, Decompress, FlushCompress, FlushDecompress},
     solana_sanitize::{Sanitize, SanitizeError},
     solana_sdk::{clock::Slot, pubkey::Pubkey},
@@ -81,30 +81,44 @@ impl std::convert::From<flate2::DecompressError> for Error {
 }
 
 impl Flate2 {
-    fn deflate(mut unc: Uncompressed) -> Result<Self> {
-        let mut compressed = Vec::with_capacity(unc.slots.block_capacity());
+    fn deflate(unc: Uncompressed) -> Result<Self> {
+        // View into the slots array as raw bytes
+        let bits = unc.slots.as_raw_slice();
+        // Assume compressed version will be smaller than the original
+        let mut compressed = Vec::with_capacity(bits.len());
+        // Perform compression and check status to make sure everything fits
         let mut compressor = Compress::new(Compression::best(), false);
-        let first_slot = unc.first_slot;
-        let num = unc.num;
-        unc.slots.shrink_to_fit();
-        let bits = unc.slots.into_boxed_slice();
-        compressor.compress_vec(&bits, &mut compressed, FlushCompress::Finish)?;
+        let status = compressor.compress_vec(bits, &mut compressed, FlushCompress::Finish)?;
+        if status != flate2::Status::StreamEnd {
+            return Err(Error::CompressError);
+        }
+
         let rv = Self {
-            first_slot,
-            num,
+            first_slot: unc.first_slot,
+            num: unc.num,
             compressed,
         };
         Ok(rv)
     }
+
     pub fn inflate(&self) -> Result<Uncompressed> {
         //add some head room for the decompressor which might spill more bits
         let mut uncompressed = Vec::with_capacity(32 + (self.num + 4) / 8);
+        // Perform the actual decompression and check that the result fits into provided buffer
         let mut decompress = Decompress::new(false);
-        decompress.decompress_vec(&self.compressed, &mut uncompressed, FlushDecompress::Finish)?;
+        let status = decompress.decompress_vec(
+            &self.compressed,
+            &mut uncompressed,
+            FlushDecompress::Finish,
+        )?;
+        if status != flate2::Status::StreamEnd {
+            return Err(Error::DecompressError);
+        }
+
         Ok(Uncompressed {
             first_slot: self.first_slot,
             num: self.num,
-            slots: BitVec::from_bits(&uncompressed),
+            slots: BitVec::from_vec(uncompressed),
         })
     }
 }
@@ -114,7 +128,7 @@ impl Uncompressed {
         Self {
             num: 0,
             first_slot: 0,
-            slots: BitVec::new_fill(false, 8 * max_size as u64),
+            slots: BitVec::repeat(false, 8 * max_size),
         }
     }
     pub fn to_slots(&self, min_slot: Slot) -> Vec<Slot> {
@@ -125,10 +139,10 @@ impl Uncompressed {
             (min_slot - self.first_slot) as usize
         };
         for i in start..self.num {
-            if i >= self.slots.len() as usize {
+            if i >= self.slots.len() {
                 break;
             }
-            if self.slots.get(i as u64) {
+            if *self.slots.get(i).expect("slot index should be in bounds") {
                 rv.push(self.first_slot + i as Slot);
             }
         }
@@ -145,11 +159,12 @@ impl Uncompressed {
             if *s < self.first_slot {
                 return i;
             }
-            if *s - self.first_slot >= self.slots.len() {
+            let offset = (*s - self.first_slot) as usize;
+            if offset >= self.slots.len() {
                 return i;
             }
-            self.slots.set(*s - self.first_slot, true);
-            self.num = std::cmp::max(self.num, 1 + (*s - self.first_slot) as usize);
+            self.slots.set(offset, true);
+            self.num = std::cmp::max(self.num, 1 + offset);
         }
         slots.len()
     }
@@ -422,7 +437,7 @@ mod tests {
         assert_eq!(o.sanitize(), Err(SanitizeError::ValueOutOfBounds));
 
         let mut o = slots.clone();
-        o.slots = BitVec::new_fill(false, 7); // Length not a multiple of 8
+        o.slots = BitVec::repeat(false, 7); // Length not a multiple of 8
         assert_eq!(o.sanitize(), Err(SanitizeError::ValueOutOfBounds));
 
         let mut o = slots.clone();