feat(rust): port benchmark loop and CLI bench mode

Move the implementation of programs/benchfn.c into rust/src/benchfn.rs and
wire benchmark mode (-b/-e/-i) into the Rust CLI frontend, which previously
rejected those options as not yet implemented. `zstd -b1 -i0 FILE` and range
runs like `zstd -b5e6 -i0 FILE` work again, including the synthetic-sample
benchmark when no file is given.

benchfn.rs is a faithful port of the run/timing state machine:
BMK_benchFunction keeps the exact loop accounting (first-loop blockResults
and errorFn checks, dstSize summed on the first loop only, 0xE5 warm-up of
result buffers, nbLoops minimum of 1) and BMK_benchTimedFn keeps the same
convergence behavior (x10 workload growth for short runs, budget-based
nbLoops estimation, runs below half the run budget re-tried rather than
reported, best qualifying run returned). Arithmetic that C leaves to
unsigned wrap-around uses wrapping operations so debug builds cannot panic
where release C would wrap.

ABI notes: BMK_runTime_t and BMK_runOutcome_t are returned by value across
the C boundary and BMK_benchParams_t is passed by value, so all three are
repr(C) mirrors of benchfn.h; their field offsets are pinned by const
asserts in Rust and matching C static asserts in the benchfn.c shim, which
is now declaration-only. BMK_timedFnState_t stays opaque, fits the 64-byte
BMK_timedFnState_shell (compile-time checked), and is malloc/free-managed
so creation and destruction remain interchangeable with C callers.

The CLI parses -b (bench mode), -e (range end, digits attach directly,
defaulting to 0 like readU32FromChar) and -i (duration in seconds), then
dispatches through a new ZSTD_rust_cli_bench bridge in the zstdcli.c shim.
The bridge exists because benchmark availability is a C preprocessor
property (ZSTD_NOBENCH): orchestration and reporting stay in C benchzstd.c,
stripped variants (zstd-small, zstd-compress, zstd-decompress) compile the
stub branch and report "benchmark mode is not available in this build", and
the Rust side never references benchmark symbols directly. Level clamping
against ZSTD_maxCLevel() happens in the bridge, where the symbol is
guaranteed to exist whenever benchmarking is compiled in. -T selects the
worker count, defaulting to single-threaded like the C bench path; -S
(separate files) and --priority=rt remain unimplemented.

Makefile updates only extend the Rust source prerequisite lists with
benchfn.rs; the helpers-archive plumbing from the timefn commit already
links fullbench(-lib/-dll/32) and paramgrill, the benchfn consumers among
the C tests. Original C test sources are untouched.

Known pre-existing issues, unchanged by this commit: tests/fullbench-lib
fails to link at the base commit too (libzstd.a precedes fullbench.c in its
link line), and the cli-tests basic/help.sh, compression/levels.sh,
compression/golden.sh, and decompression/pass-through.sh scripts fail
identically with a base-commit binary because the Rust CLI frontend is
still a partial reimplementation.

Test Plan:
- cd rust && cargo fmt --check && cargo clippy --all-targets -- -D warnings
  && cargo test --all-targets && cargo build --release
- cd rust/cli && cargo fmt --check && cargo clippy --all-targets -- -D
  warnings && cargo test --all-targets; repeat tests with
  --no-default-features plus features compression / decompression / (none)
- make -C programs zstd; ./programs/zstd -b1 -i0 lib/common/xxhash.c;
  ./programs/zstd -b5e6 -i0 programs/fileio.c; ./programs/zstd -b1 -i0
  (synthetic); echo roundtrip via zstd | zstd -d
- make -C programs zstd-small zstd-compress zstd-decompress zstd-nolegacy
  zstd-dictBuilder; zstd-small -b reports benchmark unavailable; compress/
  decompress roundtrip across the split binaries
- make -C tests fullbench fuzzer zstreamtest paramgrill decodecorpus
  poolTests fullbench32 fuzzer32; ./tests/fullbench -i0 (exercises Rust
  BMK_benchTimedFn from C); ./tests/fullbench32 -i0; ./tests/fuzzer -i1
  --no-big-tests; ./tests/poolTests; make -C tests test-rust-lib-smoke
- cli-tests subset: basic/version.sh, compression/basic.sh,
  compression/multiple-files.sh pass; failing scripts match the base commit

Refs: rust/README.md

.gitignore

@@ -34,6 +34,7 @@ install/
 
 # Build artefacts
 /rust/target/
+/rust/cli/target/
 contrib/linux-kernel/linux/
 projects/
 bin/

lib/compress/zstd_compress.c

@@ -38,62 +38,6 @@ size_t ZSTD_rust_writeFrameHeader(void* dst, size_t dstCapacity,
                                   U32 windowLog, U64 pledgedSrcSize,
                                   U32 dictID);
 
-/* Context-free compression-parameter selection and sizing leaves live in
- * Rust (rust/src/zstd_compress_params.rs).  This file retains
- * configuration-sensitive policy: the excluded-block-compressor strategy
- * cascade, private ZSTD_CCtx_params handling, and sanitizer workspace
- * policy, which it feeds to the leaves as explicit scalar inputs.  The
- * ZSTD_CParamMode_e and ZSTD_ParamSwitch_e enums are passed as int; the
- * Rust side mirrors their values. */
-int ZSTD_rust_params_maxCLevel(void);
-int ZSTD_rust_params_minCLevel(void);
-int ZSTD_rust_params_defaultCLevel(void);
-ZSTD_bounds ZSTD_rust_params_getBounds(int param);
-size_t ZSTD_rust_params_checkCParams(ZSTD_compressionParameters cParams);
-ZSTD_compressionParameters
-ZSTD_rust_params_clampCParams(ZSTD_compressionParameters cParams);
-U32 ZSTD_rust_params_cycleLog(U32 hashLog, int strategy);
-ZSTD_compressionParameters
-ZSTD_rust_params_selectCParams(int compressionLevel, U64 srcSizeHint,
-                               size_t dictSize, int mode);
-ZSTD_compressionParameters
-ZSTD_rust_params_adjustCParams(ZSTD_compressionParameters cParams, U64 srcSize,
-                               size_t dictSize, int mode,
-                               int useRowMatchFinder);
-ZSTD_parameters ZSTD_rust_params_makeParams(ZSTD_compressionParameters cParams);
-size_t ZSTD_rust_params_maxNbSeq(size_t blockSize, U32 minMatch,
-                                 int useSequenceProducer);
-size_t ZSTD_rust_params_resolveMaxBlockSize(size_t maxBlockSize);
-
-typedef struct {
-    U32 hashLog3Max;
-    size_t matchTSize;
-    size_t optimalTSize;
-    size_t asanRedzoneSize;
-} ZSTD_rustMatchStateSizing;
-size_t ZSTD_rust_params_estimateMatchStateSize(
-        ZSTD_compressionParameters cParams, int useRowMatchFinder,
-        int enableDedicatedDictSearch, U32 forCCtx,
-        const ZSTD_rustMatchStateSizing* sizing);
-
-typedef struct {
-    size_t cdictSize;
-    size_t hufWorkspaceSize;
-    U32 hashLog3Max;
-    size_t matchTSize;
-    size_t optimalTSize;
-    size_t asanRedzoneSize;
-} ZSTD_rustCDictSizing;
-size_t ZSTD_rust_params_estimateCDictSizeFromCParams(
-        size_t dictSize, ZSTD_compressionParameters cParams,
-        int dictLoadMethod, const ZSTD_rustCDictSizing* sizing);
-
-#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
-#  define ZSTD_RUST_ASAN_REDZONE_SIZE ((size_t)ZSTD_CWKSP_ASAN_REDZONE_SIZE)
-#else
-#  define ZSTD_RUST_ASAN_REDZONE_SIZE ((size_t)0)
-#endif
-
 /* ***************************************************************
 *  Tuning parameters
 *****************************************************************/
@@ -332,7 +276,11 @@ static int ZSTD_resolveExternalSequenceValidation(int mode) {
 
 /* Resolves maxBlockSize to the default if no value is present. */
 static size_t ZSTD_resolveMaxBlockSize(size_t maxBlockSize) {
-    return ZSTD_rust_params_resolveMaxBlockSize(maxBlockSize);
+    if (maxBlockSize == 0) {
+        return ZSTD_BLOCKSIZE_MAX;
+    } else {
+        return maxBlockSize;
+    }
 }
 
 static ZSTD_ParamSwitch_e ZSTD_resolveExternalRepcodeSearch(ZSTD_ParamSwitch_e value, int cLevel) {
@@ -472,17 +420,45 @@ ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
 
     switch(param)
     {
-    /* The compression level and the seven core compression parameters are
-     * bounded by the Rust leaf. */
     case ZSTD_c_compressionLevel:
+        bounds.lowerBound = ZSTD_minCLevel();
+        bounds.upperBound = ZSTD_maxCLevel();
+        return bounds;
+
     case ZSTD_c_windowLog:
+        bounds.lowerBound = ZSTD_WINDOWLOG_MIN;
+        bounds.upperBound = ZSTD_WINDOWLOG_MAX;
+        return bounds;
+
     case ZSTD_c_hashLog:
+        bounds.lowerBound = ZSTD_HASHLOG_MIN;
+        bounds.upperBound = ZSTD_HASHLOG_MAX;
+        return bounds;
+
     case ZSTD_c_chainLog:
+        bounds.lowerBound = ZSTD_CHAINLOG_MIN;
+        bounds.upperBound = ZSTD_CHAINLOG_MAX;
+        return bounds;
+
     case ZSTD_c_searchLog:
+        bounds.lowerBound = ZSTD_SEARCHLOG_MIN;
+        bounds.upperBound = ZSTD_SEARCHLOG_MAX;
+        return bounds;
+
     case ZSTD_c_minMatch:
+        bounds.lowerBound = ZSTD_MINMATCH_MIN;
+        bounds.upperBound = ZSTD_MINMATCH_MAX;
+        return bounds;
+
     case ZSTD_c_targetLength:
+        bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;
+        bounds.upperBound = ZSTD_TARGETLENGTH_MAX;
+        return bounds;
+
     case ZSTD_c_strategy:
-        return ZSTD_rust_params_getBounds((int)param);
+        bounds.lowerBound = ZSTD_STRATEGY_MIN;
+        bounds.upperBound = ZSTD_STRATEGY_MAX;
+        return bounds;
 
     case ZSTD_c_contentSizeFlag:
         bounds.lowerBound = 0;
@@ -1409,7 +1385,14 @@ size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)
     @return : 0, or an error code if one value is beyond authorized range */
 size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
 {
-    return ZSTD_rust_params_checkCParams(cParams);
+    BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
+    BOUNDCHECK(ZSTD_c_chainLog,  (int)cParams.chainLog);
+    BOUNDCHECK(ZSTD_c_hashLog,   (int)cParams.hashLog);
+    BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
+    BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);
+    BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
+    BOUNDCHECK(ZSTD_c_strategy,  (int)cParams.strategy);
+    return 0;
 }
 
 /** ZSTD_clampCParams() :
@@ -1418,14 +1401,63 @@ size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
 static ZSTD_compressionParameters
 ZSTD_clampCParams(ZSTD_compressionParameters cParams)
 {
-    return ZSTD_rust_params_clampCParams(cParams);
+#   define CLAMP_TYPE(cParam, val, type)                                      \
+        do {                                                                  \
+            ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);         \
+            if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound;      \
+            else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
+        } while (0)
+#   define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)
+    CLAMP(ZSTD_c_windowLog, cParams.windowLog);
+    CLAMP(ZSTD_c_chainLog,  cParams.chainLog);
+    CLAMP(ZSTD_c_hashLog,   cParams.hashLog);
+    CLAMP(ZSTD_c_searchLog, cParams.searchLog);
+    CLAMP(ZSTD_c_minMatch,  cParams.minMatch);
+    CLAMP(ZSTD_c_targetLength,cParams.targetLength);
+    CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
+    return cParams;
 }
 
 /** ZSTD_cycleLog() :
  *  condition for correct operation : hashLog > 1 */
 U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
 {
-    return ZSTD_rust_params_cycleLog(hashLog, (int)strat);
+    U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);
+    return hashLog - btScale;
+}
+
+/** ZSTD_dictAndWindowLog() :
+ * Returns an adjusted window log that is large enough to fit the source and the dictionary.
+ * The zstd format says that the entire dictionary is valid if one byte of the dictionary
+ * is within the window. So the hashLog and chainLog should be large enough to reference both
+ * the dictionary and the window. So we must use this adjusted dictAndWindowLog when downsizing
+ * the hashLog and windowLog.
+ * NOTE: srcSize must not be ZSTD_CONTENTSIZE_UNKNOWN.
+ */
+static U32 ZSTD_dictAndWindowLog(U32 windowLog, U64 srcSize, U64 dictSize)
+{
+    const U64 maxWindowSize = 1ULL << ZSTD_WINDOWLOG_MAX;
+    /* No dictionary ==> No change */
+    if (dictSize == 0) {
+        return windowLog;
+    }
+    assert(windowLog <= ZSTD_WINDOWLOG_MAX);
+    assert(srcSize != ZSTD_CONTENTSIZE_UNKNOWN); /* Handled in ZSTD_adjustCParams_internal() */
+    {
+        U64 const windowSize = 1ULL << windowLog;
+        U64 const dictAndWindowSize = dictSize + windowSize;
+        /* If the window size is already large enough to fit both the source and the dictionary
+         * then just use the window size. Otherwise adjust so that it fits the dictionary and
+         * the window.
+         */
+        if (windowSize >= dictSize + srcSize) {
+            return windowLog; /* Window size large enough already */
+        } else if (dictAndWindowSize >= maxWindowSize) {
+            return ZSTD_WINDOWLOG_MAX; /* Larger than max window log */
+        } else  {
+            return ZSTD_highbit32((U32)dictAndWindowSize - 1) + 1;
+        }
+    }
 }
 
 /** ZSTD_adjustCParams_internal() :
@@ -1442,6 +1474,8 @@ ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
                             ZSTD_CParamMode_e mode,
                             ZSTD_ParamSwitch_e useRowMatchFinder)
 {
+    const U64 minSrcSize = 513; /* (1<<9) + 1 */
+    const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);
     assert(ZSTD_checkCParams(cPar)==0);
 
     /* Cascade the selected strategy down to the next-highest one built into
@@ -1486,13 +1520,90 @@ ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
     }
 #endif
 
-    /* The remaining adjustment logic is context-free and lives in Rust.  The
-     * short-cache and row-hash tag widths the leaf assumes are fixed
-     * private-header constants; keep them checked here. */
-    ZSTD_STATIC_ASSERT(ZSTD_SHORT_CACHE_TAG_BITS == 8);
-    ZSTD_STATIC_ASSERT(ZSTD_ROW_HASH_TAG_BITS == 8);
-    return ZSTD_rust_params_adjustCParams(cPar, (U64)srcSize, dictSize,
-                                          (int)mode, (int)useRowMatchFinder);
+    switch (mode) {
+    case ZSTD_cpm_unknown:
+    case ZSTD_cpm_noAttachDict:
+        /* If we don't know the source size, don't make any
+         * assumptions about it. We will already have selected
+         * smaller parameters if a dictionary is in use.
+         */
+        break;
+    case ZSTD_cpm_createCDict:
+        /* Assume a small source size when creating a dictionary
+         * with an unknown source size.
+         */
+        if (dictSize && srcSize == ZSTD_CONTENTSIZE_UNKNOWN)
+            srcSize = minSrcSize;
+        break;
+    case ZSTD_cpm_attachDict:
+        /* Dictionary has its own dedicated parameters which have
+         * already been selected. We are selecting parameters
+         * for only the source.
+         */
+        dictSize = 0;
+        break;
+    default:
+        assert(0);
+        break;
+    }
+
+    /* resize windowLog if input is small enough, to use less memory */
+    if ( (srcSize <= maxWindowResize)
+      && (dictSize <= maxWindowResize) )  {
+        U32 const tSize = (U32)(srcSize + dictSize);
+        static U32 const hashSizeMin = 1 << ZSTD_HASHLOG_MIN;
+        U32 const srcLog = (tSize < hashSizeMin) ? ZSTD_HASHLOG_MIN :
+                            ZSTD_highbit32(tSize-1) + 1;
+        if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;
+    }
+    if (srcSize != ZSTD_CONTENTSIZE_UNKNOWN) {
+        U32 const dictAndWindowLog = ZSTD_dictAndWindowLog(cPar.windowLog, (U64)srcSize, (U64)dictSize);
+        U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
+        if (cPar.hashLog > dictAndWindowLog+1) cPar.hashLog = dictAndWindowLog+1;
+        if (cycleLog > dictAndWindowLog)
+            cPar.chainLog -= (cycleLog - dictAndWindowLog);
+    }
+
+    if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
+        cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */
+
+    /* We can't use more than 32 bits of hash in total, so that means that we require:
+     * (hashLog + 8) <= 32 && (chainLog + 8) <= 32
+     */
+    if (mode == ZSTD_cpm_createCDict && ZSTD_CDictIndicesAreTagged(&cPar)) {
+        U32 const maxShortCacheHashLog = 32 - ZSTD_SHORT_CACHE_TAG_BITS;
+        if (cPar.hashLog > maxShortCacheHashLog) {
+            cPar.hashLog = maxShortCacheHashLog;
+        }
+        if (cPar.chainLog > maxShortCacheHashLog) {
+            cPar.chainLog = maxShortCacheHashLog;
+        }
+    }
+
+
+    /* At this point, we aren't 100% sure if we are using the row match finder.
+     * Unless it is explicitly disabled, conservatively assume that it is enabled.
+     * In this case it will only be disabled for small sources, so shrinking the
+     * hash log a little bit shouldn't result in any ratio loss.
+     */
+    if (useRowMatchFinder == ZSTD_ps_auto)
+        useRowMatchFinder = ZSTD_ps_enable;
+
+    /* We can't hash more than 32-bits in total. So that means that we require:
+     * (hashLog - rowLog + 8) <= 32
+     */
+    if (ZSTD_rowMatchFinderUsed(cPar.strategy, useRowMatchFinder)) {
+        /* Switch to 32-entry rows if searchLog is 5 (or more) */
+        U32 const rowLog = BOUNDED(4, cPar.searchLog, 6);
+        U32 const maxRowHashLog = 32 - ZSTD_ROW_HASH_TAG_BITS;
+        U32 const maxHashLog = maxRowHashLog + rowLog;
+        assert(cPar.hashLog >= rowLog);
+        if (cPar.hashLog > maxHashLog) {
+            cPar.hashLog = maxHashLog;
+        }
+    }
+
+    return cPar;
 }
 
 ZSTD_compressionParameters
