

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: zstd_ldm.c</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'>/*
 * Copyright (c) Yann Collet, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under both the BSD-style license (found in the
 * LICENSE file in the root directory of this source tree) and the GPLv2 (found
 * in the COPYING file in the root directory of this source tree).
 * You may select, at your option, one of the above-listed licenses.
 */

#include &quot;zstd_ldm.h&quot;

#include &quot;../common/debug.h&quot;
#include &quot;../common/xxhash.h&quot;
#include &quot;zstd_fast.h&quot;          /* ZSTD_fillHashTable() */
#include &quot;zstd_double_fast.h&quot;   /* ZSTD_fillDoubleHashTable() */
#include &quot;zstd_ldm_geartab.h&quot;

#define LDM_BUCKET_SIZE_LOG 3
#define LDM_MIN_MATCH_LENGTH 64
#define LDM_HASH_RLOG 7

typedef struct {
    U64 rolling;
    U64 stopMask;
} ldmRollingHashState_t;

/** ZSTD_ldm_gear_init():
 *
 * Initializes the rolling hash state such that it will honor the
 * settings in params. */
static void ZSTD_ldm_gear_init(ldmRollingHashState_t* state, ldmParams_t const* params)
{
    unsigned maxBitsInMask = MIN(params-&gt;minMatchLength, 64);
    unsigned hashRateLog = params-&gt;hashRateLog;

    state-&gt;rolling = ~(U32)0;

    /* The choice of the splitting criterion is subject to two conditions:
     *   1. it has to trigger on average every 2^(hashRateLog) bytes;
     *   2. ideally, it has to depend on a window of minMatchLength bytes.
     *
     * In the gear hash algorithm, bit n depends on the last n bytes;
     * so in order to obtain a good quality splitting criterion it is
     * preferable to use bits with high weight.
     *
     * To match condition 1 we use a mask with hashRateLog bits set
     * and, because of the previous remark, we make sure these bits
     * have the highest possible weight while still respecting
     * condition 2.
     */
    if (hashRateLog &gt; 0 &amp;&amp; hashRateLog &lt;= maxBitsInMask) {
        state-&gt;stopMask = (((U64)1 &lt;&lt; hashRateLog) - 1) &lt;&lt; (maxBitsInMask - hashRateLog);
    } else {
        /* In this degenerate case we simply honor the hash rate. */
        state-&gt;stopMask = ((U64)1 &lt;&lt; hashRateLog) - 1;
    }
}

/** ZSTD_ldm_gear_reset()
 * Feeds [data, data + minMatchLength) into the hash without registering any
 * splits. This effectively resets the hash state. This is used when skipping
 * over data, either at the beginning of a block, or skipping sections.
 */
static void ZSTD_ldm_gear_reset(ldmRollingHashState_t* state,
                                BYTE const* data, size_t minMatchLength)
{
    U64 hash = state-&gt;rolling;
    size_t n = 0;

#define GEAR_ITER_ONCE() do {                                  \
        hash = (hash &lt;&lt; 1) + ZSTD_ldm_gearTab[data[n] &amp; 0xff]; \
        n += 1;                                                \
    } while (0)
    while (n + 3 &lt; minMatchLength) {
        GEAR_ITER_ONCE();
        GEAR_ITER_ONCE();
        GEAR_ITER_ONCE();
        GEAR_ITER_ONCE();
    }
    while (n &lt; minMatchLength) {
        GEAR_ITER_ONCE();
    }
#undef GEAR_ITER_ONCE
}

/** ZSTD_ldm_gear_feed():
 *
 * Registers in the splits array all the split points found in the first
 * size bytes following the data pointer. This function terminates when
 * either all the data has been processed or LDM_BATCH_SIZE splits are
 * present in the splits array.
 *
 * Precondition: The splits array must not be full.
 * Returns: The number of bytes processed. */
