update regression results

first block is no longer splitted since adding the @savings over-split protection

apply limit conditions for all splitting strategies

instead of just for blind split.

This is in anticipation of adversarial input,
that would intentionally target the sampling pattern of the split detector.

Note that, even without this protection, splitting can never expand beyond ZSTD_COMPRESSBOUND(),
because this upper limit uses a 1KB block size worst case scenario,
and splitting never creates blocks thath small.

The protection is more to ensure that data is not expanded by more than 3-bytes per 128 KB full block,
which is a much stricter limit.

update regression results

stricter limits to ensure expansion factor with blind-split strategy

issue reported by @terrelln

split all full 128 KB blocks

this helps make the streaming behavior more consistent,
since it does no longer depend on having more data presented on the input.

suggested by @terrelln

rewrite fingerprint storage to no longer need 64-bit members

so that it can be stored using standard alignment requirement (sizeof(void*)).

Distance function still requires 64-bit signed multiplication though,
so it won't change the issue regarding the bug in ubsan for clang 32-bit on github ci.

fixed minor strict pedantic C90 issue

fixed extraneous return

strict C90 compliance test

updated compression results

due to integration of `sample5` strategy, leading to better compression ratios on a range of levels

fixes static state allocation check

detected by @felixhandte

rewrote ZSTD_cwksp_initialAllocStart() to be easier to read

following a discussion with @felixhandte

rewrite penalty update

suggested by @terrelln

changed loop exit condition so that there is no need to assert() within the loop.

renamed: FingerPrint => Fingerprint

suggested by @terrelln

conservatively estimate over-splitting in presence of incompressible loss

ensure data can never be expanded by more than 3 bytes per full block.

ensure `lastBlock` is correctly determined

reported by @terrelln

made ZSTD_isPower2() an inline function

added a faster block splitter variant

that samples 1 in 5 positions.

This variant is fast enough for lazy2 and btlazy2,
but it's less good in combination with post-splitter at higher levels (>= btopt).

minor split optimization

let's fill the initial stats directly into target fingerprint

updated regression test results

fixed workspace alignment on non 64-bit systems

splitter workspace is now provided by ZSTD_CCtx*

fix alignment test

for non 64-bit systems

fixed minor conversion warnings on Visual

ZSTD_splitBlock_4k() uses externally provided workspace

ideally, this workspace would be provided from the ZSTD_CCtx* state

replaced uasan32 test by asan32 test

fixing minor formatting issue in 32-bit mode with logs enabled

fixed VS2010 solution

new Makefile target mesonbuild

for easier local testing

fixed meson build

fixed zstreamtest

fixed c90 comment style

fix assert

only split full blocks

short term simplification

fixed single-library build

fixed kernel build

fixed RLE detection test

fix overlap write scenario in presence of incompressible data

more ZSTD_memset() to apply

minor C++-ism

though I really wonder if this is a property worth maintaining.

use ZSTD_memset()

for better portability on Linux kernel

do not use `new` as variable name

fixed strict C90 semantic

XP: add a pre-splitter

instead of ingesting only full blocks, make an analysis of data, and infer where to split.

Merge pull request #4174 from facebook/bench_loadOnce

Modify benchmark to load sources only once

improve man page on benchmark mode

update the man page in troff format,
and the README with latest `--help` content and complementary details about benchmark mode.

also: display level 0 when doing decompression benchmark

Modify benchmark to only load sources once

After a regrettable update,
the benchmark module ended up reloading sources for every compression level.

While the delay itself is likely torelable,
the main issue is that the `--quiet` mode now also displays a loading summary between each compression line.
This wasn't the original intention, which is to produce a compact view of all compressions.

This is fixed in this version,
where sources are loaded only once, for all compression levels,
and loading summary is only displayed once.

Merge pull request #4171 from facebook/lvl3_ratio+

Improve compression ratio of levels 3 & 4

updated regression tests results

enable regression tests at pull request time

