ddidderr
8ac9855309
Move row matchfinder, block-splitter, LDM, chain-table, external-repcode, and tagged-dictionary policy leaves into Rust while preserving the existing C helper names and private parameter flow. Add boundary coverage for each policy decision. Test Plan: cargo test --manifest-path rust/Cargo.toml --no-default-features --features compression; cargo clippy --manifest-path rust/Cargo.toml; cargo clippy --manifest-path rust/Cargo.toml --benches; cargo clippy --manifest-path rust/Cargo.toml --tests; make -B -C lib -j2 lib; make -B -C tests -j2 test-cli-tests; make -B -C tests -j2 test-zstream
1323 lines
43 KiB
Rust
1323 lines
43 KiB
Rust
#![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
|
|
}
|
|
|
|
/// 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 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 cdict_indices_are_tagged(cparams: ZSTD_compressionParameters) -> bool {
|
|
cparams.strategy == ZSTD_FAST || cparams.strategy == ZSTD_DFAST
|
|
}
|
|
|
|
/// 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))
|
|
}
|
|
|
|
#[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))
|
|
}
|
|
|
|
/// 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
|
|
}
|
|
}
|
|
|
|
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_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 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);
|
|
}
|
|
}
|