static size_t ZSTD_ldm_gear_feed(ldmRollingHashState_t* state,
                                 BYTE const* data, size_t size,
                                 size_t* splits, unsigned* numSplits)
{
    size_t n;
    U64 hash, mask;

    hash = state-&gt;rolling;
    mask = state-&gt;stopMask;
    n = 0;

#define GEAR_ITER_ONCE() do { \
        hash = (hash &lt;&lt; 1) + ZSTD_ldm_gearTab[data[n] &amp; 0xff]; \
        n += 1; \
        if (UNLIKELY((hash &amp; mask) == 0)) { \
            splits[*numSplits] = n; \
            *numSplits += 1; \
            if (*numSplits == LDM_BATCH_SIZE) \
                goto done; \
        } \
    } while (0)

    while (n + 3 &lt; size) {
        GEAR_ITER_ONCE();
        GEAR_ITER_ONCE();
        GEAR_ITER_ONCE();
        GEAR_ITER_ONCE();
    }
    while (n &lt; size) {
        GEAR_ITER_ONCE();
    }

#undef GEAR_ITER_ONCE

done:
    state-&gt;rolling = hash;
    return n;
}

void ZSTD_ldm_adjustParameters(ldmParams_t* params,
                               ZSTD_compressionParameters const* cParams)
{
    params-&gt;windowLog = cParams-&gt;windowLog;
    ZSTD_STATIC_ASSERT(LDM_BUCKET_SIZE_LOG &lt;= ZSTD_LDM_BUCKETSIZELOG_MAX);
    DEBUGLOG(4, &quot;ZSTD_ldm_adjustParameters&quot;);
    if (!params-&gt;bucketSizeLog) params-&gt;bucketSizeLog = LDM_BUCKET_SIZE_LOG;
    if (!params-&gt;minMatchLength) params-&gt;minMatchLength = LDM_MIN_MATCH_LENGTH;
    if (params-&gt;hashLog == 0) {
        params-&gt;hashLog = MAX(ZSTD_HASHLOG_MIN, params-&gt;windowLog - LDM_HASH_RLOG);
        assert(params-&gt;hashLog &lt;= ZSTD_HASHLOG_MAX);
    }
    if (params-&gt;hashRateLog == 0) {
        params-&gt;hashRateLog = params-&gt;windowLog &lt; params-&gt;hashLog
                                   ? 0
                                   : params-&gt;windowLog - params-&gt;hashLog;
    }
    params-&gt;bucketSizeLog = MIN(params-&gt;bucketSizeLog, params-&gt;hashLog);
}

size_t ZSTD_ldm_getTableSize(ldmParams_t params)
{
    size_t const ldmHSize = ((size_t)1) &lt;&lt; params.hashLog;
    size_t const ldmBucketSizeLog = MIN(params.bucketSizeLog, params.hashLog);
    size_t const ldmBucketSize = ((size_t)1) &lt;&lt; (params.hashLog - ldmBucketSizeLog);
    size_t const totalSize = ZSTD_cwksp_alloc_size(ldmBucketSize)
                           + ZSTD_cwksp_alloc_size(ldmHSize * sizeof(ldmEntry_t));
    return params.enableLdm ? totalSize : 0;
}

size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize)
{
    return params.enableLdm ? (maxChunkSize / params.minMatchLength) : 0;
}

/** ZSTD_ldm_getBucket() :
 *  Returns a pointer to the start of the bucket associated with hash. */
static ldmEntry_t* ZSTD_ldm_getBucket(
        ldmState_t* ldmState, size_t hash, ldmParams_t const ldmParams)
{
    return ldmState-&gt;hashTable + (hash &lt;&lt; ldmParams.bucketSizeLog);
}

/** ZSTD_ldm_insertEntry() :
 *  Insert the entry with corresponding hash into the hash table */
static void ZSTD_ldm_insertEntry(ldmState_t* ldmState,
                                 size_t const hash, const ldmEntry_t entry,
                                 ldmParams_t const ldmParams)
{
    BYTE* const pOffset = ldmState-&gt;bucketOffsets + hash;
    unsigned const offset = *pOffset;

    *(ZSTD_ldm_getBucket(ldmState, hash, ldmParams) + offset) = entry;
    *pOffset = (BYTE)((offset + 1) &amp; ((1u &lt;&lt; ldmParams.bucketSizeLog) - 1));

}