was transferred from circleci,
but was only triggered on push into dev,
i.e. after pull request is merged.

rewrite code in the manner suggested by @terrelln

fix test

a margin of 4 is insufficient to guarantee compression success.

slightly improved compression ratio at levels 3 & 4

The compression ratio benefits are small but consistent, i.e. always positive.
On `silesia.tar` corpus, this modification saves ~75 KB at level 3.
The measured speed cost is negligible, i.e. below noise level, between 0 and -1%.

Merge pull request #4170 from facebook/dict_cSpeed

Improve dictionary compression speed

fix test

minor improvement to level 3 dictionary compression ratio

small dictionary compression speed improvement

not as good as small-blocks improvement,
but generally positive.

Merge pull request #4167 from facebook/ci_m32test_faster

attempt to make 32-bit tests faster

attempt parallel test running with -j

measure if -O2 makes the test complete faster

attempt to make 32-bit tests faster

this is the longest CI test, reaching ~40mn on last PR

Merge pull request #4165 from facebook/cspeed_cmov

Improve compression speed on small blocks

rename variable name

findMatch -> matchFound
since it's a test, as opposed to an active search operation.
suggested by @terrelln

fixed parameter ordering in `dfast`

noticed by @terrelln

Merge pull request #4164 from facebook/spec_043

spec update: huffman prefix code paragraph

minor: better variable naming

added ascending order example

make __asm__ a __GNUC__ specific

store dummy bytes within ZSTD_match4Found_cmov()

feels more logical, better contained

introduce memory barrier to force test order

suggested by @terrelln

made search strategy switchable

between cmov and branch
and use a simple heuristic based on wlog to select between them.

note: performance is not good on clang (yet)

refactor search into an inline function

for easier swapping with a parameter

refactor huffman prefix code paragraph

minor refactor zstd_fast

make hot variables more local

Merge pull request #4160 from facebook/fix_nightly

fix dependency for nightly github actions tests

fix dependency for nightly github actions tests

Merge pull request #4159 from facebook/spec_refactor_fse

specification update

refactor documentation of the FSE decoding table build process

Merge pull request #4153 from artem/fix-meson-includes

meson: Do not export private headers in libzstd_dep to avoid name clash

Merge pull request #4156 from facebook/rm_circleci

removing nightly tests built on circleci

Merge pull request #4157 from facebook/fix_result_c

fix incorrect pointer manipulation

Merge pull request #4158 from facebook/benchzstd_fclose

fix missing fclose()

fix missing fclose()

fix #4151

fix incorrect pointer manipulation

fix #4155

removing nightly tests built on circleci

Merge pull request #4154 from dearblue/freebsd-14.1

Update FreeBSD VM image to 14.1

meson: Fix contrib and tests build

meson: Do not export private headers in libzstd_dep to avoid name clash

This way libzstd_dep does not override, for instance, <xxhash.h>

Update FreeBSD VM image to 14.1

FreeBSD 14.0 will reach the end of life on 2024-09-30.
The updated 14.1 is scheduled to end-of-life on 2025-03-31.

ref. https://www.freebsd.org/releases/14.2R/schedule/

Merge pull request #4146 from facebook/dictBench_Doc

update documentation: specify that Dictionary can be used for benchmark

Merge pull request #4013 from elasota/spec-clarify-offset-code-overflow

Specify that decoders may reject non-zero probabilities for larger offset codes than implementation supports

update documentation to specify that Dictionary can be used for benchmark

fix #4139

Included suggestion from @neheb

Fixed warning when compiling pzstd with CPPFLAGS=-Wunused-result and CXXFLAGS=-std=c++17

Merge pull request #4119 from xionghul/dev

Fix zstd-pgo run error

Merge pull request #4143 from facebook/fix_dictsizemin_dic

fix doc nit: ZDICT_DICTSIZE_MIN

Optimize compression by avoiding unpredictable branches

Avoid unpredictable branch. Use conditional move to generate the address
that is guaranteed to be safe and compare unconditionally.
Instead of

