Reduce unnecessary allocations and indirections

* Changed literal_probs array from a Vec<Vec<u16>> to a Vec2D backed by a contiguous allocation
* BitTrees in LenDecoder and DecoderState are now stored inline. The actual BitTree data still
  lives in a Vec but one level of indirection is reduced.
* Don't bother with filling stack-allocated DecoderState arrays on reset, and just recreate the
  arrays dropping the existing ones.

# Conflicts:
#	src/decode/lzma.rs

Author: gendx

.github/workflows/format.yml

@@ -1,11 +1,11 @@
 on: [push, pull_request]
-name: Formatting on stable toolchain
+name: Formatting on nightly toolchain
 jobs:
   format:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: dtolnay/rust-toolchain@nightly
         with:
           components: rustfmt
 

rustfmt.toml

@@ -0,0 +1 @@
+imports_granularity = "Module"

src/decode/lzma.rs

@@ -1,9 +1,8 @@
 use crate::decode::lzbuffer::{LzBuffer, LzCircularBuffer};
-use crate::decode::rangecoder;
-use crate::decode::rangecoder::RangeDecoder;
-use crate::decompress::Options;
-use crate::decompress::UnpackedSize;
+use crate::decode::rangecoder::{BitTree, LenDecoder, RangeDecoder};
+use crate::decompress::{Options, UnpackedSize};
 use crate::error;
+use crate::util::vec2d::Vec2D;
 use byteorder::{LittleEndian, ReadBytesExt};
 use std::io;
 
