Esempio n. 1
0
        static internal ulong InternalDigestState64(State64 state)
        {
            InputTextStream p    = new InputTextStream(state.mem64);
            long            bEnd = state.memsize;
            ulong           h64;

            if (state.total_len >= 32)
            {
                ulong v1 = state.v1;
                ulong v2 = state.v2;
                ulong v3 = state.v3;
                ulong v4 = state.v4;

                h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
                h64 = XXH64_mergeRound(h64, v1);
                h64 = XXH64_mergeRound(h64, v2);
                h64 = XXH64_mergeRound(h64, v3);
                h64 = XXH64_mergeRound(h64, v4);
            }
            else
            {
                h64 = state.v3 + PRIME64_5;
            }

            h64 += state.total_len;

            while (p.Position + 8 <= bEnd)
            {
                ulong k1 = XXH64_round(0, p.ReadUInt64());
                h64 ^= k1;
                h64  = XXH_rotl64(h64, 27) * PRIME64_1 + PRIME64_4;
            }

            if (p.Position + 4 <= bEnd)
            {
                h64 ^= (ulong)(p.ReadUInt32()) * PRIME64_1;
                h64  = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
            }

            while (p.Position < bEnd)
            {
                h64 ^= p.ReadByte() * PRIME64_5;
                h64  = XXH_rotl64(h64, 11) * PRIME64_1;
            }

            h64 ^= h64 >> 33;
            h64 *= PRIME64_2;
            h64 ^= h64 >> 29;
            h64 *= PRIME64_3;
            h64 ^= h64 >> 32;

            return(h64);
        }
Esempio n. 2
0
        static public ulong XXH64(byte[] input, int offset, int length, ulong seed)
        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }
            if (input.Rank != 1)
            {
                ThrowArrayMultiRank("input");
            }
            if (input.GetLowerBound(0) != 0)
            {
                ThrowArrayNonZeroLowerBound("input");
            }
            if (offset < 0)
            {
                ThrowArgumentNonNegativeNumber("offset");
            }
            if (length < 0)
            {
                ThrowArgumentNonNegativeNumber("length");
            }
            if (input.Length < (offset + length))
            {
                ThrowArrayInvalidOffsetAndLength();
            }

#if EnableSimpleVersion
            /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
            State64 state = new State64();
            ResetState64(state, seed);
            UpdateState64(state, input, offset, length);
            return(DigestState64(state));