if (idx < limit && x[idx] == val ) // mispredicted idx < limit branch

Do

addr = cmov(safe,x+idx)
if (*addr == val && idx < limit) // almost always false so well predicted

Using microbenchmarks from https://github.com/google/fleetbench,
I get about ~10% speed-up:

name                                                                                          old cpu/op   new cpu/op    delta
BM_ZSTD_COMPRESS_Fleet/compression_level:-7/window_log:15                                     1.46ns ± 3%   1.31ns ± 7%   -9.88%  (p=0.000 n=35+38)
BM_ZSTD_COMPRESS_Fleet/compression_level:-7/window_log:16                                     1.41ns ± 3%   1.28ns ± 3%   -9.56%  (p=0.000 n=36+39)
BM_ZSTD_COMPRESS_Fleet/compression_level:-5/window_log:15                                     1.61ns ± 1%   1.43ns ± 3%  -10.70%  (p=0.000 n=30+39)
BM_ZSTD_COMPRESS_Fleet/compression_level:-5/window_log:16                                     1.54ns ± 2%   1.39ns ± 3%   -9.21%  (p=0.000 n=37+39)
BM_ZSTD_COMPRESS_Fleet/compression_level:-3/window_log:15                                     1.82ns ± 2%   1.61ns ± 3%  -11.31%  (p=0.000 n=37+40)
BM_ZSTD_COMPRESS_Fleet/compression_level:-3/window_log:16                                     1.73ns ± 3%   1.56ns ± 3%   -9.50%  (p=0.000 n=38+39)
BM_ZSTD_COMPRESS_Fleet/compression_level:-1/window_log:15                                     2.12ns ± 2%   1.79ns ± 3%  -15.55%  (p=0.000 n=34+39)
BM_ZSTD_COMPRESS_Fleet/compression_level:-1/window_log:16                                     1.99ns ± 3%   1.72ns ± 3%  -13.70%  (p=0.000 n=38+38)
BM_ZSTD_COMPRESS_Fleet/compression_level:0/window_log:15                                      3.22ns ± 3%   2.94ns ± 3%   -8.67%  (p=0.000 n=38+40)
BM_ZSTD_COMPRESS_Fleet/compression_level:0/window_log:16                                      3.19ns ± 4%   2.86ns ± 4%  -10.55%  (p=0.000 n=40+38)
BM_ZSTD_COMPRESS_Fleet/compression_level:1/window_log:15                                      2.60ns ± 3%   2.22ns ± 3%  -14.53%  (p=0.000 n=40+39)
BM_ZSTD_COMPRESS_Fleet/compression_level:1/window_log:16                                      2.46ns ± 3%   2.13ns ± 2%  -13.67%  (p=0.000 n=39+36)
BM_ZSTD_COMPRESS_Fleet/compression_level:2/window_log:15                                      2.69ns ± 3%   2.46ns ± 3%   -8.63%  (p=0.000 n=37+39)
BM_ZSTD_COMPRESS_Fleet/compression_level:2/window_log:16                                      2.63ns ± 3%   2.36ns ± 3%  -10.47%  (p=0.000 n=40+40)
BM_ZSTD_COMPRESS_Fleet/compression_level:3/window_log:15                                      3.20ns ± 2%   2.95ns ± 3%   -7.94%  (p=0.000 n=35+40)
BM_ZSTD_COMPRESS_Fleet/compression_level:3/window_log:16                                      3.20ns ± 4%   2.87ns ± 4%  -10.33%  (p=0.000 n=40+40)

I've also measured the impact on internal workloads and saw similar
~10% improvement in performance, measured by cpu usage/byte of data.

fix doc nit: ZDICT_DICTSIZE_MIN

fix #4142

Merge pull request #4129 from facebook/mitigate_32bit

Limit range of operations on Indexes in 32-bit mode

Limit range of operations on Indexes in 32-bit mode

and use unsigned type.
This reduce risks that an operation produces a negative number when crossing the 2 GB limit.