/** ZSTD_ldm_countBackwardsMatch() :
 *  Returns the number of bytes that match backwards before pIn and pMatch.
 *
 *  We count only bytes where pMatch &gt;= pBase and pIn &gt;= pAnchor. */
static size_t ZSTD_ldm_countBackwardsMatch(
            const BYTE* pIn, const BYTE* pAnchor,
            const BYTE* pMatch, const BYTE* pMatchBase)
{
    size_t matchLength = 0;
    while (pIn &gt; pAnchor &amp;&amp; pMatch &gt; pMatchBase &amp;&amp; pIn[-1] == pMatch[-1]) {
        pIn--;
        pMatch--;
        matchLength++;
    }
    return matchLength;
}

/** ZSTD_ldm_countBackwardsMatch_2segments() :
 *  Returns the number of bytes that match backwards from pMatch,
 *  even with the backwards match spanning 2 different segments.
 *
 *  On reaching `pMatchBase`, start counting from mEnd */
static size_t ZSTD_ldm_countBackwardsMatch_2segments(
                    const BYTE* pIn, const BYTE* pAnchor,
                    const BYTE* pMatch, const BYTE* pMatchBase,
                    const BYTE* pExtDictStart, const BYTE* pExtDictEnd)
{
    size_t matchLength = ZSTD_ldm_countBackwardsMatch(pIn, pAnchor, pMatch, pMatchBase);
    if (pMatch - matchLength != pMatchBase || pMatchBase == pExtDictStart) {
        /* If backwards match is entirely in the extDict or prefix, immediately return */
        return matchLength;
    }
    DEBUGLOG(7, &quot;ZSTD_ldm_countBackwardsMatch_2segments: found 2-parts backwards match (length in prefix==%zu)&quot;, matchLength);
    matchLength += ZSTD_ldm_countBackwardsMatch(pIn - matchLength, pAnchor, pExtDictEnd, pExtDictStart);
    DEBUGLOG(7, &quot;final backwards match length = %zu&quot;, matchLength);
    return matchLength;
}

/** ZSTD_ldm_fillFastTables() :
 *
 *  Fills the relevant tables for the ZSTD_fast and ZSTD_dfast strategies.
 *  This is similar to ZSTD_loadDictionaryContent.
 *
 *  The tables for the other strategies are filled within their
 *  block compressors. */
static size_t ZSTD_ldm_fillFastTables(ZSTD_matchState_t* ms,
                                      void const* end)
{
    const BYTE* const iend = (const BYTE*)end;

    switch(ms-&gt;cParams.strategy)
    {
    case ZSTD_fast:
        ZSTD_fillHashTable(ms, iend, ZSTD_dtlm_fast);
        break;

    case ZSTD_dfast:
        ZSTD_fillDoubleHashTable(ms, iend, ZSTD_dtlm_fast);
        break;

    case ZSTD_greedy:
    case ZSTD_lazy:
    case ZSTD_lazy2:
    case ZSTD_btlazy2:
    case ZSTD_btopt:
    case ZSTD_btultra:
    case ZSTD_btultra2:
        break;
    default:
        assert(0);  /* not possible : not a valid strategy id */
    }

    return 0;
}

void ZSTD_ldm_fillHashTable(
            ldmState_t* ldmState, const BYTE* ip,
            const BYTE* iend, ldmParams_t const* params)
{
    U32 const minMatchLength = params-&gt;minMatchLength;
    U32 const hBits = params-&gt;hashLog - params-&gt;bucketSizeLog;
    BYTE const* const base = ldmState-&gt;window.base;
    BYTE const* const istart = ip;
    ldmRollingHashState_t hashState;
    size_t* const splits = ldmState-&gt;splitIndices;
    unsigned numSplits;

    DEBUGLOG(5, &quot;ZSTD_ldm_fillHashTable&quot;);

    ZSTD_ldm_gear_init(&amp;hashState, params);
    while (ip &lt; iend) {
        size_t hashed;
        unsigned n;

        numSplits = 0;
        hashed = ZSTD_ldm_gear_feed(&amp;hashState, ip, iend - ip, splits, &amp;numSplits);

        for (n = 0; n &lt; numSplits; n++) {
            if (ip + splits[n] &gt;= istart + minMatchLength) {
                BYTE const* const split = ip + splits[n] - minMatchLength;
                U64 const xxhash = XXH64(split, minMatchLength, 0);
                U32 const hash = (U32)(xxhash &amp; (((U32)1 &lt;&lt; hBits) - 1));
                ldmEntry_t entry;

                entry.offset = (U32)(split - base);
                entry.checksum = (U32)(xxhash &gt;&gt; 32);
                ZSTD_ldm_insertEntry(ldmState, hash, entry, *params);
            }
        }

        ip += hashed;
    }
}


