From dd95dd321df944f28efe467f0f5b8ae726ba580a Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Thu, 19 Feb 2026 01:49:58 +0000
Subject: [PATCH] Optimize literal writing by unrolling loops

Unrolled literal writing loops in `compress_greedy_block` and `write_dynamic_block_with_sequences` to process 4 literals per iteration instead of 2. This reduces loop overhead and improves performance for incompressible data.

- Modified `src/compress/mod.rs` to add `while lit_remain >= 4` loops.
- Uses `write_literals_2` twice within the unrolled loop.
- Relies on existing buffer space checks (which cover the worst case expansion).

Performance:
- Throughput for "Compress Parallel Incompressible" improved by ~0.6% (234.2 MiB/s -> 235.7 MiB/s).
- Verified correctness with `cargo test`.

Co-authored-by: 404Setup <153366651+404Setup@users.noreply.github.com>
---
 src/compress/mod.rs | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/compress/mod.rs b/src/compress/mod.rs
index 7f36cf6..9c7dfee 100644
--- a/src/compress/mod.rs
+++ b/src/compress/mod.rs
@@ -1145,6 +1145,18 @@ impl Compressor {
                 // We add 16 bytes margin for the last flush (8 bytes) and safety.
                 if bs.out_idx + 16 + (seq.litrunlen as usize * 2) < bs.output.len() {
                     let mut lit_remain = seq.litrunlen as usize;
+                    while lit_remain >= 4 {
+                        // SAFETY: We verified sufficient buffer space above.
+                        // `write_literals_2` writes at most 30 bits and may flush 4 bytes.
+                        // We do this twice, so max 60 bits + flush overhead.
+                        // The loop precondition checks for space.
+                        unsafe {
+                            self.write_literals_2(bs, input[in_pos], input[in_pos + 1]);
+                            self.write_literals_2(bs, input[in_pos + 2], input[in_pos + 3]);
+                        }
+                        in_pos += 4;
+                        lit_remain -= 4;
+                    }
                     while lit_remain >= 2 {
                         // SAFETY: We verified sufficient buffer space above.
                         // `write_literals_2` writes at most 30 bits and may flush 4 bytes.
@@ -1355,6 +1367,14 @@ impl Compressor {
             if seq.litrunlen > 0 {
                 if bs.out_idx + 16 + (seq.litrunlen as usize * 2) < bs.output.len() {
                     let mut lit_remain = seq.litrunlen as usize;
+                    while lit_remain >= 4 {
+                        unsafe {
+                            self.write_literals_2(bs, input[in_pos], input[in_pos + 1]);
+                            self.write_literals_2(bs, input[in_pos + 2], input[in_pos + 3]);
+                        }
+                        in_pos += 4;
+                        lit_remain -= 4;
+                    }
                     while lit_remain >= 2 {
                         unsafe { self.write_literals_2(bs, input[in_pos], input[in_pos + 1]) };
                         in_pos += 2;