@@ -1543,31 +1654,47 @@ ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
                        const int enableDedicatedDictSearch,
                        const U32 forCCtx)
 {
-    ZSTD_rustMatchStateSizing sizing;
-    sizing.hashLog3Max = ZSTD_HASHLOG3_MAX;
-    sizing.matchTSize = sizeof(ZSTD_match_t);
-    sizing.optimalTSize = sizeof(ZSTD_optimal_t);
-    sizing.asanRedzoneSize = ZSTD_RUST_ASAN_REDZONE_SIZE;
+    /* chain table size should be 0 for fast or row-hash strategies */
+    size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder, enableDedicatedDictSearch && !forCCtx)
+                                ? ((size_t)1 << cParams->chainLog)
+                                : 0;
+    size_t const hSize = ((size_t)1) << cParams->hashLog;
+    U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
+    size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;
+    /* We don't use ZSTD_cwksp_alloc_size() here because the tables aren't
+     * surrounded by redzones in ASAN. */
+    size_t const tableSpace = chainSize * sizeof(U32)
+                            + hSize * sizeof(U32)
+                            + h3Size * sizeof(U32);
+    size_t const optPotentialSpace =
+        ZSTD_cwksp_aligned64_alloc_size((MaxML+1) * sizeof(U32))
+      + ZSTD_cwksp_aligned64_alloc_size((MaxLL+1) * sizeof(U32))
+      + ZSTD_cwksp_aligned64_alloc_size((MaxOff+1) * sizeof(U32))
+      + ZSTD_cwksp_aligned64_alloc_size((1<<Litbits) * sizeof(U32))
+      + ZSTD_cwksp_aligned64_alloc_size(ZSTD_OPT_SIZE * sizeof(ZSTD_match_t))
+      + ZSTD_cwksp_aligned64_alloc_size(ZSTD_OPT_SIZE * sizeof(ZSTD_optimal_t));
+    size_t const lazyAdditionalSpace = ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)
+                                            ? ZSTD_cwksp_aligned64_alloc_size(hSize)
+                                            : 0;
+    size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
+                                ? optPotentialSpace
+                                : 0;
+    size_t const slackSpace = ZSTD_cwksp_slack_space_required();
 
-    /* The Rust leaf hardcodes the frozen format bounds and workspace rules;
-     * keep them checked against the private headers here. */
-    ZSTD_STATIC_ASSERT(MaxML == 52 && MaxLL == 35 && MaxOff == 31);
-    ZSTD_STATIC_ASSERT(Litbits == 8 && ZSTD_OPT_SIZE == 4099);
-    ZSTD_STATIC_ASSERT(ZSTD_CWKSP_ALIGNMENT_BYTES == 64);
     /* tables are guaranteed to be sized in multiples of 64 bytes (or 16 uint32_t) */
     ZSTD_STATIC_ASSERT(ZSTD_HASHLOG_MIN >= 4 && ZSTD_WINDOWLOG_MIN >= 4 && ZSTD_CHAINLOG_MIN >= 4);
     assert(useRowMatchFinder != ZSTD_ps_auto);
 
-    return ZSTD_rust_params_estimateMatchStateSize(*cParams,
-                                                   (int)useRowMatchFinder,
-                                                   enableDedicatedDictSearch,
-                                                   forCCtx, &sizing);
+    DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u",
+                (U32)chainSize, (U32)hSize, (U32)h3Size);
+    return tableSpace + optSpace + slackSpace + lazyAdditionalSpace;
 }
 
 /* Helper function for calculating memory requirements.
  * Gives a tighter bound than ZSTD_sequenceBound() by taking minMatch into account. */
 static size_t ZSTD_maxNbSeq(size_t blockSize, unsigned minMatch, int useSequenceProducer) {
-    return ZSTD_rust_params_maxNbSeq(blockSize, minMatch, useSequenceProducer);
+    U32 const divider = (minMatch==3 || useSequenceProducer) ? 3 : 4;
+    return blockSize / divider;
 }
 
 static size_t ZSTD_estimateCCtxSize_usingCCtxParams_internal(
@@ -5303,15 +5430,15 @@ size_t ZSTD_estimateCDictSize_advanced(
         size_t dictSize, ZSTD_compressionParameters cParams,
         ZSTD_dictLoadMethod_e dictLoadMethod)
 {
-    ZSTD_rustCDictSizing sizing;
-    sizing.cdictSize = sizeof(ZSTD_CDict);
-    sizing.hufWorkspaceSize = HUF_WORKSPACE_SIZE;
-    sizing.hashLog3Max = ZSTD_HASHLOG3_MAX;
-    sizing.matchTSize = sizeof(ZSTD_match_t);
-    sizing.optimalTSize = sizeof(ZSTD_optimal_t);
-    sizing.asanRedzoneSize = ZSTD_RUST_ASAN_REDZONE_SIZE;
-    return ZSTD_rust_params_estimateCDictSizeFromCParams(
-            dictSize, cParams, (int)dictLoadMethod, &sizing);
+    DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict));
+    return ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))
+         + ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)
+         /* enableDedicatedDictSearch == 1 ensures that CDict estimation will not be too small
+          * in case we are using DDS with row-hash. */
+         + ZSTD_sizeof_matchState(&cParams, ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams),
+                                  /* enableDedicatedDictSearch */ 1, /* forCCtx */ 0)
+         + (dictLoadMethod == ZSTD_dlm_byRef ? 0
+            : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void *))));
 }
 
 size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)
@@ -7449,12 +7576,11 @@ size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
 
 
 /*-=====  Pre-defined compression levels  =====-*/
-/* The compression-level tables (formerly included from clevels.h) live in
- * rust/src/zstd_compress_params.rs. */
+#include "clevels.h"
 
-int ZSTD_maxCLevel(void) { return ZSTD_rust_params_maxCLevel(); }
-int ZSTD_minCLevel(void) { return ZSTD_rust_params_minCLevel(); }
-int ZSTD_defaultCLevel(void) { return ZSTD_rust_params_defaultCLevel(); }
+int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
+int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }
+int ZSTD_defaultCLevel(void) { return ZSTD_CLEVEL_DEFAULT; }
 
 static ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(int const compressionLevel, size_t const dictSize)
 {
@@ -7513,6 +7639,26 @@ static void ZSTD_dedicatedDictSearch_revertCParams(
     }
 }
 
+static U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)
+{
+    switch (mode) {
+    case ZSTD_cpm_unknown:
+    case ZSTD_cpm_noAttachDict:
+    case ZSTD_cpm_createCDict:
+        break;
+    case ZSTD_cpm_attachDict:
+        dictSize = 0;
+        break;
+    default:
+        assert(0);
+        break;
+    }
+    {   int const unknown = srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN;
+        size_t const addedSize = unknown && dictSize > 0 ? 500 : 0;
+        return unknown && dictSize == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : srcSizeHint+dictSize+addedSize;
+    }
+}
+
 /*! ZSTD_getCParams_internal() :
  * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
  *  Note: srcSizeHint 0 means 0, use ZSTD_CONTENTSIZE_UNKNOWN for unknown.
@@ -7520,12 +7666,27 @@ static void ZSTD_dedicatedDictSearch_revertCParams(
  *  Note: `mode` controls how we treat the `dictSize`. See docs for `ZSTD_CParamMode_e`. */
 static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)
 {
-    /* Table selection is context-free and lives in Rust; the adjustment step
-     * stays behind ZSTD_adjustCParams_internal() so this build's strategy
-     * cascade applies. */
-    ZSTD_compressionParameters const cp = ZSTD_rust_params_selectCParams(
-            compressionLevel, srcSizeHint, dictSize, (int)mode);
-    return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode, ZSTD_ps_auto);
+    U64 const rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode);
+    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
+    int row;
+    DEBUGLOG(5, "ZSTD_getCParams_internal (cLevel=%i)", compressionLevel);
+
+    /* row */
+    if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT;   /* 0 == default */
+    else if (compressionLevel < 0) row = 0;   /* entry 0 is baseline for fast mode */
+    else if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL;
+    else row = compressionLevel;
+
+    {   ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row];
+        DEBUGLOG(5, "ZSTD_getCParams_internal selected tableID: %u row: %u strat: %u", tableID, row, (U32)cp.strategy);
+        /* acceleration factor */
+        if (compressionLevel < 0) {
+            int const clampedCompressionLevel = MAX(ZSTD_minCLevel(), compressionLevel);
+            cp.targetLength = (unsigned)(-clampedCompressionLevel);
+        }
+        /* refine parameters based on srcSize & dictSize */
+        return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode, ZSTD_ps_auto);
+    }
 }
 
 /*! ZSTD_getCParams() :
@@ -7544,9 +7705,13 @@ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long l
 static ZSTD_parameters
 ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)
 {
+    ZSTD_parameters params;
     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, mode);
     DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel);
-    return ZSTD_rust_params_makeParams(cParams);
+    ZSTD_memset(&params, 0, sizeof(params));
+    params.cParams = cParams;
+    params.fParams.contentSizeFlag = 1;
+    return params;
 }
 
 /*! ZSTD_getParams() :

programs/Makefile

@@ -32,7 +32,8 @@ RUST_CLI_MANIFEST := $(RUST_CLI_DIR)/Cargo.toml
 RUST_SOURCES := $(RUST_MANIFEST) $(RUST_DIR)/Cargo.lock \
                 $(shell find $(RUST_DIR)/src -type f -name '*.rs' -print)
 RUST_CLI_SOURCES := $(RUST_CLI_MANIFEST) $(RUST_CLI_DIR)/Cargo.lock \
-                    $(RUST_CLI_DIR)/src/lib.rs $(RUST_DIR)/src/zstd_cli.rs
+                    $(RUST_CLI_DIR)/src/lib.rs $(RUST_DIR)/src/zstd_cli.rs \
+                    $(RUST_DIR)/src/timefn.rs $(RUST_DIR)/src/benchfn.rs
 
 # Keep Rust's HUF implementation in lockstep with libzstd.mk's C selection.
 # Forced modes may arrive as libzstd.mk variables or as direct -D flags in
@@ -88,7 +89,7 @@ RUST_CLI_STATICLIB := $(RUST_CLI_TARGET_DIR)/release/libzstd_cli_rs.a
 RUST_CLI_STATICLIB_32 := $(RUST_CLI_TARGET_DIR)/$(RUST_TARGET_32)/release/libzstd_cli_rs.a
 RUST_CLI_CARGO_FLAGS := --manifest-path $(RUST_CLI_MANIFEST) --release \
                         --target-dir $(RUST_CLI_TARGET_DIR) \
-                        --no-default-features --features compression,decompression
+                        --no-default-features --features cli,compression,decompression
 
 $(RUST_CLI_STATICLIB): $(RUST_CLI_SOURCES)
 	$(CARGO) build $(RUST_CLI_CARGO_FLAGS)
@@ -114,7 +115,7 @@ RUST_DECOMPRESS_CLI_TARGET_DIR := $(RUST_DIR)/target/$(RUST_DECOMPRESS_CLI_BUILD
 RUST_DECOMPRESS_CLI_STATICLIB := $(RUST_DECOMPRESS_CLI_TARGET_DIR)/release/libzstd_cli_rs.a
 RUST_DECOMPRESS_CLI_CARGO_FLAGS := --manifest-path $(RUST_CLI_MANIFEST) --release \
                                     --target-dir $(RUST_DECOMPRESS_CLI_TARGET_DIR) \
-                                    --no-default-features --features decompression
+                                    --no-default-features --features cli,decompression
 
 $(RUST_DECOMPRESS_CLI_STATICLIB): $(RUST_CLI_SOURCES)
 	$(CARGO) build $(RUST_DECOMPRESS_CLI_CARGO_FLAGS)
@@ -134,7 +135,7 @@ RUST_COMPRESS_CLI_TARGET_DIR := $(RUST_DIR)/target/$(RUST_COMPRESS_CLI_BUILD_CON
 RUST_COMPRESS_CLI_STATICLIB := $(RUST_COMPRESS_CLI_TARGET_DIR)/release/libzstd_cli_rs.a
 RUST_COMPRESS_CLI_CARGO_FLAGS := --manifest-path $(RUST_CLI_MANIFEST) --release \
                                   --target-dir $(RUST_COMPRESS_CLI_TARGET_DIR) \
-                                  --no-default-features --features compression
+                                  --no-default-features --features cli,compression
 
 $(RUST_COMPRESS_CLI_STATICLIB): $(RUST_CLI_SOURCES)
 	$(CARGO) build $(RUST_COMPRESS_CLI_CARGO_FLAGS)

programs/benchfn.c

@@ -8,249 +8,23 @@
  * You may select, at your option, one of the above-listed licenses.
  */
 
+/* The implementation lives in rust/src/benchfn.rs, built into the Rust CLI
+ * static archive. This translation unit stays in the original source lists so
+ * build configuration keeps working while the implementation is in Rust. */
 
-
-/* *************************************
-*  Includes
-***************************************/
-#include <stdlib.h>      /* malloc, free */
-#include <string.h>      /* memset */
-#include <assert.h>      /* assert */
-
-#include "timefn.h"        /* UTIL_time_t, UTIL_getTime */
+#include <stddef.h>   /* size_t, offsetof */
 #include "benchfn.h"
 
-
-/* *************************************
-*  Constants
-***************************************/
-#define TIMELOOP_MICROSEC     SEC_TO_MICRO      /* 1 second */
-#define TIMELOOP_NANOSEC      (1*1000000000ULL) /* 1 second */
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-
-/* *************************************
-*  Debug errors
-***************************************/
-#if defined(DEBUG) && (DEBUG >= 1)
-#  include <stdio.h>       /* fprintf */
-#  define DISPLAY(...)       fprintf(stderr, __VA_ARGS__)
-#  define DEBUGOUTPUT(...) { if (DEBUG) DISPLAY(__VA_ARGS__); }
-#else
-#  define DEBUGOUTPUT(...)
-#endif
-
-
-/* error without displaying */
-#define RETURN_QUIET_ERROR(retValue, ...) {           \
-    DEBUGOUTPUT("%s: %i: \n", __FILE__, __LINE__);    \
-    DEBUGOUTPUT("Error : ");                          \
-    DEBUGOUTPUT(__VA_ARGS__);                         \
-    DEBUGOUTPUT(" \n");                               \
-    return retValue;                                  \
-}
-
-/* Abort execution if a condition is not met */
-#define CONTROL(c) { if (!(c)) { DEBUGOUTPUT("error: %s \n", #c); abort(); } }
-
-
-/* *************************************
-*  Benchmarking an arbitrary function
-***************************************/
-
-int BMK_isSuccessful_runOutcome(BMK_runOutcome_t outcome)
-{
-    return outcome.error_tag_never_ever_use_directly == 0;
-}
-
-/* warning : this function will stop program execution if outcome is invalid !
- *           check outcome validity first, using BMK_isValid_runResult() */
-BMK_runTime_t BMK_extract_runTime(BMK_runOutcome_t outcome)
-{
-    CONTROL(outcome.error_tag_never_ever_use_directly == 0);
-    return outcome.internal_never_ever_use_directly;
-}
-
-size_t BMK_extract_errorResult(BMK_runOutcome_t outcome)
-{
-    CONTROL(outcome.error_tag_never_ever_use_directly != 0);
-    return outcome.error_result_never_ever_use_directly;
-}
-
-static BMK_runOutcome_t BMK_runOutcome_error(size_t errorResult)
-{
-    BMK_runOutcome_t b;
-    memset(&b, 0, sizeof(b));
-    b.error_tag_never_ever_use_directly = 1;
-    b.error_result_never_ever_use_directly = errorResult;
-    return b;
-}
-
-static BMK_runOutcome_t BMK_setValid_runTime(BMK_runTime_t runTime)
-{
-    BMK_runOutcome_t outcome;
-    outcome.error_tag_never_ever_use_directly = 0;
-    outcome.internal_never_ever_use_directly = runTime;
-    return outcome;
-}
-
-
-/* initFn will be measured once, benchFn will be measured `nbLoops` times */
-/* initFn is optional, provide NULL if none */
-/* benchFn must return a size_t value that errorFn can interpret */
-/* takes # of blocks and list of size & stuff for each. */
-/* can report result of benchFn for each block into blockResult. */
-/* blockResult is optional, provide NULL if this information is not required */
-/* note : time per loop can be reported as zero if run time < timer resolution */
-BMK_runOutcome_t BMK_benchFunction(BMK_benchParams_t p,
-                                   unsigned nbLoops)
-{
-    nbLoops += !nbLoops;   /* minimum nbLoops is 1 */
-
-    /* init */
-    {   size_t i;
-        for(i = 0; i < p.blockCount; i++) {
-            memset(p.dstBuffers[i], 0xE5, p.dstCapacities[i]);  /* warm up and erase result buffer */
-    }   }
-
-    /* benchmark */
-    {   size_t dstSize = 0;
-        UTIL_time_t const clockStart = UTIL_getTime();
-        unsigned loopNb, blockNb;
-        if (p.initFn != NULL) p.initFn(p.initPayload);
-        for (loopNb = 0; loopNb < nbLoops; loopNb++) {
-            for (blockNb = 0; blockNb < p.blockCount; blockNb++) {
-                size_t const res = p.benchFn(p.srcBuffers[blockNb], p.srcSizes[blockNb],
-                                   p.dstBuffers[blockNb], p.dstCapacities[blockNb],
-                                   p.benchPayload);
-                if (loopNb == 0) {
-                    if (p.blockResults != NULL) p.blockResults[blockNb] = res;
-                    if ((p.errorFn != NULL) && (p.errorFn(res))) {
-                        RETURN_QUIET_ERROR(BMK_runOutcome_error(res),
-                            "Function benchmark failed on block %u (of size %u) with error %i",
-                            blockNb, (unsigned)p.srcSizes[blockNb], (int)res);
-                    }
-                    dstSize += res;
-            }   }
-        }  /* for (loopNb = 0; loopNb < nbLoops; loopNb++) */
-
-        {   PTime const totalTime = UTIL_clockSpanNano(clockStart);
-            BMK_runTime_t rt;
-            rt.nanoSecPerRun = (double)totalTime / nbLoops;
-            rt.sumOfReturn = dstSize;
-            return BMK_setValid_runTime(rt);
-    }   }
-}
-
-
-/* ====  Benchmarking any function, providing intermediate results  ==== */
-
-struct BMK_timedFnState_s {
-    PTime timeSpent_ns;
-    PTime timeBudget_ns;
-    PTime runBudget_ns;
-    BMK_runTime_t fastestRun;
-    unsigned nbLoops;
-    UTIL_time_t coolTime;
-};  /* typedef'd to BMK_timedFnState_t within bench.h */
-
-BMK_timedFnState_t* BMK_createTimedFnState(unsigned total_ms, unsigned run_ms)
-{
-    BMK_timedFnState_t* const r = (BMK_timedFnState_t*)malloc(sizeof(*r));
-    if (r == NULL) return NULL;   /* malloc() error */
-    BMK_resetTimedFnState(r, total_ms, run_ms);
-    return r;
-}
-
-void BMK_freeTimedFnState(BMK_timedFnState_t* state) { free(state); }
-
-BMK_timedFnState_t*
-BMK_initStatic_timedFnState(void* buffer, size_t size, unsigned total_ms, unsigned run_ms)
-{
-    typedef char check_size[ 2 * (sizeof(BMK_timedFnState_shell) >= sizeof(struct BMK_timedFnState_s)) - 1];  /* static assert : a compilation failure indicates that BMK_timedFnState_shell is not large enough */
-    typedef struct { check_size c; BMK_timedFnState_t tfs; } tfs_align;  /* force tfs to be aligned at its next best position */
-    size_t const tfs_alignment = offsetof(tfs_align, tfs); /* provides the minimal alignment restriction for BMK_timedFnState_t */
-    BMK_timedFnState_t* const r = (BMK_timedFnState_t*)buffer;
-    if (buffer == NULL) return NULL;
-    if (size < sizeof(struct BMK_timedFnState_s)) return NULL;
-    if ((size_t)buffer % tfs_alignment) return NULL;  /* buffer must be properly aligned */
-    BMK_resetTimedFnState(r, total_ms, run_ms);
-    return r;
-}
-
-void BMK_resetTimedFnState(BMK_timedFnState_t* timedFnState, unsigned total_ms, unsigned run_ms)
-{
-    if (!total_ms) total_ms = 1 ;
-    if (!run_ms) run_ms = 1;
-    if (run_ms > total_ms) run_ms = total_ms;
-    timedFnState->timeSpent_ns = 0;
-    timedFnState->timeBudget_ns = (PTime)total_ms * TIMELOOP_NANOSEC / 1000;
-    timedFnState->runBudget_ns = (PTime)run_ms * TIMELOOP_NANOSEC / 1000;
-    timedFnState->fastestRun.nanoSecPerRun = (double)TIMELOOP_NANOSEC * 2000000000;  /* hopefully large enough : must be larger than any potential measurement */
-    timedFnState->fastestRun.sumOfReturn = (size_t)(-1LL);
-    timedFnState->nbLoops = 1;
-    timedFnState->coolTime = UTIL_getTime();
-}
-
-/* Tells if nb of seconds set in timedFnState for all runs is spent.
- * note : this function will return 1 if BMK_benchFunctionTimed() has actually errored. */
-int BMK_isCompleted_TimedFn(const BMK_timedFnState_t* timedFnState)
-{
-    return (timedFnState->timeSpent_ns >= timedFnState->timeBudget_ns);
-}
-
-
-#undef MIN
-#define MIN(a,b)   ( (a) < (b) ? (a) : (b) )
-
-#define MINUSABLETIME  (TIMELOOP_NANOSEC / 2)  /* 0.5 seconds */
-
-BMK_runOutcome_t BMK_benchTimedFn(BMK_timedFnState_t* cont,
-                                  BMK_benchParams_t p)
-{
-    PTime const runBudget_ns = cont->runBudget_ns;
-    PTime const runTimeMin_ns = runBudget_ns / 2;
-    int completed = 0;
-    BMK_runTime_t bestRunTime = cont->fastestRun;
-
-    while (!completed) {
-        BMK_runOutcome_t const runResult = BMK_benchFunction(p, cont->nbLoops);
-
-        if(!BMK_isSuccessful_runOutcome(runResult)) { /* error : move out */
-            return runResult;
-        }
-
-        {   BMK_runTime_t const newRunTime = BMK_extract_runTime(runResult);
-            double const loopDuration_ns = newRunTime.nanoSecPerRun * cont->nbLoops;
-
-            cont->timeSpent_ns += (unsigned long long)loopDuration_ns;
-
-            /* estimate nbLoops for next run to last approximately 1 second */
-            if (loopDuration_ns > ((double)runBudget_ns / 50)) {
-                double const fastestRun_ns = MIN(bestRunTime.nanoSecPerRun, newRunTime.nanoSecPerRun);
-                cont->nbLoops = (unsigned)((double)runBudget_ns / fastestRun_ns) + 1;
-            } else {
-                /* previous run was too short : blindly increase workload by x multiplier */
-                const unsigned multiplier = 10;
-                assert(cont->nbLoops < ((unsigned)-1) / multiplier);  /* avoid overflow */
-                cont->nbLoops *= multiplier;
-            }
-
-            if(loopDuration_ns < (double)runTimeMin_ns) {
-                /* don't report results for which benchmark run time was too small : increased risks of rounding errors */
-                assert(completed == 0);
-                continue;
-            } else {
-                if(newRunTime.nanoSecPerRun < bestRunTime.nanoSecPerRun) {
-                    bestRunTime = newRunTime;
-                }
-                completed = 1;
-            }
-        }
-    }   /* while (!completed) */
-
-    return BMK_setValid_runTime(bestRunTime);
-}
+/* BMK_runTime_t and BMK_runOutcome_t are returned by value across the C/Rust
+ * boundary, and BMK_benchParams_t is passed by value. The Rust #[repr(C)]
+ * definitions mirror the offsets pinned here. */
+typedef char BMK_staticAssert_runTimeSumOffset[
+    (offsetof(BMK_runTime_t, sumOfReturn) == sizeof(double)) ? 1 : -1];
+typedef char BMK_staticAssert_outcomeResultOffset[
+    (offsetof(BMK_runOutcome_t, error_result_never_ever_use_directly)
+     == sizeof(BMK_runTime_t)) ? 1 : -1];
+typedef char BMK_staticAssert_outcomeTagOffset[
+    (offsetof(BMK_runOutcome_t, error_tag_never_ever_use_directly)
+     == sizeof(BMK_runTime_t) + sizeof(size_t)) ? 1 : -1];
+typedef char BMK_staticAssert_shellAlignment[
+    (sizeof(BMK_timedFnState_shell) == BMK_TIMEDFNSTATE_SIZE) ? 1 : -1];