/** ZSTD_ldm_limitTableUpdate() :
 *
 *  Sets cctx-&gt;nextToUpdate to a position corresponding closer to anchor
 *  if it is far way
 *  (after a long match, only update tables a limited amount). */
static void ZSTD_ldm_limitTableUpdate(ZSTD_matchState_t* ms, const BYTE* anchor)
{
    U32 const curr = (U32)(anchor - ms-&gt;window.base);
    if (curr &gt; ms-&gt;nextToUpdate + 1024) {
        ms-&gt;nextToUpdate =
            curr - MIN(512, curr - ms-&gt;nextToUpdate - 1024);
    }
}

static size_t ZSTD_ldm_generateSequences_internal(
        ldmState_t* ldmState, rawSeqStore_t* rawSeqStore,
        ldmParams_t const* params, void const* src, size_t srcSize)
{
    /* LDM parameters */
    int const extDict = ZSTD_window_hasExtDict(ldmState-&gt;window);
    U32 const minMatchLength = params-&gt;minMatchLength;
    U32 const entsPerBucket = 1U &lt;&lt; params-&gt;bucketSizeLog;
    U32 const hBits = params-&gt;hashLog - params-&gt;bucketSizeLog;
    /* Prefix and extDict parameters */
    U32 const dictLimit = ldmState-&gt;window.dictLimit;
    U32 const lowestIndex = extDict ? ldmState-&gt;window.lowLimit : dictLimit;
    BYTE const* const base = ldmState-&gt;window.base;
    BYTE const* const dictBase = extDict ? ldmState-&gt;window.dictBase : NULL;
    BYTE const* const dictStart = extDict ? dictBase + lowestIndex : NULL;
    BYTE const* const dictEnd = extDict ? dictBase + dictLimit : NULL;
    BYTE const* const lowPrefixPtr = base + dictLimit;
    /* Input bounds */
    BYTE const* const istart = (BYTE const*)src;
    BYTE const* const iend = istart + srcSize;
    BYTE const* const ilimit = iend - HASH_READ_SIZE;
    /* Input positions */
    BYTE const* anchor = istart;
    BYTE const* ip = istart;
    /* Rolling hash state */
    ldmRollingHashState_t hashState;
    /* Arrays for staged-processing */
    size_t* const splits = ldmState-&gt;splitIndices;
    ldmMatchCandidate_t* const candidates = ldmState-&gt;matchCandidates;
    unsigned numSplits;

    if (srcSize &lt; minMatchLength)
        return iend - anchor;

    /* Initialize the rolling hash state with the first minMatchLength bytes */
    ZSTD_ldm_gear_init(&amp;hashState, params);
    ZSTD_ldm_gear_reset(&amp;hashState, ip, minMatchLength);
    ip += minMatchLength;

    while (ip &lt; ilimit) {
        size_t hashed;
        unsigned n;

        numSplits = 0;
        hashed = ZSTD_ldm_gear_feed(&amp;hashState, ip, ilimit - ip,
                                    splits, &amp;numSplits);

        for (n = 0; n &lt; numSplits; n++) {
            BYTE const* const split = ip + splits[n] - minMatchLength;
            U64 const xxhash = XXH64(split, minMatchLength, 0);
            U32 const hash = (U32)(xxhash &amp; (((U32)1 &lt;&lt; hBits) - 1));

            candidates[n].split = split;
            candidates[n].hash = hash;
            candidates[n].checksum = (U32)(xxhash &gt;&gt; 32);
            candidates[n].bucket = ZSTD_ldm_getBucket(ldmState, hash, *params);
            PREFETCH_L1(candidates[n].bucket);
        }

        for (n = 0; n &lt; numSplits; n++) {
            size_t forwardMatchLength = 0, backwardMatchLength = 0,
                   bestMatchLength = 0, mLength;
            U32 offset;
            BYTE const* const split = candidates[n].split;
            U32 const checksum = candidates[n].checksum;
            U32 const hash = candidates[n].hash;
            ldmEntry_t* const bucket = candidates[n].bucket;
            ldmEntry_t const* cur;
            ldmEntry_t const* bestEntry = NULL;
            ldmEntry_t newEntry;

            newEntry.offset = (U32)(split - base);
            newEntry.checksum = checksum;

            /* If a split point would generate a sequence overlapping with
             * the previous one, we merely register it in the hash table and
             * move on */
            if (split &lt; anchor) {
                ZSTD_ldm_insertEntry(ldmState, hash, newEntry, *params);
                continue;
            }

            for (cur = bucket; cur &lt; bucket + entsPerBucket; cur++) {
                size_t curForwardMatchLength, curBackwardMatchLength,
                       curTotalMatchLength;
                if (cur-&gt;checksum != checksum || cur-&gt;offset &lt;= lowestIndex) {
                    continue;
                }
                if (extDict) {
                    BYTE const* const curMatchBase =
                        cur-&gt;offset &lt; dictLimit ? dictBase : base;
                    BYTE const* const pMatch = curMatchBase + cur-&gt;offset;
                    BYTE const* const matchEnd =
                        cur-&gt;offset &lt; dictLimit ? dictEnd : iend;
                    BYTE const* const lowMatchPtr =
                        cur-&gt;offset &lt; dictLimit ? dictStart : lowPrefixPtr;
                    curForwardMatchLength =
                        ZSTD_count_2segments(split, pMatch, iend, matchEnd, lowPrefixPtr);
                    if (curForwardMatchLength &lt; minMatchLength) {
                        continue;
                    }
                    curBackwardMatchLength = ZSTD_ldm_countBackwardsMatch_2segments(
                            split, anchor, pMatch, lowMatchPtr, dictStart, dictEnd);
                } else { /* !extDict */
                    BYTE const* const pMatch = base + cur-&gt;offset;
                    curForwardMatchLength = ZSTD_count(split, pMatch, iend);
                    if (curForwardMatchLength &lt; minMatchLength) {
                        continue;
                    }
                    curBackwardMatchLength =
                        ZSTD_ldm_countBackwardsMatch(split, anchor, pMatch, lowPrefixPtr);
                }
                curTotalMatchLength = curForwardMatchLength + curBackwardMatchLength;

                if (curTotalMatchLength &gt; bestMatchLength) {
                    bestMatchLength = curTotalMatchLength;
                    forwardMatchLength = curForwardMatchLength;
                    backwardMatchLength = curBackwardMatchLength;
                    bestEntry = cur;
                }
            }

            /* No match found -- insert an entry into the hash table
             * and process the next candidate match */
            if (bestEntry == NULL) {
                ZSTD_ldm_insertEntry(ldmState, hash, newEntry, *params);
                continue;
            }

            /* Match found */
            offset = (U32)(split - base) - bestEntry-&gt;offset;
            mLength = forwardMatchLength + backwardMatchLength;
            {
                rawSeq* const seq = rawSeqStore-&gt;seq + rawSeqStore-&gt;size;

                /* Out of sequence storage */
                if (rawSeqStore-&gt;size == rawSeqStore-&gt;capacity)
                    return ERROR(dstSize_tooSmall);
                seq-&gt;litLength = (U32)(split - backwardMatchLength - anchor);
                seq-&gt;matchLength = (U32)mLength;
                seq-&gt;offset = offset;
                rawSeqStore-&gt;size++;
            }

            /* Insert the current entry into the hash table --- it must be
             * done after the previous block to avoid clobbering bestEntry */
            ZSTD_ldm_insertEntry(ldmState, hash, newEntry, *params);

            anchor = split + forwardMatchLength;

            /* If we find a match that ends after the data that we've hashed
             * then we have a repeating, overlapping, pattern. E.g. all zeros.
             * If one repetition of the pattern matches our `stopMask` then all
             * repetitions will. We don't need to insert them all into out table,
             * only the first one. So skip over overlapping matches.
             * This is a major speed boost (20x) for compressing a single byte
             * repeated, when that byte ends up in the table.
             */
            if (anchor &gt; ip + hashed) {
                ZSTD_ldm_gear_reset(&amp;hashState, anchor - minMatchLength, minMatchLength);
                /* Continue the outter loop at anchor (ip + hashed == anchor). */
                ip = anchor - hashed;
                break;
            }
        }

        ip += hashed;
    }

    return iend - anchor;
}

