ddidderr/zstd-rs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
896397f729a016c060f2a4f44188fb945f2eee01
zstd-rs/rust/src/zstd_compress_params.rs
T
ddidderr 7867f64413 feat(params): move context-free getters into Rust 
Compression-parameter table selection and adjustment were already implemented
as Rust leaves, but the internal and public ZSTD_getCParams/ZSTD_getParams
helpers still assembled those results in the C translation unit. That left
source-size and dictionary-mode policy duplicated at the C/Rust boundary.

Add Rust implementations for the internal and public getter policies. The
internal helpers preserve a zero source size as a known empty input, while the
public helpers retain the API rule that zero means unknown. The C side keeps
only the build-specific exclusion-mask construction and thin ABI adapters, so
reduced builds continue to select the same available strategy cascade.

Test Plan:
- `cargo test --manifest-path rust/Cargo.toml --lib -- --test-threads=1`
  -- passed (411 tests).
- `cargo clippy --manifest-path rust/Cargo.toml --lib -- -D warnings`
  -- passed.
- `cargo +nightly fmt --manifest-path rust/Cargo.toml -- --check` -- passed.
- `make -B -C lib -j2 lib` -- passed.
- Focused tests cover public zero-to-unknown translation, internal zero
  semantics, default frame parameters, and dictionary attachment modes.
2026-07-18 18:43:00 +02:00

2659 lines
84 KiB
Rust
Raw Blame History