programs/timefn.c

@@ -8,161 +8,14 @@
  * You may select, at your option, one of the above-listed licenses.
  */
 
-
-/* ===  Dependencies  === */
+/* The implementation lives in rust/src/timefn.rs, built into the Rust CLI
+ * static archive. This translation unit stays in the original source lists so
+ * build configuration keeps working while the implementation is in Rust. */
 
 #include "timefn.h"
-#include "platform.h" /* set _POSIX_C_SOURCE */
-#include <time.h>     /* CLOCK_MONOTONIC, TIME_UTC */
 
-/*-****************************************
-*  Time functions
-******************************************/
-
-#if defined(_WIN32)   /* Windows */
-
-#include <windows.h>  /* LARGE_INTEGER */
-#include <stdlib.h>   /* abort */
-#include <stdio.h>    /* perror */
-
-UTIL_time_t UTIL_getTime(void)
-{
-    static LARGE_INTEGER ticksPerSecond;
-    static int init = 0;
-    if (!init) {
-        if (!QueryPerformanceFrequency(&ticksPerSecond)) {
-            perror("timefn::QueryPerformanceFrequency");
-            abort();
-        }
-        init = 1;
-    }
-    {   UTIL_time_t r;
-        LARGE_INTEGER x;
-        QueryPerformanceCounter(&x);
-        r.t = (PTime)(x.QuadPart * 1000000000ULL / ticksPerSecond.QuadPart);
-        return r;
-    }
-}
-
-
-#elif defined(__APPLE__) && defined(__MACH__)
-
-#include <mach/mach_time.h> /* mach_timebase_info_data_t, mach_timebase_info, mach_absolute_time */
-
-UTIL_time_t UTIL_getTime(void)
-{
-    static mach_timebase_info_data_t rate;
-    static int init = 0;
-    if (!init) {
-        mach_timebase_info(&rate);
-        init = 1;
-    }
-    {   UTIL_time_t r;
-        r.t = mach_absolute_time() * (PTime)rate.numer / (PTime)rate.denom;
-        return r;
-    }
-}
-
-/* POSIX.1-2001 (optional) */
-#elif defined(CLOCK_MONOTONIC)
-
-#include <stdlib.h>   /* abort */
-#include <stdio.h>    /* perror */
-
-UTIL_time_t UTIL_getTime(void)
-{
-    /* time must be initialized, othersize it may fail msan test.
-     * No good reason, likely a limitation of timespec_get() for some target */
-    struct timespec time = { 0, 0 };
-    if (clock_gettime(CLOCK_MONOTONIC, &time) != 0) {
-        perror("timefn::clock_gettime(CLOCK_MONOTONIC)");
-        abort();
-    }
-    {   UTIL_time_t r;
-        r.t = (PTime)time.tv_sec * 1000000000ULL + (PTime)time.tv_nsec;
-        return r;
-    }
-}
-
-
-/* C11 requires support of timespec_get().
- * However, FreeBSD 11 claims C11 compliance while lacking timespec_get().
- * Double confirm timespec_get() support by checking the definition of TIME_UTC.
- * However, some versions of Android manage to simultaneously define TIME_UTC
- * and lack timespec_get() support... */
-#elif (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* C11 */) \
-    && defined(TIME_UTC) && !defined(__ANDROID__)
-
-#include <stdlib.h>   /* abort */
-#include <stdio.h>    /* perror */
-
-UTIL_time_t UTIL_getTime(void)
-{
-    /* time must be initialized, othersize it may fail msan test.
-     * No good reason, likely a limitation of timespec_get() for some target */
-    struct timespec time = { 0, 0 };
-    if (timespec_get(&time, TIME_UTC) != TIME_UTC) {
-        perror("timefn::timespec_get(TIME_UTC)");
-        abort();
-    }
-    {   UTIL_time_t r;
-        r.t = (PTime)time.tv_sec * 1000000000ULL + (PTime)time.tv_nsec;
-        return r;
-    }
-}
-
-
-#else   /* relies on standard C90 (note : clock_t produces wrong measurements for multi-threaded workloads) */
-
-UTIL_time_t UTIL_getTime(void)
-{
-    UTIL_time_t r;
-    r.t = (PTime)clock() * 1000000000ULL / CLOCKS_PER_SEC;
-    return r;
-}
-
-#define TIME_MT_MEASUREMENTS_NOT_SUPPORTED
-
-#endif
-
-/* ==== Common functions, valid for all time API ==== */
-
-PTime UTIL_getSpanTimeNano(UTIL_time_t clockStart, UTIL_time_t clockEnd)
-{
-    return clockEnd.t - clockStart.t;
-}
-
-PTime UTIL_getSpanTimeMicro(UTIL_time_t begin, UTIL_time_t end)
-{
-    return UTIL_getSpanTimeNano(begin, end) / 1000ULL;
-}
-
-PTime UTIL_clockSpanMicro(UTIL_time_t clockStart )
-{
-    UTIL_time_t const clockEnd = UTIL_getTime();
-    return UTIL_getSpanTimeMicro(clockStart, clockEnd);
-}
-
-PTime UTIL_clockSpanNano(UTIL_time_t clockStart )
-{
-    UTIL_time_t const clockEnd = UTIL_getTime();
-    return UTIL_getSpanTimeNano(clockStart, clockEnd);
-}
-
-void UTIL_waitForNextTick(void)
-{
-    UTIL_time_t const clockStart = UTIL_getTime();
-    UTIL_time_t clockEnd;
-    do {
-        clockEnd = UTIL_getTime();
-    } while (UTIL_getSpanTimeNano(clockStart, clockEnd) == 0);
-}
-
-int UTIL_support_MT_measurements(void)
-{
-# if defined(TIME_MT_MEASUREMENTS_NOT_SUPPORTED)
-    return 0;
-# else
-    return 1;
-# endif
-}
+/* The Rust port mirrors this exact ABI: UTIL_time_t is returned by value and
+ * must remain a plain 64-bit nanosecond counter. */
+typedef char UTIL_staticAssert_ptimeIs64Bit[(sizeof(PTime) == 8) ? 1 : -1];
+typedef char UTIL_staticAssert_timeIsPlainCounter[
+    (sizeof(UTIL_time_t) == sizeof(PTime)) ? 1 : -1];

programs/zstdcli.c

@@ -10,16 +10,67 @@
 
 /* The CLI parser and control flow live in rust/src/zstd_cli.rs. Keep this
  * translation unit as the stable C entry point used by program launchers. */
+#include <stddef.h>       /* size_t */
+#define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_compressionParameters */
 #include "../lib/zstd.h"
+#ifndef ZSTD_NOBENCH
+#  include "benchzstd.h"  /* BMK_benchFilesAdvanced, BMK_syntheticTest */
+#endif
 
 int ZSTD_rust_cli_main(int argCount, const char* const argv[]);
 const char* ZSTD_rust_cli_expected_version(void);
+int ZSTD_rust_cli_bench(const char* const* fileNames, unsigned nbFiles,
+                        const char* dictFileName,
+                        int startCLevel, int endCLevel,
+                        const ZSTD_compressionParameters* compressionParams,
+                        int displayLevel, unsigned nbSeconds,
+                        size_t blockSize, int nbWorkers);
 
 const char* ZSTD_rust_cli_expected_version(void)
 {
     return ZSTD_VERSION_STRING;
 }
 