/*! ZSTD_ldm_reduceTable() :
 *  reduce table indexes by `reducerValue` */
static void ZSTD_ldm_reduceTable(ldmEntry_t* const table, U32 const size,
                                 U32 const reducerValue)
{
    U32 u;
    for (u = 0; u &lt; size; u++) {
        if (table[u].offset &lt; reducerValue) table[u].offset = 0;
        else table[u].offset -= reducerValue;
    }
}

size_t ZSTD_ldm_generateSequences(
        ldmState_t* ldmState, rawSeqStore_t* sequences,
        ldmParams_t const* params, void const* src, size_t srcSize)
{
    U32 const maxDist = 1U &lt;&lt; params-&gt;windowLog;
    BYTE const* const istart = (BYTE const*)src;
    BYTE const* const iend = istart + srcSize;
    size_t const kMaxChunkSize = 1 &lt;&lt; 20;
    size_t const nbChunks = (srcSize / kMaxChunkSize) + ((srcSize % kMaxChunkSize) != 0);
    size_t chunk;
    size_t leftoverSize = 0;

    assert(ZSTD_CHUNKSIZE_MAX &gt;= kMaxChunkSize);
    /* Check that ZSTD_window_update() has been called for this chunk prior
     * to passing it to this function.
     */
    assert(ldmState-&gt;window.nextSrc &gt;= (BYTE const*)src + srcSize);
    /* The input could be very large (in zstdmt), so it must be broken up into
     * chunks to enforce the maximum distance and handle overflow correction.
     */
    assert(sequences-&gt;pos &lt;= sequences-&gt;size);
    assert(sequences-&gt;size &lt;= sequences-&gt;capacity);
    for (chunk = 0; chunk &lt; nbChunks &amp;&amp; sequences-&gt;size &lt; sequences-&gt;capacity; ++chunk) {
        BYTE const* const chunkStart = istart + chunk * kMaxChunkSize;
        size_t const remaining = (size_t)(iend - chunkStart);
        BYTE const *const chunkEnd =
            (remaining &lt; kMaxChunkSize) ? iend : chunkStart + kMaxChunkSize;
        size_t const chunkSize = chunkEnd - chunkStart;
        size_t newLeftoverSize;
        size_t const prevSize = sequences-&gt;size;

        assert(chunkStart &lt; iend);
        /* 1. Perform overflow correction if necessary. */
        if (ZSTD_window_needOverflowCorrection(ldmState-&gt;window, 0, maxDist, ldmState-&gt;loadedDictEnd, chunkStart, chunkEnd)) {
            U32 const ldmHSize = 1U &lt;&lt; params-&gt;hashLog;
            U32 const correction = ZSTD_window_correctOverflow(
                &amp;ldmState-&gt;window, /* cycleLog */ 0, maxDist, chunkStart);
            ZSTD_ldm_reduceTable(ldmState-&gt;hashTable, ldmHSize, correction);
            /* invalidate dictionaries on overflow correction */
            ldmState-&gt;loadedDictEnd = 0;
        }
        /* 2. We enforce the maximum offset allowed.
         *
         * kMaxChunkSize should be small enough that we don't lose too much of
         * the window through early invalidation.
         * TODO: * Test the chunk size.
         *       * Try invalidation after the sequence generation and test the
         *         the offset against maxDist directly.
         *
         * NOTE: Because of dictionaries + sequence splitting we MUST make sure
         * that any offset used is valid at the END of the sequence, since it may
         * be split into two sequences. This condition holds when using
         * ZSTD_window_enforceMaxDist(), but if we move to checking offsets
         * against maxDist directly, we'll have to carefully handle that case.
         */
        ZSTD_window_enforceMaxDist(&amp;ldmState-&gt;window, chunkEnd, maxDist, &amp;ldmState-&gt;loadedDictEnd, NULL);
        /* 3. Generate the sequences for the chunk, and get newLeftoverSize. */
        newLeftoverSize = ZSTD_ldm_generateSequences_internal(
            ldmState, sequences, params, chunkStart, chunkSize);
        if (ZSTD_isError(newLeftoverSize))
            return newLeftoverSize;
        /* 4. We add the leftover literals from previous iterations to the first
         *    newly generated sequence, or add the `newLeftoverSize` if none are
         *    generated.
         */
        /* Prepend the leftover literals from the last call */
        if (prevSize &lt; sequences-&gt;size) {
            sequences-&gt;seq[prevSize].litLength += (U32)leftoverSize;
            leftoverSize = newLeftoverSize;
        } else {
            assert(newLeftoverSize == chunkSize);
            leftoverSize += chunkSize;
        }
    }
    return 0;
}