@@ -167,9 +166,9 @@ pub(crate) struct DecoderState {
     partial_input_buf: std::io::Cursor<[u8; MAX_REQUIRED_INPUT]>,
     pub(crate) lzma_props: LzmaProperties,
     unpacked_size: Option<u64>,
-    literal_probs: Vec<Vec<u16>>,
-    pos_slot_decoder: Vec<rangecoder::BitTree>,
-    align_decoder: rangecoder::BitTree,
+    literal_probs: Vec2D<u16>,
+    pos_slot_decoder: [BitTree; 4],
+    align_decoder: BitTree,
     pos_decoders: [u16; 115],
     is_match: [u16; 192], // true = LZ, false = literal
     is_rep: [u16; 12],
@@ -179,8 +178,8 @@ pub(crate) struct DecoderState {
     is_rep_0long: [u16; 192],
     state: usize,
     rep: [usize; 4],
-    len_decoder: rangecoder::LenDecoder,
-    rep_len_decoder: rangecoder::LenDecoder,
+    len_decoder: LenDecoder,
+    rep_len_decoder: LenDecoder,
 }
 
 impl DecoderState {
@@ -190,9 +189,14 @@ impl DecoderState {
             partial_input_buf: std::io::Cursor::new([0; MAX_REQUIRED_INPUT]),
             lzma_props,
             unpacked_size,
-            literal_probs: vec![vec![0x400; 0x300]; 1 << (lzma_props.lc + lzma_props.lp)],
-            pos_slot_decoder: vec![rangecoder::BitTree::new(6); 4],
-            align_decoder: rangecoder::BitTree::new(4),
+            literal_probs: Vec2D::init(0x400, (1 << (lzma_props.lc + lzma_props.lp), 0x300)),
+            pos_slot_decoder: [
+                BitTree::new(6),
+                BitTree::new(6),
+                BitTree::new(6),
+                BitTree::new(6),
+            ],
+            align_decoder: BitTree::new(4),
             pos_decoders: [0x400; 115],
             is_match: [0x400; 192],
             is_rep: [0x400; 12],
@@ -202,33 +206,36 @@ impl DecoderState {
             is_rep_0long: [0x400; 192],
             state: 0,
             rep: [0; 4],
-            len_decoder: rangecoder::LenDecoder::new(),
-            rep_len_decoder: rangecoder::LenDecoder::new(),
+            len_decoder: LenDecoder::new(),
+            rep_len_decoder: LenDecoder::new(),
         }
     }
 
     pub fn reset_state(&mut self, new_props: LzmaProperties) {
         new_props.validate();
         if self.lzma_props.lc + self.lzma_props.lp == new_props.lc + new_props.lp {
             // We can reset here by filling the existing buffer with 0x400.
-            self.literal_probs.iter_mut().for_each(|v| v.fill(0x400))
+            self.literal_probs.fill(0x400);
         } else {
             // We need to reallocate because of the new size of `lc+lp`.
-            self.literal_probs = vec![vec![0x400; 0x300]; 1 << (new_props.lc + new_props.lp)];
+            self.literal_probs = Vec2D::init(0x400, (1 << (new_props.lc + new_props.lp), 0x300));
         }
 
         self.lzma_props = new_props;
         self.pos_slot_decoder.iter_mut().for_each(|t| t.reset());
         self.align_decoder.reset();
-        self.pos_decoders.fill(0x400);
-        self.is_match.fill(0x400);
-        self.is_rep.fill(0x400);
-        self.is_rep_g0.fill(0x400);
-        self.is_rep_g1.fill(0x400);
-        self.is_rep_g2.fill(0x400);
-        self.is_rep_0long.fill(0x400);
+        // For stack-allocated arrays, it was found to be faster to re-create new arrays
+        // dropping the existing one, rather than using `fill` to reset the contents to zero.
+        // Heap-based arrays use fill to keep their allocation rather than reallocate.
+        self.pos_decoders = [0x400; 115];
+        self.is_match = [0x400; 192];
+        self.is_rep = [0x400; 12];
+        self.is_rep_g0 = [0x400; 12];
+        self.is_rep_g1 = [0x400; 12];
+        self.is_rep_g2 = [0x400; 12];
+        self.is_rep_0long = [0x400; 192];
         self.state = 0;
-        self.rep.fill(0);
+        self.rep = [0; 4];
         self.len_decoder.reset();
         self.rep_len_decoder.reset();
     }
@@ -240,7 +247,7 @@ impl DecoderState {
     pub fn process<'a, W: io::Write, LZB: LzBuffer<W>, R: io::BufRead>(
         &mut self,
         output: &mut LZB,
-        rangecoder: &mut rangecoder::RangeDecoder<'a, R>,
+        rangecoder: &mut RangeDecoder<'a, R>,
     ) -> error::Result<()> {
         self.process_mode(output, rangecoder, ProcessingMode::Finish)
     }
@@ -249,7 +256,7 @@ impl DecoderState {
     pub fn process_stream<'a, W: io::Write, LZB: LzBuffer<W>, R: io::BufRead>(
         &mut self,
         output: &mut LZB,
-        rangecoder: &mut rangecoder::RangeDecoder<'a, R>,
+        rangecoder: &mut RangeDecoder<'a, R>,
     ) -> error::Result<()> {
         self.process_mode(output, rangecoder, ProcessingMode::Partial)
     }
@@ -263,7 +270,7 @@ impl DecoderState {
     fn process_next_inner<'a, W: io::Write, LZB: LzBuffer<W>, R: io::BufRead>(
         &mut self,
         output: &mut LZB,
-        rangecoder: &mut rangecoder::RangeDecoder<'a, R>,
+        rangecoder: &mut RangeDecoder<'a, R>,
         update: bool,
     ) -> error::Result<ProcessingStatus> {
         let pos_state = output.len() & ((1 << self.lzma_props.pb) - 1);
@@ -380,7 +387,7 @@ impl DecoderState {
     fn process_next<'a, W: io::Write, LZB: LzBuffer<W>, R: io::BufRead>(
         &mut self,
         output: &mut LZB,
-        rangecoder: &mut rangecoder::RangeDecoder<'a, R>,
+        rangecoder: &mut RangeDecoder<'a, R>,
     ) -> error::Result<ProcessingStatus> {
         self.process_next_inner(output, rangecoder, true)
     }
@@ -398,15 +405,15 @@ impl DecoderState {
         code: u32,
     ) -> error::Result<()> {
         let mut temp = std::io::Cursor::new(buf);
-        let mut rangecoder = rangecoder::RangeDecoder::from_parts(&mut temp, range, code);
+        let mut rangecoder = RangeDecoder::from_parts(&mut temp, range, code);
         let _ = self.process_next_inner(output, &mut rangecoder, false)?;
         Ok(())
     }
 
     /// Utility function to read data into the partial input buffer.
     fn read_partial_input_buf<'a, R: io::BufRead>(
         &mut self,
-        rangecoder: &mut rangecoder::RangeDecoder<'a, R>,
+        rangecoder: &mut RangeDecoder<'a, R>,
     ) -> error::Result<()> {
         // Fill as much of the tmp buffer as possible
         let start = self.partial_input_buf.position() as usize;
@@ -420,7 +427,7 @@ impl DecoderState {
     fn process_mode<'a, W: io::Write, LZB: LzBuffer<W>, R: io::BufRead>(
         &mut self,
         output: &mut LZB,
-        rangecoder: &mut rangecoder::RangeDecoder<'a, R>,
+        rangecoder: &mut RangeDecoder<'a, R>,
         mode: ProcessingMode,
     ) -> error::Result<()> {
         loop {
@@ -461,11 +468,8 @@ impl DecoderState {
                 // Run the decompressor on the tmp buffer
                 let mut tmp_reader =
                     io::Cursor::new(&tmp[..self.partial_input_buf.position() as usize]);
-                let mut tmp_rangecoder = rangecoder::RangeDecoder::from_parts(
-                    &mut tmp_reader,
-                    rangecoder.range,
-                    rangecoder.code,
-                );
+                let mut tmp_rangecoder =
+                    RangeDecoder::from_parts(&mut tmp_reader, rangecoder.range, rangecoder.code);
                 let res = self.process_next(output, &mut tmp_rangecoder)?;
 
                 // Update the actual rangecoder
@@ -514,7 +518,7 @@ impl DecoderState {
     fn decode_literal<'a, W: io::Write, LZB: LzBuffer<W>, R: io::BufRead>(
         &mut self,
         output: &mut LZB,
-        rangecoder: &mut rangecoder::RangeDecoder<'a, R>,
+        rangecoder: &mut RangeDecoder<'a, R>,
         update: bool,
     ) -> error::Result<u8> {
         let def_prev_byte = 0u8;
@@ -550,7 +554,7 @@ impl DecoderState {
 
     fn decode_distance<'a, R: io::BufRead>(
         &mut self,
-        rangecoder: &mut rangecoder::RangeDecoder<'a, R>,
+        rangecoder: &mut RangeDecoder<'a, R>,
         length: usize,
         update: bool,
     ) -> error::Result<usize> {

src/decode/lzma2.rs

@@ -1,8 +1,6 @@
-use crate::decode::lzbuffer;
 use crate::decode::lzbuffer::LzBuffer;
-use crate::decode::lzma::DecoderState;
-use crate::decode::lzma::LzmaProperties;
-use crate::decode::rangecoder;
+use crate::decode::lzma::{DecoderState, LzmaProperties};
+use crate::decode::{lzbuffer, rangecoder};
 use crate::error;
 use byteorder::{BigEndian, ReadBytesExt};
 use std::io;

src/decode/rangecoder.rs

@@ -190,8 +190,8 @@ impl BitTree {
 pub struct LenDecoder {
     choice: u16,
     choice2: u16,
-    low_coder: Vec<BitTree>,
-    mid_coder: Vec<BitTree>,
+    low_coder: [BitTree; 16],
+    mid_coder: [BitTree; 16],
     high_coder: BitTree,
 }
 
@@ -200,8 +200,42 @@ impl LenDecoder {
         LenDecoder {
             choice: 0x400,
             choice2: 0x400,
-            low_coder: vec![BitTree::new(3); 16],
-            mid_coder: vec![BitTree::new(3); 16],
+            low_coder: [
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+            ],
+            mid_coder: [
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+                BitTree::new(3),
+            ],
             high_coder: BitTree::new(8),
         }
     }

src/decode/util.rs

@@ -1,5 +1,4 @@
-use std::hash;
-use std::io;
+use std::{hash, io};
 
 pub fn read_tag<R: io::BufRead>(input: &mut R, tag: &[u8]) -> io::Result<bool> {
     let mut buf = vec![0; tag.len()];

src/encode/util.rs

@@ -1,5 +1,4 @@
-use std::hash;
-use std::io;
+use std::{hash, io};
 
 // A Write computing a digest on the bytes written.
 pub struct HasherWrite<'a, W, H>

src/encode/xz.rs

@@ -1,6 +1,5 @@
 use crate::decode;
-use crate::encode::lzma2;
-use crate::encode::util;
+use crate::encode::{lzma2, util};
 use crate::xz::{footer, header, CheckMethod, StreamFlags};
 use byteorder::{LittleEndian, WriteBytesExt};
 use crc::{crc32, Hasher32};

src/error.rs

@@ -1,8 +1,7 @@
 //! Error handling.
 
 use std::fmt::Display;
-use std::io;
-use std::result;
+use std::{io, result};
 
 /// Library errors.
 #[derive(Debug)]

src/lib.rs

@@ -12,6 +12,7 @@ mod encode;
 
 pub mod error;
 
+mod util;
 mod xz;
 
 use std::io;

src/util/mod.rs

@@ -0,0 +1 @@
+pub mod vec2d;