#else
            InputTextStream p    = new InputTextStream(input, offset);
            long            bEnd = p.Position + length;
            ulong           h64;

            if (length >= 32)
            {
                long  limit = bEnd - 32;
                ulong v1    = seed + PRIME64_1 + PRIME64_2;
                ulong v2    = seed + PRIME64_2;
                ulong v3    = seed + 0;
                ulong v4    = seed - PRIME64_1;

                do
                {
                    v1 += p.ReadUInt64() * PRIME64_2;
                    v1  = XXH_rotl64(v1, 31);
                    v1 *= PRIME64_1;

                    v2 += p.ReadUInt64() * PRIME64_2;
                    v2  = XXH_rotl64(v2, 31);
                    v2 *= PRIME64_1;

                    v3 += p.ReadUInt64() * PRIME64_2;
                    v3  = XXH_rotl64(v3, 31);
                    v3 *= PRIME64_1;

                    v4 += p.ReadUInt64() * PRIME64_2;
                    v4  = XXH_rotl64(v4, 31);
                    v4 *= PRIME64_1;
                }while (p.Position <= limit);

                h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);

                v1  *= PRIME64_2;
                v1   = XXH_rotl64(v1, 31);
                v1  *= PRIME64_1;
                h64 ^= v1;
                h64  = h64 * PRIME64_1 + PRIME64_4;

                v2  *= PRIME64_2;
                v2   = XXH_rotl64(v2, 31);
                v2  *= PRIME64_1;
                h64 ^= v2;
                h64  = h64 * PRIME64_1 + PRIME64_4;

                v3  *= PRIME64_2;
                v3   = XXH_rotl64(v3, 31);
                v3  *= PRIME64_1;
                h64 ^= v3;
                h64  = h64 * PRIME64_1 + PRIME64_4;

                v4  *= PRIME64_2;
                v4   = XXH_rotl64(v4, 31);
                v4  *= PRIME64_1;
                h64 ^= v4;
                h64  = h64 * PRIME64_1 + PRIME64_4;
            }
            else
            {
                h64 = seed + PRIME64_5;
            }

            h64 += (ulong)length;

            while (p.Position + 8 <= bEnd)
            {
                ulong k1 = p.ReadUInt64();
                k1  *= PRIME64_2;
                k1   = XXH_rotl64(k1, 31);
                k1  *= PRIME64_1;
                h64 ^= k1;
                h64  = XXH_rotl64(h64, 27) * PRIME64_1 + PRIME64_4;
            }

            if (p.Position + 4 <= bEnd)
            {
                h64 ^= (ulong)(p.ReadUInt32()) * PRIME64_1;
                h64  = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
            }

            while (p.Position < bEnd)
            {
                h64 ^= p.ReadByte() * PRIME64_5;
                h64  = XXH_rotl64(h64, 11) * PRIME64_1;
            }

            h64 ^= h64 >> 33;
            h64 *= PRIME64_2;
            h64 ^= h64 >> 29;
            h64 *= PRIME64_3;
            h64 ^= h64 >> 32;

            return(h64);
#endif
        }
Esempio n. 3
0
        static internal ErrorCode InternalUpdateState64(State64 state, byte[] input, int offset, int length)
        {
            InputTextStream p    = new InputTextStream(input, offset);
            long            bEnd = p.Position + length;

            state.total_len += (ulong)length;

            if (state.memsize + length < 32)               /* fill in tmp buffer */
            {
                Array.Copy(input, offset, state.mem64, state.memsize, length);
                state.memsize += (uint)length;
                return(ErrorCode.XXH_OK);
            }

            if (state.memsize > 0)               /* tmp buffer is full */
            {
                Array.Copy(input, offset, state.mem64, state.memsize, 32 - state.memsize);
                {
                    InputTextStream p64 = new InputTextStream(state.mem64);
                    state.v1 += p64.ReadUInt64() * PRIME64_2;
                    state.v1  = XXH_rotl64(state.v1, 31);
                    state.v1 *= PRIME64_1;

                    state.v2 += p64.ReadUInt64() * PRIME64_2;
                    state.v2  = XXH_rotl64(state.v2, 31);
                    state.v2 *= PRIME64_1;

                    state.v3 += p64.ReadUInt64() * PRIME64_2;
                    state.v3  = XXH_rotl64(state.v3, 31);
                    state.v3 *= PRIME64_1;

                    state.v4 += p64.ReadUInt64() * PRIME64_2;
                    state.v4  = XXH_rotl64(state.v4, 31);
                    state.v4 *= PRIME64_1;
                }
                p.Skip(32 - (int)state.memsize);
                state.memsize = 0;
            }

            if (p.Position + 32 <= bEnd)
            {
                long  limit = bEnd - 32;
                ulong v1    = state.v1;
                ulong v2    = state.v2;
                ulong v3    = state.v3;
                ulong v4    = state.v4;

                do
                {
                    v1 = XXH64_round(v1, p.ReadUInt64());
                    v2 = XXH64_round(v2, p.ReadUInt64());
                    v3 = XXH64_round(v3, p.ReadUInt64());
                    v4 = XXH64_round(v4, p.ReadUInt64());
                }while (p.Position <= limit);

                state.v1 = v1;
                state.v2 = v2;
                state.v3 = v3;
                state.v4 = v4;
            }

            if (p.Position < bEnd)
            {
                Array.Copy(input, p.Position, state.mem64, 0, bEnd - p.Position);
                state.memsize = (uint)(bEnd - p.Position);
            }

            return(ErrorCode.XXH_OK);
        }