void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize, U32 const minMatch) {
    while (srcSize &gt; 0 &amp;&amp; rawSeqStore-&gt;pos &lt; rawSeqStore-&gt;size) {
        rawSeq* seq = rawSeqStore-&gt;seq + rawSeqStore-&gt;pos;
        if (srcSize &lt;= seq-&gt;litLength) {
            /* Skip past srcSize literals */
            seq-&gt;litLength -= (U32)srcSize;
            return;
        }
        srcSize -= seq-&gt;litLength;
        seq-&gt;litLength = 0;
        if (srcSize &lt; seq-&gt;matchLength) {
            /* Skip past the first srcSize of the match */
            seq-&gt;matchLength -= (U32)srcSize;
            if (seq-&gt;matchLength &lt; minMatch) {
                /* The match is too short, omit it */
                if (rawSeqStore-&gt;pos + 1 &lt; rawSeqStore-&gt;size) {
                    seq[1].litLength += seq[0].matchLength;
                }
                rawSeqStore-&gt;pos++;
            }
            return;
        }
        srcSize -= seq-&gt;matchLength;
        seq-&gt;matchLength = 0;
        rawSeqStore-&gt;pos++;
    }
}

/**
 * If the sequence length is longer than remaining then the sequence is split
 * between this block and the next.
 *
 * Returns the current sequence to handle, or if the rest of the block should
 * be literals, it returns a sequence with offset == 0.
 */
