From d8e8683353350a7aaaee1977ac137b6262a561bc Mon Sep 17 00:00:00 2001 From: ddidderr Date: Sun, 19 Jul 2026 23:49:43 +0200 Subject: [PATCH] feat(compress): move CDict attachment into Rust Project the prepared CDict window extent and destination match-state fields through an explicit ABI state so Rust owns the post-reset attachment operation. Preserve the original empty-dictionary and already-advanced window branches, including window-limit clearing and loaded-dictionary referential updates, while keeping private C pointer arithmetic and layout ownership in the C adapter. Test Plan: - CARGO_BUILD_JOBS=1 cargo test --lib zstd_compress_dictionary::tests::reset_cctx_by_attaching_cdict -- --nocapture - CARGO_BUILD_JOBS=1 cargo clippy --all-targets -- -D warnings - CARGO_BUILD_JOBS=1 cargo test - CARGO_BUILD_JOBS=1 make -j1 - CARGO_BUILD_JOBS=1 make -j1 -C tests test-zstream ZSTREAM_TESTTIME=-T2s - CARGO_BUILD_JOBS=1 make -j1 -C tests test-fuzzer FUZZERTEST=-T3s FUZZER_FLAGS=--no-big-tests All commands were run serially with a 40 GiB virtual-memory cap. --- lib/compress/zstd_compress.c | 63 +++++------ rust/src/zstd_compress_dictionary.rs | 149 ++++++++++++++++++++++----- 2 files changed, 154 insertions(+), 58 deletions(-) diff --git a/lib/compress/zstd_compress.c b/lib/compress/zstd_compress.c index a825d9de0..be965c57e 100644 --- a/lib/compress/zstd_compress.c +++ b/lib/compress/zstd_compress.c @@ -2563,15 +2563,21 @@ typedef char ZSTD_rust_reset_cctx_by_copying_cdict_state_layout[ typedef size_t (*ZSTD_rust_resetCCtxByAttachingCDictReset_f)( void* context, const void* cdict, const void* params, U64 pledgedSrcSize, int zbuff); -typedef void (*ZSTD_rust_resetCCtxByAttachingCDictAttach_f)( - void* context, const void* cdict); typedef struct { void* callbackContext; const void* cdict; const void* params; U64 pledgedSrcSize; ZSTD_rust_resetCCtxByAttachingCDictReset_f reset; - ZSTD_rust_resetCCtxByAttachingCDictAttach_f attach; + const ZSTD_MatchState_t* sourceMatchState; + const U32* sourceCDictEnd; + const U32* sourceCDictLen; + const ZSTD_MatchState_t** destinationDictMatchState; + const BYTE** destinationWindowNextSrc; + const BYTE* const* destinationWindowBase; + U32* destinationWindowLowLimit; + U32* destinationWindowDictLimit; + U32* destinationLoadedDictEnd; U32* destinationDictID; const U32* sourceDictID; size_t* destinationDictContentSize; @@ -2593,7 +2599,7 @@ typedef char ZSTD_rust_reset_cctx_by_attaching_cdict_state_layout[ && offsetof(ZSTD_rust_resetCCtxByAttachingCDictState, reset) == 3 * sizeof(void*) + sizeof(U64) && offsetof(ZSTD_rust_resetCCtxByAttachingCDictState, zbuff) - == 3 * sizeof(void*) + sizeof(U64) + 8 * sizeof(void*) + == 3 * sizeof(void*) + sizeof(U64) + 16 * sizeof(void*) && sizeof(ZSTD_rust_resetCCtxByAttachingCDictState) == ((offsetof(ZSTD_rust_resetCCtxByAttachingCDictState, zbuff) + sizeof(int) + sizeof(void*) - 1) / sizeof(void*)) @@ -4505,36 +4511,6 @@ static size_t ZSTD_rust_resetCCtx_byAttachingCDict_reset( return 0; } -static void ZSTD_rust_resetCCtx_byAttachingCDict_attach( - void* context, const void* cdictOpaque) -{ - ZSTD_CCtx* const cctx = (ZSTD_CCtx*)context; - const ZSTD_CDict* const cdict = (const ZSTD_CDict*)cdictOpaque; - U32 const cdictEnd = (U32)(cdict->matchState.window.nextSrc - - cdict->matchState.window.base); - U32 const cdictLen = cdictEnd - cdict->matchState.window.dictLimit; - - if (cdictLen == 0) { - DEBUGLOG(4, "skipping attaching empty dictionary"); - return; - } - - DEBUGLOG(4, "attaching dictionary into context"); - cctx->blockState.matchState.dictMatchState = &cdict->matchState; - if (cctx->blockState.matchState.window.dictLimit < cdictEnd) { - cctx->blockState.matchState.window.nextSrc = - cctx->blockState.matchState.window.base + cdictEnd; - ZSTD_rust_windowClear( - (size_t)(cctx->blockState.matchState.window.nextSrc - - cctx->blockState.matchState.window.base), - &cctx->blockState.matchState.window.lowLimit, - &cctx->blockState.matchState.window.dictLimit); - } - /* loadedDictEnd is expressed within the active context referential. */ - cctx->blockState.matchState.loadedDictEnd = - cctx->blockState.matchState.window.dictLimit; -} - static size_t ZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict, @@ -4542,13 +4518,30 @@ ZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx, U64 pledgedSrcSize, ZSTD_buffered_policy_e zbuff) { + U32 const cdictEnd = (U32)(cdict->matchState.window.nextSrc + - cdict->matchState.window.base); + U32 const cdictLen = cdictEnd - cdict->matchState.window.dictLimit; ZSTD_rust_resetCCtxByAttachingCDictState state; state.callbackContext = cctx; state.cdict = cdict; state.params = ¶ms; state.pledgedSrcSize = pledgedSrcSize; state.reset = ZSTD_rust_resetCCtx_byAttachingCDict_reset; - state.attach = ZSTD_rust_resetCCtx_byAttachingCDict_attach; + state.sourceMatchState = &cdict->matchState; + state.sourceCDictEnd = &cdictEnd; + state.sourceCDictLen = &cdictLen; + state.destinationDictMatchState = + &cctx->blockState.matchState.dictMatchState; + state.destinationWindowNextSrc = + &cctx->blockState.matchState.window.nextSrc; + state.destinationWindowBase = + &cctx->blockState.matchState.window.base; + state.destinationWindowLowLimit = + &cctx->blockState.matchState.window.lowLimit; + state.destinationWindowDictLimit = + &cctx->blockState.matchState.window.dictLimit; + state.destinationLoadedDictEnd = + &cctx->blockState.matchState.loadedDictEnd; state.destinationDictID = &cctx->dictID; state.sourceDictID = &cdict->dictID; state.destinationDictContentSize = &cctx->dictContentSize; diff --git a/rust/src/zstd_compress_dictionary.rs b/rust/src/zstd_compress_dictionary.rs index 7dba99e70..862bf20ef 100644 --- a/rust/src/zstd_compress_dictionary.rs +++ b/rust/src/zstd_compress_dictionary.rs @@ -15,7 +15,7 @@ use crate::entropy_common::FSE_readNCount; use crate::errors::{ERR_isError, ZstdErrorCode, ERROR}; use crate::fse_compress::FSE_buildCTable_wksp; use crate::huf_compress::HUF_readCTable; -use crate::zstd_compress::ZSTD_rust_copyCDictTableIntoCCtx; +use crate::zstd_compress::{ZSTD_rust_copyCDictTableIntoCCtx, ZSTD_rust_windowClear}; use crate::zstd_compress_params::{ ZSTD_compressionParameters, ZSTD_frameParameters, ZSTD_parameters, ZSTD_rust_params_allocateChainTable, ZSTD_rust_params_defaultCLevel, @@ -1575,12 +1575,12 @@ pub unsafe extern "C" fn ZSTD_rust_resetCCtxByCopyingCDict( type ResetCCtxByAttachingCDictResetFn = unsafe extern "C" fn(*mut c_void, *const c_void, *const c_void, u64, c_int) -> usize; -type ResetCCtxByAttachingCDictAttachFn = unsafe extern "C" fn(*mut c_void, *const c_void); /// Projection for attaching a prepared CDict to a working CCtx. /// /// Rust owns reset, attach, and metadata-copy ordering. C retains parameter -/// adjustment, private window linkage, and the CCtx/CDict field layout. +/// adjustment, private pointer-difference calculation, and the CCtx/CDict +/// field layout. #[repr(C)] pub struct ZSTD_rust_resetCCtxByAttachingCDictState { callback_context: *mut c_void, @@ -1588,7 +1588,15 @@ pub struct ZSTD_rust_resetCCtxByAttachingCDictState { params: *const c_void, pledged_src_size: u64, reset: Option, - attach: Option, + source_match_state: *const c_void, + source_cdict_end: *const c_uint, + source_cdict_len: *const c_uint, + destination_dict_match_state: *mut *const c_void, + destination_window_next_src: *mut *const c_void, + destination_window_base: *const *const c_void, + destination_window_low_limit: *mut c_uint, + destination_window_dict_limit: *mut c_uint, + destination_loaded_dict_end: *mut c_uint, destination_dict_id: *mut c_uint, source_dict_id: *const c_uint, destination_dict_content_size: *mut usize, @@ -1600,7 +1608,6 @@ pub struct ZSTD_rust_resetCCtxByAttachingCDictState { const _: () = { assert!(size_of::() == size_of::()); - assert!(size_of::() == size_of::()); assert!(offset_of!(ZSTD_rust_resetCCtxByAttachingCDictState, callback_context) == 0); assert!(offset_of!(ZSTD_rust_resetCCtxByAttachingCDictState, cdict) == size_of::()); assert!(offset_of!(ZSTD_rust_resetCCtxByAttachingCDictState, params) == 2 * size_of::()); @@ -1614,7 +1621,7 @@ const _: () = { ); assert!( offset_of!(ZSTD_rust_resetCCtxByAttachingCDictState, zbuff) - == 3 * size_of::() + size_of::() + size_of::<[usize; 8]>() + == 3 * size_of::() + size_of::() + size_of::<[usize; 16]>() ); assert!( size_of::() @@ -1624,8 +1631,8 @@ const _: () = { ); }; -/// Run the private CDict-attachment operation through C-owned layout callbacks -/// and copy the compressed-block state directly in Rust. +/// Run the private CDict-attachment operation through explicit C-owned field +/// projections and copy the compressed-block state directly in Rust. #[no_mangle] pub unsafe extern "C" fn ZSTD_rust_resetCCtxByAttachingCDict( state: *const ZSTD_rust_resetCCtxByAttachingCDictState, @@ -1634,12 +1641,21 @@ pub unsafe extern "C" fn ZSTD_rust_resetCCtxByAttachingCDict( return ERROR(ZstdErrorCode::Generic); } let state = unsafe { &*state }; - let (Some(reset), Some(attach)) = (state.reset, state.attach) else { + let Some(reset) = state.reset else { return ERROR(ZstdErrorCode::Generic); }; if state.callback_context.is_null() || state.cdict.is_null() || state.params.is_null() + || state.source_match_state.is_null() + || state.source_cdict_end.is_null() + || state.source_cdict_len.is_null() + || state.destination_dict_match_state.is_null() + || state.destination_window_next_src.is_null() + || state.destination_window_base.is_null() + || state.destination_window_low_limit.is_null() + || state.destination_window_dict_limit.is_null() + || state.destination_loaded_dict_end.is_null() || state.destination_dict_id.is_null() || state.source_dict_id.is_null() || state.destination_dict_content_size.is_null() @@ -1661,7 +1677,26 @@ pub unsafe extern "C" fn ZSTD_rust_resetCCtxByAttachingCDict( if ERR_isError(reset_error) { return reset_error; } - attach(state.callback_context, state.cdict); + let cdict_end = *state.source_cdict_end; + if *state.source_cdict_len != 0 { + *state.destination_dict_match_state = state.source_match_state; + if *state.destination_window_dict_limit < cdict_end { + let destination_window_base = *state.destination_window_base; + if destination_window_base.is_null() { + return ERROR(ZstdErrorCode::Generic); + } + *state.destination_window_next_src = destination_window_base + .cast::() + .wrapping_add(cdict_end as usize) + .cast(); + ZSTD_rust_windowClear( + cdict_end as usize, + state.destination_window_low_limit, + state.destination_window_dict_limit, + ); + } + *state.destination_loaded_dict_end = *state.destination_window_dict_limit; + } *state.destination_dict_id = *state.source_dict_id; *state.destination_dict_content_size = *state.source_dict_content_size; let destination_block_state = *state.destination_block_state; @@ -3161,7 +3196,6 @@ mod tests { assert_eq!(probe.events, ["reset"]); } - #[derive(Default)] struct ResetCCtxByAttachingCDictProbe { events: Vec<&'static str>, reset_result: usize, @@ -3169,6 +3203,37 @@ mod tests { params: *const c_void, pledged_src_size: u64, zbuff: c_int, + source_match_state: *const c_void, + source_cdict_end: c_uint, + source_cdict_len: c_uint, + destination_dict_match_state: *const c_void, + destination_window_next_src: *const c_void, + destination_window_base: *const c_void, + destination_window_low_limit: c_uint, + destination_window_dict_limit: c_uint, + destination_loaded_dict_end: c_uint, + } + + impl Default for ResetCCtxByAttachingCDictProbe { + fn default() -> Self { + Self { + events: Vec::new(), + reset_result: 0, + cdict: ptr::null(), + params: ptr::null(), + pledged_src_size: 0, + zbuff: 0, + source_match_state: 0x5000usize as *const c_void, + source_cdict_end: 21, + source_cdict_len: 5, + destination_dict_match_state: ptr::null(), + destination_window_next_src: ptr::null(), + destination_window_base: 0x1000usize as *const c_void, + destination_window_low_limit: 3, + destination_window_dict_limit: 13, + destination_loaded_dict_end: 0, + } + } } unsafe fn reset_cctx_by_attaching_cdict_probe( @@ -3193,15 +3258,6 @@ mod tests { probe.reset_result } - unsafe extern "C" fn reset_cctx_by_attaching_cdict_attach( - context: *mut c_void, - _cdict: *const c_void, - ) { - unsafe { reset_cctx_by_attaching_cdict_probe(context) } - .events - .push("attach"); - } - fn reset_cctx_by_attaching_cdict_test_state( probe: &mut ResetCCtxByAttachingCDictProbe, cdict: *const c_void, @@ -3219,7 +3275,15 @@ mod tests { params, pledged_src_size: 123, reset: Some(reset_cctx_by_attaching_cdict_reset), - attach: Some(reset_cctx_by_attaching_cdict_attach), + source_match_state: probe.source_match_state, + source_cdict_end: &probe.source_cdict_end, + source_cdict_len: &probe.source_cdict_len, + destination_dict_match_state: &mut probe.destination_dict_match_state, + destination_window_next_src: &mut probe.destination_window_next_src, + destination_window_base: &probe.destination_window_base, + destination_window_low_limit: &mut probe.destination_window_low_limit, + destination_window_dict_limit: &mut probe.destination_window_dict_limit, + destination_loaded_dict_end: &mut probe.destination_loaded_dict_end, destination_dict_id, source_dict_id, destination_dict_content_size, @@ -3231,7 +3295,7 @@ mod tests { } #[test] - fn reset_cctx_by_attaching_cdict_runs_callbacks_in_original_order() { + fn reset_cctx_by_attaching_cdict_updates_window_in_rust_after_reset() { let mut probe = ResetCCtxByAttachingCDictProbe::default(); let cdict = 0x4000usize as *const c_void; let params = 0x3000usize as *const c_void; @@ -3262,18 +3326,57 @@ mod tests { let result = unsafe { ZSTD_rust_resetCCtxByAttachingCDict(&state) }; assert_eq!(result, 0); - assert_eq!(probe.events, ["reset", "attach"]); + assert_eq!(probe.events, ["reset"]); assert_eq!(probe.cdict, cdict); assert_eq!(probe.params, params); assert_eq!(probe.pledged_src_size, 123); assert_eq!(probe.zbuff, 7); assert_eq!(destination_dict_id, source_dict_id); assert_eq!(destination_dict_content_size, source_dict_content_size); + assert_eq!(probe.destination_dict_match_state, probe.source_match_state); + assert_eq!( + probe.destination_window_next_src, + 0x1015usize as *const c_void + ); + assert_eq!(probe.destination_window_low_limit, probe.source_cdict_end); + assert_eq!(probe.destination_window_dict_limit, probe.source_cdict_end); + assert_eq!(probe.destination_loaded_dict_end, probe.source_cdict_end); assert_eq!(destination_block_state.rep, source_block_state.rep); assert_eq!( destination_block_state.entropy.huf.repeatMode, source_block_state.entropy.huf.repeatMode ); + + probe.events.clear(); + probe.destination_window_next_src = 0x2000usize as *const c_void; + probe.destination_window_low_limit = 7; + probe.destination_window_dict_limit = 25; + probe.destination_loaded_dict_end = 0; + + let result = unsafe { ZSTD_rust_resetCCtxByAttachingCDict(&state) }; + + assert_eq!(result, 0); + assert_eq!(probe.events, ["reset"]); + assert_eq!(probe.destination_dict_match_state, probe.source_match_state); + assert_eq!( + probe.destination_window_next_src, + 0x2000usize as *const c_void + ); + assert_eq!(probe.destination_window_low_limit, 7); + assert_eq!(probe.destination_window_dict_limit, 25); + assert_eq!(probe.destination_loaded_dict_end, 25); + + probe.events.clear(); + probe.source_cdict_len = 0; + probe.destination_dict_match_state = ptr::null(); + probe.destination_loaded_dict_end = 99; + + let result = unsafe { ZSTD_rust_resetCCtxByAttachingCDict(&state) }; + + assert_eq!(result, 0); + assert_eq!(probe.events, ["reset"]); + assert!(probe.destination_dict_match_state.is_null()); + assert_eq!(probe.destination_loaded_dict_end, 99); } #[test]