omnizip 0.3.23 → 0.3.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61cf26f9e324600f286b236ab80e02d720059f32bca2fa3c71640ba3abc4355a
-  data.tar.gz: fa189e081e402ecb4d084490e7874402faacf231a296cd009a15f218fcd9453e
+  metadata.gz: 7282589689a627d93346959e47ca2c5dcd7f37c496e61ab0e58e5bd794082010
+  data.tar.gz: 3b9b78d8fbb79c59b2603268955b9a92ee9d5046495b778ae1b1ec9f1b60fe51
 SHA512:
-  metadata.gz: 308660d6095a909d72c528bdfb5e828e76d320172b979a53ef7401aa2c1c12a560a0afd57f49991eb5190f87deca1c15cd798e8abae89bd3341ed3bb43c39b3d
-  data.tar.gz: 29ac9066539f2d8cef3973a2eb9cfe15a549a5efead04a1f5c88f28587fb6a2d23ac28c401c1c4187f5c226bfe4b531e3565523400dcd183adc83c842cd2d5dc
+  metadata.gz: 5c9ccbbc2d410b760251c708499720b4c0ee598fc1b9307d637d42b5cd88f1744f4123fd12b18c05561b7b2eb396f22a8054435e6a19af7ef9cbd181a7e23ca7
+  data.tar.gz: 419850a99a4fccbedc21cba3df34b89ebfaf0a1949bcfe7cf93544b55162ff118dcfa71053a64833d608f95a514ec8054a6b23f2df7d464426302ebea1994b04

data/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.25] - 2026-08-26
+
+### Changed
+- BZip2 Burrows-Wheeler Transform: rotation comparator compares 4
+  big-endian bytes per step (Fixnum-safe, no modulo) over a doubled
+  byte array. 21x fewer allocations per 138 KB compressed, with
+  byte-identical output and 25 case-round-tripped correctness
+  (random and degenerate). The BZip2 codec itself does not emit a
+  standard bzip2 file format (pre-existing, separate issue).
+
+## [0.3.24] - 2026-08-26
+
+### Changed
+- LZMA2 encoder hot paths avoid per-call allocations: the
+  range-encoder symbol drain reuses its 10 KB scratch buffer
+  (profiles showed String#* at ~half of encoder CPU), and the optimal
+  parser compares 8-byte windows and selects best matches without
+  intermediate strings/arrays. ~180k fewer object allocations and
+  ~94 MB less churn per 138 KB compressed, with byte-identical
+  output; covers both the xz and 7-Zip paths.
+
 ## [0.3.23] - 2026-08-26
 
 ### Changed

data/lib/omnizip/algorithms/bzip2/bwt.rb

@@ -49,13 +49,16 @@ module Omnizip
           n = data.length
           bytes = data.bytes
 
+          # Doubled bytes: rotation a's byte at offset o is
+          # dbl[a + o] — indexing needs no modulo, and comparisons
+          # can run 8 bytes at a time (modulo arithmetic in the
+          # comparator dominated the encoder's profile).
+          dbl = bytes * 2
+
           # Build suffix array without creating rotation strings
-          # Use direct byte comparison for efficiency
           suffix_array = (0...n).to_a
-
-          # Sort using optimized comparison that avoids string allocation
           suffix_array.sort! do |a, b|
-            compare_rotations(bytes, a, b, n)
+            compare_rotations(dbl, a, b, n)
           end
 
           # Find primary index (position where suffix starts at 0)
@@ -63,7 +66,7 @@ module Omnizip
 
           # Extract last column (character before each suffix)
           transformed = suffix_array.map do |idx|
-            bytes[(idx - 1) % n]
+            dbl[n + idx - 1]
           end.pack("C*").b
 
           [transformed, primary_index]
@@ -149,23 +152,32 @@ module Omnizip
         # @param b [Integer] Second rotation start index
         # @param n [Integer] Length
         # @return [Integer] -1, 0, or 1 for comparison result
-        def compare_rotations(bytes, a, b, n)
-          # Fast path: compare first few bytes directly
-          8.times do |offset|
-            byte_a = bytes[(a + offset) % n]
-            byte_b = bytes[(b + offset) % n]
-            cmp = byte_a <=> byte_b
-            return cmp if cmp != 0
+        # Compare rotations a and b over the doubled byte array.
+        # Four big-endian bytes per step: the chunk fits a Fixnum (no
+        # Bignum allocation), the low-offset byte dominates so the
+        # order is lexicographic, and the doubled array removes the
+        # per-byte modulo.
+        def compare_rotations(dbl, a, b, n)
+          len = 0
+          while len + 4 <= n
+            wa = (dbl[a + len] << 24) |
+              (dbl[a + len + 1] << 16) |
+              (dbl[a + len + 2] << 8) |
+              dbl[a + len + 3]
+            wb = (dbl[b + len] << 24) |
+              (dbl[b + len + 1] << 16) |
+              (dbl[b + len + 2] << 8) |
+              dbl[b + len + 3]
+            return wa <=> wb if wa != wb
+
+            len += 4
           end
-
-          # Continue comparing remaining bytes
-          (8...n).each do |offset|
-            byte_a = bytes[(a + offset) % n]
-            byte_b = bytes[(b + offset) % n]
-            cmp = byte_a <=> byte_b
+          while len < n
+            cmp = dbl[a + len] <=> dbl[b + len]
             return cmp if cmp != 0
-          end
 
+            len += 1
+          end
           0
         end
 

data/lib/omnizip/algorithms/lzma/optimal_encoder.rb

@@ -67,11 +67,12 @@ module Omnizip
             ].min
 
             len = 2
