Optimize LEB128 data reading

As it turns out, the Rust compiler uses variable length LEB128 encoded
integers internally. It so happens that they spent a fair amount of
effort micro-optimizing the decoding functionality [0] [1], as it's in
the hot path.
With this change we replace our decoding routines with these optimized
ones. To make that happen more easily (and to gain some base line speed
up), also remove the "shift" return from the respective methods. As a
result of these changes, we see a respectable speed up:

System gimli-rs#1:
  Before:
    test bench_reading_leb128_unsigned  ... bench:  235.83 ns/iter (+/- 32.53)
  After:
    test bench_reading_leb128_unsigned  ... bench:  157.38 ns/iter (+/- 17.09)

System gimli-rs#2:
  Before:
    test bench_reading_leb128_unsigned  ... bench:  183.70 ns/iter (+/- 2.72)
  After:
    test bench_reading_leb128_unsigned  ... bench:  103.83 ns/iter (+/- 3.28)

[0] rust-lang/rust#69050
[1] rust-lang/rust#69157

Signed-off-by: Daniel Müller <[email protected]>

Author: d-e-s-o

benches/bench.rs

@@ -3,17 +3,51 @@
 extern crate test;
 
 use gimli::{
-    AttributeValue, DebugAbbrev, DebugAddr, DebugAddrBase, DebugAranges, DebugInfo, DebugLine,
-    DebugLineOffset, DebugLoc, DebugLocLists, DebugPubNames, DebugPubTypes, DebugRanges,
+    leb128, AttributeValue, DebugAbbrev, DebugAddr, DebugAddrBase, DebugAranges, DebugInfo,
+    DebugLine, DebugLineOffset, DebugLoc, DebugLocLists, DebugPubNames, DebugPubTypes, DebugRanges,
     DebugRngLists, Encoding, EndianSlice, EntriesTreeNode, Expression, LittleEndian, LocationLists,
-    Operation, RangeLists, RangeListsOffset, Reader, ReaderOffset,
+    NativeEndian, Operation, RangeLists, RangeListsOffset, Reader, ReaderOffset,
 };
 use std::env;
 use std::fs::File;
 use std::io::Read;
 use std::path::PathBuf;
 use std::rc::Rc;
 
+#[bench]
+fn bench_reading_leb128_unsigned(b: &mut test::Bencher) {
+    #[rustfmt::skip]
+    let data = [
+        (&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01][..], u64::MAX),
+        (&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00][..], u64::MAX / 2),
+        (&[0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0xaa, 0x55, 0x00][..], u64::MAX / 3),
+        (&[0xb3, 0xe6, 0xcc, 0x99, 0xb3, 0xe6, 0xcc, 0x99, 0x33, 0x00][..], u64::MAX / 5),
+        (&[0xaa, 0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0x2a, 0x00][..], u64::MAX / 6),
+        (&[0x92, 0xc9, 0xa4, 0x92, 0xc9, 0xa4, 0x92, 0xc9, 0x24, 0x00][..], u64::MAX / 7),
+        (&[0xf1, 0xb8, 0x9c, 0x8e, 0xc7, 0xe3, 0xf1, 0xb8, 0x1c, 0x00][..], u64::MAX / 9),
+        (&[0x99, 0xb3, 0xe6, 0xcc, 0x99, 0xb3, 0xe6, 0xcc, 0x19, 0x00][..], u64::MAX / 10),
+        (&[0xd1, 0x8b, 0xdd, 0xe8, 0xc5, 0xae, 0xf4, 0xa2, 0x17, 0x00][..], u64::MAX / 11),
+        (&[0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0xaa, 0xd5, 0xaa, 0x15, 0x00][..], u64::MAX / 12),
+        (&[0xb1, 0xa7, 0xec, 0x89, 0xbb, 0xe2, 0xce, 0xd8, 0x13, 0x00][..], u64::MAX / 13),
+        (&[0xc9, 0xa4, 0x92, 0xc9, 0xa4, 0x92, 0xc9, 0xa4, 0x12, 0x00][..], u64::MAX / 14),
+        (&[0x91, 0xa2, 0xc4, 0x88, 0x91, 0xa2, 0xc4, 0x88, 0x11, 0x00][..], u64::MAX / 15),
+    ];
+
+    for (data, expected) in data {
+        let mut slice = test::black_box(EndianSlice::new(data, NativeEndian));
+        let v = leb128::read::unsigned(&mut slice).unwrap();
+        assert_eq!(v, expected);
+    }
+
+    let () = b.iter(|| {
+        for (data, _) in data {
+            let mut slice = test::black_box(EndianSlice::new(data, NativeEndian));
+            let v = leb128::read::unsigned(&mut slice).unwrap();
+            test::black_box(v);
+        }
+    });
+}
+
 pub fn read_section(section: &str) -> Vec<u8> {
     let mut path = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| ".".into()));
     path.push("./fixtures/self/");

src/leb128.rs

@@ -79,23 +79,30 @@ pub mod read {
 
     /// Read an unsigned LEB128 number from the given `Reader` and
     /// return it or an error if reading failed.
+    // Slightly adjusted copy of `rustc` implementation:
+    // https://github.com/rust-lang/rust/blob/be8de5d6a0fc5cb2924e174a809a0aff303f281a/compiler/rustc_serialize/src/leb128.rs#L53
     pub fn unsigned<R: Reader>(r: &mut R) -> Result<u64> {
-        let mut result = 0;
-        let mut shift = 0;
-
+        // The first iteration of this loop is unpeeled. This is a
+        // performance win because this code is hot and integer values less
+        // than 128 are very common, typically occurring 50-80% or more of
+        // the time, even for u64 and u128.
+        let byte = r.read_u8()?;
+        if byte & CONTINUATION_BIT == 0 {
+            return Ok(u64::from(byte));
+        }
+        let mut result = u64::from(low_bits_of_byte(byte));
+        let mut shift = 7;
         loop {
             let byte = r.read_u8()?;
-            if shift == 63 && byte != 0x00 && byte != 0x01 {
-                return Err(Error::BadUnsignedLeb128);
-            }
-
-            let low_bits = u64::from(low_bits_of_byte(byte));
-            result |= low_bits << shift;
-
             if byte & CONTINUATION_BIT == 0 {
+                result |= u64::from(byte) << shift;
                 return Ok(result);
+            } else {
+                result |= u64::from(low_bits_of_byte(byte)) << shift;
+            }
+            if shift >= 63 {
+                return Err(Error::BadUnsignedLeb128);
             }
-
             shift += 7;
         }
     }