static rawSeq maybeSplitSequence(rawSeqStore_t* rawSeqStore,
                                 U32 const remaining, U32 const minMatch)
{
    rawSeq sequence = rawSeqStore-&gt;seq[rawSeqStore-&gt;pos];
    assert(sequence.offset &gt; 0);
    /* Likely: No partial sequence */
    if (remaining &gt;= sequence.litLength + sequence.matchLength) {
        rawSeqStore-&gt;pos++;
        return sequence;
    }
    /* Cut the sequence short (offset == 0 ==&gt; rest is literals). */
    if (remaining &lt;= sequence.litLength) {
        sequence.offset = 0;
    } else if (remaining &lt; sequence.litLength + sequence.matchLength) {
        sequence.matchLength = remaining - sequence.litLength;
        if (sequence.matchLength &lt; minMatch) {
            sequence.offset = 0;
        }
    }
    /* Skip past `remaining` bytes for the future sequences. */
    ZSTD_ldm_skipSequences(rawSeqStore, remaining, minMatch);
    return sequence;
}

void ZSTD_ldm_skipRawSeqStoreBytes(rawSeqStore_t* rawSeqStore, size_t nbBytes) {
    U32 currPos = (U32)(rawSeqStore-&gt;posInSequence + nbBytes);
    while (currPos &amp;&amp; rawSeqStore-&gt;pos &lt; rawSeqStore-&gt;size) {
        rawSeq currSeq = rawSeqStore-&gt;seq[rawSeqStore-&gt;pos];
        if (currPos &gt;= currSeq.litLength + currSeq.matchLength) {
            currPos -= currSeq.litLength + currSeq.matchLength;
            rawSeqStore-&gt;pos++;
        } else {
            rawSeqStore-&gt;posInSequence = currPos;
            break;
        }
    }
    if (currPos == 0 || rawSeqStore-&gt;pos == rawSeqStore-&gt;size) {
        rawSeqStore-&gt;posInSequence = 0;
    }
}