Esempio n. 4
0
        public static ulong XXH64(byte[] input, int offset, int length, ulong seed)
        {
            if (input == null)
            {
                throw new ArgumentNullException(nameof(input));
            }
            if (input.Rank != 1)
            {
                ThrowArrayMultiRank("input");
            }
            if (input.GetLowerBound(0) != 0)
            {
                ThrowArrayNonZeroLowerBound("input");
            }
            if (offset < 0)
            {
                ThrowArgumentNonNegativeNumber("offset");
            }
            if (length < 0)
            {
                ThrowArgumentNonNegativeNumber("length");
            }
            if (input.Length < (offset + length))
            {
                ThrowArrayInvalidOffsetAndLength();
            }

            var   p    = new InputTextStream(input, offset);
            long  bEnd = p.Position + length;
            ulong h64;

            if (length >= 32)
            {
                var limit = bEnd - 32;
                var v1    = seed + PRIME64_1 + PRIME64_2;
                var v2    = seed + PRIME64_2;
                var v3    = seed + 0;
                var v4    = seed - PRIME64_1;

                do
                {
                    v1 += p.ReadUInt64() * PRIME64_2;
                    v1  = XXH_rotl64(v1, 31);
                    v1 *= PRIME64_1;

                    v2 += p.ReadUInt64() * PRIME64_2;
                    v2  = XXH_rotl64(v2, 31);
                    v2 *= PRIME64_1;

                    v3 += p.ReadUInt64() * PRIME64_2;
                    v3  = XXH_rotl64(v3, 31);
                    v3 *= PRIME64_1;

                    v4 += p.ReadUInt64() * PRIME64_2;
                    v4  = XXH_rotl64(v4, 31);
                    v4 *= PRIME64_1;
                } while (p.Position <= limit);

                h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);

                v1  *= PRIME64_2;
                v1   = XXH_rotl64(v1, 31);
                v1  *= PRIME64_1;
                h64 ^= v1;
                h64  = h64 * PRIME64_1 + PRIME64_4;

                v2  *= PRIME64_2;
                v2   = XXH_rotl64(v2, 31);
                v2  *= PRIME64_1;
                h64 ^= v2;
                h64  = h64 * PRIME64_1 + PRIME64_4;

                v3  *= PRIME64_2;
                v3   = XXH_rotl64(v3, 31);
                v3  *= PRIME64_1;
                h64 ^= v3;
                h64  = h64 * PRIME64_1 + PRIME64_4;

                v4  *= PRIME64_2;
                v4   = XXH_rotl64(v4, 31);
                v4  *= PRIME64_1;
                h64 ^= v4;
                h64  = h64 * PRIME64_1 + PRIME64_4;
            }
            else
            {
                h64 = seed + PRIME64_5;
            }

            h64 += (ulong)length;

            while (p.Position + 8 <= bEnd)
            {
                var k1 = p.ReadUInt64();
                k1  *= PRIME64_2;
                k1   = XXH_rotl64(k1, 31);
                k1  *= PRIME64_1;
                h64 ^= k1;
                h64  = XXH_rotl64(h64, 27) * PRIME64_1 + PRIME64_4;
            }

            if (p.Position + 4 <= bEnd)
            {
                h64 ^= (ulong)(p.ReadUInt32()) * PRIME64_1;
                h64  = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
            }

            while (p.Position < bEnd)
            {
                h64 ^= p.ReadByte() * PRIME64_5;
                h64  = XXH_rotl64(h64, 11) * PRIME64_1;
            }

            h64 ^= h64 >> 33;
            h64 *= PRIME64_2;
            h64 ^= h64 >> 29;
            h64 *= PRIME64_3;
            h64 ^= h64 >> 32;

            return(h64);
        }