Optimize out some read operations from the quick deflate algorithm

Author: brianpane

zlib-rs/src/deflate/algorithm/quick.rs

@@ -93,23 +93,27 @@ pub fn deflate_quick(stream: &mut DeflateStream, flush: DeflateFlush) -> BlockSt
             }
         }
 
+        let lc: u8;
         if state.lookahead >= WANT_MIN_MATCH {
-            let hash_head = StandardHashCalc::quick_insert_string(state, state.strstart);
+            macro_rules! first_four_bytes {
+                ($slice:expr, $offset:expr) => {
+                    u32::from_le_bytes($slice[$offset..$offset + 4].try_into().unwrap())
+                };
+            }
+
+            let str_val = {
+                let str_start = &state.window.filled()[state.strstart..];
+                first_four_bytes!(str_start, 0)
+            };
+            let hash_head = StandardHashCalc::quick_insert_value(state, state.strstart, str_val);
             let dist = state.strstart as isize - hash_head as isize;
 
             if dist <= state.max_dist() as isize && dist > 0 {
-                let str_start = &state.window.filled()[state.strstart..];
                 let match_start = &state.window.filled()[hash_head as usize..];
 
-                macro_rules! first_two_bytes {
-                    ($slice:expr, $offset:expr) => {
-                        u16::from_le_bytes($slice[$offset..$offset + 2].try_into().unwrap())
-                    };
-                }
-
-                if first_two_bytes!(str_start, 0) == first_two_bytes!(match_start, 0) {
+                if str_val == first_four_bytes!(match_start, 0) {
                     let mut match_len = crate::deflate::compare256::compare256_slice(
-                        &str_start[2..],
+                        &state.window.filled()[state.strstart + 2..],
                         &match_start[2..],
                     ) + 2;
 
@@ -133,9 +137,10 @@ pub fn deflate_quick(stream: &mut DeflateStream, flush: DeflateFlush) -> BlockSt
                     }
                 }
             }
+            lc = str_val as u8;
+        } else {
+            lc = state.window.filled()[state.strstart];
         }
-
-        let lc = state.window.filled()[state.strstart];
         state.bit_writer.emit_lit(StaticTreeDesc::L.static_tree, lc);
         state.strstart += 1;
         state.lookahead -= 1;

zlib-rs/src/deflate/hash_calc.rs

@@ -38,6 +38,10 @@ impl StandardHashCalc {
         let slice = &state.window.filled()[string + Self::HASH_CALC_OFFSET..];
         let val = u32::from_le_bytes(slice[..4].try_into().unwrap());
 
+        Self::quick_insert_value(state, string, val)
+    }
+
+    pub fn quick_insert_value(state: &mut State, string: usize, val: u32) -> u16 {
         let hm = Self::update_hash(0, val) as usize;
 
         let head = state.head.as_slice()[hm];