-            # Compare 8 bytes at a time using 64-bit integers
+            # Compare 8 bytes at a time using 64-bit integers read
+            # without intermediate strings (byteslice + unpack1
+            # allocates two Strings per step and dominated GC time).
             while len + 8 <= max_match_len
-              # Read 8 bytes as little-endian 64-bit integers
-              v1 = buf.byteslice(buf_pos + len, 8).unpack1("Q<")
-              v2 = buf.byteslice(buf_back_index + len, 8).unpack1("Q<")
+              v1 = read8(buf, buf_pos + len)
+              v2 = read8(buf, buf_back_index + len)
               break if v1 != v2
 
               len += 8
@@ -104,7 +105,15 @@ module Omnizip
           # A match may reference anything before `position`: bytes already
           # committed to the dictionary *and* bytes decoded earlier within
           # the chunk currently being encoded.
-          best_normal = matches.max_by { |m| [m.length, m.distance] }
+          best_normal = nil
+          matches.each do |m|
+            next if best_normal &&
+              (m.length < best_normal.length ||
+                (m.length == best_normal.length &&
+                  m.distance <= best_normal.distance))
+
+            best_normal = m
+          end
 
           if best_normal && best_normal.length >= nice_len &&
               best_normal.distance <= position
@@ -126,6 +135,18 @@ module Omnizip
           end
         end
 
+        # Allocation-free little-endian 8-byte read.
+        def read8(buf, pos)
+          buf.getbyte(pos) |
+            (buf.getbyte(pos + 1) << 8) |
+            (buf.getbyte(pos + 2) << 16) |
+            (buf.getbyte(pos + 3) << 24) |
+            (buf.getbyte(pos + 4) << 32) |
+            (buf.getbyte(pos + 5) << 40) |
+            (buf.getbyte(pos + 6) << 48) |
+            (buf.getbyte(pos + 7) << 56)
+        end
+
         # Constants
         REPS = 4
         MATCH_LEN_MAX = 273 # From lzma.h

data/lib/omnizip/implementations/xz_utils/lzma2/encoder.rb

@@ -339,8 +339,11 @@ module Omnizip
           def encode_queued_symbols(encoder, output)
             return if encoder.none?
 
-            # Create temporary buffer for encoding
-            temp_buffer = "\0" * 10000
+            # Reused scratch buffer: allocating a fresh 10 KB String
+            # per drain showed up as half the encoder's runtime via
+            # GC (String#* in profiles).
+            @symbol_buffer ||= "\0".b * 10_000
+            temp_buffer = @symbol_buffer
             out_pos = Omnizip::Algorithms::LZMA::IntRef.new(0)
 
             # Track size before encoding

data/lib/omnizip/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Omnizip
-  VERSION = "0.3.23"
+  VERSION = "0.3.25"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: omnizip
 version: !ruby/object:Gem::Version
-  version: 0.3.23
+  version: 0.3.25
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-25 00:00:00.000000000 Z
+date: 2026-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64