Esempio n. 1
0
        /** ZSTD_ldm_gear_init():
         *
         * Initializes the rolling hash state such that it will honor the
         * settings in params. */
        private static void ZSTD_ldm_gear_init(ldmRollingHashState_t *state, ldmParams_t * @params)
        {
            uint maxBitsInMask = ((@params->minMatchLength) < (64) ? (@params->minMatchLength) : (64));
            uint hashRateLog   = @params->hashRateLog;

            state->rolling = unchecked (~(uint)(0));
            if (hashRateLog > 0 && hashRateLog <= maxBitsInMask)
            {
                state->stopMask = (((ulong)(1) << (int)hashRateLog) - 1) << (int)(maxBitsInMask - hashRateLog);
            }
            else
            {
                state->stopMask = ((ulong)(1) << (int)hashRateLog) - 1;
            }
        }
Esempio n. 2
0
        /** 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. */
        private static nuint ZSTD_ldm_gear_feed(ldmRollingHashState_t *state, byte *data, nuint size, nuint *splits, uint *numSplits)
        {
            nuint n;
            ulong hash, mask;

            hash = state->rolling;
            mask = state->stopMask;
            n    = 0;
            while (n + 3 < size)
            {
                {
                    hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff];
                    n   += 1;
                    if (((hash & mask) == 0))
                    {
                        splits[*numSplits] = n;
                        *numSplits += 1;
                        if (*numSplits == 64)
                        {
                            goto done;
                        }
                    }
                }


                {
                    hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff];
                    n   += 1;
                    if (((hash & mask) == 0))
                    {
                        splits[*numSplits] = n;
                        *numSplits += 1;
                        if (*numSplits == 64)
                        {
                            goto done;
                        }
                    }
                }


                {
                    hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff];
                    n   += 1;
                    if (((hash & mask) == 0))
                    {
                        splits[*numSplits] = n;
                        *numSplits += 1;
                        if (*numSplits == 64)
                        {
                            goto done;
                        }
                    }
                }


                {
                    hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff];
                    n   += 1;
                    if (((hash & mask) == 0))
                    {
                        splits[*numSplits] = n;
                        *numSplits += 1;
                        if (*numSplits == 64)
                        {
                            goto done;
                        }
                    }
                }
            }

            while (n < size)
            {
                {
                    hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff];
                    n   += 1;
                    if (((hash & mask) == 0))
                    {
                        splits[*numSplits] = n;
                        *numSplits += 1;
                        if (*numSplits == 64)
                        {
                            goto done;
                        }
                    }
                }
            }

done:
            state->rolling = hash;
            return(n);
        }