Ejemplo n.º 1
0
        public static void ZSTD_fillHashTable(ZSTD_matchState_t *ms, void *end, ZSTD_dictTableLoadMethod_e dtlm)
        {
            ZSTD_compressionParameters *cParams = &ms->cParams;
            uint * hashTable        = ms->hashTable;
            uint   hBits            = cParams->hashLog;
            uint   mls              = cParams->minMatch;
            byte * @base            = ms->window.@base;
            byte * ip               = @base + ms->nextToUpdate;
            byte * iend             = ((byte *)(end)) - 8;
            uint   fastHashFillStep = 3;

            for (; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep)
            {
                uint  curr  = (uint)(ip - @base);
                nuint hash0 = ZSTD_hashPtr((void *)ip, hBits, mls);

                hashTable[hash0] = curr;
                if (dtlm == ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast)
                {
                    continue;
                }


                {
                    uint p;

                    for (p = 1; p < fastHashFillStep; ++p)
                    {
                        nuint hash = ZSTD_hashPtr((void *)(ip + p), hBits, mls);

                        if (hashTable[hash] == 0)
                        {
                            hashTable[hash] = curr + p;
                        }
                    }
                }
            }
        }
Ejemplo n.º 2
0
        public static void ZSTD_fillDoubleHashTable(ZSTD_matchState_t *ms, void *end, ZSTD_dictTableLoadMethod_e dtlm)
        {
            ZSTD_compressionParameters *cParams = &ms->cParams;
            uint * hashLarge        = ms->hashTable;
            uint   hBitsL           = cParams->hashLog;
            uint   mls              = cParams->minMatch;
            uint * hashSmall        = ms->chainTable;
            uint   hBitsS           = cParams->chainLog;
            byte * @base            = ms->window.@base;
            byte * ip               = @base + ms->nextToUpdate;
            byte * iend             = ((byte *)(end)) - 8;
            uint   fastHashFillStep = 3;

            for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep)
            {
                uint curr = (uint)(ip - @base);
                uint i;

                for (i = 0; i < fastHashFillStep; ++i)
                {
                    nuint smHash = ZSTD_hashPtr((void *)(ip + i), hBitsS, mls);
                    nuint lgHash = ZSTD_hashPtr((void *)(ip + i), hBitsL, 8);

                    if (i == 0)
                    {
                        hashSmall[smHash] = curr + i;
                    }

                    if (i == 0 || hashLarge[lgHash] == 0)
                    {
                        hashLarge[lgHash] = curr + i;
                    }

                    if (dtlm == ZSTD_dictTableLoadMethod_e.ZSTD_dtlm_fast)
                    {
                        break;
                    }
                }
            }
        }