feat(compress): move block split search to Rust

Port the recursive post-block-split partition search behind a narrow Rust ABI leaf while keeping CCtx ownership, entropy-state projection, and block emission in C. Preserve left-first midpoint insertion, minimum-sequence gating, the split cap, and error-as-no-split behavior.

Test Plan:

- cargo test --manifest-path rust/Cargo.toml --no-default-features --features compression

- cargo clippy --manifest-path rust/Cargo.toml --no-default-features --features compression --all-targets

- cargo +nightly fmt --manifest-path rust/Cargo.toml

- make -B -C lib -j2 lib

- tests/fuzzer -s4560 -t47 -i48 -v

lib/compress/zstd_compress.c

@@ -288,6 +288,17 @@ size_t ZSTD_rust_countSeqStoreMatchBytes(const SeqStore_t* seqStore);
 void ZSTD_rust_deriveSeqStoreChunk(SeqStore_t* resultSeqStore,
                                    const SeqStore_t* originalSeqStore,
                                    size_t startIdx, size_t endIdx);
+size_t ZSTD_rust_deriveBlockSplits(
+        U32* partitions, U32 nbSeq,
+        const SeqStore_t* originalSeqStore,
+        SeqStore_t* fullSeqStoreChunk,
+        SeqStore_t* firstHalfSeqStore,
+        SeqStore_t* secondHalfSeqStore,
+        const ZSTD_entropyCTables_t* prevEntropy,
+        ZSTD_entropyCTables_t* nextEntropy,
+        int strategy, int disableLiteralCompression,
+        ZSTD_entropyCTablesMetadata_t* entropyMetadata,
+        void* workspace, size_t workspaceSize);
 void ZSTD_rust_seqStore_resolveOffCodes(U32 dRep[ZSTD_REP_NUM],
                                         U32 cRep[ZSTD_REP_NUM],
                                         const SeqStore_t* seqStore,
@@ -2651,7 +2662,7 @@ ZSTD_estimateBlockSize(const BYTE* literals, size_t litSize,
  *
  * @return: estimated compressed size of the seqStore, or a zstd error.
  */
-static size_t
+UNUSED_ATTR static size_t
 ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(SeqStore_t* seqStore, ZSTD_CCtx* zc)
 {
     ZSTD_entropyCTablesMetadata_t* const entropyMetadata = &zc->blockSplitCtx.entropyMetadata;
@@ -2791,66 +2802,6 @@ ZSTD_compressSeqStore_singleBlock(ZSTD_CCtx* zc,
     return cSize;
 }
 
-/* Struct to keep track of where we are in our recursive calls. */
-typedef struct {
-    U32* splitLocations;    /* Array of split indices */
-    size_t idx;             /* The current index within splitLocations being worked on */
-} seqStoreSplits;
-
-#define MIN_SEQUENCES_BLOCK_SPLITTING 300
-
-/* Helper function to perform the recursive search for block splits.
- * Estimates the cost of seqStore prior to split, and estimates the cost of splitting the sequences in half.
- * If advantageous to split, then we recurse down the two sub-blocks.
- * If not, or if an error occurred in estimation, then we do not recurse.
- *
- * Note: The recursion depth is capped by a heuristic minimum number of sequences,
- * defined by MIN_SEQUENCES_BLOCK_SPLITTING.
- * In theory, this means the absolute largest recursion depth is 10 == log2(maxNbSeqInBlock/MIN_SEQUENCES_BLOCK_SPLITTING).
- * In practice, recursion depth usually doesn't go beyond 4.
- *
- * Furthermore, the number of splits is capped by ZSTD_MAX_NB_BLOCK_SPLITS.
- * At ZSTD_MAX_NB_BLOCK_SPLITS == 196 with the current existing blockSize
- * maximum of 128 KB, this value is actually impossible to reach.
- */
-static void
-ZSTD_deriveBlockSplitsHelper(seqStoreSplits* splits, size_t startIdx, size_t endIdx,
-                             ZSTD_CCtx* zc, const SeqStore_t* origSeqStore)
-{
-    SeqStore_t* const fullSeqStoreChunk = &zc->blockSplitCtx.fullSeqStoreChunk;
-    SeqStore_t* const firstHalfSeqStore = &zc->blockSplitCtx.firstHalfSeqStore;
-    SeqStore_t* const secondHalfSeqStore = &zc->blockSplitCtx.secondHalfSeqStore;
-    size_t estimatedOriginalSize;
-    size_t estimatedFirstHalfSize;
-    size_t estimatedSecondHalfSize;
-    size_t midIdx = (startIdx + endIdx)/2;
-
-    DEBUGLOG(5, "ZSTD_deriveBlockSplitsHelper: startIdx=%zu endIdx=%zu", startIdx, endIdx);
-    assert(endIdx >= startIdx);
-    if (endIdx - startIdx < MIN_SEQUENCES_BLOCK_SPLITTING || splits->idx >= ZSTD_MAX_NB_BLOCK_SPLITS) {
-        DEBUGLOG(6, "ZSTD_deriveBlockSplitsHelper: Too few sequences (%zu)", endIdx - startIdx);
-        return;
-    }
-    ZSTD_deriveSeqStoreChunk(fullSeqStoreChunk, origSeqStore, startIdx, endIdx);
-    ZSTD_deriveSeqStoreChunk(firstHalfSeqStore, origSeqStore, startIdx, midIdx);
-    ZSTD_deriveSeqStoreChunk(secondHalfSeqStore, origSeqStore, midIdx, endIdx);
-    estimatedOriginalSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(fullSeqStoreChunk, zc);
-    estimatedFirstHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(firstHalfSeqStore, zc);
-    estimatedSecondHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(secondHalfSeqStore, zc);
-    DEBUGLOG(5, "Estimated original block size: %zu -- First half split: %zu -- Second half split: %zu",
-             estimatedOriginalSize, estimatedFirstHalfSize, estimatedSecondHalfSize);
-    if (ZSTD_isError(estimatedOriginalSize) || ZSTD_isError(estimatedFirstHalfSize) || ZSTD_isError(estimatedSecondHalfSize)) {
-        return;
-    }
-    if (estimatedFirstHalfSize + estimatedSecondHalfSize < estimatedOriginalSize) {
-        DEBUGLOG(5, "split decided at seqNb:%zu", midIdx);
-        ZSTD_deriveBlockSplitsHelper(splits, startIdx, midIdx, zc, origSeqStore);
-        splits->splitLocations[splits->idx] = (U32)midIdx;
-        splits->idx++;
-        ZSTD_deriveBlockSplitsHelper(splits, midIdx, endIdx, zc, origSeqStore);
-    }
-}
-
 /* Base recursive function.
  * Populates a table with intra-block partition indices that can improve compression ratio.
  *
@@ -2858,18 +2809,19 @@ ZSTD_deriveBlockSplitsHelper(seqStoreSplits* splits, size_t startIdx, size_t end
  */
 static size_t ZSTD_deriveBlockSplits(ZSTD_CCtx* zc, U32 partitions[], U32 nbSeq)
 {
-    seqStoreSplits splits;
-    splits.splitLocations = partitions;
-    splits.idx = 0;
-    if (nbSeq <= 4) {
-        DEBUGLOG(5, "ZSTD_deriveBlockSplits: Too few sequences to split (%u <= 4)", nbSeq);
-        /* Refuse to try and split anything with less than 4 sequences */
-        return 0;
-    }
-    ZSTD_deriveBlockSplitsHelper(&splits, 0, nbSeq, zc, &zc->seqStore);
-    splits.splitLocations[splits.idx] = nbSeq;
-    DEBUGLOG(5, "ZSTD_deriveBlockSplits: final nb partitions: %zu", splits.idx+1);
-    return splits.idx;
+    return ZSTD_rust_deriveBlockSplits(
+            partitions, nbSeq,
+            &zc->seqStore,
+            &zc->blockSplitCtx.fullSeqStoreChunk,
+            &zc->blockSplitCtx.firstHalfSeqStore,
+            &zc->blockSplitCtx.secondHalfSeqStore,
+            &zc->blockState.prevCBlock->entropy,
+            &zc->blockState.nextCBlock->entropy,
+            (int)zc->appliedParams.cParams.strategy,
+            ZSTD_literalsCompressionIsDisabled(&zc->appliedParams),
+            &zc->blockSplitCtx.entropyMetadata,
+            zc->tmpWorkspace,
+            zc->tmpWkspSize);
 }
 
 /* ZSTD_compressBlock_splitBlock():