#![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.
//!
//! The public `ZSTD_*` symbols remain C-owned thin adapters. Rust owns the
//! context-free getter policy behind scalar ABI functions. `zstd_compress.c`
//! still owns configuration-sensitive policy: private `ZSTD_CCtx_params`
//! layouts, the C-preprocessor construction of excluded block-compressor
//! bits, LDM workspace sizing, and ASAN workspace policy. The Rust policy
//! leaves receive those build values as explicit scalar inputs, retaining
//! byte-for-byte C behavior for reduced builds without exposing private C
//! state across the ABI.
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_LAZY_DDSS_BUCKET_LOG: u32 = 2;
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;
/* Build-policy bits supplied by the C shim. C preprocessor configuration
* stays on the C side; the bit positions are the ABI between the shim and
* this pure strategy cascade. */
const ZSTD_RUST_EXCLUDE_BTULTRA: u32 = 1 << 0;
const ZSTD_RUST_EXCLUDE_BTOPT: u32 = 1 << 1;
const ZSTD_RUST_EXCLUDE_BTLAZY2: u32 = 1 << 2;
const ZSTD_RUST_EXCLUDE_LAZY2: u32 = 1 << 3;
const ZSTD_RUST_EXCLUDE_LAZY: u32 = 1 << 4;
const ZSTD_RUST_EXCLUDE_GREEDY: u32 = 1 << 5;
const ZSTD_RUST_EXCLUDE_DFAST: u32 = 1 << 6;
const ZSTD_DICT_FORCE_ATTACH: c_int = 1;
const ZSTD_DICT_FORCE_COPY: c_int = 2;
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
}
/// C ABI for `ZSTD_rowMatchFinderSupported()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_rowMatchFinderSupported(strategy: c_int) -> c_int {
c_int::from(strategy_supports_row_match_finder(strategy))
}
/// C ABI for `ZSTD_rowMatchFinderUsed()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_rowMatchFinderUsed(strategy: c_int, mode: c_int) -> c_int {
c_int::from(row_match_finder_used(strategy, mode))
}
#[inline]
fn select_block_compressor(strategy: c_int, mode: c_int) -> c_int {
debug_assert!((ZSTD_FAST..=ZSTD_BTULTRA2).contains(&strategy));
if row_match_finder_used(strategy, mode) {
strategy - ZSTD_GREEDY
} else {
3 + strategy
}
}
/// Returns the C block-compressor table index encoding.
///
/// Row-based entries use indices 0..2. The ordinary table uses the strategy
/// index after the C caller subtracts 3 from the returned value.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_selectBlockCompressor(strategy: c_int, mode: c_int) -> c_int {
select_block_compressor(strategy, mode)
}
#[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
}
}
/// C ABI for `ZSTD_resolveRowMatchFinderMode()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_resolveRowMatchFinderMode(
mode: c_int,
cparams: ZSTD_compressionParameters,
) -> c_int {
resolve_row_match_finder(mode, cparams)
}
#[inline]
fn resolve_block_splitter(mode: c_int, cparams: ZSTD_compressionParameters) -> c_int {
if mode != ZSTD_RUST_PS_AUTO {
return mode;
}
if cparams.strategy >= ZSTD_BTOPT && cparams.windowLog >= 17 {
ZSTD_RUST_PS_ENABLE
} else {
ZSTD_RUST_PS_DISABLE
}
}
/// C ABI for `ZSTD_resolveBlockSplitterMode()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_resolveBlockSplitterMode(
mode: c_int,
cparams: ZSTD_compressionParameters,
) -> c_int {
resolve_block_splitter(mode, cparams)
}
#[inline]
fn resolve_enable_ldm(mode: c_int, cparams: ZSTD_compressionParameters) -> c_int {
if mode != ZSTD_RUST_PS_AUTO {
return mode;
}
if cparams.strategy >= ZSTD_BTOPT && cparams.windowLog >= 27 {
ZSTD_RUST_PS_ENABLE
} else {
ZSTD_RUST_PS_DISABLE
}
}
/// C ABI for `ZSTD_resolveEnableLdm()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_resolveEnableLdm(
mode: c_int,
cparams: ZSTD_compressionParameters,
) -> c_int {
resolve_enable_ldm(mode, cparams)
}
#[inline]
fn resolve_external_repcode_search(mode: c_int, compression_level: c_int) -> c_int {
if mode != ZSTD_RUST_PS_AUTO {
return mode;
}
if compression_level < 10 {
ZSTD_RUST_PS_DISABLE
} else {
ZSTD_RUST_PS_ENABLE
}
}
/// C ABI for `ZSTD_resolveExternalRepcodeSearch()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_resolveExternalRepcodeSearch(
mode: c_int,
compression_level: c_int,
) -> c_int {
resolve_external_repcode_search(mode, compression_level)
}
#[inline]
fn resolve_external_sequence_validation(mode: c_int) -> c_int {
mode
}
/// C ABI for `ZSTD_resolveExternalSequenceValidation()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_resolveExternalSequenceValidation(mode: c_int) -> c_int {
resolve_external_sequence_validation(mode)
}
#[inline]
fn literals_compression_is_disabled(
literal_compression_mode: c_int,
strategy: c_int,
target_length: u32,
) -> c_int {
match literal_compression_mode {
ZSTD_RUST_PS_ENABLE => 0,
ZSTD_RUST_PS_DISABLE => 1,
ZSTD_RUST_PS_AUTO => c_int::from(strategy == ZSTD_FAST && target_length > 0),
_ => {
debug_assert!(false, "invalid ZSTD_ParamSwitch_e literal mode");
c_int::from(strategy == ZSTD_FAST && target_length > 0)
}
}
}
/// C ABI for `ZSTD_literalsCompressionIsDisabled()`.
///
/// The C wrapper extracts these scalar fields so the private
/// `ZSTD_CCtx_params` layout does not cross the Rust boundary. Invalid modes
/// retain C's debug assertion and release-mode fallthrough to the auto policy.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_literalsCompressionIsDisabled(
literal_compression_mode: c_int,
strategy: c_int,
target_length: u32,
) -> c_int {
literals_compression_is_disabled(literal_compression_mode, strategy, target_length)
}
#[inline]
fn cdict_indices_are_tagged(cparams: ZSTD_compressionParameters) -> bool {
cparams.strategy == ZSTD_FAST || cparams.strategy == ZSTD_DFAST
}
#[inline]
fn dedicated_dict_search_is_supported(cparams: ZSTD_compressionParameters) -> bool {
cparams.strategy >= ZSTD_GREEDY
&& cparams.strategy <= ZSTD_LAZY2
&& cparams.hashLog > cparams.chainLog
&& cparams.chainLog <= 24
}
#[inline]
fn dedicated_dict_search_get_hash_log(hash_log: u32) -> u32 {
hash_log.wrapping_add(ZSTD_LAZY_DDSS_BUCKET_LOG)
}
#[inline]
fn dedicated_dict_search_get_cparams(
mut cparams: ZSTD_compressionParameters,
) -> ZSTD_compressionParameters {
match cparams.strategy {
ZSTD_GREEDY | ZSTD_LAZY | ZSTD_LAZY2 => {
cparams.hashLog = dedicated_dict_search_get_hash_log(cparams.hashLog);
}
_ => {}
}
cparams
}
#[inline]
fn dedicated_dict_search_revert_hash_log(hash_log: u32) -> u32 {
hash_log
.wrapping_sub(ZSTD_LAZY_DDSS_BUCKET_LOG)
.max(ZSTD_HASHLOG_MIN as u32)
}
#[inline]
fn dedicated_dict_search_revert_cparams(
mut cparams: ZSTD_compressionParameters,
) -> ZSTD_compressionParameters {
match cparams.strategy {
ZSTD_GREEDY | ZSTD_LAZY | ZSTD_LAZY2 => {
cparams.hashLog = dedicated_dict_search_revert_hash_log(cparams.hashLog);
}
_ => {}
}
cparams
}
const ATTACH_DICT_SIZE_CUTOFFS: [u64; 10] = [
8 * 1024, /* unused */
8 * 1024, /* ZSTD_fast */
16 * 1024, /* ZSTD_dfast */
32 * 1024, /* ZSTD_greedy */
32 * 1024, /* ZSTD_lazy */
32 * 1024, /* ZSTD_lazy2 */
32 * 1024, /* ZSTD_btlazy2 */
32 * 1024, /* ZSTD_btopt */
8 * 1024, /* ZSTD_btultra */
8 * 1024, /* ZSTD_btultra2 */
];
#[inline]
fn should_attach_dict(
strategy: c_int,
dedicated_dict_search: c_int,
pledged_src_size: u64,
attach_dict_pref: c_int,
force_window: c_int,
) -> bool {
let cutoff = ATTACH_DICT_SIZE_CUTOFFS[strategy as usize];
dedicated_dict_search != 0
|| ((pledged_src_size <= cutoff
|| pledged_src_size == ZSTD_CONTENTSIZE_UNKNOWN
|| attach_dict_pref == ZSTD_DICT_FORCE_ATTACH)
&& attach_dict_pref != ZSTD_DICT_FORCE_COPY
&& force_window == 0)
}
#[inline]
fn get_cparam_mode(
cdict_present: c_int,
cdict_strategy: c_int,
cdict_dedicated_search: c_int,
pledged_src_size: u64,
params_attach_dict_pref: c_int,
params_force_window: c_int,
) -> c_int {
if cdict_present != 0
&& should_attach_dict(
cdict_strategy,
cdict_dedicated_search,
pledged_src_size,
params_attach_dict_pref,
params_force_window,
)
{
ZSTD_RUST_CPM_ATTACH_DICT
} else {
ZSTD_RUST_CPM_NO_ATTACH_DICT
}
}
/// C ABI for `ZSTD_CDictIndicesAreTagged()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_cdictIndicesAreTagged(
cparams: ZSTD_compressionParameters,
) -> c_int {
c_int::from(cdict_indices_are_tagged(cparams))
}
/// C ABI for `ZSTD_dedicatedDictSearch_isSupported()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_dedicatedDictSearchIsSupported(
cparams: ZSTD_compressionParameters,
) -> c_int {
c_int::from(dedicated_dict_search_is_supported(cparams))
}
/// C ABI for `ZSTD_dedicatedDictSearch_getCParams()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_dedicatedDictSearch_getCParams(
cparams: ZSTD_compressionParameters,
) -> ZSTD_compressionParameters {
dedicated_dict_search_get_cparams(cparams)
}
/// C ABI for `ZSTD_dedicatedDictSearch_revertCParams()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_dedicatedDictSearch_revertCParams(
cparams: ZSTD_compressionParameters,
) -> ZSTD_compressionParameters {
dedicated_dict_search_revert_cparams(cparams)
}
/// C ABI for `ZSTD_shouldAttachDict()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_shouldAttachDict(
strategy: c_int,
dedicated_dict_search: c_int,
pledged_src_size: u64,
attach_dict_pref: c_int,
force_window: c_int,
) -> c_int {
c_int::from(should_attach_dict(
strategy,
dedicated_dict_search,
pledged_src_size,
attach_dict_pref,
force_window,
))
}
/// C ABI for `ZSTD_getCParamMode()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_getCParamMode(
cdict_present: c_int,
cdict_strategy: c_int,
cdict_dedicated_search: c_int,
pledged_src_size: u64,
params_attach_dict_pref: c_int,
params_force_window: c_int,
) -> c_int {
get_cparam_mode(
cdict_present,
cdict_strategy,
cdict_dedicated_search,
pledged_src_size,
params_attach_dict_pref,
params_force_window,
)
}
#[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 apply_strategy_exclusions(
mut cparams: ZSTD_compressionParameters,
exclusion_mask: u32,
) -> ZSTD_compressionParameters {
if exclusion_mask & ZSTD_RUST_EXCLUDE_BTULTRA != 0 {
if cparams.strategy == ZSTD_BTULTRA2 {
cparams.strategy = ZSTD_BTULTRA;
}
if cparams.strategy == ZSTD_BTULTRA {
cparams.strategy = ZSTD_BTOPT;
}
}
if exclusion_mask & ZSTD_RUST_EXCLUDE_BTOPT != 0 && cparams.strategy == ZSTD_BTOPT {
cparams.strategy = ZSTD_BTLAZY2;
}
if exclusion_mask & ZSTD_RUST_EXCLUDE_BTLAZY2 != 0 && cparams.strategy == ZSTD_BTLAZY2 {
cparams.strategy = ZSTD_LAZY2;
}
if exclusion_mask & ZSTD_RUST_EXCLUDE_LAZY2 != 0 && cparams.strategy == ZSTD_LAZY2 {
cparams.strategy = ZSTD_LAZY;
}
if exclusion_mask & ZSTD_RUST_EXCLUDE_LAZY != 0 && cparams.strategy == ZSTD_LAZY {
cparams.strategy = ZSTD_GREEDY;
}
if exclusion_mask & ZSTD_RUST_EXCLUDE_GREEDY != 0 && cparams.strategy == ZSTD_GREEDY {
cparams.strategy = ZSTD_DFAST;
}
if exclusion_mask & ZSTD_RUST_EXCLUDE_DFAST != 0 && cparams.strategy == ZSTD_DFAST {
cparams.strategy = ZSTD_FAST;
cparams.targetLength = 0;
}
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.
///
/// The C wrapper supplies its active excluded-compressor configuration as a
/// mask; the orchestration leaf applies it before each adjustment stage.
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
}
fn get_cparams_internal(
compression_level: c_int,
src_size_hint: u64,
dict_size: usize,
mode: c_int,
exclusion_mask: u32,
) -> ZSTD_compressionParameters {
/* ZSTD_getCParams_internal() preserves srcSizeHint == 0 as a known empty
* input. Only the public getter translates zero to UNKNOWN. */
let cparams = select_cparams(compression_level, src_size_hint, dict_size, mode);
adjust_cparams(
apply_strategy_exclusions(cparams, exclusion_mask),
src_size_hint,
dict_size,
mode,
ZSTD_RUST_PS_AUTO,
)
}
#[inline]
fn get_params_internal(
compression_level: c_int,
src_size_hint: u64,
dict_size: usize,
mode: c_int,
exclusion_mask: u32,
) -> ZSTD_parameters {
make_params(get_cparams_internal(
compression_level,
src_size_hint,
dict_size,
mode,
exclusion_mask,
))
}
fn get_cparams_public(
compression_level: c_int,
src_size_hint: u64,
dict_size: usize,
exclusion_mask: u32,
) -> ZSTD_compressionParameters {
let src_size_hint = if src_size_hint == 0 {
ZSTD_CONTENTSIZE_UNKNOWN
} else {
src_size_hint
};
get_cparams_internal(
compression_level,
src_size_hint,
dict_size,
ZSTD_RUST_CPM_UNKNOWN,
exclusion_mask,
)
}
#[inline]
fn get_params_public(
compression_level: c_int,
src_size_hint: u64,
dict_size: usize,
exclusion_mask: u32,
) -> ZSTD_parameters {
make_params(get_cparams_public(
compression_level,
src_size_hint,
dict_size,
exclusion_mask,
))
}
fn get_cparams_from_cctx_params(
compression_level: c_int,
cctx_src_size_hint: c_int,
mut src_size_hint: u64,
dict_size: usize,
mode: c_int,
enable_ldm: c_int,
ldm_default_window_log: u32,
overrides: ZSTD_compressionParameters,
use_row_match_finder: c_int,
exclusion_mask: u32,
) -> ZSTD_compressionParameters {
if src_size_hint == ZSTD_CONTENTSIZE_UNKNOWN && cctx_src_size_hint > 0 {
debug_assert!(cctx_src_size_hint >= 0);
src_size_hint = cctx_src_size_hint as u64;
}
/* ZSTD_getCParams_internal() selects and performs the first adjustment. */
let mut cparams = get_cparams_internal(
compression_level,
src_size_hint,
dict_size,
mode,
exclusion_mask,
);
if enable_ldm == ZSTD_RUST_PS_ENABLE {
cparams.windowLog = ldm_default_window_log;
}
override_cparams(&mut cparams, &overrides);
/* Keep the C-side assertion immediately before the final adjustment. */
debug_assert_eq!(check_cparams(cparams), 0);
adjust_cparams(
apply_strategy_exclusions(cparams, exclusion_mask),
src_size_hint,
dict_size,
mode,
use_row_match_finder,
)
}
#[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
}
}
#[inline]
fn assert_equal_cparams(
cparams1: ZSTD_compressionParameters,
cparams2: ZSTD_compressionParameters,
) {
debug_assert_eq!(cparams1.windowLog, cparams2.windowLog);
debug_assert_eq!(cparams1.chainLog, cparams2.chainLog);
debug_assert_eq!(cparams1.hashLog, cparams2.hashLog);
debug_assert_eq!(cparams1.searchLog, cparams2.searchLog);
debug_assert_eq!(cparams1.minMatch, cparams2.minMatch);
debug_assert_eq!(cparams1.targetLength, cparams2.targetLength);
debug_assert_eq!(cparams1.strategy, cparams2.strategy);
}
/// 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)
}
/// C ABI for the debug-only equality invariant in `ZSTD_assertEqualCParams`.
///
/// Keep the symbol exported in release builds so the C ABI remains stable;
/// `debug_assert_eq!` compiles the checks out there, matching C's `assert()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_assertEqualCParams(
cparams1: ZSTD_compressionParameters,
cparams2: ZSTD_compressionParameters,
) {
assert_equal_cparams(cparams1, cparams2);
}
/// 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)
}
/// Applies the C-selected build's excluded block-compressor cascade.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_applyStrategyExclusions(
cparams: ZSTD_compressionParameters,
exclusionMask: u32,
) -> ZSTD_compressionParameters {
apply_strategy_exclusions(cparams, exclusionMask)
}
/// 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)
}
/// Reproduces `ZSTD_getCParams_internal()` without translating a zero source
/// size to `ZSTD_CONTENTSIZE_UNKNOWN`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_getCParamsInternal(
compressionLevel: c_int,
srcSizeHint: u64,
dictSize: usize,
mode: c_int,
exclusionMask: u32,
) -> ZSTD_compressionParameters {
get_cparams_internal(compressionLevel, srcSizeHint, dictSize, mode, exclusionMask)
}
/// Reproduces `ZSTD_getParams_internal()` without translating a zero source
/// size to `ZSTD_CONTENTSIZE_UNKNOWN`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_getParamsInternal(
compressionLevel: c_int,
srcSizeHint: u64,
dictSize: usize,
mode: c_int,
exclusionMask: u32,
) -> ZSTD_parameters {
get_params_internal(compressionLevel, srcSizeHint, dictSize, mode, exclusionMask)
}
/// Reproduces the public `ZSTD_getCParams()` source-size policy: zero means
/// an unknown size, while the internal helper keeps zero as a known empty
/// input.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_getCParams(
compressionLevel: c_int,
srcSizeHint: u64,
dictSize: usize,
exclusionMask: u32,
) -> ZSTD_compressionParameters {
get_cparams_public(compressionLevel, srcSizeHint, dictSize, exclusionMask)
}
/// Reproduces the public `ZSTD_getParams()` source-size policy and default
/// frame-parameter construction.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_getParams(
compressionLevel: c_int,
srcSizeHint: u64,
dictSize: usize,
exclusionMask: u32,
) -> ZSTD_parameters {
get_params_public(compressionLevel, srcSizeHint, dictSize, exclusionMask)
}
/// Reproduces `ZSTD_getCParamsFromCCtxParams()` from scalar snapshots.
///
/// The C shim supplies the private build policy as an exclusion mask and the
/// LDM default window log, while the context-free selection, override, and
/// two adjustment stages remain entirely in Rust.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_getCParamsFromCCtxParams(
compressionLevel: c_int,
cctxSrcSizeHint: c_int,
srcSizeHint: u64,
dictSize: usize,
mode: c_int,
enableLdm: c_int,
ldmDefaultWindowLog: u32,
overrides: ZSTD_compressionParameters,
useRowMatchFinder: c_int,
exclusionMask: u32,
) -> ZSTD_compressionParameters {
get_cparams_from_cctx_params(
compressionLevel,
cctxSrcSizeHint,
srcSizeHint,
dictSize,
mode,
enableLdm,
ldmDefaultWindowLog,
overrides,
useRowMatchFinder,
exclusionMask,
)
}
/// 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))
}
/// C ABI for `ZSTD_allocateChainTable()`.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_allocateChainTable(
strategy: c_int,
mode: c_int,
for_dds_dict: c_int,
) -> c_int {
c_int::from(allocate_chain_table(strategy, mode, for_dds_dict != 0))
}
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
}
}
#[inline]
fn get_block_size(max_block_size: usize, window_log: u32) -> usize {
max_block_size.min(1usize << window_log)
}
#[inline]
fn override_cparams(
cparams: &mut ZSTD_compressionParameters,
overrides: &ZSTD_compressionParameters,
) {
if overrides.windowLog != 0 {
cparams.windowLog = overrides.windowLog;
}
if overrides.hashLog != 0 {
cparams.hashLog = overrides.hashLog;
}
if overrides.chainLog != 0 {
cparams.chainLog = overrides.chainLog;
}
if overrides.searchLog != 0 {
cparams.searchLog = overrides.searchLog;
}
if overrides.minMatch != 0 {
cparams.minMatch = overrides.minMatch;
}
if overrides.targetLength != 0 {
cparams.targetLength = overrides.targetLength;
}
if overrides.strategy != 0 {
cparams.strategy = overrides.strategy;
}
}
/// Pure leaf for the private `ZSTD_overrideCParams()` helper.
#[no_mangle]
pub unsafe extern "C" fn ZSTD_rust_params_overrideCParams(
cparams: *mut ZSTD_compressionParameters,
overrides: *const ZSTD_compressionParameters,
) {
let (cparams, overrides) = unsafe { (&mut *cparams, &*overrides) };
override_cparams(cparams, overrides);
}
/// Pure leaf for the deprecated `ZSTD_getBlockSize()` path.
#[no_mangle]
pub extern "C" fn ZSTD_rust_params_getBlockSize(maxBlockSize: usize, windowLog: u32) -> usize {
get_block_size(maxBlockSize, windowLog)
}
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>()
);
}
fn policy_cparams(strategy: c_int, window_log: u32) -> ZSTD_compressionParameters {
ZSTD_compressionParameters {
windowLog: window_log,
strategy,
..ZSTD_compressionParameters::default()
}
}
#[test]
fn row_match_finder_policy_preserves_strategy_and_window_boundaries() {
assert_eq!(ZSTD_rust_params_rowMatchFinderSupported(ZSTD_FAST), 0);
assert_eq!(ZSTD_rust_params_rowMatchFinderSupported(ZSTD_GREEDY), 1);
assert_eq!(ZSTD_rust_params_rowMatchFinderSupported(ZSTD_LAZY2), 1);
assert_eq!(ZSTD_rust_params_rowMatchFinderSupported(ZSTD_BTLAZY2), 0);
assert_eq!(
ZSTD_rust_params_rowMatchFinderUsed(ZSTD_GREEDY, ZSTD_RUST_PS_ENABLE),
1
);
assert_eq!(
ZSTD_rust_params_rowMatchFinderUsed(ZSTD_GREEDY, ZSTD_RUST_PS_DISABLE),
0
);
assert_eq!(
ZSTD_rust_params_rowMatchFinderUsed(ZSTD_FAST, ZSTD_RUST_PS_ENABLE),
0
);
assert_eq!(
ZSTD_rust_params_resolveRowMatchFinderMode(
ZSTD_RUST_PS_AUTO,
policy_cparams(ZSTD_GREEDY, 14),
),
ZSTD_RUST_PS_DISABLE
);
assert_eq!(
ZSTD_rust_params_resolveRowMatchFinderMode(
ZSTD_RUST_PS_AUTO,
policy_cparams(ZSTD_GREEDY, 15),
),
ZSTD_RUST_PS_ENABLE
);
assert_eq!(
ZSTD_rust_params_resolveRowMatchFinderMode(
ZSTD_RUST_PS_AUTO,
policy_cparams(ZSTD_BTLAZY2, 31),
),
ZSTD_RUST_PS_DISABLE
);
assert_eq!(
ZSTD_rust_params_resolveRowMatchFinderMode(
ZSTD_RUST_PS_ENABLE,
policy_cparams(ZSTD_FAST, 14),
),
ZSTD_RUST_PS_ENABLE
);
}
#[test]
fn block_compressor_selector_maps_all_strategy_table_indices() {
for strategy in ZSTD_FAST..=ZSTD_BTULTRA2 {
assert_eq!(
ZSTD_rust_params_selectBlockCompressor(strategy, ZSTD_RUST_PS_DISABLE),
3 + strategy
);
}
assert_eq!(
ZSTD_rust_params_selectBlockCompressor(ZSTD_GREEDY, ZSTD_RUST_PS_ENABLE),
0
);
assert_eq!(
ZSTD_rust_params_selectBlockCompressor(ZSTD_LAZY, ZSTD_RUST_PS_ENABLE),
1
);
assert_eq!(
ZSTD_rust_params_selectBlockCompressor(ZSTD_LAZY2, ZSTD_RUST_PS_ENABLE),
2
);
for strategy in [
ZSTD_FAST,
ZSTD_DFAST,
ZSTD_BTLAZY2,
ZSTD_BTOPT,
ZSTD_BTULTRA,
ZSTD_BTULTRA2,
] {
assert_eq!(
ZSTD_rust_params_selectBlockCompressor(strategy, ZSTD_RUST_PS_ENABLE),
3 + strategy
);
}
}
#[cfg(debug_assertions)]
#[test]
#[should_panic]
fn block_compressor_selector_rejects_strategy_below_bounds() {
select_block_compressor(ZSTD_FAST - 1, ZSTD_RUST_PS_DISABLE);
}
#[cfg(debug_assertions)]
#[test]
#[should_panic]
fn block_compressor_selector_rejects_strategy_above_bounds() {
select_block_compressor(ZSTD_BTULTRA2 + 1, ZSTD_RUST_PS_DISABLE);
}
#[cfg(debug_assertions)]
#[test]
#[should_panic]
fn block_compressor_selector_rejects_auto_row_mode() {
select_block_compressor(ZSTD_GREEDY, ZSTD_RUST_PS_AUTO);
}
#[test]
fn block_splitter_and_ldm_policy_match_window_boundaries() {
assert_eq!(
ZSTD_rust_params_resolveBlockSplitterMode(
ZSTD_RUST_PS_AUTO,
policy_cparams(ZSTD_BTOPT, 16),
),
ZSTD_RUST_PS_DISABLE
);
assert_eq!(
ZSTD_rust_params_resolveBlockSplitterMode(
ZSTD_RUST_PS_AUTO,
policy_cparams(ZSTD_BTOPT, 17),
),
ZSTD_RUST_PS_ENABLE
);
assert_eq!(
ZSTD_rust_params_resolveBlockSplitterMode(
ZSTD_RUST_PS_AUTO,
policy_cparams(ZSTD_BTLAZY2, 31),
),
ZSTD_RUST_PS_DISABLE
);
assert_eq!(
ZSTD_rust_params_resolveBlockSplitterMode(
ZSTD_RUST_PS_ENABLE,
policy_cparams(ZSTD_FAST, 1),
),
ZSTD_RUST_PS_ENABLE
);
assert_eq!(
ZSTD_rust_params_resolveEnableLdm(ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTOPT, 26),),
ZSTD_RUST_PS_DISABLE
);
assert_eq!(
ZSTD_rust_params_resolveEnableLdm(ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTOPT, 27),),
ZSTD_RUST_PS_ENABLE
);
assert_eq!(
ZSTD_rust_params_resolveEnableLdm(ZSTD_RUST_PS_AUTO, policy_cparams(ZSTD_BTLAZY2, 31),),
ZSTD_RUST_PS_DISABLE
);
assert_eq!(
ZSTD_rust_params_resolveEnableLdm(
ZSTD_RUST_PS_DISABLE,
policy_cparams(ZSTD_BTULTRA2, 31),
),
ZSTD_RUST_PS_DISABLE
);
}
#[test]
fn chain_table_policy_matches_dds_and_row_match_finder_modes() {
assert_eq!(
ZSTD_rust_params_allocateChainTable(ZSTD_FAST, ZSTD_RUST_PS_DISABLE, 0),
0
);
assert_eq!(
ZSTD_rust_params_allocateChainTable(ZSTD_DFAST, ZSTD_RUST_PS_DISABLE, 0),
1
);
assert_eq!(
ZSTD_rust_params_allocateChainTable(ZSTD_GREEDY, ZSTD_RUST_PS_ENABLE, 0),
0
);
assert_eq!(
ZSTD_rust_params_allocateChainTable(ZSTD_FAST, ZSTD_RUST_PS_DISABLE, 1),
1
);
}
#[test]
fn external_repcode_and_cdict_tagging_match_boundaries() {
assert_eq!(
ZSTD_rust_params_resolveExternalRepcodeSearch(ZSTD_RUST_PS_AUTO, 9),
ZSTD_RUST_PS_DISABLE
);
assert_eq!(
ZSTD_rust_params_resolveExternalRepcodeSearch(ZSTD_RUST_PS_AUTO, 10),
ZSTD_RUST_PS_ENABLE
);
assert_eq!(
ZSTD_rust_params_resolveExternalRepcodeSearch(ZSTD_RUST_PS_DISABLE, 100),
ZSTD_RUST_PS_DISABLE
);
assert_eq!(
ZSTD_rust_params_resolveExternalRepcodeSearch(ZSTD_RUST_PS_ENABLE, -100),
ZSTD_RUST_PS_ENABLE
);
assert_eq!(
ZSTD_rust_params_cdictIndicesAreTagged(policy_cparams(ZSTD_FAST, 1)),
1
);
assert_eq!(
ZSTD_rust_params_cdictIndicesAreTagged(policy_cparams(ZSTD_DFAST, 1)),
1
);
assert_eq!(
ZSTD_rust_params_cdictIndicesAreTagged(policy_cparams(ZSTD_GREEDY, 1)),
0
);
assert_eq!(
ZSTD_rust_params_cdictIndicesAreTagged(policy_cparams(ZSTD_BTULTRA2, 1)),
0
);
}
#[test]
fn dedicated_dict_search_support_matches_strategy_and_log_boundaries() {
let supported = |strategy, chain_log, hash_log| {
ZSTD_rust_params_dedicatedDictSearchIsSupported(ZSTD_compressionParameters {
strategy,
chainLog: chain_log,
hashLog: hash_log,
..ZSTD_compressionParameters::default()
})
};
assert_eq!(supported(ZSTD_GREEDY, 24, 25), 1);
assert_eq!(supported(ZSTD_LAZY2, 24, 25), 1);
assert_eq!(supported(ZSTD_BTLAZY2, 24, 25), 0);
assert_eq!(supported(ZSTD_LAZY2, 24, 24), 0);
assert_eq!(supported(ZSTD_LAZY2, 25, 26), 0);
}
#[test]
fn dedicated_dict_search_hash_log_adjustments_match_strategy_cases() {
let strategies = [
ZSTD_FAST,
ZSTD_DFAST,
ZSTD_GREEDY,
ZSTD_LAZY,
ZSTD_LAZY2,
ZSTD_BTLAZY2,
ZSTD_BTOPT,
ZSTD_BTULTRA,
ZSTD_BTULTRA2,
];
for strategy in strategies {
let should_adjust = matches!(strategy, ZSTD_GREEDY | ZSTD_LAZY | ZSTD_LAZY2);
let original = 12;
let adjusted = if should_adjust {
dedicated_dict_search_get_hash_log(original)
} else {
original
};
assert_eq!(adjusted, if should_adjust { 14 } else { original });
let reverted = if should_adjust {
dedicated_dict_search_revert_hash_log(adjusted)
} else {
adjusted
};
assert_eq!(reverted, original);
}
assert_eq!(dedicated_dict_search_get_hash_log(u32::MAX), 1);
assert_eq!(
dedicated_dict_search_revert_hash_log(ZSTD_HASHLOG_MIN as u32),
ZSTD_HASHLOG_MIN as u32
);
assert_eq!(
dedicated_dict_search_revert_hash_log(ZSTD_HASHLOG_MIN as u32 + 1),
ZSTD_HASHLOG_MIN as u32
);
assert_eq!(
dedicated_dict_search_revert_hash_log(ZSTD_HASHLOG_MIN as u32 + 2),
ZSTD_HASHLOG_MIN as u32
);
assert_eq!(dedicated_dict_search_revert_hash_log(0), u32::MAX - 1);
assert_eq!(dedicated_dict_search_revert_hash_log(1), u32::MAX);
}
#[test]
fn dedicated_dict_search_get_cparams_preserves_fields_and_strategy_policy() {
let strategies = [
ZSTD_FAST,
ZSTD_DFAST,
ZSTD_GREEDY,
ZSTD_LAZY,
ZSTD_LAZY2,
ZSTD_BTLAZY2,
ZSTD_BTOPT,
ZSTD_BTULTRA,
ZSTD_BTULTRA2,
-1,
99,
];
for strategy in strategies {
let input = ZSTD_compressionParameters {
windowLog: 21,
chainLog: 19,
hashLog: 12,
searchLog: 5,
minMatch: 4,
targetLength: 48,
strategy,
};
let output = ZSTD_rust_params_dedicatedDictSearch_getCParams(input);
let expected_hash_log = if matches!(strategy, ZSTD_GREEDY | ZSTD_LAZY | ZSTD_LAZY2) {
14
} else {
input.hashLog
};
assert_eq!(output.hashLog, expected_hash_log, "strategy {strategy}");
assert_eq!(output.windowLog, input.windowLog, "strategy {strategy}");
assert_eq!(output.chainLog, input.chainLog, "strategy {strategy}");
assert_eq!(output.searchLog, input.searchLog, "strategy {strategy}");
assert_eq!(output.minMatch, input.minMatch, "strategy {strategy}");
assert_eq!(
output.targetLength, input.targetLength,
"strategy {strategy}"
);
assert_eq!(output.strategy, input.strategy, "strategy {strategy}");
}
for strategy in [ZSTD_GREEDY, ZSTD_LAZY, ZSTD_LAZY2] {
let mut input = ZSTD_compressionParameters {
hashLog: u32::MAX,
strategy,
..ZSTD_compressionParameters::default()
};
assert_eq!(
ZSTD_rust_params_dedicatedDictSearch_getCParams(input).hashLog,
1
);
input.hashLog = 0;
assert_eq!(
ZSTD_rust_params_dedicatedDictSearch_getCParams(input).hashLog,
2
);
input.hashLog = 1;
assert_eq!(
ZSTD_rust_params_dedicatedDictSearch_getCParams(input).hashLog,
3
);
}
}
#[test]
fn dedicated_dict_search_revert_cparams_preserves_fields_and_strategy_policy() {
let strategies = [
ZSTD_FAST,
ZSTD_DFAST,
ZSTD_GREEDY,
ZSTD_LAZY,
ZSTD_LAZY2,
ZSTD_BTLAZY2,
ZSTD_BTOPT,
ZSTD_BTULTRA,
ZSTD_BTULTRA2,
-1,
99,
];
for strategy in strategies {
let input = ZSTD_compressionParameters {
windowLog: 21,
chainLog: 19,
hashLog: 12,
searchLog: 5,
minMatch: 4,
targetLength: 48,
strategy,
};
let output = dedicated_dict_search_revert_cparams(input);
let expected_hash_log = if matches!(strategy, ZSTD_GREEDY | ZSTD_LAZY | ZSTD_LAZY2) {
10
} else {
input.hashLog
};
assert_eq!(output.hashLog, expected_hash_log, "strategy {strategy}");
assert_eq!(output.windowLog, input.windowLog, "strategy {strategy}");
assert_eq!(output.chainLog, input.chainLog, "strategy {strategy}");
assert_eq!(output.searchLog, input.searchLog, "strategy {strategy}");
assert_eq!(output.minMatch, input.minMatch, "strategy {strategy}");
assert_eq!(
output.targetLength, input.targetLength,
"strategy {strategy}"
);
assert_eq!(output.strategy, input.strategy, "strategy {strategy}");
}
for strategy in [ZSTD_GREEDY, ZSTD_LAZY, ZSTD_LAZY2] {
let mut input = ZSTD_compressionParameters {
hashLog: ZSTD_HASHLOG_MIN as u32,
strategy,
..ZSTD_compressionParameters::default()
};
assert_eq!(dedicated_dict_search_revert_cparams(input).hashLog, 6);
input.hashLog = 0;
assert_eq!(
dedicated_dict_search_revert_cparams(input).hashLog,
u32::MAX - 1
);
input.hashLog = 1;
assert_eq!(
dedicated_dict_search_revert_cparams(input).hashLog,
u32::MAX
);
}
}
#[test]
fn dictionary_attachment_matches_strategy_size_and_preference_boundaries() {
let strategy_cutoffs = [
(ZSTD_FAST, 8 * 1024),
(ZSTD_DFAST, 16 * 1024),
(ZSTD_GREEDY, 32 * 1024),
(ZSTD_LAZY, 32 * 1024),
(ZSTD_LAZY2, 32 * 1024),
(ZSTD_BTLAZY2, 32 * 1024),
(ZSTD_BTOPT, 32 * 1024),
(ZSTD_BTULTRA, 8 * 1024),
(ZSTD_BTULTRA2, 8 * 1024),
];
for (strategy, cutoff) in strategy_cutoffs {
assert_eq!(
ZSTD_rust_params_shouldAttachDict(strategy, 0, cutoff, 0, 0,),
1,
"attach at cutoff for strategy {strategy}",
);
assert_eq!(
ZSTD_rust_params_shouldAttachDict(strategy, 0, cutoff + 1, 0, 0,),
0,
"copy above cutoff for strategy {strategy}",
);
}
assert_eq!(
ZSTD_rust_params_shouldAttachDict(ZSTD_FAST, 0, ZSTD_CONTENTSIZE_UNKNOWN, 0, 0,),
1
);
assert_eq!(
ZSTD_rust_params_shouldAttachDict(
ZSTD_FAST,
0,
8 * 1024 + 1,
ZSTD_DICT_FORCE_ATTACH,
0,
),
1
);
assert_eq!(
ZSTD_rust_params_shouldAttachDict(
ZSTD_FAST,
0,
ZSTD_CONTENTSIZE_UNKNOWN,
ZSTD_DICT_FORCE_COPY,
0,
),
0
);
assert_eq!(
ZSTD_rust_params_shouldAttachDict(ZSTD_FAST, 0, 1, ZSTD_DICT_FORCE_COPY, 0),
0
);
}
#[test]
fn dictionary_attachment_preserves_dedicated_search_and_force_window_precedence() {
assert_eq!(
ZSTD_rust_params_shouldAttachDict(ZSTD_BTULTRA2, 1, u64::MAX, ZSTD_DICT_FORCE_COPY, 1),
1
);
assert_eq!(
ZSTD_rust_params_shouldAttachDict(ZSTD_BTULTRA2, 0, 1, 0, 1,),
0
);
assert_eq!(
ZSTD_rust_params_shouldAttachDict(
ZSTD_BTULTRA2,
0,
ZSTD_CONTENTSIZE_UNKNOWN,
ZSTD_DICT_FORCE_ATTACH,
1,
),
0
);
}
#[test]
fn cparam_mode_preserves_cdict_presence_and_attachment_policy() {
assert_eq!(
ZSTD_rust_params_getCParamMode(0, ZSTD_FAST, 0, 1, ZSTD_DICT_FORCE_ATTACH, 0,),
ZSTD_RUST_CPM_NO_ATTACH_DICT
);
assert_eq!(
ZSTD_rust_params_getCParamMode(1, ZSTD_FAST, 0, 8 * 1024, 0, 0),
ZSTD_RUST_CPM_ATTACH_DICT
);
assert_eq!(
ZSTD_rust_params_getCParamMode(
1,
ZSTD_FAST,
0,
8 * 1024 + 1,
ZSTD_DICT_FORCE_ATTACH,
0,
),
ZSTD_RUST_CPM_ATTACH_DICT
);
assert_eq!(
ZSTD_rust_params_getCParamMode(
1,
ZSTD_FAST,
0,
ZSTD_CONTENTSIZE_UNKNOWN,
ZSTD_DICT_FORCE_COPY,
0,
),
ZSTD_RUST_CPM_NO_ATTACH_DICT
);
assert_eq!(
ZSTD_rust_params_getCParamMode(1, ZSTD_FAST, 0, ZSTD_CONTENTSIZE_UNKNOWN, 0, 0,),
ZSTD_RUST_CPM_ATTACH_DICT
);
assert_eq!(
ZSTD_rust_params_getCParamMode(
1,
ZSTD_FAST,
0,
ZSTD_CONTENTSIZE_UNKNOWN,
ZSTD_DICT_FORCE_ATTACH,
1,
),
ZSTD_RUST_CPM_NO_ATTACH_DICT
);
}
#[test]
fn external_sequence_validation_preserves_its_int_mode() {
for mode in [c_int::MIN, -1, 0, 1, c_int::MAX] {
assert_eq!(
ZSTD_rust_params_resolveExternalSequenceValidation(mode),
mode
);
}
}
#[test]
fn literal_compression_policy_matches_mode_strategy_and_target_length() {
for strategy in [ZSTD_FAST, ZSTD_DFAST, ZSTD_BTULTRA2] {
for target_length in [0, 1] {
assert_eq!(
ZSTD_rust_params_literalsCompressionIsDisabled(
ZSTD_RUST_PS_ENABLE,
strategy,
target_length,
),
0
);
assert_eq!(
ZSTD_rust_params_literalsCompressionIsDisabled(
ZSTD_RUST_PS_DISABLE,
strategy,
target_length,
),
1
);
assert_eq!(
ZSTD_rust_params_literalsCompressionIsDisabled(
ZSTD_RUST_PS_AUTO,
strategy,
target_length,
),
c_int::from(strategy == ZSTD_FAST && target_length > 0)
);
}
}
}
#[cfg(debug_assertions)]
#[test]
#[should_panic]
fn literal_compression_policy_rejects_invalid_mode_in_debug() {
literals_compression_is_disabled(99, ZSTD_FAST, 1);
}
#[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 public_getters_translate_zero_to_unknown_but_internal_getters_do_not() {
let public_zero = ZSTD_rust_params_getCParams(3, 0, 1, 0);
let public_unknown = ZSTD_rust_params_getCParams(3, ZSTD_CONTENTSIZE_UNKNOWN, 1, 0);
assert_eq!(public_zero, public_unknown);
let internal_zero = ZSTD_rust_params_getCParamsInternal(3, 0, 1, ZSTD_RUST_CPM_UNKNOWN, 0);
assert_eq!(internal_zero.windowLog, 10);
assert_eq!(public_unknown.windowLog, 14);
assert_ne!(internal_zero, public_unknown);
let public_params_zero = ZSTD_rust_params_getParams(3, 0, 1, 0);
let public_params_unknown = ZSTD_rust_params_getParams(3, ZSTD_CONTENTSIZE_UNKNOWN, 1, 0);
assert_eq!(public_params_zero, public_params_unknown);
assert_eq!(public_params_zero.cParams, public_zero);
assert_eq!(
ZSTD_rust_params_getParamsInternal(3, 0, 1, ZSTD_RUST_CPM_UNKNOWN, 0).cParams,
internal_zero
);
}
#[test]
fn getter_modes_preserve_dictionary_attachment_boundaries() {
let attached_with_dict = ZSTD_rust_params_getCParamsInternal(
3,
ZSTD_CONTENTSIZE_UNKNOWN,
1,
ZSTD_RUST_CPM_ATTACH_DICT,
0,
);
let attached_without_dict = ZSTD_rust_params_getCParamsInternal(
3,
ZSTD_CONTENTSIZE_UNKNOWN,
0,
ZSTD_RUST_CPM_ATTACH_DICT,
0,
);
assert_eq!(attached_with_dict, attached_without_dict);
let no_attach = ZSTD_rust_params_getCParamsInternal(
3,
ZSTD_CONTENTSIZE_UNKNOWN,
1,
ZSTD_RUST_CPM_NO_ATTACH_DICT,
0,
);
let create_cdict = ZSTD_rust_params_getCParamsInternal(
3,
ZSTD_CONTENTSIZE_UNKNOWN,
1,
ZSTD_RUST_CPM_CREATE_CDICT,
0,
);
assert_eq!(attached_with_dict.windowLog, 21);
assert_eq!(no_attach.windowLog, 14);
assert_eq!(create_cdict.windowLog, 10);
assert!(attached_with_dict.windowLog > no_attach.windowLog);
assert!(no_attach.windowLog > create_cdict.windowLog);
assert_eq!(
ZSTD_rust_params_getCParamsInternal(
3,
ZSTD_CONTENTSIZE_UNKNOWN,
1,
ZSTD_RUST_CPM_UNKNOWN,
0,
)
.windowLog,
no_attach.windowLog
);
}
fn cctx_policy_params(
cctx_src_size_hint: c_int,
src_size_hint: u64,
dict_size: usize,
mode: c_int,
enable_ldm: c_int,
overrides: ZSTD_compressionParameters,
use_row_match_finder: c_int,
) -> ZSTD_compressionParameters {
get_cparams_from_cctx_params(
3,
cctx_src_size_hint,
src_size_hint,
dict_size,
mode,
enable_ldm,
27,
overrides,
use_row_match_finder,
0,
)
}
#[test]
fn cctx_source_size_hint_preserves_unknown_and_zero_semantics() {
let unknown = cctx_policy_params(
0,
ZSTD_CONTENTSIZE_UNKNOWN,
0,
ZSTD_RUST_CPM_UNKNOWN,
ZSTD_RUST_PS_DISABLE,
ZSTD_compressionParameters::default(),
ZSTD_RUST_PS_AUTO,
);
let hinted = cctx_policy_params(
16 * 1024,
ZSTD_CONTENTSIZE_UNKNOWN,
0,
ZSTD_RUST_CPM_UNKNOWN,
ZSTD_RUST_PS_DISABLE,
ZSTD_compressionParameters::default(),
ZSTD_RUST_PS_AUTO,
);
let explicitly_sized = cctx_policy_params(
0,
16 * 1024,
0,
ZSTD_RUST_CPM_UNKNOWN,
ZSTD_RUST_PS_DISABLE,
ZSTD_compressionParameters::default(),
ZSTD_RUST_PS_AUTO,
);
assert_eq!(hinted, explicitly_sized);
assert!(unknown.windowLog > hinted.windowLog);
let known_zero = cctx_policy_params(
0,
0,
0,
ZSTD_RUST_CPM_UNKNOWN,
ZSTD_RUST_PS_DISABLE,
ZSTD_compressionParameters::default(),
ZSTD_RUST_PS_AUTO,
);
let zero_with_hint = cctx_policy_params(
16 * 1024,
0,
0,
ZSTD_RUST_CPM_UNKNOWN,
ZSTD_RUST_PS_DISABLE,
ZSTD_compressionParameters::default(),
ZSTD_RUST_PS_AUTO,
);
assert_eq!(known_zero, zero_with_hint);
assert!(hinted.windowLog > known_zero.windowLog);
}
#[test]
fn cctx_ldm_override_uses_the_explicit_default_window_log() {
let normal = cctx_policy_params(
0,
ZSTD_CONTENTSIZE_UNKNOWN,
0,
ZSTD_RUST_CPM_UNKNOWN,
ZSTD_RUST_PS_DISABLE,
ZSTD_compressionParameters::default(),
ZSTD_RUST_PS_AUTO,
);
let ldm = cctx_policy_params(
0,
ZSTD_CONTENTSIZE_UNKNOWN,
0,
ZSTD_RUST_CPM_UNKNOWN,
ZSTD_RUST_PS_ENABLE,
ZSTD_compressionParameters::default(),
ZSTD_RUST_PS_AUTO,
);
assert_eq!(ldm.windowLog, 27);
assert_ne!(normal.windowLog, ldm.windowLog);
}
#[test]
fn cctx_nonzero_overrides_replace_only_selected_fields() {
let baseline = cctx_policy_params(
0,
ZSTD_CONTENTSIZE_UNKNOWN,
0,
ZSTD_RUST_CPM_UNKNOWN,
ZSTD_RUST_PS_DISABLE,
ZSTD_compressionParameters::default(),
ZSTD_RUST_PS_DISABLE,
);
let result = cctx_policy_params(
0,
ZSTD_CONTENTSIZE_UNKNOWN,
0,
ZSTD_RUST_CPM_UNKNOWN,
ZSTD_RUST_PS_ENABLE,
ZSTD_compressionParameters {
windowLog: 12,
chainLog: 0,
hashLog: 29,
searchLog: 4,
minMatch: 6,
targetLength: 0,
strategy: ZSTD_GREEDY,
},
ZSTD_RUST_PS_DISABLE,
);
assert_eq!(result.windowLog, 12);
assert_eq!(result.hashLog, 29);
assert_eq!(result.searchLog, 4);
assert_eq!(result.minMatch, 6);
assert_eq!(result.strategy, ZSTD_GREEDY);
assert_eq!(result.chainLog, baseline.chainLog);
assert_eq!(result.targetLength, baseline.targetLength);
}
#[test]
fn cctx_mode_and_row_match_finder_flow_reaches_final_adjustment() {
let overrides = ZSTD_compressionParameters {
hashLog: 30,
searchLog: 4,
strategy: ZSTD_GREEDY,
..ZSTD_compressionParameters::default()
};
let no_row = cctx_policy_params(
0,
ZSTD_CONTENTSIZE_UNKNOWN,
32 * 1024,
ZSTD_RUST_CPM_ATTACH_DICT,
ZSTD_RUST_PS_DISABLE,
overrides,
ZSTD_RUST_PS_DISABLE,
);
let row = cctx_policy_params(
0,
ZSTD_CONTENTSIZE_UNKNOWN,
32 * 1024,
ZSTD_RUST_CPM_ATTACH_DICT,
ZSTD_RUST_PS_DISABLE,
overrides,
ZSTD_RUST_PS_ENABLE,
);
let no_attach = cctx_policy_params(
0,
ZSTD_CONTENTSIZE_UNKNOWN,
32 * 1024,
ZSTD_RUST_CPM_NO_ATTACH_DICT,
ZSTD_RUST_PS_DISABLE,
overrides,
ZSTD_RUST_PS_DISABLE,
);
assert_eq!(no_row.hashLog, 30);
assert_eq!(row.hashLog, 28);
assert_ne!(no_attach, no_row);
}
#[test]
fn strategy_exclusion_mask_preserves_the_c_fallback_cascade() {
let cparams = policy_cparams(ZSTD_BTULTRA2, 27);
let all_excluded = ZSTD_RUST_EXCLUDE_BTULTRA
| ZSTD_RUST_EXCLUDE_BTOPT
| ZSTD_RUST_EXCLUDE_BTLAZY2
| ZSTD_RUST_EXCLUDE_LAZY2
| ZSTD_RUST_EXCLUDE_LAZY
| ZSTD_RUST_EXCLUDE_GREEDY
| ZSTD_RUST_EXCLUDE_DFAST;
let cascaded = apply_strategy_exclusions(cparams, all_excluded);
assert_eq!(cascaded.strategy, ZSTD_FAST);
assert_eq!(cascaded.targetLength, 0);
let first_only = apply_strategy_exclusions(cparams, ZSTD_RUST_EXCLUDE_BTULTRA);
assert_eq!(first_only.strategy, ZSTD_BTOPT);
}
#[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 equal_cparams_pass_the_debug_invariant() {
let cparams = ZSTD_compressionParameters {
windowLog: 21,
chainLog: 18,
hashLog: 19,
searchLog: 4,
minMatch: 5,
targetLength: 16,
strategy: ZSTD_LAZY2,
};
ZSTD_rust_params_assertEqualCParams(cparams, cparams);
}
#[cfg(debug_assertions)]
#[test]
#[should_panic]
fn mismatched_cparams_panic_only_with_debug_assertions() {
let cparams = ZSTD_compressionParameters {
windowLog: 21,
chainLog: 18,
hashLog: 19,
searchLog: 4,
minMatch: 5,
targetLength: 16,
strategy: ZSTD_LAZY2,
};
let mut mismatched = cparams;
mismatched.strategy = ZSTD_BTLAZY2;
assert_equal_cparams(cparams, mismatched);
}
#[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);
}
#[test]
fn block_size_uses_the_smaller_configured_limit() {
assert_eq!(ZSTD_rust_params_getBlockSize(64 * 1024, 17), 64 * 1024);
assert_eq!(ZSTD_rust_params_getBlockSize(128 * 1024, 16), 64 * 1024);
assert_eq!(ZSTD_rust_params_getBlockSize(128 * 1024, 17), 128 * 1024);
}
#[test]
fn cparam_overrides_replace_only_nonzero_fields() {
let mut cparams = ZSTD_compressionParameters {
windowLog: 10,
chainLog: 11,
hashLog: 12,
searchLog: 13,
minMatch: 14,
targetLength: 15,
strategy: 16,
};
let overrides = ZSTD_compressionParameters {
windowLog: 20,
chainLog: 0,
hashLog: 22,
searchLog: 0,
minMatch: 24,
targetLength: 0,
strategy: 26,
};
unsafe { ZSTD_rust_params_overrideCParams(&mut cparams, &overrides) };
assert_eq!(
cparams,
ZSTD_compressionParameters {
windowLog: 20,
chainLog: 11,
hashLog: 22,
searchLog: 13,
minMatch: 24,
targetLength: 15,
strategy: 26,
}
);
}
}
Reference in New Issue View Git Blame Copy Permalink