size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
    ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
    ZSTD_useRowMatchFinderMode_e useRowMatchFinder,
    void const* src, size_t srcSize)
{
    const ZSTD_compressionParameters* const cParams = &amp;ms-&gt;cParams;
    unsigned const minMatch = cParams-&gt;minMatch;
    ZSTD_blockCompressor const blockCompressor =
        ZSTD_selectBlockCompressor(cParams-&gt;strategy, useRowMatchFinder, ZSTD_matchState_dictMode(ms));
    /* Input bounds */
    BYTE const* const istart = (BYTE const*)src;
    BYTE const* const iend = istart + srcSize;
    /* Input positions */
    BYTE const* ip = istart;

    DEBUGLOG(5, &quot;ZSTD_ldm_blockCompress: srcSize=%zu&quot;, srcSize);
    /* If using opt parser, use LDMs only as candidates rather than always accepting them */
    if (cParams-&gt;strategy &gt;= ZSTD_btopt) {
        size_t lastLLSize;
        ms-&gt;ldmSeqStore = rawSeqStore;
        lastLLSize = blockCompressor(ms, seqStore, rep, src, srcSize);
        ZSTD_ldm_skipRawSeqStoreBytes(rawSeqStore, srcSize);
        return lastLLSize;
    }

    assert(rawSeqStore-&gt;pos &lt;= rawSeqStore-&gt;size);
    assert(rawSeqStore-&gt;size &lt;= rawSeqStore-&gt;capacity);
    /* Loop through each sequence and apply the block compressor to the literals */
    while (rawSeqStore-&gt;pos &lt; rawSeqStore-&gt;size &amp;&amp; ip &lt; iend) {
        /* maybeSplitSequence updates rawSeqStore-&gt;pos */
        rawSeq const sequence = maybeSplitSequence(rawSeqStore,
                                                   (U32)(iend - ip), minMatch);
        int i;
        /* End signal */
        if (sequence.offset == 0)
            break;

        assert(ip + sequence.litLength + sequence.matchLength &lt;= iend);

        /* Fill tables for block compressor */
        ZSTD_ldm_limitTableUpdate(ms, ip);
        ZSTD_ldm_fillFastTables(ms, ip);
        /* Run the block compressor */
        DEBUGLOG(5, &quot;pos %u : calling block compressor on segment of size %u&quot;, (unsigned)(ip-istart), sequence.litLength);
        {
            size_t const newLitLength =
                blockCompressor(ms, seqStore, rep, ip, sequence.litLength);
            ip += sequence.litLength;
            /* Update the repcodes */
            for (i = ZSTD_REP_NUM - 1; i &gt; 0; i--)
                rep[i] = rep[i-1];
            rep[0] = sequence.offset;
            /* Store the sequence */
            ZSTD_storeSeq(seqStore, newLitLength, ip - newLitLength, iend,
                          sequence.offset + ZSTD_REP_MOVE,
                          sequence.matchLength - MINMATCH);
            ip += sequence.matchLength;
        }
    }
    /* Fill the tables for the block compressor */
    ZSTD_ldm_limitTableUpdate(ms, ip);
    ZSTD_ldm_fillFastTables(ms, ip);
    /* Compress the last literals */
    return blockCompressor(ms, seqStore, rep, ip, iend - ip);
}
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/src/cmake-3.25.0/Utilities/cmzstd/lib/compress/zstd_ldm.c'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fusr%2Fsrc%2Fcmake-3.25.0%2FUtilities%2Fcmzstd%2Flib%2Fcompress' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>