feat(compress): move continue window updates into Rust
Project the match-state and optional LDM window fields directly through the compressContinue ABI so Rust can reuse the existing window-update leaf. Keep forceNonContiguous and nextToUpdate updates visible to the following C callbacks, preserve the match-before-LDM ordering, and remove the C window update callback while retaining context-sensitive overflow and block calls. Test Plan: - ulimit -v 41943040; CARGO_BUILD_JOBS=1 cargo fmt --all -- --check - ulimit -v 41943040; CARGO_BUILD_JOBS=1 cargo test --lib zstd_compress::tests::compress_continue -- --nocapture - ulimit -v 41943040; CARGO_BUILD_JOBS=1 cargo clippy --all-targets -- -D warnings - ulimit -v 41943040; CARGO_BUILD_JOBS=1 cargo test - ulimit -v 41943040; make -j1 - ulimit -v 41943040; make -j1 -C tests test-zstream ZSTREAM_TESTTIME=-T2s - ulimit -v 41943040; make -j1 -C tests test-fuzzer FUZZERTEST=-T3s FUZZER_FLAGS=--no-big-tests
This commit is contained in:
@@ -878,8 +878,20 @@ typedef char ZSTD_rust_frame_chunk_state_layout[
|
||||
? 1 : -1];
|
||||
|
||||
/* The high-level continue/block entry points are Rust-owned. This projection
|
||||
* carries frame-header scalars, mutable state, and C callbacks; the private
|
||||
* CCtx and match-state layout never crosses the ABI. */
|
||||
* carries frame-header scalars, mutable state, and C callbacks. Window
|
||||
* advancement uses direct pointers to the C-owned fields; the private CCtx
|
||||
* and match-state layout never crosses the ABI. */
|
||||
typedef struct {
|
||||
void* nextSrc;
|
||||
void* base;
|
||||
void* dictBase;
|
||||
void* dictLimit;
|
||||
void* lowLimit;
|
||||
void* forceNonContiguous;
|
||||
void* nextToUpdate;
|
||||
} ZSTD_rust_compressContinueWindowState;
|
||||
typedef char ZSTD_rust_compress_continue_window_state_layout[
|
||||
(sizeof(ZSTD_rust_compressContinueWindowState) == 7 * sizeof(void*)) ? 1 : -1];
|
||||
typedef void (*ZSTD_rust_compressContinueWindow_f)(void* context,
|
||||
const void* src,
|
||||
size_t srcSize);
|
||||
@@ -891,7 +903,8 @@ typedef size_t (*ZSTD_rust_compressContinueBlock_f)(void* context,
|
||||
U32 lastFrameChunk);
|
||||
typedef struct {
|
||||
void* callbackContext;
|
||||
ZSTD_rust_compressContinueWindow_f updateWindow;
|
||||
ZSTD_rust_compressContinueWindowState* windowState;
|
||||
ZSTD_rust_compressContinueWindowState* ldmWindowState;
|
||||
ZSTD_rust_compressContinueWindow_f correctOverflow;
|
||||
ZSTD_rust_compressContinueBlock_f compressFrameChunk;
|
||||
ZSTD_rust_compressContinueBlock_f compressBlock;
|
||||
@@ -907,6 +920,7 @@ typedef struct {
|
||||
int format;
|
||||
U32 windowLog;
|
||||
U32 dictID;
|
||||
int ldmEnabled;
|
||||
} ZSTD_rust_compressContinueState;
|
||||
size_t ZSTD_rust_compressContinue(
|
||||
const ZSTD_rust_compressContinueState* state,
|
||||
@@ -915,32 +929,35 @@ size_t ZSTD_rust_compressContinue(
|
||||
U32 frame, U32 lastFrameChunk);
|
||||
typedef char ZSTD_rust_compress_continue_state_layout[
|
||||
(offsetof(ZSTD_rust_compressContinueState, callbackContext) == 0
|
||||
&& offsetof(ZSTD_rust_compressContinueState, updateWindow) == sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, correctOverflow) == 2 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, compressFrameChunk) == 3 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, compressBlock) == 4 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, stage) == 5 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, consumedSrcSize) == 6 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, producedCSize) == 7 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, pledgedSrcSizePlusOne) == 8 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, windowState) == sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, ldmWindowState) == 2 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, correctOverflow) == 3 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, compressFrameChunk) == 4 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, compressBlock) == 5 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, stage) == 6 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, consumedSrcSize) == 7 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, producedCSize) == 8 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, pledgedSrcSizePlusOne) == 9 * sizeof(void*)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, blockSizeMax)
|
||||
== 8 * sizeof(void*) + sizeof(U64)
|
||||
== 9 * sizeof(void*) + sizeof(U64)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, checkBlockSize)
|
||||
== 8 * sizeof(void*) + sizeof(U64) + sizeof(size_t)
|
||||
== 9 * sizeof(void*) + sizeof(U64) + sizeof(size_t)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, noDictIDFlag)
|
||||
== 8 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + sizeof(int)
|
||||
== 9 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + sizeof(int)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, checksumFlag)
|
||||
== 8 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 2 * sizeof(int)
|
||||
== 9 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 2 * sizeof(int)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, contentSizeFlag)
|
||||
== 8 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 3 * sizeof(int)
|
||||
== 9 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 3 * sizeof(int)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, format)
|
||||
== 8 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 4 * sizeof(int)
|
||||
== 9 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 4 * sizeof(int)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, windowLog)
|
||||
== 8 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 5 * sizeof(int)
|
||||
== 9 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 5 * sizeof(int)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, dictID)
|
||||
== 8 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 5 * sizeof(int) + sizeof(U32)
|
||||
== 9 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 5 * sizeof(int) + sizeof(U32)
|
||||
&& offsetof(ZSTD_rust_compressContinueState, ldmEnabled)
|
||||
== 9 * sizeof(void*) + sizeof(U64) + sizeof(size_t) + 5 * sizeof(int) + 2 * sizeof(U32)
|
||||
&& sizeof(ZSTD_rust_compressContinueState)
|
||||
== (sizeof(void*) == 8 ? 112 : 72))
|
||||
== (sizeof(void*) == 8 ? 120 : 80))
|
||||
? 1 : -1];
|
||||
|
||||
/* Rust owns the end-of-frame orchestration. The callbacks retain the
|
||||
@@ -5612,22 +5629,6 @@ static size_t ZSTD_compress_frameChunk(ZSTD_CCtx* cctx,
|
||||
}
|
||||
|
||||
|
||||
static void ZSTD_rust_compressContinue_updateWindow(
|
||||
void* context, const void* src, size_t srcSize)
|
||||
{
|
||||
ZSTD_CCtx* const cctx = (ZSTD_CCtx*)context;
|
||||
ZSTD_MatchState_t* const ms = &cctx->blockState.matchState;
|
||||
|
||||
if (!ZSTD_window_update(&ms->window, src, srcSize, ms->forceNonContiguous)) {
|
||||
ms->forceNonContiguous = 0;
|
||||
ms->nextToUpdate = ms->window.dictLimit;
|
||||
}
|
||||
if (cctx->appliedParams.ldmParams.enableLdm == ZSTD_ps_enable) {
|
||||
ZSTD_window_update(&cctx->ldmState.window, src, srcSize,
|
||||
/* forceNonContiguous */ 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void ZSTD_rust_compressContinue_correctOverflow(
|
||||
void* context, const void* src, size_t srcSize)
|
||||
{
|
||||
@@ -5665,8 +5666,30 @@ static size_t ZSTD_compressContinue_dispatch(
|
||||
size_t blockSizeMax, int checkBlockSize)
|
||||
{
|
||||
ZSTD_rust_compressContinueState state;
|
||||
ZSTD_rust_compressContinueWindowState windowState;
|
||||
ZSTD_rust_compressContinueWindowState ldmWindowState;
|
||||
ZSTD_MatchState_t* const ms = &cctx->blockState.matchState;
|
||||
ZSTD_window_t* const window = &ms->window;
|
||||
ZSTD_window_t* const ldmWindow = &cctx->ldmState.window;
|
||||
|
||||
windowState.nextSrc = &window->nextSrc;
|
||||
windowState.base = &window->base;
|
||||
windowState.dictBase = &window->dictBase;
|
||||
windowState.dictLimit = &window->dictLimit;
|
||||
windowState.lowLimit = &window->lowLimit;
|
||||
windowState.forceNonContiguous = &ms->forceNonContiguous;
|
||||
windowState.nextToUpdate = &ms->nextToUpdate;
|
||||
ldmWindowState.nextSrc = &ldmWindow->nextSrc;
|
||||
ldmWindowState.base = &ldmWindow->base;
|
||||
ldmWindowState.dictBase = &ldmWindow->dictBase;
|
||||
ldmWindowState.dictLimit = &ldmWindow->dictLimit;
|
||||
ldmWindowState.lowLimit = &ldmWindow->lowLimit;
|
||||
ldmWindowState.forceNonContiguous = NULL;
|
||||
ldmWindowState.nextToUpdate = NULL;
|
||||
|
||||
state.callbackContext = cctx;
|
||||
state.updateWindow = ZSTD_rust_compressContinue_updateWindow;
|
||||
state.windowState = &windowState;
|
||||
state.ldmWindowState = &ldmWindowState;
|
||||
state.correctOverflow = ZSTD_rust_compressContinue_correctOverflow;
|
||||
state.compressFrameChunk = ZSTD_rust_compressContinue_frameChunk;
|
||||
state.compressBlock = ZSTD_rust_compressContinue_block;
|
||||
@@ -5682,6 +5705,7 @@ static size_t ZSTD_compressContinue_dispatch(
|
||||
state.format = (int)cctx->appliedParams.format;
|
||||
state.windowLog = cctx->appliedParams.cParams.windowLog;
|
||||
state.dictID = cctx->dictID;
|
||||
state.ldmEnabled = cctx->appliedParams.ldmParams.enableLdm == ZSTD_ps_enable;
|
||||
return ZSTD_rust_compressContinue(
|
||||
&state, dst, dstCapacity, src, srcSize, frame, lastFrameChunk);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user