+/* Benchmark bridge for the Rust CLI. Whether benchmarking exists is a C
+ * preprocessor property (ZSTD_NOBENCH), so the decision stays in this shim:
+ * the Rust frontend calls in unconditionally, and stripped program variants
+ * never reference benchmark symbols.
+ * @return the benchmark result code (>= 0), or -1 when unavailable. */
+int ZSTD_rust_cli_bench(const char* const* fileNames, unsigned nbFiles,
+                        const char* dictFileName,
+                        int startCLevel, int endCLevel,
+                        const ZSTD_compressionParameters* compressionParams,
+                        int displayLevel, unsigned nbSeconds,
+                        size_t blockSize, int nbWorkers)
+{
+#ifndef ZSTD_NOBENCH
+    BMK_advancedParams_t advancedParams = BMK_initAdvancedParams();
+    int startLevel = startCLevel;
+    int endLevel = endCLevel;
+    advancedParams.nbSeconds = nbSeconds;
+    advancedParams.blockSize = blockSize;
+    advancedParams.nbWorkers = nbWorkers;
+    if (startLevel > ZSTD_maxCLevel()) startLevel = ZSTD_maxCLevel();
+    if (endLevel > ZSTD_maxCLevel()) endLevel = ZSTD_maxCLevel();
+    if (endLevel < startLevel) endLevel = startLevel;
+    if (nbFiles == 0) {
+        /* No input file: benchmark a synthetic sample (lorem generator). */
+        return BMK_syntheticTest(-1.0, startLevel, endLevel,
+                                 compressionParams, displayLevel,
+                                 &advancedParams);
+    }
+    return BMK_benchFilesAdvanced(fileNames, nbFiles, dictFileName,
+                                  startLevel, endLevel,
+                                  compressionParams, displayLevel,
+                                  &advancedParams);
+#else
+    (void)fileNames; (void)nbFiles; (void)dictFileName;
+    (void)startCLevel; (void)endCLevel; (void)compressionParams;
+    (void)displayLevel; (void)nbSeconds; (void)blockSize; (void)nbWorkers;
+    return -1;
+#endif
+}
+
 int main(int argCount, const char* argv[])
 {
     return ZSTD_rust_cli_main(argCount, argv);

rust/README.md

@@ -34,12 +34,6 @@ zstd ABI:
   - `zstd_compress_frame` serializes frame headers, skippable frames, and the
     last empty block; it takes scalar frame parameters so the C-owned
     `ZSTD_CCtx_params` layout never crosses the language boundary.
-  - `zstd_compress_params` owns the compression-level tables (formerly
-    `clevels.h`), parameter bounds, clamping, validation, table selection,
-    source/dictionary adjustment, and match-state/CDict size estimation.
-    The C integration layer keeps the public `ZSTD_*` symbols and feeds the
-    leaves configuration-owned scalars: the excluded-block-compressor
-    strategy cascade, struct sizes, and sanitizer redzone policy.
   - `zstd_fast` and `zstd_double_fast` implement the single- and two-table
     fast block match finders, including attached and external dictionary paths.
   - `zstd_lazy` implements greedy, lazy, lazy2, and binary-tree matching,
@@ -65,11 +59,21 @@ zstd ABI:
     so library builds do not acquire program-only dependencies.  The C
     `fileio` backend still owns file opening, safe replacement, sparse writes,
     metadata, and streaming I/O.
+  - `timefn` provides the monotonic nanosecond clock behind `UTIL_time_t`,
+    and `benchfn` owns the benchmark run/timing loop (`BMK_benchFunction`,
+    `BMK_benchTimedFn`) used by the CLI benchmark mode and by C test tools.
+    Both live in the `cli/` package, but C test binaries (fullbench, fuzzer,
+    zstreamtest, paramgrill, ...) link a helpers-only build of that archive,
+    produced without the package's `cli` feature, because the parser layer
+    requires the C `fileio` backend that tests do not compile.  Benchmark
+    orchestration and reporting (`benchzstd.c`) remain C, reached from the
+    Rust parser through the `ZSTD_NOBENCH`-gated bridge in `zstdcli.c`.
 
 The optimal block matcher, high-level frame compression, dictionary-building,
-legacy decoding callbacks, and the CLI file-I/O backend are still C. They must
-move before the rewrite is complete. Keeping that boundary explicit prevents a
-passing hybrid build from being mistaken for the final all-Rust result.
+legacy decoding callbacks, benchmark orchestration (`benchzstd`), and the CLI
+file-I/O backend are still C. They must move before the rewrite is complete.
+Keeping that boundary explicit prevents a passing hybrid build from being
+mistaken for the final all-Rust result.
 
 ## Compatibility boundary
 
@@ -105,8 +109,9 @@ from `rust/cli` as well:
 ```sh
 cargo clippy --all-targets -- -D warnings
 cargo test --all-targets
-cargo test --no-default-features --features compression --all-targets
-cargo test --no-default-features --features decompression --all-targets
+cargo test --no-default-features --features cli,compression --all-targets
+cargo test --no-default-features --features cli,decompression --all-targets
+cargo test --no-default-features --all-targets
 ```
 
 Then run original compatibility tests from the repository root, starting with

rust/cli/Cargo.lock

@@ -2,6 +2,15 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
 [[package]]
 name = "zstd-cli-rs"
 version = "0.1.0"
+dependencies = [
+ "libc",
+]

rust/cli/Cargo.toml

@@ -7,6 +7,13 @@ edition = "2021"
 crate-type = ["staticlib"]
 
 [features]
-default = ["compression", "decompression"]
+default = ["cli", "compression", "decompression"]
+# The command-line parser and dispatch layer, which requires the C fileio
+# backend at link time. Program archives enable it; C test binaries link a
+# helpers-only archive (timefn) built without it.
+cli = []
 compression = []
 decompression = []
+
+[dependencies]
+libc = "0.2"

rust/cli/src/lib.rs

@@ -1,2 +1,7 @@
+#[path = "../../src/benchfn.rs"]
+mod benchfn;
+#[path = "../../src/timefn.rs"]
+mod timefn;
+#[cfg(feature = "cli")]
 #[path = "../../src/zstd_cli.rs"]
 mod zstd_cli;

rust/src/benchfn.rs

@@ -0,0 +1,575 @@
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(clippy::missing_safety_doc)]
+
+//! Benchmark loop for arbitrary functions over a set of blocks.
+//!
+//! Port of `programs/benchfn.c`.  `BMK_benchFunction` measures one batch of
+//! runs; `BMK_benchTimedFn` repeats batches, growing the loop count until a
+//! run lasts long enough to be reported reliably against `run_ms`, within a
+//! `total_ms` budget tracked by `BMK_timedFnState_t`.
+//!
+//! ABI notes: `BMK_runOutcome_t` and `BMK_runTime_t` are returned by value
+//! across the C boundary and `BMK_benchParams_t` is passed by value, so all
+//! three are `repr(C)` mirrors of the `benchfn.h` layout, pinned by asserts
+//! here and in the C shim.  `BMK_timedFnState_t` is opaque to C, but
+//! `BMK_initStatic_timedFnState` guarantees it fits the 64-byte
+//! `BMK_timedFnState_shell`, and `BMK_createTimedFnState` uses `malloc` so
+//! creation and destruction stay interchangeable with C callers.
+
+use std::os::raw::{c_int, c_uint, c_void};
+use std::ptr;
+
+use crate::timefn::{PTime, UTIL_clockSpanNano, UTIL_getTime, UTIL_time_t};
+
+const TIMELOOP_NANOSEC: PTime = 1_000_000_000;
+
+/// Valid benchmark result (`BMK_runTime_t` in benchfn.h).
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct BMK_runTime_t {
+    /// Time per iteration, over all blocks.
+    pub nanoSecPerRun: f64,
+    /// Sum of the benchmarked function's return values, first loop only.
+    pub sumOfReturn: usize,
+}
+
+/// Outcome variant of a benchmark run (`BMK_runOutcome_t` in benchfn.h):
+/// either a valid `BMK_runTime_t` or an error result. C callers treat it as
+/// opaque and use the accessor functions below.
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct BMK_runOutcome_t {
+    pub internal_never_ever_use_directly: BMK_runTime_t,
+    pub error_result_never_ever_use_directly: usize,
+    pub error_tag_never_ever_use_directly: c_int,
+}
+
+// These mirror the static asserts in the programs/benchfn.c shim: the structs
+// cross the ABI by value, so field offsets must match the C header exactly.
+const _: () =
+    assert!(std::mem::offset_of!(BMK_runTime_t, sumOfReturn) == std::mem::size_of::<f64>());
+const _: () = assert!(
+    std::mem::offset_of!(BMK_runOutcome_t, error_result_never_ever_use_directly)
+        == std::mem::size_of::<BMK_runTime_t>()
+);
+const _: () = assert!(
+    std::mem::offset_of!(BMK_runOutcome_t, error_tag_never_ever_use_directly)
+        == std::mem::size_of::<BMK_runTime_t>() + std::mem::size_of::<usize>()
+);
+
+/// `size_t (*BMK_benchFn_t)(const void*, size_t, void*, size_t, void*)`
+pub type BMK_benchFn_t = Option<
+    unsafe extern "C" fn(
+        src: *const c_void,
+        srcSize: usize,
+        dst: *mut c_void,
+        dstCapacity: usize,
+        customPayload: *mut c_void,
+    ) -> usize,
+>;
+/// `size_t (*BMK_initFn_t)(void*)`
+pub type BMK_initFn_t = Option<unsafe extern "C" fn(initPayload: *mut c_void) -> usize>;
+/// `unsigned (*BMK_errorFn_t)(size_t)`
+pub type BMK_errorFn_t = Option<unsafe extern "C" fn(result: usize) -> c_uint>;
+
+/// Parameters of `BMK_benchFunction`, passed by value (`BMK_benchParams_t`).
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct BMK_benchParams_t {
+    pub benchFn: BMK_benchFn_t,
+    pub benchPayload: *mut c_void,
+    pub initFn: BMK_initFn_t,
+    pub initPayload: *mut c_void,
+    pub errorFn: BMK_errorFn_t,
+    pub blockCount: usize,
+    pub srcBuffers: *const *const c_void,
+    pub srcSizes: *const usize,
+    pub dstBuffers: *const *mut c_void,
+    pub dstCapacities: *const usize,
+    pub blockResults: *mut usize,
+}
+
+/// Aborts, like benchfn.c's `CONTROL`, when an accessor is used on the wrong
+/// outcome variant.
+fn control(condition: bool) {
+    if !condition {
+        std::process::abort();
+    }
+}
+
+fn error_outcome(errorResult: usize) -> BMK_runOutcome_t {
+    BMK_runOutcome_t {
+        internal_never_ever_use_directly: BMK_runTime_t {
+            nanoSecPerRun: 0.0,
+            sumOfReturn: 0,
+        },
+        error_result_never_ever_use_directly: errorResult,
+        error_tag_never_ever_use_directly: 1,
+    }
+}
+
+fn valid_outcome(runTime: BMK_runTime_t) -> BMK_runOutcome_t {
+    BMK_runOutcome_t {
+        internal_never_ever_use_directly: runTime,
+        error_result_never_ever_use_directly: 0,
+        error_tag_never_ever_use_directly: 0,
+    }
+}
+
+/// Tells if the outcome carries a valid measurement.
+#[no_mangle]
+pub extern "C" fn BMK_isSuccessful_runOutcome(outcome: BMK_runOutcome_t) -> c_int {
+    c_int::from(outcome.error_tag_never_ever_use_directly == 0)
+}
+
+/// Extracts the measurement; aborts if the outcome is an error, so validity
+/// must be checked first with `BMK_isSuccessful_runOutcome`.
+#[no_mangle]
+pub extern "C" fn BMK_extract_runTime(outcome: BMK_runOutcome_t) -> BMK_runTime_t {
+    control(outcome.error_tag_never_ever_use_directly == 0);
+    outcome.internal_never_ever_use_directly
+}
+
+/// Extracts the faulty `benchFn` return value; aborts if the outcome is
+/// valid, so failure must be checked first.
+#[no_mangle]
+pub extern "C" fn BMK_extract_errorResult(outcome: BMK_runOutcome_t) -> usize {
+    control(outcome.error_tag_never_ever_use_directly != 0);
+    outcome.error_result_never_ever_use_directly
+}
+
+/// Runs `initFn` once, then `benchFn` `nbLoops` times over every block, and
+/// reports the mean time per loop.  On the first loop, per-block results are
+/// stored into `blockResults` (when provided) and checked with `errorFn`
+/// (when provided); the first failing block aborts the measurement and
+/// produces an error outcome carrying the faulty return value.
+#[no_mangle]
+pub unsafe extern "C" fn BMK_benchFunction(
+    p: BMK_benchParams_t,
+    mut nbLoops: c_uint,
+) -> BMK_runOutcome_t {
+    // Minimum nbLoops is 1.
+    nbLoops += c_uint::from(nbLoops == 0);
+
+    // Warm up and erase the result buffers.
+    for blockNb in 0..p.blockCount {
+        unsafe {
+            let dst = *p.dstBuffers.add(blockNb);
+            ptr::write_bytes(dst.cast::<u8>(), 0xE5, *p.dstCapacities.add(blockNb));
+        }
+    }
+
+    let benchFn = p.benchFn.expect("benchFn is mandatory");
+    let mut dstSize = 0usize;
+    let clockStart = UTIL_getTime();
+    if let Some(initFn) = p.initFn {
+        unsafe { initFn(p.initPayload) };
+    }
+    for loopNb in 0..nbLoops {
+        for blockNb in 0..p.blockCount {
+            let res = unsafe {
+                benchFn(
+                    *p.srcBuffers.add(blockNb),
+                    *p.srcSizes.add(blockNb),
+                    *p.dstBuffers.add(blockNb),
+                    *p.dstCapacities.add(blockNb),
+                    p.benchPayload,
+                )
+            };
+            if loopNb == 0 {
+                if !p.blockResults.is_null() {
+                    unsafe { *p.blockResults.add(blockNb) = res };
+                }
+                if let Some(errorFn) = p.errorFn {
+                    if unsafe { errorFn(res) } != 0 {
+                        return error_outcome(res);
+                    }
+                }
+                dstSize = dstSize.wrapping_add(res);
+            }
+        }
+    }
+
+    let totalTime = UTIL_clockSpanNano(clockStart);
+    valid_outcome(BMK_runTime_t {
+        nanoSecPerRun: totalTime as f64 / f64::from(nbLoops),
+        sumOfReturn: dstSize,
+    })
+}
+
+/// Benchmark session state (`struct BMK_timedFnState_s`), opaque to C.
+#[repr(C)]
+pub struct BMK_timedFnState_t {
+    timeSpent_ns: PTime,
+    timeBudget_ns: PTime,
+    runBudget_ns: PTime,
+    fastestRun: BMK_runTime_t,
+    nbLoops: c_uint,
+    coolTime: UTIL_time_t,
+}
+
+/// `BMK_TIMEDFNSTATE_SIZE` in benchfn.h: capacity of the caller-provided
+/// `BMK_timedFnState_shell`, which the state must always fit.
+const BMK_TIMEDFNSTATE_SIZE: usize = 64;
+const _: () = assert!(std::mem::size_of::<BMK_timedFnState_t>() <= BMK_TIMEDFNSTATE_SIZE);
+// The shell aligns via a `long long` member; the state must not need more.
+const _: () = assert!(std::mem::align_of::<BMK_timedFnState_t>() <= std::mem::align_of::<u64>());
+
+/// Allocates and initializes a benchmark session lasting a minimum of
+/// `total_ms`, paced at intervals of approximately `run_ms`.  Uses `malloc`
+/// so ownership stays interchangeable with the original C implementation.
+#[no_mangle]
+pub extern "C" fn BMK_createTimedFnState(
+    total_ms: c_uint,
+    run_ms: c_uint,
+) -> *mut BMK_timedFnState_t {
+    let state = unsafe { libc::malloc(std::mem::size_of::<BMK_timedFnState_t>()) }
+        .cast::<BMK_timedFnState_t>();
+    if state.is_null() {
+        return ptr::null_mut();
+    }
+    unsafe { BMK_resetTimedFnState(state, total_ms, run_ms) };
+    state
+}
+
+/// Releases a state obtained from `BMK_createTimedFnState`.
+#[no_mangle]
+pub unsafe extern "C" fn BMK_freeTimedFnState(state: *mut BMK_timedFnState_t) {
+    unsafe { libc::free(state.cast()) };
+}
+
+/// Places the session state into a caller-provided buffer, typically a
+/// `BMK_timedFnState_shell`.  Returns NULL when the buffer is missing, too
+/// small, or misaligned.
+#[no_mangle]
+pub unsafe extern "C" fn BMK_initStatic_timedFnState(
+    buffer: *mut c_void,
+    size: usize,
+    total_ms: c_uint,
+    run_ms: c_uint,
+) -> *mut BMK_timedFnState_t {
+    if buffer.is_null() {
+        return ptr::null_mut();
+    }
+    if size < std::mem::size_of::<BMK_timedFnState_t>() {
+        return ptr::null_mut();
+    }
+    if !(buffer as usize).is_multiple_of(std::mem::align_of::<BMK_timedFnState_t>()) {
+        return ptr::null_mut();
+    }
+    let state = buffer.cast::<BMK_timedFnState_t>();
+    unsafe { BMK_resetTimedFnState(state, total_ms, run_ms) };
+    state
+}
+
+/// Re-arms a session for a new benchmark of `total_ms`, paced at `run_ms`.
+#[no_mangle]
+pub unsafe extern "C" fn BMK_resetTimedFnState(
+    timedFnState: *mut BMK_timedFnState_t,
+    total_ms: c_uint,
+    run_ms: c_uint,
+) {
+    let total_ms = if total_ms == 0 { 1 } else { total_ms };
+    let mut run_ms = if run_ms == 0 { 1 } else { run_ms };
+    if run_ms > total_ms {
+        run_ms = total_ms;
+    }
+    let state = BMK_timedFnState_t {
+        timeSpent_ns: 0,
+        timeBudget_ns: PTime::from(total_ms) * TIMELOOP_NANOSEC / 1000,
+        runBudget_ns: PTime::from(run_ms) * TIMELOOP_NANOSEC / 1000,
+        fastestRun: BMK_runTime_t {
+            // Must be larger than any potential measurement.
+            nanoSecPerRun: TIMELOOP_NANOSEC as f64 * 2_000_000_000.0,
+            sumOfReturn: usize::MAX,
+        },
+        nbLoops: 1,
+        coolTime: UTIL_getTime(),
+    };
+    unsafe { timedFnState.write(state) };
+}
+
+/// Tells if the total time budget of the session is spent.  Also reports 1
+/// after `BMK_benchTimedFn` returned an error.
+#[no_mangle]
+pub unsafe extern "C" fn BMK_isCompleted_TimedFn(timedFnState: *const BMK_timedFnState_t) -> c_int {
+    let state = unsafe { &*timedFnState };
+    c_int::from(state.timeSpent_ns >= state.timeBudget_ns)
+}
+
+/// Runs one measurement supposed to last about `run_ms`, automatically
+/// scaling `nbLoops`.  Runs shorter than half the run budget are re-tried
+/// with a larger workload instead of being reported, limiting rounding-error
+/// risks; the best (fastest) qualifying run is returned.
+#[no_mangle]
+pub unsafe extern "C" fn BMK_benchTimedFn(
+    cont: *mut BMK_timedFnState_t,
+    p: BMK_benchParams_t,
+) -> BMK_runOutcome_t {
+    let cont = unsafe { &mut *cont };
+    let runBudget_ns = cont.runBudget_ns;
+    let runTimeMin_ns = runBudget_ns / 2;
+    let mut bestRunTime = cont.fastestRun;
+
+    loop {
+        let runResult = unsafe { BMK_benchFunction(p, cont.nbLoops) };
+
+        if BMK_isSuccessful_runOutcome(runResult) == 0 {
+            // Error: move out.
+            return runResult;
+        }
+
+        let newRunTime = BMK_extract_runTime(runResult);
+        let loopDuration_ns = newRunTime.nanoSecPerRun * f64::from(cont.nbLoops);
+
+        cont.timeSpent_ns = cont.timeSpent_ns.wrapping_add(loopDuration_ns as PTime);
+
+        // Estimate nbLoops for the next run to last approximately run_ms.
+        if loopDuration_ns > runBudget_ns as f64 / 50.0 {
+            let fastestRun_ns = bestRunTime.nanoSecPerRun.min(newRunTime.nanoSecPerRun);
+            cont.nbLoops = ((runBudget_ns as f64 / fastestRun_ns) as c_uint).wrapping_add(1);
+        } else {
+            // Previous run was too short: blindly increase workload by a
+            // x10 multiplier.
+            const MULTIPLIER: c_uint = 10;
+            debug_assert!(cont.nbLoops < c_uint::MAX / MULTIPLIER); // avoid overflow
+            cont.nbLoops = cont.nbLoops.wrapping_mul(MULTIPLIER);
+        }
+
+        if loopDuration_ns < runTimeMin_ns as f64 {
+            // Don't report results when the run time was too small, which
+            // increases the risk of rounding errors.
+            continue;
+        }
+        if newRunTime.nanoSecPerRun < bestRunTime.nanoSecPerRun {
+            bestRunTime = newRunTime;
+        }
+        return valid_outcome(bestRunTime);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Test payload observed through `benchPayload`/`initPayload` pointers.
+    #[derive(Default)]
+    struct CallLog {
+        bench_calls: usize,
+        init_calls: usize,
+    }
+
+    /// Counts invocations and reports `srcSize`, like a size-preserving codec.
+    unsafe extern "C" fn counting_bench_fn(
+        _src: *const c_void,
+        srcSize: usize,
+        _dst: *mut c_void,
+        _dstCapacity: usize,
+        payload: *mut c_void,
+    ) -> usize {
+        let log = unsafe { &mut *payload.cast::<CallLog>() };
+        log.bench_calls += 1;
+        srcSize
+    }
+
+    unsafe extern "C" fn counting_init_fn(payload: *mut c_void) -> usize {
+        let log = unsafe { &mut *payload.cast::<CallLog>() };
+        log.init_calls += 1;
+        0
+    }
+
+    /// Flags results of 5 bytes and above as errors.
+    unsafe extern "C" fn error_on_5(result: usize) -> c_uint {
+        c_uint::from(result >= 5)
+    }
+
+    struct Fixture {
+        srcs: Vec<Vec<u8>>,
+        dsts: Vec<Vec<u8>>,
+        src_ptrs: Vec<*const c_void>,
+        src_sizes: Vec<usize>,
+        dst_ptrs: Vec<*mut c_void>,
+        dst_capacities: Vec<usize>,
+        block_results: Vec<usize>,
+        log: CallLog,
+    }
+
+    impl Fixture {
+        fn new(block_sizes: &[usize]) -> Box<Self> {
+            let srcs: Vec<Vec<u8>> = block_sizes.iter().map(|size| vec![0u8; *size]).collect();
+            let mut dsts: Vec<Vec<u8>> = block_sizes.iter().map(|size| vec![0u8; *size]).collect();
+            let src_ptrs = srcs.iter().map(|src| src.as_ptr().cast()).collect();
+            let src_sizes = srcs.iter().map(Vec::len).collect();
+            let dst_ptrs = dsts.iter_mut().map(|dst| dst.as_mut_ptr().cast()).collect();
+            let dst_capacities = dsts.iter().map(Vec::len).collect();
+            let block_results = vec![0usize; block_sizes.len()];
+            Box::new(Self {
+                srcs,
+                dsts,
+                src_ptrs,
+                src_sizes,
+                dst_ptrs,
+                dst_capacities,
+                block_results,
+                log: CallLog::default(),
+            })
+        }
+
+        fn params(&mut self, errorFn: BMK_errorFn_t) -> BMK_benchParams_t {
+            let payload: *mut CallLog = &mut self.log;
+            BMK_benchParams_t {
+                benchFn: Some(counting_bench_fn),
+                benchPayload: payload.cast(),
+                initFn: Some(counting_init_fn),
+                initPayload: payload.cast(),
+                errorFn,
+                blockCount: self.srcs.len(),
+                srcBuffers: self.src_ptrs.as_ptr(),
+                srcSizes: self.src_sizes.as_ptr(),
+                dstBuffers: self.dst_ptrs.as_ptr(),
+                dstCapacities: self.dst_capacities.as_ptr(),
+                blockResults: self.block_results.as_mut_ptr(),
+            }
+        }
+    }
+
+    #[test]
+    fn bench_function_accounts_loops_blocks_and_first_loop_results() {
+        let mut fixture = Fixture::new(&[3, 8]);
+        let params = fixture.params(None);
+
+        let outcome = unsafe { BMK_benchFunction(params, 4) };
+
+        assert_eq!(BMK_isSuccessful_runOutcome(outcome), 1);
+        let run_time = BMK_extract_runTime(outcome);
+        // benchFn ran nbLoops times over each block; initFn ran once.
+        assert_eq!(fixture.log.bench_calls, 4 * 2);
+        assert_eq!(fixture.log.init_calls, 1);
+        // sumOfReturn and blockResults reflect the first loop only.
+        assert_eq!(run_time.sumOfReturn, 3 + 8);
+        assert_eq!(fixture.block_results, vec![3, 8]);
+        assert!(run_time.nanoSecPerRun >= 0.0);
+    }
+
+    #[test]
+    fn bench_function_treats_zero_loops_as_one_and_warms_up_buffers() {
+        let mut fixture = Fixture::new(&[4]);
+        let params = fixture.params(None);
+
+        let outcome = unsafe { BMK_benchFunction(params, 0) };
+
+        assert_eq!(BMK_isSuccessful_runOutcome(outcome), 1);
+        assert_eq!(fixture.log.bench_calls, 1);
+        // The result buffer was erased with the 0xE5 warm-up pattern.
+        assert_eq!(fixture.dsts[0], vec![0xE5; 4]);
+    }
+
+    #[test]
+    fn bench_function_reports_the_first_failing_block() {
+        let mut fixture = Fixture::new(&[3, 5, 7]);
+        let params = fixture.params(Some(error_on_5));
+
+        let outcome = unsafe { BMK_benchFunction(params, 10) };
+
+        assert_eq!(BMK_isSuccessful_runOutcome(outcome), 0);
+        assert_eq!(BMK_extract_errorResult(outcome), 5);
+        // Execution stopped at the failing block, before the third one.
+        assert_eq!(fixture.log.bench_calls, 2);
+        // blockResults were recorded up to and including the failure.
+        assert_eq!(fixture.block_results[..2], [3, 5]);
+    }
+
+    #[test]
+    fn reset_clamps_budgets_and_rearms_the_loop_counter() {
+        let state = BMK_createTimedFnState(0, 7);
+        assert!(!state.is_null());
+
+        {
+            let state = unsafe { &*state };
+            // total_ms 0 becomes 1ms, and run_ms is clamped to total_ms.
+            assert_eq!(state.timeBudget_ns, 1_000_000);
+            assert_eq!(state.runBudget_ns, 1_000_000);
+            assert_eq!(state.nbLoops, 1);
+            assert_eq!(state.timeSpent_ns, 0);
+            assert_eq!(state.fastestRun.sumOfReturn, usize::MAX);
+        }
+        assert_eq!(unsafe { BMK_isCompleted_TimedFn(state) }, 0);
+
+        unsafe { BMK_resetTimedFnState(state, 2_000, 500) };
+        {
+            let state = unsafe { &*state };
+            assert_eq!(state.timeBudget_ns, 2_000_000_000);
+            assert_eq!(state.runBudget_ns, 500_000_000);
+        }
+
+        unsafe { BMK_freeTimedFnState(state) };
+    }
+
+    #[test]
+    fn static_state_initialization_validates_its_buffer() {
+        let mut shell = [0u64; BMK_TIMEDFNSTATE_SIZE / 8];
+        let buffer: *mut c_void = shell.as_mut_ptr().cast();
+
+        // A properly sized and aligned buffer is accepted.
+        let state = unsafe { BMK_initStatic_timedFnState(buffer, 64, 1_000, 100) };
+        assert!(!state.is_null());
+        assert_eq!(unsafe { BMK_isCompleted_TimedFn(state) }, 0);
+
+        // NULL, undersized, and misaligned buffers are rejected.
+        let too_small = std::mem::size_of::<BMK_timedFnState_t>() - 1;
+        unsafe {
+            assert!(BMK_initStatic_timedFnState(ptr::null_mut(), 64, 1, 1).is_null());
+            assert!(BMK_initStatic_timedFnState(buffer, too_small, 1, 1).is_null());
+            assert!(
+                BMK_initStatic_timedFnState(buffer.cast::<u8>().add(1).cast(), 63, 1, 1).is_null()
+            );
+        }
+    }
+
+    #[test]
+    fn timed_runs_grow_the_workload_and_spend_the_budget() {
+        let mut fixture = Fixture::new(&[16]);
+        let params = fixture.params(None);
+        let state = BMK_createTimedFnState(4, 2);
+        assert!(!state.is_null());
+
+        let mut rounds = 0usize;
+        while unsafe { BMK_isCompleted_TimedFn(state) } == 0 {
+            let outcome = unsafe { BMK_benchTimedFn(state, params) };
+            assert_eq!(BMK_isSuccessful_runOutcome(outcome), 1);
+            let run_time = BMK_extract_runTime(outcome);
+            assert_eq!(run_time.sumOfReturn, 16);
+            rounds += 1;
+            assert!(rounds < 1_000, "the time budget must eventually be spent");
+        }
+
+        {
+            let state = unsafe { &*state };
+            // A reported run had to last at least runBudget/2, which is only
+            // reachable for this trivial function with a grown loop counter.
+            assert!(state.nbLoops > 1);
+            assert!(state.timeSpent_ns >= state.timeBudget_ns);
+        }
+        // Every reported outcome came from a run of >= runBudget/2, and the
+        // budget accounting matches BMK_isCompleted_TimedFn.
+        assert!(rounds >= 1);
+        assert!(fixture.log.bench_calls >= rounds);
+
+        unsafe { BMK_freeTimedFnState(state) };
+    }
+
+    #[test]
+    fn timed_runs_propagate_errors_without_aborting() {
+        let mut fixture = Fixture::new(&[9]);
+        let params = fixture.params(Some(error_on_5));
+        let state = BMK_createTimedFnState(1_000, 100);
+
+        let outcome = unsafe { BMK_benchTimedFn(state, params) };
+
+        assert_eq!(BMK_isSuccessful_runOutcome(outcome), 0);
+        assert_eq!(BMK_extract_errorResult(outcome), 9);
+
+        unsafe { BMK_freeTimedFnState(state) };
+    }
+}

rust/src/lib.rs

@@ -28,8 +28,6 @@ pub mod zstd_compress_frame;
 #[cfg(feature = "compression")]
 pub mod zstd_compress_literals;
 #[cfg(feature = "compression")]
-pub mod zstd_compress_params;
-#[cfg(feature = "compression")]
 pub mod zstd_compress_sequences;
 #[cfg(feature = "compression")]
 pub mod zstd_compress_superblock;

rust/src/timefn.rs

@@ -0,0 +1,198 @@
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+//! Precise monotonic time measurement for the command-line programs.
+//!
+//! Port of `programs/timefn.c`.  `UTIL_time_t` is a plain nanosecond counter
+//! whose absolute value is meaningless; only spans between two measurements
+//! are valid.  The struct crosses the C ABI by value, so it stays `repr(C)`
+//! with the exact `timefn.h` layout.
+//!
+//! Platform selection mirrors the C preprocessor structure: Windows uses the
+//! performance counter, Apple systems use the Mach absolute clock, and other
+//! POSIX systems use `clock_gettime(CLOCK_MONOTONIC)`.  The C90 `clock()`
+//! fallback is never needed on targets Rust supports, so multi-threaded
+//! measurements are always supported.
+
+use std::os::raw::c_int;
+
+/// Precise Time (`PTime` in timefn.h): an unsigned 64-bit nanosecond count.
+pub type PTime = u64;
+
+/// Nanosecond time counter with the `timefn.h` `UTIL_time_t` layout.
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct UTIL_time_t {
+    pub t: PTime,
+}
+
+const _: () = assert!(std::mem::size_of::<PTime>() == 8);
+const _: () = assert!(std::mem::size_of::<UTIL_time_t>() == std::mem::size_of::<PTime>());
+
+#[cfg(windows)]
+mod platform {
+    use super::PTime;
+    use std::sync::OnceLock;
+
+    #[link(name = "kernel32")]
+    unsafe extern "system" {
+        /// Takes a `LARGE_INTEGER*`; the union is ABI-identical to `i64*`.
+        fn QueryPerformanceCounter(count: *mut i64) -> i32;
+        fn QueryPerformanceFrequency(frequency: *mut i64) -> i32;
+    }
+
+    pub fn monotonic_ns() -> PTime {
+        static TICKS_PER_SECOND: OnceLock<i64> = OnceLock::new();
+        let ticks_per_second = *TICKS_PER_SECOND.get_or_init(|| {
+            let mut frequency = 0i64;
+            if unsafe { QueryPerformanceFrequency(&mut frequency) } == 0 {
+                eprintln!(
+                    "timefn::QueryPerformanceFrequency: {}",
+                    std::io::Error::last_os_error()
+                );
+                std::process::abort();
+            }
+            frequency
+        });
+        let mut counter = 0i64;
+        unsafe { QueryPerformanceCounter(&mut counter) };
+        (counter as PTime).wrapping_mul(1_000_000_000) / ticks_per_second as PTime
+    }
+}
+
+#[cfg(all(unix, target_vendor = "apple"))]
+mod platform {
+    use super::PTime;
+    use std::sync::OnceLock;
+
+    pub fn monotonic_ns() -> PTime {
+        static RATE: OnceLock<(PTime, PTime)> = OnceLock::new();
+        let (numer, denom) = *RATE.get_or_init(|| {
+            let mut rate = libc::mach_timebase_info { numer: 0, denom: 0 };
+            unsafe { libc::mach_timebase_info(&mut rate) };
+            (PTime::from(rate.numer), PTime::from(rate.denom))
+        });
+        unsafe { libc::mach_absolute_time() }.wrapping_mul(numer) / denom
+    }
+}
+
+#[cfg(all(unix, not(target_vendor = "apple")))]
+mod platform {
+    use super::PTime;
+
+    pub fn monotonic_ns() -> PTime {
+        // Zero-initialized like the C source, which works around timespec_get
+        // msan limitations on some targets.
+        let mut time: libc::timespec = unsafe { std::mem::zeroed() };
+        if unsafe { libc::clock_gettime(libc::CLOCK_MONOTONIC, &mut time) } != 0 {
+            eprintln!(
+                "timefn::clock_gettime(CLOCK_MONOTONIC): {}",
+                std::io::Error::last_os_error()
+            );
+            std::process::abort();
+        }
+        (time.tv_sec as PTime)
+            .wrapping_mul(1_000_000_000)
+            .wrapping_add(time.tv_nsec as PTime)
+    }
+}
+
+/// Returns the current value of the platform's monotonic nanosecond clock.
+#[no_mangle]
+pub extern "C" fn UTIL_getTime() -> UTIL_time_t {
+    UTIL_time_t {
+        t: platform::monotonic_ns(),
+    }
+}
+
+/// Nanoseconds elapsed between two measurements, with C unsigned wrap-around.
+#[no_mangle]
+pub extern "C" fn UTIL_getSpanTimeNano(clockStart: UTIL_time_t, clockEnd: UTIL_time_t) -> PTime {
+    clockEnd.t.wrapping_sub(clockStart.t)
+}
+
+/// Microseconds elapsed between two measurements, truncated like C division.
+#[no_mangle]
+pub extern "C" fn UTIL_getSpanTimeMicro(begin: UTIL_time_t, end: UTIL_time_t) -> PTime {
+    UTIL_getSpanTimeNano(begin, end) / 1000
+}
+
+/// Microseconds elapsed since `clockStart`.
+#[no_mangle]
+pub extern "C" fn UTIL_clockSpanMicro(clockStart: UTIL_time_t) -> PTime {
+    UTIL_getSpanTimeMicro(clockStart, UTIL_getTime())
+}
+
+/// Nanoseconds elapsed since `clockStart`.
+#[no_mangle]
+pub extern "C" fn UTIL_clockSpanNano(clockStart: UTIL_time_t) -> PTime {
+    UTIL_getSpanTimeNano(clockStart, UTIL_getTime())
+}
+
+/// Busy-waits until the clock produces a new tick, improving measurement
+/// accuracy on platforms with a low timer resolution.
+#[no_mangle]
+pub extern "C" fn UTIL_waitForNextTick() {
+    let clockStart = UTIL_getTime();
+    loop {
+        let clockEnd = UTIL_getTime();
+        if UTIL_getSpanTimeNano(clockStart, clockEnd) != 0 {
+            return;
+        }
+    }
+}
+
+/// All clock sources used by the Rust port are valid under multi-threaded
+/// workloads; only the C90 `clock()` fallback of the C source was not.
+#[no_mangle]
+pub extern "C" fn UTIL_support_MT_measurements() -> c_int {
+    1
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn nanosecond_spans_subtract_with_unsigned_wrap_around() {
+        let start = UTIL_time_t { t: 100 };
+        let end = UTIL_time_t { t: 350 };
+
+        assert_eq!(UTIL_getSpanTimeNano(start, end), 250);
+        assert_eq!(UTIL_getSpanTimeNano(end, start), u64::MAX - 249);
+        assert_eq!(UTIL_getSpanTimeNano(start, start), 0);
+    }
+
+    #[test]
+    fn microsecond_spans_truncate_sub_tick_remainders() {
+        let start = UTIL_time_t { t: 0 };
+
+        assert_eq!(UTIL_getSpanTimeMicro(start, UTIL_time_t { t: 999 }), 0);
+        assert_eq!(UTIL_getSpanTimeMicro(start, UTIL_time_t { t: 1_000 }), 1);
+        assert_eq!(UTIL_getSpanTimeMicro(start, UTIL_time_t { t: 1_999 }), 1);
+        assert_eq!(UTIL_getSpanTimeMicro(start, UTIL_time_t { t: 2_000 }), 2);
+    }
+
+    #[test]
+    fn clock_is_monotonic_across_measurements() {
+        let first = UTIL_getTime();
+        let second = UTIL_getTime();
+
+        assert!(second.t >= first.t);
+        assert!(UTIL_clockSpanNano(first) >= UTIL_getSpanTimeNano(first, second));
+    }
+
+    #[test]
+    fn waiting_for_the_next_tick_advances_the_clock() {
+        let before = UTIL_getTime();
+        UTIL_waitForNextTick();
+        let after = UTIL_getTime();
+
+        assert!(UTIL_getSpanTimeNano(before, after) > 0);
+    }
+
+    #[test]
+    fn multi_threaded_measurements_are_supported() {
+        assert_eq!(UTIL_support_MT_measurements(), 1);
+    }
+}

rust/src/zstd_cli.rs

@@ -10,9 +10,15 @@
 //! writes, dictionary loading, streaming, and metadata preservation remain in
 //! `programs/fileio.c` for this first migration step.
 //!
+//! Benchmark mode (`-b`) parses here and dispatches through the
+//! `ZSTD_rust_cli_bench` bridge in `programs/zstdcli.c`: the run/timing loop
+//! (benchfn, timefn) is Rust, while orchestration and result formatting
+//! (`benchzstd.c`) remain C behind the preprocessor-gated bridge, so builds
+//! with `ZSTD_NOBENCH` never reference benchmark symbols.
+//!
 //! Remaining C-only CLI boundaries are called out in `unsupported()` below:
-//! benchmark execution, dictionary training, recursive/file-list expansion,
-//! tracing, alternate-format selection, and the advanced directory modes.
+//! dictionary training, recursive/file-list expansion, tracing,
+//! alternate-format selection, and the advanced directory modes.
 
 use std::env;
 use std::ffi::{CStr, CString, OsStr, OsString};
@@ -30,6 +36,7 @@ use std::os::unix::fs::FileTypeExt;
 const DEFAULT_CLEVEL: i32 = 3;
 #[cfg(feature = "compression")]
 const DEFAULT_MAX_CLEVEL: i32 = 19;
+const DEFAULT_BENCH_NB_SECONDS: u32 = 3;
 const DEFAULT_MEM_LIMIT: u32 = 1 << 27;
 const DEFAULT_LONG_WINDOW_LOG: u32 = 27;
 const MAX_FAST_ACCELERATION: i32 = 128 << 10;
@@ -173,6 +180,22 @@ unsafe extern "C" {
         output: *const c_char,
         dict: *const c_char,
     ) -> c_int;
+
+    /// Benchmark bridge implemented by the `programs/zstdcli.c` shim, which
+    /// owns the `ZSTD_NOBENCH` preprocessor decision. Returns the benchmark
+    /// result (>= 0), or -1 when benchmarking is compiled out.
+    fn ZSTD_rust_cli_bench(
+        file_names: *const *const c_char,
+        nb_files: c_uint,
+        dict_file_name: *const c_char,
+        start_level: c_int,
+        end_level: c_int,
+        compression_params: *const ZSTD_compressionParameters,
+        display_level: c_int,
+        nb_seconds: c_uint,
+        block_size: usize,
+        nb_workers: c_int,
+    ) -> c_int;
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -180,6 +203,7 @@ enum Operation {
     Compress,
     Decompress,
     Test,
+    Bench,
 }
 
 #[derive(Debug)]
@@ -210,7 +234,6 @@ struct Cli {
     mmap_dict: i32,
     progress: i32,
     workers: Option<i32>,
-    single_thread: bool,
     block_size: Option<usize>,
     mem_limit: Option<u32>,
     ldm: bool,
@@ -230,6 +253,8 @@ struct Cli {
     row_match_finder: i32,
     exclude_compressed: bool,
     compression_params: ZSTD_compressionParameters,
+    bench_end_level: Option<i32>,
+    bench_nb_seconds: Option<u32>,
     unsupported_program: Option<String>,
 }
 
@@ -255,7 +280,6 @@ impl Cli {
             mmap_dict: ZSTD_PS_AUTO,
             progress: FIO_PS_AUTO,
             workers: None,
-            single_thread: false,
             block_size: None,
             mem_limit: None,
             ldm: false,
@@ -275,6 +299,8 @@ impl Cli {
             row_match_finder: ZSTD_PS_AUTO,
             exclude_compressed: false,
             compression_params: ZSTD_compressionParameters::default(),
+            bench_end_level: None,
+            bench_nb_seconds: None,
             unsupported_program: None,
         };
 
@@ -334,11 +360,8 @@ unsafe fn default_worker_count() -> i32 {
 }
 
 #[cfg(feature = "compression")]
-unsafe fn resolved_worker_count(workers: Option<i32>, single_thread: bool) -> i32 {
+unsafe fn resolved_worker_count(workers: Option<i32>) -> i32 {
     match workers {
-        /* --single-thread pins zero workers; a bare zero (-T0 or the zstdmt
-         * program name) auto-detects the core count as in the C CLI. */
-        Some(0) if single_thread => 0,
         Some(0) => unsafe { UTIL_countPhysicalCores() }.max(1),
         Some(workers) => workers,
         None => unsafe { default_worker_count() },
@@ -390,7 +413,7 @@ fn usage(advanced: bool) {
         let _ = writeln!(out, "\nImplemented advanced compression controls:");
         let _ = writeln!(
             out,
-            "  --fast[=#], --ultra, --long[=#], --threads=#, --single-thread, --block-size=#"
+            "  --fast[=#], --ultra, --long[=#], --threads=#, --block-size=#"
         );
         let _ = writeln!(
             out,
@@ -404,9 +427,22 @@ fn usage(advanced: bool) {
             out,
             "  --adapt[=min=#,max=#], --rsyncable, --[no-]row-match-finder"
         );
+        let _ = writeln!(out, "\nBenchmark options:");
         let _ = writeln!(
             out,
-            "\nNot yet migrated: benchmark, dictionary training, recursive/file-list expansion,"
+            "  -b#                           Benchmark file(s) at compression level #"
+        );
+        let _ = writeln!(
+            out,
+            "  -e#                           Test all levels from -b# up to # included"
+        );
+        let _ = writeln!(
+            out,
+            "  -i#                           Set the minimum evaluation time to # seconds"
+        );
+        let _ = writeln!(
+            out,
+            "\nNot yet migrated: dictionary training, recursive/file-list expansion,"
         );
         let _ = writeln!(out, "trace, alternate formats, and output-directory modes.");
     }
@@ -643,7 +679,6 @@ fn parse_long_option(
                 | "--no-row-match-finder"
                 | "--row-match-finder"
                 | "--rsyncable"
-                | "--single-thread"
                 | "--compress-literals"
                 | "--no-compress-literals"
                 | "--exclude-compressed"
@@ -815,14 +850,6 @@ fn parse_long_option(
             cli.workers = Some(parse_worker_count(&value)?);
             Ok(None)
         }
-        "--single-thread" => {
-            /* As in the C CLI: zero workers plus a latch that suppresses the
-             * automatic core-count resolution, so fileio runs its
-             * single-thread streaming mode (slightly different from -T1). */
-            cli.workers = Some(0);
-            cli.single_thread = true;
-            Ok(None)
-        }
         "--memlimit" | "--memory" | "--memlimit-decompress" => {
             let value = next_value(attached, args, index, name)?;
             cli.mem_limit = Some(parse_u32(&value, "memory limit")?);
@@ -868,6 +895,7 @@ fn parse_long_option(
         | "--trace"
         | "--format"
         | "--priority"
+        | "--single-thread"
         | "--auto-threads"
         | "--fake-stdin-is-console"
         | "--fake-stdout-is-console"
@@ -905,6 +933,33 @@ fn parse_short_options(
             'd' => cli.operation = Operation::Decompress,
             'z' => cli.operation = Operation::Compress,
             't' => cli.operation = Operation::Test,
+            'b' => cli.operation = Operation::Bench,
+            'e' | 'i' => {
+                // Benchmark range end (-e#) and duration (-i#): like the C
+                // parser, digits attach directly and default to 0.
+                let mut digits_end = offset + 1;
+                while digits_end < bytes.len() && bytes[digits_end].is_ascii_digit() {
+                    digits_end += 1;
+                }
+                let digits = &value[offset + 1..digits_end];
+                if option == 'e' {
+                    cli.bench_end_level = Some(if digits.is_empty() {
+                        0
+                    } else {
+                        parse_i32(digits, "benchmark end level")?
+                    });
+                } else {
+                    cli.bench_nb_seconds = Some(if digits.is_empty() {
+                        0
+                    } else {
+                        digits
+                            .parse::<u32>()
+                            .map_err(|_| format!("invalid benchmark duration: {digits:?}"))?
+                    });
+                }
+                offset = digits_end;
+                continue;
+            }
             'c' => {
                 cli.output = Some(cstring(STDOUT_MARK)?);
                 cli.force_stdout = true;
@@ -940,7 +995,7 @@ fn parse_short_options(
                 }
                 break;
             }
-            'b' | 'e' | 'i' | 'l' | 'p' | 'P' | 'r' | 's' | 'S' => {
+            'l' | 'p' | 'P' | 'r' | 's' | 'S' => {
                 unsupported(&format!("-{option}"))?;
             }
             _ => return Err(format!("unknown option -{option}")),
@@ -1025,7 +1080,7 @@ unsafe fn apply_preferences(cli: &Cli, prefs: *mut FIO_prefs_t, ctx: *mut FIO_ct
                 }),
         );
         #[cfg(feature = "compression")]
-        FIO_setNbWorkers(prefs, resolved_worker_count(cli.workers, cli.single_thread));
+        FIO_setNbWorkers(prefs, resolved_worker_count(cli.workers));
         FIO_setLdmFlag(prefs, u32::from(cli.ldm));
         FIO_setAdaptiveMode(prefs, i32::from(cli.adapt));
         FIO_setRsyncable(prefs, i32::from(cli.rsyncable));
@@ -1231,16 +1286,52 @@ unsafe fn run_decompress(
                 dictionary,
             )
         },
-        Operation::Compress => unreachable!("compression is dispatched separately"),
+        Operation::Compress | Operation::Bench => {
+            unreachable!("compression and benchmark are dispatched separately")
+        }
     }
 }
 
+/// Runs benchmark mode through the C bridge. Level clamping against
+/// `ZSTD_maxCLevel()` happens on the C side, where the symbol is always
+/// available when benchmarking is compiled in. No input file means a
+/// synthetic-sample benchmark, matching the C CLI.
+fn run_bench(cli: &Cli) -> Result<i32, String> {
+    let inputs: Vec<*const c_char> = cli.inputs.iter().map(|value| value.as_ptr()).collect();
+    let dictionary = cli
+        .dictionary
+        .as_ref()
+        .map_or(ptr::null(), |value| value.as_ptr());
+    let result = unsafe {
+        ZSTD_rust_cli_bench(
+            inputs.as_ptr(),
+            inputs.len() as c_uint,
+            dictionary,
+            cli.level,
+            cli.bench_end_level.unwrap_or(cli.level),
+            &cli.compression_params,
+            cli.display_level,
+            cli.bench_nb_seconds.unwrap_or(DEFAULT_BENCH_NB_SECONDS),
+            cli.block_size.unwrap_or(0),
+            // The C CLI benchmarks single-threaded unless -T was given.
+            cli.workers.unwrap_or(1),
+        )
+    };
+    if result < 0 {
+        return Err("benchmark mode is not available in this build".to_owned());
+    }
+    Ok(result)
+}
+
 fn run_cli(mut cli: Cli) -> Result<i32, String> {
     if let Some(program_name) = &cli.unsupported_program {
         return Err(format!(
             "{program_name} compatibility mode is not yet implemented by the Rust CLI frontend"
         ));
     }
+    if cli.operation == Operation::Bench {
+        return run_bench(&cli);
+    }
     let explicit_input_count = cli.inputs.len();
     filter_symlink_inputs(&mut cli);
     if explicit_input_count > 0 && cli.inputs.is_empty() {
@@ -1347,6 +1438,7 @@ fn run_cli(mut cli: Cli) -> Result<i32, String> {
                 #[cfg(not(feature = "decompression"))]
                 unreachable!("unsupported decompression was rejected above")
             }
+            Operation::Bench => unreachable!("benchmark mode was dispatched earlier"),
         }
     };
 
@@ -1515,36 +1607,6 @@ mod tests {
         let cli = parse(&["zstdmt", "input"]);
 
         assert_eq!(cli.workers, Some(0));
-        assert!(!cli.single_thread);
-    }
-
-    #[test]
-    fn single_thread_pins_zero_workers() {
-        let cli = parse(&["zstd", "--single-thread", "input"]);
-
-        assert_eq!(cli.workers, Some(0));
-        assert!(cli.single_thread);
-    }
-
-    #[test]
-    fn a_later_thread_count_overrides_single_thread_workers() {
-        /* Mirrors the C CLI: -T after --single-thread wins the worker count,
-         * while the single-thread latch stays set. */
-        let cli = parse(&["zstd", "--single-thread", "-T2", "input"]);
-
-        assert_eq!(cli.workers, Some(2));
-        assert!(cli.single_thread);
-    }
-
-    #[test]
-    fn single_thread_rejects_attached_values() {
-        let error = parse_args(vec![
-            OsString::from("zstd"),
-            OsString::from("--single-thread=1"),
-        ])
-        .expect_err("an attached value must not activate --single-thread");
-
-        assert!(error.contains("does not take an argument"));
     }
 
     #[test]
@@ -1581,4 +1643,41 @@ mod tests {
 
         assert!(error.contains("not yet implemented"));
     }
+
+    #[test]
+    fn bench_mode_parses_level_duration_and_defaults() {
+        let cli = parse(&["zstd", "-b1", "-i0", "input"]);
+
+        assert_eq!(cli.operation, Operation::Bench);
+        assert_eq!(cli.level, 1);
+        assert_eq!(cli.bench_nb_seconds, Some(0));
+        assert_eq!(cli.bench_end_level, None);
+        assert_eq!(
+            cli.inputs
+                .iter()
+                .map(|input| input.as_bytes())
+                .collect::<Vec<_>>(),
+            vec![&b"input"[..]]
+        );
+    }
+
+    #[test]
+    fn bench_range_aggregates_within_a_single_argument() {
+        let cli = parse(&["zstd", "-b5e6i2", "input"]);
+
+        assert_eq!(cli.operation, Operation::Bench);
+        assert_eq!(cli.level, 5);
+        assert_eq!(cli.bench_end_level, Some(6));
+        assert_eq!(cli.bench_nb_seconds, Some(2));
+    }
+
+    #[test]
+    fn bench_duration_without_digits_defaults_to_zero() {
+        let cli = parse(&["zstd", "-b", "-e", "-i"]);
+
+        assert_eq!(cli.operation, Operation::Bench);
+        assert_eq!(cli.level, DEFAULT_CLEVEL);
+        assert_eq!(cli.bench_end_level, Some(0));
+        assert_eq!(cli.bench_nb_seconds, Some(0));
+    }
 }

rust/src/zstd_compress_params.rs

@@ -1,1048 +0,0 @@
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
-#![allow(clippy::missing_safety_doc)]
-#![allow(clippy::too_many_arguments)]
-
-//! Context-free compression-parameter selection and sizing leaves.
-//!
-//! This module deliberately does **not** own the public `ZSTD_*` symbols yet.
-//! `zstd_compress.c` still owns configuration-sensitive policy: excluded block
-//! compressors, private `ZSTD_CCtx_params` layouts, LDM workspace sizing, and
-//! ASAN workspace policy.  The C integration layer can select a raw table
-//! entry here, apply its configured strategy cascade, then use the adjustment
-//! and sizing leaves below.  That keeps the Rust implementation independent of
-//! C preprocessor state while retaining byte-for-byte C policy for reduced
-//! builds.
-
-use crate::errors::{ZstdErrorCode, ERROR};
-use std::mem::size_of;
-use std::os::raw::c_int;
-
-pub const ZSTD_CONTENTSIZE_UNKNOWN: u64 = u64::MAX;
-
-const ZSTD_CLEVEL_DEFAULT: c_int = 3;
-const ZSTD_MAX_CLEVEL: c_int = 22;
-const ZSTD_TARGETLENGTH_MAX: c_int = 1 << 17;
-const ZSTD_BLOCKSIZE_MAX: usize = 1 << 17;
-
-const ZSTD_WINDOWLOG_MIN: c_int = 10;
-#[cfg(target_pointer_width = "32")]
-const ZSTD_WINDOWLOG_MAX: c_int = 30;
-#[cfg(not(target_pointer_width = "32"))]
-const ZSTD_WINDOWLOG_MAX: c_int = 31;
-const ZSTD_HASHLOG_MIN: c_int = 6;
-const ZSTD_HASHLOG_MAX: c_int = 30;
-const ZSTD_CHAINLOG_MIN: c_int = ZSTD_HASHLOG_MIN;
-#[cfg(target_pointer_width = "32")]
-const ZSTD_CHAINLOG_MAX: c_int = 29;
-#[cfg(not(target_pointer_width = "32"))]
-const ZSTD_CHAINLOG_MAX: c_int = 30;
-const ZSTD_SEARCHLOG_MIN: c_int = 1;
-const ZSTD_SEARCHLOG_MAX: c_int = ZSTD_WINDOWLOG_MAX - 1;
-const ZSTD_MINMATCH_MIN: c_int = 3;
-const ZSTD_MINMATCH_MAX: c_int = 7;
-const ZSTD_TARGETLENGTH_MIN: c_int = 0;
-
-const ZSTD_FAST: c_int = 1;
-const ZSTD_DFAST: c_int = 2;
-const ZSTD_GREEDY: c_int = 3;
-const ZSTD_LAZY: c_int = 4;
-const ZSTD_LAZY2: c_int = 5;
-const ZSTD_BTLAZY2: c_int = 6;
-const ZSTD_BTOPT: c_int = 7;
-const ZSTD_BTULTRA: c_int = 8;
-const ZSTD_BTULTRA2: c_int = 9;
-
-const ZSTD_C_COMPRESSION_LEVEL: c_int = 100;
-const ZSTD_C_WINDOW_LOG: c_int = 101;
-const ZSTD_C_HASH_LOG: c_int = 102;
-const ZSTD_C_CHAIN_LOG: c_int = 103;
-const ZSTD_C_SEARCH_LOG: c_int = 104;
-const ZSTD_C_MIN_MATCH: c_int = 105;
-const ZSTD_C_TARGET_LENGTH: c_int = 106;
-const ZSTD_C_STRATEGY: c_int = 107;
-
-/// Private compression-parameter modes from `zstd_compress_internal.h`.
-///
-/// They are ABI-compatible with `ZSTD_CParamMode_e` and intentionally kept as
-/// integer constants because that enum remains private C API for now.
-pub const ZSTD_RUST_CPM_NO_ATTACH_DICT: c_int = 0;
-pub const ZSTD_RUST_CPM_ATTACH_DICT: c_int = 1;
-pub const ZSTD_RUST_CPM_CREATE_CDICT: c_int = 2;
-pub const ZSTD_RUST_CPM_UNKNOWN: c_int = 3;
-
-/// `ZSTD_ParamSwitch_e` values used by the adjustment and sizing leaves.
-pub const ZSTD_RUST_PS_AUTO: c_int = 0;
-pub const ZSTD_RUST_PS_ENABLE: c_int = 1;
-pub const ZSTD_RUST_PS_DISABLE: c_int = 2;
-
-/// ABI-compatible `ZSTD_compressionParameters` from `zstd.h`.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct ZSTD_compressionParameters {
-    pub windowLog: u32,
-    pub chainLog: u32,
-    pub hashLog: u32,
-    pub searchLog: u32,
-    pub minMatch: u32,
-    pub targetLength: u32,
-    pub strategy: c_int,
-}
-
-/// ABI-compatible `ZSTD_frameParameters` from `zstd.h`.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct ZSTD_frameParameters {
-    pub contentSizeFlag: c_int,
-    pub checksumFlag: c_int,
-    pub noDictIDFlag: c_int,
-}
-
-/// ABI-compatible `ZSTD_parameters` from `zstd.h`.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct ZSTD_parameters {
-    pub cParams: ZSTD_compressionParameters,
-    pub fParams: ZSTD_frameParameters,
-}
-
-/// ABI-compatible `ZSTD_bounds` from `zstd.h`.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct ZSTD_bounds {
-    pub error: usize,
-    pub lowerBound: c_int,
-    pub upperBound: c_int,
-}
-
-/* `clevels.h`, represented as raw fields so the table stays compact and easy
- * to compare mechanically against its C source.  Field order is W, C, H, S,
- * L, TL, strategy. */
-const DEFAULT_CPARAMS: [[[u32; 7]; 23]; 4] = [
-    [
-        [19, 12, 13, 1, 6, 1, ZSTD_FAST as u32],
-        [19, 13, 14, 1, 7, 0, ZSTD_FAST as u32],
-        [20, 15, 16, 1, 6, 0, ZSTD_FAST as u32],
-        [21, 16, 17, 1, 5, 0, ZSTD_DFAST as u32],
-        [21, 18, 18, 1, 5, 0, ZSTD_DFAST as u32],
-        [21, 18, 19, 3, 5, 2, ZSTD_GREEDY as u32],
-        [21, 18, 19, 3, 5, 4, ZSTD_LAZY as u32],
-        [21, 19, 20, 4, 5, 8, ZSTD_LAZY as u32],
-        [21, 19, 20, 4, 5, 16, ZSTD_LAZY2 as u32],
-        [22, 20, 21, 4, 5, 16, ZSTD_LAZY2 as u32],
-        [22, 21, 22, 5, 5, 16, ZSTD_LAZY2 as u32],
-        [22, 21, 22, 6, 5, 16, ZSTD_LAZY2 as u32],
-        [22, 22, 23, 6, 5, 32, ZSTD_LAZY2 as u32],
-        [22, 22, 22, 4, 5, 32, ZSTD_BTLAZY2 as u32],
-        [22, 22, 23, 5, 5, 32, ZSTD_BTLAZY2 as u32],
-        [22, 23, 23, 6, 5, 32, ZSTD_BTLAZY2 as u32],
-        [22, 22, 22, 5, 5, 48, ZSTD_BTOPT as u32],
-        [23, 23, 22, 5, 4, 64, ZSTD_BTOPT as u32],
-        [23, 23, 22, 6, 3, 64, ZSTD_BTULTRA as u32],
-        [23, 24, 22, 7, 3, 256, ZSTD_BTULTRA2 as u32],
-        [25, 25, 23, 7, 3, 256, ZSTD_BTULTRA2 as u32],
-        [26, 26, 24, 7, 3, 512, ZSTD_BTULTRA2 as u32],
-        [27, 27, 25, 9, 3, 999, ZSTD_BTULTRA2 as u32],
-    ],
-    [
-        [18, 12, 13, 1, 5, 1, ZSTD_FAST as u32],
-        [18, 13, 14, 1, 6, 0, ZSTD_FAST as u32],
-        [18, 14, 14, 1, 5, 0, ZSTD_DFAST as u32],
-        [18, 16, 16, 1, 4, 0, ZSTD_DFAST as u32],
-        [18, 16, 17, 3, 5, 2, ZSTD_GREEDY as u32],
-        [18, 17, 18, 5, 5, 2, ZSTD_GREEDY as u32],
-        [18, 18, 19, 3, 5, 4, ZSTD_LAZY as u32],
-        [18, 18, 19, 4, 4, 4, ZSTD_LAZY as u32],
-        [18, 18, 19, 4, 4, 8, ZSTD_LAZY2 as u32],
-        [18, 18, 19, 5, 4, 8, ZSTD_LAZY2 as u32],
-        [18, 18, 19, 6, 4, 8, ZSTD_LAZY2 as u32],
-        [18, 18, 19, 5, 4, 12, ZSTD_BTLAZY2 as u32],
-        [18, 19, 19, 7, 4, 12, ZSTD_BTLAZY2 as u32],
-        [18, 18, 19, 4, 4, 16, ZSTD_BTOPT as u32],
-        [18, 18, 19, 4, 3, 32, ZSTD_BTOPT as u32],
-        [18, 18, 19, 6, 3, 128, ZSTD_BTOPT as u32],
-        [18, 19, 19, 6, 3, 128, ZSTD_BTULTRA as u32],
-        [18, 19, 19, 8, 3, 256, ZSTD_BTULTRA as u32],
-        [18, 19, 19, 6, 3, 128, ZSTD_BTULTRA2 as u32],
-        [18, 19, 19, 8, 3, 256, ZSTD_BTULTRA2 as u32],
-        [18, 19, 19, 10, 3, 512, ZSTD_BTULTRA2 as u32],
-        [18, 19, 19, 12, 3, 512, ZSTD_BTULTRA2 as u32],
-        [18, 19, 19, 13, 3, 999, ZSTD_BTULTRA2 as u32],
-    ],
-    [
-        [17, 12, 12, 1, 5, 1, ZSTD_FAST as u32],
-        [17, 12, 13, 1, 6, 0, ZSTD_FAST as u32],
-        [17, 13, 15, 1, 5, 0, ZSTD_FAST as u32],
-        [17, 15, 16, 2, 5, 0, ZSTD_DFAST as u32],
-        [17, 17, 17, 2, 4, 0, ZSTD_DFAST as u32],
-        [17, 16, 17, 3, 4, 2, ZSTD_GREEDY as u32],
-        [17, 16, 17, 3, 4, 4, ZSTD_LAZY as u32],
-        [17, 16, 17, 3, 4, 8, ZSTD_LAZY2 as u32],
-        [17, 16, 17, 4, 4, 8, ZSTD_LAZY2 as u32],
-        [17, 16, 17, 5, 4, 8, ZSTD_LAZY2 as u32],
-        [17, 16, 17, 6, 4, 8, ZSTD_LAZY2 as u32],
-        [17, 17, 17, 5, 4, 8, ZSTD_BTLAZY2 as u32],
-        [17, 18, 17, 7, 4, 12, ZSTD_BTLAZY2 as u32],
-        [17, 18, 17, 3, 4, 12, ZSTD_BTOPT as u32],
-        [17, 18, 17, 4, 3, 32, ZSTD_BTOPT as u32],
-        [17, 18, 17, 6, 3, 256, ZSTD_BTOPT as u32],
-        [17, 18, 17, 6, 3, 128, ZSTD_BTULTRA as u32],
-        [17, 18, 17, 8, 3, 256, ZSTD_BTULTRA as u32],
-        [17, 18, 17, 10, 3, 512, ZSTD_BTULTRA as u32],
-        [17, 18, 17, 5, 3, 256, ZSTD_BTULTRA2 as u32],
-        [17, 18, 17, 7, 3, 512, ZSTD_BTULTRA2 as u32],
-        [17, 18, 17, 9, 3, 512, ZSTD_BTULTRA2 as u32],
-        [17, 18, 17, 11, 3, 999, ZSTD_BTULTRA2 as u32],
-    ],
-    [
-        [14, 12, 13, 1, 5, 1, ZSTD_FAST as u32],
-        [14, 14, 15, 1, 5, 0, ZSTD_FAST as u32],
-        [14, 14, 15, 1, 4, 0, ZSTD_FAST as u32],
-        [14, 14, 15, 2, 4, 0, ZSTD_DFAST as u32],
-        [14, 14, 14, 4, 4, 2, ZSTD_GREEDY as u32],
-        [14, 14, 14, 3, 4, 4, ZSTD_LAZY as u32],
-        [14, 14, 14, 4, 4, 8, ZSTD_LAZY2 as u32],
-        [14, 14, 14, 6, 4, 8, ZSTD_LAZY2 as u32],
-        [14, 14, 14, 8, 4, 8, ZSTD_LAZY2 as u32],
-        [14, 15, 14, 5, 4, 8, ZSTD_BTLAZY2 as u32],
-        [14, 15, 14, 9, 4, 8, ZSTD_BTLAZY2 as u32],
-        [14, 15, 14, 3, 4, 12, ZSTD_BTOPT as u32],
-        [14, 15, 14, 4, 3, 24, ZSTD_BTOPT as u32],
-        [14, 15, 14, 5, 3, 32, ZSTD_BTULTRA as u32],
-        [14, 15, 15, 6, 3, 64, ZSTD_BTULTRA as u32],
-        [14, 15, 15, 7, 3, 256, ZSTD_BTULTRA as u32],
-        [14, 15, 15, 5, 3, 48, ZSTD_BTULTRA2 as u32],
-        [14, 15, 15, 6, 3, 128, ZSTD_BTULTRA2 as u32],
-        [14, 15, 15, 7, 3, 256, ZSTD_BTULTRA2 as u32],
-        [14, 15, 15, 8, 3, 256, ZSTD_BTULTRA2 as u32],
-        [14, 15, 15, 8, 3, 512, ZSTD_BTULTRA2 as u32],
-        [14, 15, 15, 9, 3, 512, ZSTD_BTULTRA2 as u32],
-        [14, 15, 15, 10, 3, 999, ZSTD_BTULTRA2 as u32],
-    ],
-];
-
-#[inline]
-fn cparams_from_row(row: [u32; 7]) -> ZSTD_compressionParameters {
-    ZSTD_compressionParameters {
-        windowLog: row[0],
-        chainLog: row[1],
-        hashLog: row[2],
-        searchLog: row[3],
-        minMatch: row[4],
-        targetLength: row[5],
-        strategy: row[6] as c_int,
-    }
-}
-
-#[inline]
-fn bounds(param: c_int) -> ZSTD_bounds {
-    let (lowerBound, upperBound) = match param {
-        ZSTD_C_COMPRESSION_LEVEL => (ZSTD_rust_params_minCLevel(), ZSTD_rust_params_maxCLevel()),
-        ZSTD_C_WINDOW_LOG => (ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX),
-        ZSTD_C_HASH_LOG => (ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX),
-        ZSTD_C_CHAIN_LOG => (ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX),
-        ZSTD_C_SEARCH_LOG => (ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX),
-        ZSTD_C_MIN_MATCH => (ZSTD_MINMATCH_MIN, ZSTD_MINMATCH_MAX),
-        ZSTD_C_TARGET_LENGTH => (ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX),
-        ZSTD_C_STRATEGY => (ZSTD_FAST, ZSTD_BTULTRA2),
-        _ => {
-            return ZSTD_bounds {
-                error: ERROR(ZstdErrorCode::ParameterUnsupported),
-                lowerBound: 0,
-                upperBound: 0,
-            }
-        }
-    };
-    ZSTD_bounds {
-        error: 0,
-        lowerBound,
-        upperBound,
-    }
-}
-
-#[inline]
-fn within_bounds(param: c_int, value: c_int) -> bool {
-    let bounds = bounds(param);
-    bounds.error == 0 && value >= bounds.lowerBound && value <= bounds.upperBound
-}
-
-#[inline]
-fn clamp_unsigned(value: u32, param: c_int) -> u32 {
-    let bounds = bounds(param);
-    debug_assert_eq!(bounds.error, 0);
-    let signed = value as c_int;
-    if signed < bounds.lowerBound {
-        bounds.lowerBound as u32
-    } else if signed > bounds.upperBound {
-        bounds.upperBound as u32
-    } else {
-        value
-    }
-}
-
-#[inline]
-fn clamp_cparams(mut cparams: ZSTD_compressionParameters) -> ZSTD_compressionParameters {
-    cparams.windowLog = clamp_unsigned(cparams.windowLog, ZSTD_C_WINDOW_LOG);
-    cparams.chainLog = clamp_unsigned(cparams.chainLog, ZSTD_C_CHAIN_LOG);
-    cparams.hashLog = clamp_unsigned(cparams.hashLog, ZSTD_C_HASH_LOG);
-    cparams.searchLog = clamp_unsigned(cparams.searchLog, ZSTD_C_SEARCH_LOG);
-    cparams.minMatch = clamp_unsigned(cparams.minMatch, ZSTD_C_MIN_MATCH);
-    cparams.targetLength = clamp_unsigned(cparams.targetLength, ZSTD_C_TARGET_LENGTH);
-    let strategy_bounds = bounds(ZSTD_C_STRATEGY);
-    if cparams.strategy < strategy_bounds.lowerBound {
-        cparams.strategy = strategy_bounds.lowerBound;
-    } else if cparams.strategy > strategy_bounds.upperBound {
-        cparams.strategy = strategy_bounds.upperBound;
-    }
-    cparams
-}
-
-#[inline]
-fn highbit32(value: u32) -> u32 {
-    debug_assert_ne!(value, 0);
-    u32::BITS - 1 - value.leading_zeros()
-}
-
-#[inline]
-fn cycle_log(hash_log: u32, strategy: c_int) -> u32 {
-    hash_log.wrapping_sub((strategy >= ZSTD_BTLAZY2) as u32)
-}
-
-#[inline]
-fn strategy_supports_row_match_finder(strategy: c_int) -> bool {
-    (ZSTD_GREEDY..=ZSTD_LAZY2).contains(&strategy)
-}
-
-#[inline]
-fn row_match_finder_used(strategy: c_int, mode: c_int) -> bool {
-    debug_assert_ne!(mode, ZSTD_RUST_PS_AUTO);
-    strategy_supports_row_match_finder(strategy) && mode == ZSTD_RUST_PS_ENABLE
-}
-
-#[inline]
-fn resolve_row_match_finder(mode: c_int, cparams: ZSTD_compressionParameters) -> c_int {
-    if mode != ZSTD_RUST_PS_AUTO {
-        return mode;
-    }
-    if strategy_supports_row_match_finder(cparams.strategy) && cparams.windowLog > 14 {
-        ZSTD_RUST_PS_ENABLE
-    } else {
-        ZSTD_RUST_PS_DISABLE
-    }
-}
-
-#[inline]
-fn dict_and_window_log(window_log: u32, src_size: u64, dict_size: u64) -> u32 {
-    /* 1ULL << ZSTD_WINDOWLOG_MAX, which is smaller for 32-bit builds. */
-    const MAX_WINDOW_SIZE: u64 = 1u64 << ZSTD_WINDOWLOG_MAX;
-    if dict_size == 0 {
-        return window_log;
-    }
-    debug_assert!(window_log <= ZSTD_WINDOWLOG_MAX as u32);
-    debug_assert_ne!(src_size, ZSTD_CONTENTSIZE_UNKNOWN);
-    let window_size = 1u64 << window_log;
-    if window_size >= dict_size.wrapping_add(src_size) {
-        window_log
-    } else {
-        let dict_and_window_size = dict_size.wrapping_add(window_size);
-        if dict_and_window_size >= MAX_WINDOW_SIZE {
-            ZSTD_WINDOWLOG_MAX as u32
-        } else {
-            highbit32((dict_and_window_size as u32).wrapping_sub(1)) + 1
-        }
-    }
-}
-
-/// Adjusts a *validated, configuration-resolved* parameter set.
-///
-/// This is the direct Rust leaf for `ZSTD_adjustCParams_internal()` after the
-/// C wrapper has applied its `ZSTD_EXCLUDE_*_BLOCK_COMPRESSOR` cascade.  In
-/// particular, it does not select a fallback strategy itself. `srcSize == 0`
-/// means a known empty input here, just as it does in the C internal helper;
-/// the public C wrapper must translate zero to `ZSTD_CONTENTSIZE_UNKNOWN`.
-fn adjust_cparams(
-    mut cparams: ZSTD_compressionParameters,
-    mut src_size: u64,
-    mut dict_size: usize,
-    mode: c_int,
-    mut use_row_match_finder: c_int,
-) -> ZSTD_compressionParameters {
-    debug_assert_eq!(check_cparams(cparams), 0);
-
-    const MIN_SRC_SIZE: u64 = 513;
-    /* 1ULL << (ZSTD_WINDOWLOG_MAX - 1), which is smaller for 32-bit builds. */
-    const MAX_WINDOW_RESIZE: u64 = 1u64 << (ZSTD_WINDOWLOG_MAX - 1);
-
-    match mode {
-        ZSTD_RUST_CPM_UNKNOWN | ZSTD_RUST_CPM_NO_ATTACH_DICT => {}
-        ZSTD_RUST_CPM_CREATE_CDICT => {
-            if dict_size != 0 && src_size == ZSTD_CONTENTSIZE_UNKNOWN {
-                src_size = MIN_SRC_SIZE;
-            }
-        }
-        ZSTD_RUST_CPM_ATTACH_DICT => dict_size = 0,
-        _ => debug_assert!(false, "invalid ZSTD_CParamMode_e"),
-    }
-
-    if src_size <= MAX_WINDOW_RESIZE && (dict_size as u64) <= MAX_WINDOW_RESIZE {
-        let total_size = src_size.wrapping_add(dict_size as u64) as u32;
-        let hash_size_min = 1u32 << ZSTD_HASHLOG_MIN;
-        let src_log = if total_size < hash_size_min {
-            ZSTD_HASHLOG_MIN as u32
-        } else {
-            highbit32(total_size.wrapping_sub(1)) + 1
-        };
-        cparams.windowLog = cparams.windowLog.min(src_log);
-    }
-
-    if src_size != ZSTD_CONTENTSIZE_UNKNOWN {
-        let dict_and_window_log =
-            dict_and_window_log(cparams.windowLog, src_size, dict_size as u64);
-        let cycle_log = cycle_log(cparams.chainLog, cparams.strategy);
-        cparams.hashLog = cparams.hashLog.min(dict_and_window_log + 1);
-        if cycle_log > dict_and_window_log {
-            cparams.chainLog = cparams
-                .chainLog
-                .wrapping_sub(cycle_log - dict_and_window_log);
-        }
-    }
-
-    cparams.windowLog = cparams.windowLog.max(ZSTD_WINDOWLOG_MIN as u32);
-
-    /* The short-cache tags used for fast and dfast CDicts consume eight bits
-     * of each 32-bit index.  This is a fixed private-header constant today;
-     * if it becomes configurable, the C shim must pass it as an explicit
-     * adjustment input rather than silently changing this leaf. */
-    if mode == ZSTD_RUST_CPM_CREATE_CDICT
-        && (cparams.strategy == ZSTD_FAST || cparams.strategy == ZSTD_DFAST)
-    {
-        const SHORT_CACHE_TAG_BITS: u32 = 8;
-        let max_short_cache_hash_log = 32 - SHORT_CACHE_TAG_BITS;
-        cparams.hashLog = cparams.hashLog.min(max_short_cache_hash_log);
-        cparams.chainLog = cparams.chainLog.min(max_short_cache_hash_log);
-    }
-
-    if use_row_match_finder == ZSTD_RUST_PS_AUTO {
-        use_row_match_finder = ZSTD_RUST_PS_ENABLE;
-    }
-    if row_match_finder_used(cparams.strategy, use_row_match_finder) {
-        const ROW_HASH_TAG_BITS: u32 = 8;
-        let row_log = cparams.searchLog.clamp(4, 6);
-        let max_hash_log = (32 - ROW_HASH_TAG_BITS) + row_log;
-        debug_assert!(cparams.hashLog >= row_log);
-        cparams.hashLog = cparams.hashLog.min(max_hash_log);
-    }
-
-    cparams
-}
-
-#[inline]
-fn get_cparam_row_size(src_size_hint: u64, dict_size: usize, mode: c_int) -> u64 {
-    let mut dict_size = dict_size as u64;
-    match mode {
-        ZSTD_RUST_CPM_UNKNOWN | ZSTD_RUST_CPM_NO_ATTACH_DICT | ZSTD_RUST_CPM_CREATE_CDICT => {}
-        ZSTD_RUST_CPM_ATTACH_DICT => dict_size = 0,
-        _ => debug_assert!(false, "invalid ZSTD_CParamMode_e"),
-    }
-    let unknown = src_size_hint == ZSTD_CONTENTSIZE_UNKNOWN;
-    let added_size = if unknown && dict_size > 0 { 500 } else { 0 };
-    if unknown && dict_size == 0 {
-        ZSTD_CONTENTSIZE_UNKNOWN
-    } else {
-        src_size_hint
-            .wrapping_add(dict_size)
-            .wrapping_add(added_size)
-    }
-}
-
-/// Selects a raw compression-level-table entry, without strategy cascading or
-/// source/dictionary adjustment.
-///
-/// A C wrapper must apply its active excluded-compressor cascade to the
-/// returned strategy before calling [`ZSTD_rust_params_adjustCParams`].
-fn select_cparams(
-    compression_level: c_int,
-    src_size_hint: u64,
-    dict_size: usize,
-    mode: c_int,
-) -> ZSTD_compressionParameters {
-    let row_size = get_cparam_row_size(src_size_hint, dict_size, mode);
-    let table_id = usize::from(row_size <= 256 * 1024)
-        + usize::from(row_size <= 128 * 1024)
-        + usize::from(row_size <= 16 * 1024);
-    let row = if compression_level == 0 {
-        ZSTD_CLEVEL_DEFAULT
-    } else if compression_level < 0 {
-        0
-    } else {
-        compression_level.min(ZSTD_MAX_CLEVEL)
-    } as usize;
-
-    let mut cparams = cparams_from_row(DEFAULT_CPARAMS[table_id][row]);
-    if compression_level < 0 {
-        let clamped = compression_level.max(ZSTD_rust_params_minCLevel());
-        cparams.targetLength = (-clamped) as u32;
-    }
-    cparams
-}
-
-#[inline]
-fn make_params(cparams: ZSTD_compressionParameters) -> ZSTD_parameters {
-    ZSTD_parameters {
-        cParams: cparams,
-        fParams: ZSTD_frameParameters {
-            contentSizeFlag: 1,
-            checksumFlag: 0,
-            noDictIDFlag: 0,
-        },
-    }
-}
-
-#[inline]
-fn check_cparams(cparams: ZSTD_compressionParameters) -> usize {
-    if !within_bounds(ZSTD_C_WINDOW_LOG, cparams.windowLog as c_int)
-        || !within_bounds(ZSTD_C_CHAIN_LOG, cparams.chainLog as c_int)
-        || !within_bounds(ZSTD_C_HASH_LOG, cparams.hashLog as c_int)
-        || !within_bounds(ZSTD_C_SEARCH_LOG, cparams.searchLog as c_int)
-        || !within_bounds(ZSTD_C_MIN_MATCH, cparams.minMatch as c_int)
-        || !within_bounds(ZSTD_C_TARGET_LENGTH, cparams.targetLength as c_int)
-        || !within_bounds(ZSTD_C_STRATEGY, cparams.strategy)
-    {
-        ERROR(ZstdErrorCode::ParameterOutOfBound)
-    } else {
-        0
-    }
-}
-
-/// Returns the highest table-backed compression level (`ZSTD_MAX_CLEVEL`).
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_maxCLevel() -> c_int {
-    ZSTD_MAX_CLEVEL
-}
-
-/// Returns the lowest public fast level (`-ZSTD_TARGETLENGTH_MAX`).
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_minCLevel() -> c_int {
-    -ZSTD_TARGETLENGTH_MAX
-}
-
-/// Returns the default compression level from `zstd.h`.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_defaultCLevel() -> c_int {
-    ZSTD_CLEVEL_DEFAULT
-}
-
-/// Returns bounds for the seven core compression parameters and compression
-/// level.  Other `ZSTD_cParameter` cases remain C-owned.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_getBounds(param: c_int) -> ZSTD_bounds {
-    bounds(param)
-}
-
-/// Checks the seven fields of `ZSTD_compressionParameters`.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_checkCParams(cparams: ZSTD_compressionParameters) -> usize {
-    check_cparams(cparams)
-}
-
-/// Clamps the seven fields of `ZSTD_compressionParameters` to public bounds.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_clampCParams(
-    cparams: ZSTD_compressionParameters,
-) -> ZSTD_compressionParameters {
-    clamp_cparams(cparams)
-}
-
-/// C ABI for `ZSTD_cycleLog()`.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_cycleLog(hashLog: u32, strategy: c_int) -> u32 {
-    cycle_log(hashLog, strategy)
-}
-
-/// C ABI for private `ZSTD_getCParamRowSize()`.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_getCParamRowSize(
-    srcSizeHint: u64,
-    dictSize: usize,
-    mode: c_int,
-) -> u64 {
-    get_cparam_row_size(srcSizeHint, dictSize, mode)
-}
-
-/// Returns the unadjusted compression-level-table entry.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_selectCParams(
-    compressionLevel: c_int,
-    srcSizeHint: u64,
-    dictSize: usize,
-    mode: c_int,
-) -> ZSTD_compressionParameters {
-    select_cparams(compressionLevel, srcSizeHint, dictSize, mode)
-}
-
-/// Adjusts a validated, strategy-resolved C parameter set.
-///
-/// See [`adjust_cparams`] for the required C-side policy step.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_adjustCParams(
-    cparams: ZSTD_compressionParameters,
-    srcSize: u64,
-    dictSize: usize,
-    mode: c_int,
-    useRowMatchFinder: c_int,
-) -> ZSTD_compressionParameters {
-    adjust_cparams(cparams, srcSize, dictSize, mode, useRowMatchFinder)
-}
-
-/// Builds `ZSTD_parameters` with the public default frame parameters.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_makeParams(
-    cparams: ZSTD_compressionParameters,
-) -> ZSTD_parameters {
-    make_params(cparams)
-}
-
-/// Runtime sizes needed to reproduce `ZSTD_sizeof_matchState()` without
-/// exposing private C structures to Rust.
-///
-/// `asanRedzoneSize` is `ZSTD_CWKSP_ASAN_REDZONE_SIZE` when workspace
-/// poisoning is enabled and zero otherwise. `matchTSize` and `optimalTSize`
-/// must be `sizeof(ZSTD_match_t)` and `sizeof(ZSTD_optimal_t)` respectively.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default)]
-pub struct ZSTD_rustMatchStateSizing {
-    pub hashLog3Max: u32,
-    pub matchTSize: usize,
-    pub optimalTSize: usize,
-    pub asanRedzoneSize: usize,
-}
-
-/// C-only layout inputs for `ZSTD_estimateCDictSize_advanced()`.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default)]
-pub struct ZSTD_rustCDictSizing {
-    pub cdictSize: usize,
-    pub hufWorkspaceSize: usize,
-    pub hashLog3Max: u32,
-    pub matchTSize: usize,
-    pub optimalTSize: usize,
-    pub asanRedzoneSize: usize,
-}
-
-#[inline]
-fn cwksp_alloc_size(size: usize, asan_redzone_size: usize) -> usize {
-    if size == 0 {
-        0
-    } else {
-        size.wrapping_add(asan_redzone_size.wrapping_mul(2))
-    }
-}
-
-#[inline]
-fn cwksp_align(size: usize, alignment: usize) -> usize {
-    debug_assert!(alignment.is_power_of_two());
-    size.wrapping_add(alignment - 1) & !(alignment - 1)
-}
-
-#[inline]
-fn cwksp_aligned64_alloc_size(size: usize, asan_redzone_size: usize) -> usize {
-    cwksp_alloc_size(cwksp_align(size, 64), asan_redzone_size)
-}
-
-#[inline]
-fn shift_size(log: u32) -> usize {
-    debug_assert!(log < usize::BITS);
-    1usize << log
-}
-
-#[inline]
-fn allocate_chain_table(strategy: c_int, use_row_match_finder: c_int, for_dds_dict: bool) -> bool {
-    for_dds_dict
-        || (strategy != ZSTD_FAST && !row_match_finder_used(strategy, use_row_match_finder))
-}
-
-fn estimate_match_state_size(
-    cparams: ZSTD_compressionParameters,
-    use_row_match_finder: c_int,
-    enable_dedicated_dict_search: bool,
-    for_cctx: bool,
-    sizing: ZSTD_rustMatchStateSizing,
-) -> usize {
-    if check_cparams(cparams) != 0 || use_row_match_finder == ZSTD_RUST_PS_AUTO {
-        return 0;
-    }
-
-    let chain_size = if allocate_chain_table(
-        cparams.strategy,
-        use_row_match_finder,
-        enable_dedicated_dict_search && !for_cctx,
-    ) {
-        shift_size(cparams.chainLog)
-    } else {
-        0
-    };
-    let hash_size = shift_size(cparams.hashLog);
-    let hash_log_3 = if for_cctx && cparams.minMatch == 3 {
-        cparams.windowLog.min(sizing.hashLog3Max)
-    } else {
-        0
-    };
-    let hash3_size = if hash_log_3 == 0 {
-        0
-    } else {
-        shift_size(hash_log_3)
-    };
-    let table_space = chain_size
-        .wrapping_mul(size_of::<u32>())
-        .wrapping_add(hash_size.wrapping_mul(size_of::<u32>()))
-        .wrapping_add(hash3_size.wrapping_mul(size_of::<u32>()));
-
-    let redzone = sizing.asanRedzoneSize;
-    let opt_potential_space = cwksp_aligned64_alloc_size((52 + 1) * size_of::<u32>(), redzone)
-        .wrapping_add(cwksp_aligned64_alloc_size(
-            (35 + 1) * size_of::<u32>(),
-            redzone,
-        ))
-        .wrapping_add(cwksp_aligned64_alloc_size(
-            (31 + 1) * size_of::<u32>(),
-            redzone,
-        ))
-        .wrapping_add(cwksp_aligned64_alloc_size(
-            (1 << 8) * size_of::<u32>(),
-            redzone,
-        ))
-        .wrapping_add(cwksp_aligned64_alloc_size(
-            4099usize.wrapping_mul(sizing.matchTSize),
-            redzone,
-        ))
-        .wrapping_add(cwksp_aligned64_alloc_size(
-            4099usize.wrapping_mul(sizing.optimalTSize),
-            redzone,
-        ));
-    let lazy_additional_space = if row_match_finder_used(cparams.strategy, use_row_match_finder) {
-        cwksp_aligned64_alloc_size(hash_size, redzone)
-    } else {
-        0
-    };
-    let opt_space = if for_cctx && cparams.strategy >= ZSTD_BTOPT {
-        opt_potential_space
-    } else {
-        0
-    };
-    let slack_space = 2 * 64;
-
-    table_space
-        .wrapping_add(opt_space)
-        .wrapping_add(slack_space)
-        .wrapping_add(lazy_additional_space)
-}
-
-/// Pure leaf for private `ZSTD_sizeof_matchState()`.
-///
-/// `useRowMatchFinder` must already be resolved to enable or disable.  A NULL
-/// `sizing` pointer or invalid C parameters returns zero; C never supplies
-/// either in a valid estimator call.
-#[no_mangle]
-pub unsafe extern "C" fn ZSTD_rust_params_estimateMatchStateSize(
-    cparams: ZSTD_compressionParameters,
-    useRowMatchFinder: c_int,
-    enableDedicatedDictSearch: c_int,
-    forCCtx: u32,
-    sizing: *const ZSTD_rustMatchStateSizing,
-) -> usize {
-    if sizing.is_null() {
-        return 0;
-    }
-    let sizing = unsafe { *sizing };
-    estimate_match_state_size(
-        cparams,
-        useRowMatchFinder,
-        enableDedicatedDictSearch != 0,
-        forCCtx != 0,
-        sizing,
-    )
-}
-
-#[inline]
-fn max_nb_seq(block_size: usize, min_match: u32, use_sequence_producer: bool) -> usize {
-    let divider = if min_match == 3 || use_sequence_producer {
-        3
-    } else {
-        4
-    };
-    block_size / divider
-}
-
-/// Pure leaf for private `ZSTD_maxNbSeq()`.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_maxNbSeq(
-    blockSize: usize,
-    minMatch: u32,
-    useSequenceProducer: c_int,
-) -> usize {
-    max_nb_seq(blockSize, minMatch, useSequenceProducer != 0)
-}
-
-/// Pure leaf for private `ZSTD_resolveMaxBlockSize()`.
-#[no_mangle]
-pub extern "C" fn ZSTD_rust_params_resolveMaxBlockSize(maxBlockSize: usize) -> usize {
-    if maxBlockSize == 0 {
-        ZSTD_BLOCKSIZE_MAX
-    } else {
-        maxBlockSize
-    }
-}
-
-fn estimate_cdict_size_from_cparams(
-    dict_size: usize,
-    cparams: ZSTD_compressionParameters,
-    dict_load_method: c_int,
-    sizing: ZSTD_rustCDictSizing,
-) -> usize {
-    if check_cparams(cparams) != 0 {
-        return 0;
-    }
-    let match_state_sizing = ZSTD_rustMatchStateSizing {
-        hashLog3Max: sizing.hashLog3Max,
-        matchTSize: sizing.matchTSize,
-        optimalTSize: sizing.optimalTSize,
-        asanRedzoneSize: sizing.asanRedzoneSize,
-    };
-    let row_match_finder = resolve_row_match_finder(ZSTD_RUST_PS_AUTO, cparams);
-    let copied_dict_space = if dict_load_method == 1 {
-        0
-    } else {
-        cwksp_alloc_size(
-            cwksp_align(dict_size, size_of::<usize>()),
-            sizing.asanRedzoneSize,
-        )
-    };
-    cwksp_alloc_size(sizing.cdictSize, sizing.asanRedzoneSize)
-        .wrapping_add(cwksp_alloc_size(
-            sizing.hufWorkspaceSize,
-            sizing.asanRedzoneSize,
-        ))
-        .wrapping_add(estimate_match_state_size(
-            cparams,
-            row_match_finder,
-            true,
-            false,
-            match_state_sizing,
-        ))
-        .wrapping_add(copied_dict_space)
-}
-
-/// Parameter-only leaf for `ZSTD_estimateCDictSize_advanced()`.
-///
-/// C retains ownership of `sizeof(ZSTD_CDict)`, HUF workspace configuration,
-/// and sanitizer workspace policy, then passes them in `sizing`. A NULL sizing
-/// pointer returns zero.
-#[no_mangle]
-pub unsafe extern "C" fn ZSTD_rust_params_estimateCDictSizeFromCParams(
-    dictSize: usize,
-    cparams: ZSTD_compressionParameters,
-    dictLoadMethod: c_int,
-    sizing: *const ZSTD_rustCDictSizing,
-) -> usize {
-    if sizing.is_null() {
-        return 0;
-    }
-    estimate_cdict_size_from_cparams(dictSize, cparams, dictLoadMethod, unsafe { *sizing })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::errors::ERR_isError;
-    use std::mem::{align_of, size_of};
-
-    fn adjust_public(
-        cparams: ZSTD_compressionParameters,
-        src_size: u64,
-        dict_size: usize,
-    ) -> ZSTD_compressionParameters {
-        let src_size = if src_size == 0 {
-            ZSTD_CONTENTSIZE_UNKNOWN
-        } else {
-            src_size
-        };
-        adjust_cparams(
-            clamp_cparams(cparams),
-            src_size,
-            dict_size,
-            ZSTD_RUST_CPM_UNKNOWN,
-            ZSTD_RUST_PS_AUTO,
-        )
-    }
-
-    #[test]
-    fn abi_parameter_layouts_match_zstd_h() {
-        assert_eq!(
-            size_of::<ZSTD_compressionParameters>(),
-            7 * size_of::<u32>()
-        );
-        assert_eq!(align_of::<ZSTD_compressionParameters>(), align_of::<u32>());
-        assert_eq!(size_of::<ZSTD_frameParameters>(), 3 * size_of::<c_int>());
-        assert_eq!(size_of::<ZSTD_parameters>(), 10 * size_of::<u32>());
-        assert_eq!(
-            size_of::<ZSTD_bounds>(),
-            size_of::<usize>() + 2 * size_of::<c_int>()
-        );
-    }
-
-    #[test]
-    fn level_tables_match_representative_clevels_entries() {
-        let large = select_cparams(3, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
-        assert_eq!(
-            large,
-            ZSTD_compressionParameters {
-                windowLog: 21,
-                chainLog: 16,
-                hashLog: 17,
-                searchLog: 1,
-                minMatch: 5,
-                targetLength: 0,
-                strategy: ZSTD_DFAST,
-            }
-        );
-
-        let small = select_cparams(3, 16 * 1024, 0, ZSTD_RUST_CPM_UNKNOWN);
-        assert_eq!(
-            small,
-            ZSTD_compressionParameters {
-                windowLog: 14,
-                chainLog: 14,
-                hashLog: 15,
-                searchLog: 2,
-                minMatch: 4,
-                targetLength: 0,
-                strategy: ZSTD_DFAST,
-            }
-        );
-
-        let fast = select_cparams(-5, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
-        assert_eq!(fast.strategy, ZSTD_FAST);
-        assert_eq!(fast.targetLength, 5);
-        assert_eq!(
-            select_cparams(999, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN),
-            select_cparams(22, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN)
-        );
-    }
-
-    #[test]
-    fn adjustment_clamps_and_downsizes_like_the_c_leaf() {
-        let input = ZSTD_compressionParameters {
-            windowLog: 31,
-            chainLog: 30,
-            hashLog: 30,
-            searchLog: 1,
-            minMatch: 3,
-            targetLength: 0,
-            strategy: ZSTD_BTOPT,
-        };
-        let adjusted = adjust_public(input, 1, 0);
-        assert_eq!(adjusted.windowLog, 10);
-        /* C applies WINDOWLOG_ABSOLUTEMIN only after it has used the smaller
-         * temporary window to downsize the hash and chain logs. */
-        assert_eq!(adjusted.hashLog, 7);
-        assert_eq!(adjusted.chainLog, 7);
-        assert_eq!(ZSTD_rust_params_checkCParams(adjusted), 0);
-
-        let clamped = ZSTD_rust_params_clampCParams(ZSTD_compressionParameters {
-            windowLog: u32::MAX,
-            chainLog: 0,
-            hashLog: 0,
-            searchLog: 0,
-            minMatch: 0,
-            targetLength: u32::MAX,
-            strategy: 99,
-        });
-        assert_eq!(clamped.windowLog, ZSTD_WINDOWLOG_MIN as u32);
-        assert_eq!(clamped.chainLog, ZSTD_CHAINLOG_MIN as u32);
-        assert_eq!(clamped.hashLog, ZSTD_HASHLOG_MIN as u32);
-        assert_eq!(clamped.searchLog, ZSTD_SEARCHLOG_MIN as u32);
-        assert_eq!(clamped.minMatch, ZSTD_MINMATCH_MIN as u32);
-        assert_eq!(clamped.targetLength, ZSTD_TARGETLENGTH_MIN as u32);
-        assert_eq!(clamped.strategy, ZSTD_BTULTRA2);
-    }
-
-    #[test]
-    fn checking_and_bounds_preserve_the_public_error_contract() {
-        let valid = select_cparams(1, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
-        assert_eq!(check_cparams(valid), 0);
-        let mut invalid = valid;
-        invalid.minMatch = 2;
-        assert!(ERR_isError(check_cparams(invalid)));
-        let bounds = ZSTD_rust_params_getBounds(ZSTD_C_HASH_LOG);
-        assert_eq!(bounds.error, 0);
-        assert_eq!(bounds.lowerBound, 6);
-        assert_eq!(bounds.upperBound, 30);
-        assert!(ERR_isError(ZSTD_rust_params_getBounds(-1).error));
-    }
-
-    #[test]
-    fn params_default_frame_flags_match_c() {
-        let cparams = select_cparams(5, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
-        let params = ZSTD_rust_params_makeParams(cparams);
-        assert_eq!(params.cParams, cparams);
-        assert_eq!(params.fParams.contentSizeFlag, 1);
-        assert_eq!(params.fParams.checksumFlag, 0);
-        assert_eq!(params.fParams.noDictIDFlag, 0);
-    }
-
-    #[test]
-    fn row_size_preserves_unknown_dictionary_overflow_semantics() {
-        assert_eq!(
-            get_cparam_row_size(ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN),
-            ZSTD_CONTENTSIZE_UNKNOWN
-        );
-        assert_eq!(
-            get_cparam_row_size(ZSTD_CONTENTSIZE_UNKNOWN, 1, ZSTD_RUST_CPM_UNKNOWN),
-            500
-        );
-        assert_eq!(
-            get_cparam_row_size(128 * 1024, 1, ZSTD_RUST_CPM_ATTACH_DICT),
-            128 * 1024
-        );
-    }
-
-    #[test]
-    fn match_state_sizing_reproduces_table_and_row_rules() {
-        let sizing = ZSTD_rustMatchStateSizing {
-            hashLog3Max: 17,
-            matchTSize: 16,
-            optimalTSize: 32,
-            asanRedzoneSize: 0,
-        };
-        let fast = ZSTD_compressionParameters {
-            windowLog: 10,
-            chainLog: 10,
-            hashLog: 10,
-            searchLog: 1,
-            minMatch: 4,
-            targetLength: 0,
-            strategy: ZSTD_FAST,
-        };
-        assert_eq!(
-            estimate_match_state_size(fast, ZSTD_RUST_PS_DISABLE, false, true, sizing),
-            4096 + 128
-        );
-
-        let row = ZSTD_compressionParameters {
-            windowLog: 15,
-            chainLog: 10,
-            hashLog: 10,
-            searchLog: 4,
-            minMatch: 4,
-            targetLength: 0,
-            strategy: ZSTD_GREEDY,
-        };
-        assert_eq!(
-            estimate_match_state_size(row, ZSTD_RUST_PS_ENABLE, false, true, sizing),
-            4096 + 1024 + 128
-        );
-        assert_eq!(ZSTD_rust_params_maxNbSeq(100, 3, 0), 33);
-        assert_eq!(ZSTD_rust_params_maxNbSeq(100, 4, 0), 25);
-        assert_eq!(ZSTD_rust_params_resolveMaxBlockSize(0), 128 * 1024);
-    }
-}

tests/Makefile

@@ -91,6 +91,28 @@ $(RUST_STATICLIB): $(RUST_SOURCES)
 $(RUST_STATICLIB_32): $(RUST_SOURCES)
 	$(CARGO) build $(RUST_CARGO_FLAGS) --target $(RUST_TARGET_32)
 
+# Program-only helpers that were C sources shared with the tests (timefn,
+# benchfn) now live in the Rust CLI package. The tests link a helpers-only
+# archive, built without the `cli` feature: the parser/dispatch layer needs
+# the C fileio backend, which test binaries do not provide.
+RUST_CLI_DIR := $(RUST_DIR)/cli
+RUST_CLI_MANIFEST := $(RUST_CLI_DIR)/Cargo.toml
+RUST_CLI_HELPER_SOURCES := $(RUST_CLI_MANIFEST) $(RUST_CLI_DIR)/Cargo.lock \
+                           $(RUST_CLI_DIR)/src/lib.rs \
+                           $(RUST_DIR)/src/timefn.rs $(RUST_DIR)/src/benchfn.rs
+RUST_CLI_HELPERS_TARGET_DIR := $(RUST_DIR)/target/cli-helpers
+RUST_CLI_HELPERS_STATICLIB := $(RUST_CLI_HELPERS_TARGET_DIR)/release/libzstd_cli_rs.a
+RUST_CLI_HELPERS_STATICLIB_32 := $(RUST_CLI_HELPERS_TARGET_DIR)/$(RUST_TARGET_32)/release/libzstd_cli_rs.a
+RUST_CLI_HELPERS_CARGO_FLAGS := --manifest-path $(RUST_CLI_MANIFEST) --release \
+                                --target-dir $(RUST_CLI_HELPERS_TARGET_DIR) \
+                                --no-default-features
+
+$(RUST_CLI_HELPERS_STATICLIB): $(RUST_CLI_HELPER_SOURCES)
+	$(CARGO) build $(RUST_CLI_HELPERS_CARGO_FLAGS)
+
+$(RUST_CLI_HELPERS_STATICLIB_32): $(RUST_CLI_HELPER_SOURCES)
+	$(CARGO) build $(RUST_CLI_HELPERS_CARGO_FLAGS) --target $(RUST_TARGET_32)
+
 # These test objects have flat filenames, unlike the configuration-hashed
 # program objects. Track the HUF mode separately so a C object set compiled
 # for one decoder is never relinked with a Rust archive for another decoder.
@@ -250,8 +272,8 @@ fuzzer32 : $(ZSTD_FILES)
 	$(LINK.c) $^ -o $@$(EXT)
 
 # note : broken : requires symbols unavailable from dynamic library
-fuzzer-dll : $(LIB_SRCDIR)/common/xxhash.c $(PRGDIR)/util.c $(PRGDIR)/timefn.c $(PRGDIR)/datagen.c fuzzer.c
-	$(CC) $(CPPFLAGS) $(CFLAGS) $(filter %.c,$^) $(LDFLAGS) -o $@$(EXT)
+fuzzer-dll : $(LIB_SRCDIR)/common/xxhash.c $(PRGDIR)/util.c $(PRGDIR)/timefn.c $(PRGDIR)/datagen.c fuzzer.c $(RUST_CLI_HELPERS_STATICLIB)
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(filter %.c,$^) $(RUST_CLI_HELPERS_STATICLIB) $(LDFLAGS) -o $@$(EXT)
 
 CLEAN += zstreamtest zstreamtest32
 ZSTREAM_LOCAL_FILES := $(PRGDIR)/datagen.c $(PRGDIR)/util.c $(PRGDIR)/timefn.c seqgen.c zstreamtest.c external_matchfinder.c
@@ -282,8 +304,8 @@ zstreamtest_ubsan : $(ZSTREAMFILES)
 
 # note : broken : requires symbols unavailable from dynamic library
 zstreamtest-dll : $(LIB_SRCDIR)/common/xxhash.c  # xxh symbols not exposed from dll
-zstreamtest-dll : $(ZSTREAM_LOCAL_FILES)
-	$(CC) $(CPPFLAGS) $(CFLAGS) $(filter %.c,$^) $(LDFLAGS) -o $@$(EXT)
+zstreamtest-dll : $(ZSTREAM_LOCAL_FILES) $(RUST_CLI_HELPERS_STATICLIB)
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(filter %.c,$^) $(RUST_CLI_HELPERS_STATICLIB) $(LDFLAGS) -o $@$(EXT)
 
 CLEAN += paramgrill
 paramgrill : DEBUGFLAGS =   # turn off debug for speed measurements
@@ -342,6 +364,17 @@ $(RUST_LINK_TARGETS_32): $(RUST_STATICLIB_32)
 
 $(RUST_LINK_TARGETS) $(RUST_LINK_TARGETS_32): $(RUST_HUF_C_MODE_STAMP)
 
+# Tests that compile the timefn/benchfn C shims also link the Rust CLI
+# helpers archive, which owns those implementations. The archive is a
+# prerequisite so `$^` places it after every C object referencing its symbols.
+RUST_CLI_LINK_TARGETS := fullbench fullbench-lib fullbench-dll fuzzer \
+                         zstreamtest zstreamtest_asan zstreamtest_tsan \
+                         zstreamtest_ubsan paramgrill decodecorpus poolTests
+$(RUST_CLI_LINK_TARGETS): $(RUST_CLI_HELPERS_STATICLIB)
+
+RUST_CLI_LINK_TARGETS_32 := fullbench32 fuzzer32 zstreamtest32
+$(RUST_CLI_LINK_TARGETS_32): $(RUST_CLI_HELPERS_STATICLIB_32)
+
 .PHONY: versionsTest
 versionsTest: clean
 	$(PYTHON) test-zstd-versions.py