improve hybrid rle decoding performance ~-40%

src/encoding/delta_bitpacked/decoder.rs

@@ -136,15 +136,15 @@ pub struct Decoder<'a> {
 impl<'a> Decoder<'a> {
     pub fn try_new(mut values: &'a [u8]) -> Result<Self, Error> {
         let mut consumed_bytes = 0;
-        let (block_size, consumed) = uleb128::decode(values)?;
+        let (block_size, consumed) = uleb128::decode(values);
         consumed_bytes += consumed;
         assert_eq!(block_size % 128, 0);
         values = &values[consumed..];
-        let (num_mini_blocks, consumed) = uleb128::decode(values)?;
+        let (num_mini_blocks, consumed) = uleb128::decode(values);
         let num_mini_blocks = num_mini_blocks as usize;
         consumed_bytes += consumed;
         values = &values[consumed..];
-        let (total_count, consumed) = uleb128::decode(values)?;
+        let (total_count, consumed) = uleb128::decode(values);
         let total_count = total_count as usize;
         consumed_bytes += consumed;
         values = &values[consumed..];

src/encoding/hybrid_rle/decoder.rs

@@ -36,10 +36,7 @@ impl<'a> Iterator for Decoder<'a> {
             return None;
         }
 
-        let (indicator, consumed) = match uleb128::decode(self.values) {
-            Ok((indicator, consumed)) => (indicator, consumed),
-            Err(e) => return Some(Err(e)),
-        };
+        let (indicator, consumed) = uleb128::decode(self.values);
         self.values = &self.values[consumed..];
         if self.values.is_empty() {
             return None;

src/encoding/hybrid_rle/mod.rs

@@ -25,6 +25,9 @@ enum State<'a> {
     None,
     Bitpacked(bitpacked::Decoder<'a, u32>),
     Rle(std::iter::Take<std::iter::Repeat<u32>>),
+    // Add a special branch for a single value to
+    // adhere to the law of small numbers
+    Single(u32),
 }
 
 /// [`Iterator`] of [`u32`] from a byte slice of Hybrid-RLE encoded values
@@ -50,7 +53,11 @@ fn read_next<'a, 'b>(decoder: &'b mut Decoder<'a>, remaining: usize) -> Result<S
                 .enumerate()
                 .for_each(|(i, byte)| bytes[i] = *byte);
             let value = u32::from_le_bytes(bytes);
-            State::Rle(std::iter::repeat(value).take(additional))
+            if additional == 1 {
+                State::Single(value)
+            } else {
+                State::Rle(std::iter::repeat(value).take(additional))
+            }
         }
         None => State::None,
     })
@@ -80,6 +87,7 @@ impl<'a> Iterator for HybridRleDecoder<'a> {
         let result = match &mut self.state {
             State::Bitpacked(decoder) => decoder.next(),
             State::Rle(iter) => iter.next(),
+            State::Single(i) => Some(*i),
             State::None => Some(0),
         };
         if let Some(result) = result {

src/encoding/uleb128.rs

@@ -1,6 +1,5 @@
-use crate::error::Error;
-
-pub fn decode(values: &[u8]) -> Result<(u64, usize), Error> {
+#[inline]
+pub fn decode(values: &[u8]) -> (u64, usize) {
     let mut result = 0;
     let mut shift = 0;
 
@@ -19,7 +18,7 @@ pub fn decode(values: &[u8]) -> Result<(u64, usize), Error> {
 
         shift += 7;
     }
-    Ok((result, consumed))
+    (result, consumed)
 }
 
 /// Encodes `value` in ULEB128 into `container`. The exact number of bytes written
@@ -52,15 +51,15 @@ mod tests {
     #[test]
     fn decode_1() {
         let data = vec![0xe5, 0x8e, 0x26, 0xDE, 0xAD, 0xBE, 0xEF];
-        let (value, len) = decode(&data).unwrap();
+        let (value, len) = decode(&data);
         assert_eq!(value, 624_485);
         assert_eq!(len, 3);
     }
 
     #[test]
     fn decode_2() {
         let data = vec![0b00010000, 0b00000001, 0b00000011, 0b00000011];
-        let (value, len) = decode(&data).unwrap();
+        let (value, len) = decode(&data);
         assert_eq!(value, 16);
         assert_eq!(len, 1);
     }
@@ -70,7 +69,7 @@ mod tests {
         let original = 123124234u64;
         let mut container = [0u8; 10];
         let encoded_len = encode(original, &mut container);
-        let (value, len) = decode(&container).unwrap();
+        let (value, len) = decode(&container);
         assert_eq!(value, original);
         assert_eq!(len, encoded_len);
     }
@@ -80,7 +79,7 @@ mod tests {
         let original = u64::MIN;
         let mut container = [0u8; 10];
         let encoded_len = encode(original, &mut container);
-        let (value, len) = decode(&container).unwrap();
+        let (value, len) = decode(&container);
         assert_eq!(value, original);
         assert_eq!(len, encoded_len);
     }
@@ -90,7 +89,7 @@ mod tests {
         let original = u64::MAX;
         let mut container = [0u8; 10];
         let encoded_len = encode(original, &mut container);
-        let (value, len) = decode(&container).unwrap();
+        let (value, len) = decode(&container);
         assert_eq!(value, original);
         assert_eq!(len, encoded_len);
     }

src/encoding/zigzag_leb128.rs

@@ -3,7 +3,7 @@ use crate::error::Error;
 use super::uleb128;
 
 pub fn decode(values: &[u8]) -> Result<(i64, usize), Error> {
-    let (u, consumed) = uleb128::decode(values)?;
+    let (u, consumed) = uleb128::decode(values);
     Ok(((u >> 1) as i64 ^ -((u & 1) as i64), consumed))
 }
 

tests/it/read/primitive_nested.rs

@@ -183,7 +183,7 @@ fn read_dict_array<T: NativeType>(
     let bit_width = values[0];
     let values = &values[1..];
 
-    let (_, consumed) = uleb128::decode(values)?;
+    let (_, consumed) = uleb128::decode(values);
     let values = &values[consumed..];
 
     let indices = bitpacked::Decoder::<u32>::try_new(values, bit_width as usize, length as usize)?;