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 <[email protected]>

Author: google-labs-jules[bot]

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;