Mika Lindqvist [Wed, 17 Jun 2026 21:23:23 +0000 (00:23 +0300)]
[CI] Add coveralls as trusted formula for Homebrew under MacOS
* Homebrew 6.0.0 requires explicit trust when installing formulae from
third-party taps (repositories)
Cleanup deflate_quick variable reuse and call signatures
Drop the lc local: the four-byte window read is hoisted above the
match-search branch, and the literal-emit takes the low byte of
str_val directly so the short-lookahead arm no longer needs its own
load. Pass strstart into quick_start_block and quick_end_block so
they no longer reach into s for block_start. In the early-finish
arm, pass 1 to quick_start_block since last is known to be 1.
Hoist strstart and lookahead to locals in deflate strategies
Lift s->strstart and s->lookahead into function-local variables in
deflate_quick, deflate_huff, and deflate_rle, synced back to s before
external callouts that observe them (fill_window, longest_match,
FLUSH_BLOCK, returns) and reloaded after callouts that mutate them.
Use broadcast chunk store instead of memset for dist=1 on NEON/AVX2/AVX-512
Benchmarks show broadcasting the byte into a vector register and
falling through to the chunk store loop beats libc memset for the
short lengths common in inflate output (29-58% on AVX-512, 15-26%
on AVX2, 33% on NEON at len=8).
In 49a6bb5d, chunkmemset_1 was replaced with memset under the
assumption that libc memset would be at least as fast. According
to benchmarking, this isn't true in all cases.
When dist >= len the source bytes don't overlap the destination, so no pattern repeat is needed and CHUNKCOPY produces the same output. Extends the existing `dist >= sizeof(chunk_t)` shortcut so archs with chunk_t > 8 also catch dist in [chunk_t/2, chunk_t-1] with small lengths.
Skip CHUNKMEMSET loops when length fits in one chunk
When len <= sizeof(chunk_t) a single storechunk on chunk_load gives the same output as the two while-loops + tail. The over-write of chunk_t - len bytes lies in caller headroom.
Inline CHUNKMEMSET tail with bit-decomposed stores
Replace variable-length memcpy with bitmask-gated fixed-size copies (16 + 8 + 4 + 2 + 1) so the compiler can inline each as a direct store instead of a libc call.
Args span every dispatch arc in CHUNKMEMSET — dist=1 memset, dist>=chunk_t CHUNKCOPY, fast dist=2/4/8/16, GET_CHUNK_MAG, the unrolled loops, and the trailing remainder. Registered against chunkmemset_safe_{c,neon,sse2,ssse3,avx2,avx512,power8,rvv,lsx,lasx} where the symbol is built.
ptrdiff_t is defined in <stddef.h> since C89 and is guaranteed to
exist on any C99+ compiler. zlib-ng requires C99, so the build-time
check and the fallback typedef in zconf headers are unnecessary.
The AVX2 and AVX512 flags enable BMI2 but not BMI1, and TZCNT is a
BMI1 instruction. GCC emits the rep bsf encoding that executes as
TZCNT on BMI hardware regardless, but clang gates on the feature bit
and emits plain BSF, which is slower on AMD. Every CPU with AVX2 also
has BMI1, so the flag only affects code already behind AVX2 runtime
detection.
Add branch prediction hints to deflate strategy hot loops
The deflate strategies were inconsistent about branch-prediction hints
on their per-iteration lookahead checks. deflate_quick marked both the
window-refill path unlikely and the steady-state path likely;
deflate_slow marked only the steady-state path; deflate_fast and
deflate_medium marked neither, leaving the compiler to guess the inner
loop's hot/cold block placement.
Mark the window-refill and end-of-input paths unlikely and the
steady-state path likely across deflate_fast, deflate_slow,
deflate_medium, deflate_rle, and deflate_huff, following deflate_quick,
so the rarely-taken refill block stays off the hot fall-through path
and block placement is consistent across all strategies.
Remove dead unlink forward declaration in minigzip tests
Both files include zbuild.h which now unconditionally defines
_LARGEFILE64_SOURCE, making the !defined(_LARGEFILE64_SOURCE) clause
always false and the whole block unreachable. The upstream-zlib
purpose was forward-declaring unlink on platforms without unistd.h
that aren't Windows, but zlib-ng's supported platforms either have
unistd.h or define _WIN32.
zlib-ng never calls fseeko; gzlib.c was rewritten to use
lseek / lseek64 / _lseeki64 directly. The NO_FSEEKO define is not
referenced by any source file, so the CMake check_function_exists
and matching configure probe are dead code.
Drop dead glibc feature-macro juggling from gzguts.h
_LARGEFILE_SOURCE enables fseeko/ftello, which zlib-ng never calls
(gzlib.c uses lseek/lseek64/_lseeki64 directly). The _FILE_OFFSET_BITS
and _TIME_BITS undefs were defensive against a consumer-provided
-D_FILE_OFFSET_BITS=64 leaking into library internals, but they sat
after zbuild.h had already included <stdio.h> so they never affected
system-header sizing. The zlib.h gzopen->gzopen64 remap they were
guarding against is already blocked by the Z_INTERNAL gate for
library builds.
zbuild.h defines _LARGEFILE64_SOURCE, but the macro only takes effect
if seen before any system header. The tools and fuzz/test files that
included <stdio.h> ahead of zbuild.h processed <features.h> without it,
so _LFS64_LARGEFILE never got set and z_off64_t expanded to an unknown
off64_t once LFS64 detection moved out of the build system.
Reorder so zbuild.h precedes any system header, and drop the redundant
<stdio.h>/<stdlib.h>/<string.h> includes that zbuild.h already pulls in.
Move LFS64 detection from build system to C preprocessor
zbuild.h now defines _LARGEFILE64_SOURCE before any system header, so
glibc exposes off64_t and lseek64 where available. The _LFS64_LARGEFILE
check already in zconf.h handles per-platform gating. Drops the
redundant -D__USE_LARGEFILE64 (internal glibc macro, set automatically)
and the unused __off64_t probe that only wrote to HAVE___OFF64_T.
The configure script's _off64_t probe was log-only and the off64_t=yes
path assumed fseeko exists without testing; both are removed in favor
of the standalone fseeko check.
Use local block_start and window variables in FLUSH_BLOCK.
Also ensure all deflate methods use local window variable.
deflate_medium now passes local window to its static functions.
Split out writing deflate headers into a separate function, keeping the
deflate hot-path clean. This only benefits cases where you call deflate()
multiple times to provide more data.
Make CRC32 checking of headers use crc32_small directly, instead of taking
a detour through functable to spin up a vector optimized function when the
header is too small to be handled by it.
CRC2 and CRC4 call CRC_DO1_B macro directly since knowing the exact size
lets us inline a very small crc implementation.
The awk block parsing the size command output used bt/bd/bb/bD for
base values and dt/dd/db/dD for deltas, with case-only distinction
between bd (data) and bD (dec) that's easy to misread. Spell them out
as base_text/base_data/base_bss/base_dec and d_text/d_data/d_bss/d_dec
for legibility.
Show stripped library file size in delta workflow.
The size table reports text/data/bss/dec from the size command, which
sums section sizes but doesn't account for ELF segment alignment padding.
A delta can show up in the dec column without changing the on-disk byte
count of the shipped .so. Add a row reporting the actual file size of
the stripped library so the shipping deliverable is visible alongside
the segment accounting.
Remove the separate NEON_accum32 function and inline its body
directly into the adler32_copy_impl loop. This eliminates the
function call boundary and lets src/dst pointers advance
naturally through the NEON processing iterations.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Combine NEON_accum32_copy and NEON_accum32 into single function
Use a const int COPY parameter to select between the copy and
non-copy paths, matching the pattern used by adler32_copy_impl.
The copy variant uses 4x individual loads+stores (better ILP),
while the non-copy variant uses a single ld1x4 quad load.
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Fix scan_endstr offset in longest_match slow path.
LONGEST_MATCH_SLOW was using len - (STD_MIN_MATCH+1) instead of
len - (STD_MIN_MATCH-1) for the end-of-string hash probe, hashing a
window inside the already-matched region instead of ending one byte
past the current match. The slow path was missing match extensions
it should have been finding. The comment and the upstream fast_zlib
source both specify the correct offset.
Closes #2248.
Reported-by: Sergey "Shnatsel" Davidoff <291257+Shnatsel@users.noreply.github.com> Reported-by: Folkert de Vries <7949978+folkertdev@users.noreply.github.com>
Mika Lindqvist [Tue, 5 May 2026 22:33:15 +0000 (01:33 +0300)]
[CI] Cache Ubuntu .deb packages to speed up installing dependencies.
* Purge old packages and unneeded dependencies before copying remaining packages to cached directory
Add early return when prev_length already exceeds lookahead
Near end-of-input the caller's prev_length can exceed the
current lookahead, making the chain walk pointless since no
match can be longer than the available input. The non-slow
path never clamped this case — break_matching was slow-path
only — leaving the output contract unguarded.
Together with the existing `if (len >= lookahead)` early
return in the update block — which stops the chain walk as
soon as a match reaches lookahead — this ensures no
unnecessary chain steps are taken. madler/zlib does the full
chain walk when prev_length exceeds lookahead and clamps
best_len at the function exit resulting in extra work.
Remove dead break_matching label from longest_match
The lookahead guard at break_matching is unreachable because
the early return `if (len >= lookahead) return lookahead` fires
before best_len is ever assigned, keeping best_len < lookahead
as a loop invariant. Replace the three goto sites with direct
returns and delete the label entirely.
The author_association gate already restricts triggers to OWNER, MEMBER,
or COLLABORATOR, so a maintainer running /delta on a fork PR carries the
same trust as checking the PR out locally. Drop the fork rejection and
the unused base/head repo id parsing.
Benchmark libpng row-by-row decoding where avail_out falls
below the 260-byte inflate_fast threshold. Uses a synthetic
gradient-with-noise pixel generator that produces deflate
token distributions representative of real photographs.
Also fix encode_png to use the passed width and height
instead of the hardcoded IMWIDTH and IMHEIGHT constants.
Fix libpng linking and include paths for benchmark apps
The FetchContent path was missing the binary directory from
PNG_INCLUDE_DIR, causing pnglibconf.h not to be found. The
link target was hardcoded to libpng.a which does not resolve
when libpng is built via FetchContent. Use png_static as the
CMake target when fetched, and normalize both paths through
PNG_STATIC_LIBRARY and PNG_INCLUDE_DIR variables.
Call adler32_c directly in adler32_copy_c scalar fallback
The generic copy function was calling through the function
table, which dispatched to the best SIMD implementation
instead of the scalar path. This led to incorrect benchmarks
for adler32_copy/c since it measured the SIMD path rather
than the scalar fallback. Call adler32_c directly so the
scalar copy variant actually exercises the scalar checksum.
Add SWAR scalar adler32 for 64-bit platforms with unaligned access
Borrows the SWAR (SIMD Within A Register) technique from FFmpeg's
libavutil/adler32.c by Michael Niedermayer. The original splits each
8-byte load into even/odd byte lanes packed as 4x16-bit accumulators
in a uint64_t, with a running prefix sum for the s2 contribution, and
a final reduction using multiply-and-shift with positional weight
constants. The chunk size is capped at 23 iterations of 8 bytes (184
bytes) to keep the 16-bit accumulators from overflowing.
Our improvements over the original FFmpeg implementation:
- Process 16 bytes per iteration (two 64-bit loads) instead of 8,
halving loop overhead while staying within the 23-iteration limit.
- Handle an 8-byte remainder after the 16-byte loop so no bytes
fall through to the slow scalar path unnecessarily.
- Applied to both the NMAX inner loop (adler32_c) and the combined
copy+checksum tail path (adler32_copy_tail) for all callers.
Simplify safe-mode copy path selection in inflate_fast
The branch structure now tests safe_mode directly, which is clearer and
produces the same code on all platforms. No functional change to the copy
operations used.
Improve inflate_fast performance for small output buffers
Lowers the inflate_fast entry threshold from 260 to 3 bytes of
available output by adding a safe_mode parameter that uses
bounds-checked copies and bails to the MATCH state when output
space is insufficient. This eliminates the performance cliff
where libpng-style row-by-row decompression falls back to the
slow inflate path for the last 260 bytes of each row.
Replace small/large buffer tests with parameterized test_chunked
test_large_buffers reset d_stream.next_out on every inflate iteration, so the
decompressed output was never compared against the source. test_chunked keeps
the input, compressed, and decompressed buffers separate and checks them with
memcmp.
New avail_out values (3, 64, 128, 256, 259) exercise inflate_fast()'s safe-mode
MATCH-state bailout around the 258-byte maximum match length.
Bump Google Benchmark to v1.9.5
* Google Benchmark v1.9.4 fails to compile with recent versions of clang and Visual C++ if warnings are treated as errors
Adds benchmark_corpora.cc which dynamically discovers and benchmarks
all files from the zlib-ng/corpora repository (silesia, calgary,
canterbury, large, snappy, etc.).
Benchmarks are registered at startup using RegisterBenchmark. If the
corpora directory is not present, no benchmarks are registered.
Deflate is tested at levels 1, 6, and 9 per file. Inflate is tested
once per file using data pre-compressed at level 9.
Add --benchmark_cooldown flag to mitigate thermal throttling
Adds a --benchmark_cooldown=<seconds> flag that inserts a sleep between
benchmark families. This helps produce consistent results on systems
where sustained workloads cause thermal throttling and CPU frequency
scaling.
Uses a wrapping BenchmarkReporter that sleeps before forwarding results
to the default display reporter.
Add /delta workflow for per-PR binary size comparison
On a /delta PR comment the job builds the PR head and base with
RelWithDebInfo, splits the DWARF into sibling .debug companions, and
runs several tools against both stripped libraries:
- binutils size for text/data/bss totals plus a Δ row
- bloaty for sections, top 30 compile units, and top 30 symbols
- nm --defined-only --dynamic to diff the exported symbol set
- abidiff for C ABI changes (honouring test/abi/ignore)
- minigzip at levels 1-9 over silesia-small.tar and, on native
builds, the full silesia.tar
Results come back as a "## Delta Report" PR comment with a details
block per section, reporting both head and base SHAs so offset runs
are unambiguous.
Comment syntax is /delta [arch] [-N]. Arch defaults to x86_64 and
accepts aarch64, powerpc64le, riscv64, and s390x. -N selects the Nth
commit back from the PR head so a regression can be bisected without
force-pushing. Cross-compile builds reuse cmake/toolchain-*.cmake
and run the stripped binaries under qemu-user.
Gate Scalar and SSE chorba uniformly on CRC32_CHORBA_FALLBACK and
CRC32_CHORBA_SSE_FALLBACK across prototypes, dispatch, sources, tests
and benchmarks instead of spot-checking WITHOUT_CHORBA /
WITHOUT_CHORBA_SSE directly at each site.
Also move crc32_chorba_c.c into ZLIB_GENERIC_SRCS and align Makefile.in
to match so the CMake and autotools builds stay bit-identical.
The 'Ubuntu GCC No Chorba' matrix entry was passing -DWITH_CHORBA=OFF
since its introduction in 9d4af458, but the actual CMake option is
named WITH_CRC32_CHORBA.
The MSVC and GCC 32-bit polyfills for _mm_cvtsi64_si128 /
_mm_cvtsi128_si64 had identical bodies. Merge them into a single
block guarded by !__clang__ && ARCH_32BIT, with the MSVC-only
#include <intrin.h> nested inside.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Fix MSVC v142 miscompile of _mm_cvtsi64_si128 polyfill on 32-bit
MSVC v142 (Visual Studio 2019, and VS 2022 pre-17.11) miscompiles
_mm_set_epi64x(0, a) on 32-bit Windows by routing part of the synthesis
through a GPR, clobbering live register data and causing stack corruption
in the chorba SSE2/SSE4.1 CRC32 code paths.
Replace the _mm_set_epi64x(0, a) polyfill with _mm_loadl_epi64 which
compiles to a single MOVQ xmm,m64 that bypasses the buggy synthesis
path. Also convert the GCC 32-bit _mm_cvtsi64_si128 macro to a static
inline for consistency, and drop the redundant ARCH_X86 guard since
x86_intrins.h is only reachable from x86 code.
projects / thirdparty / zlib-ng.git / log
