Exemple #1
0
        public unsafe void XXHash64_StreamedHashingEquivalence(int bufferSize)
        {
            var rnd = new Random(1000);

            byte[] values = new byte[bufferSize];
            rnd.NextBytes(values);

            uint seed = 233;

            int blockSize;
            int iteration = 1;

            do
            {
                blockSize = Hashing.Streamed.XXHash64.Alignment * iteration;

                var context = new Hashing.Streamed.XXHash64Context {
                    Seed = seed
                };
                Hashing.Streamed.XXHash64.BeginProcess(ref context);
                fixed(byte *buffer = values)
                {
                    byte *current = buffer;
                    byte *bEnd    = buffer + bufferSize;

                    do
                    {
                        int block = Math.Min(blockSize, (int)(bEnd - current));
                        Hashing.Streamed.XXHash64.Process(ref context, current, block);
                        current += block;
                    }while (current < bEnd);
                }

                iteration++;

                var result   = Hashing.Streamed.XXHash64.EndProcess(ref context);
                var expected = Hashing.XXHash64.Calculate(values, -1, seed);

                Assert.Equal(expected, result);
            }while (blockSize <= bufferSize);
        }
        public static ulong CalculateFileHeaderHash(FileHeader *header)
        {
            var ctx = new Hashing.Streamed.XXHash64Context
            {
                Seed = (ulong)header->TransactionId
            };

            Hashing.Streamed.XXHash64.BeginProcess(ref ctx);

            // First part of header, until the Hash field
            Hashing.Streamed.XXHash64.Process(ref ctx, (byte *)header, FileHeader.HashOffset);

            // Second part of header, after the hash field
            var secondPartOfHeaderLength = sizeof(FileHeader) - (FileHeader.HashOffset + sizeof(ulong));

            if (secondPartOfHeaderLength > 0)
            {
                Hashing.Streamed.XXHash64.Process(ref ctx, (byte *)header + FileHeader.HashOffset + sizeof(ulong), secondPartOfHeaderLength);
            }

            return(Hashing.Streamed.XXHash64.EndProcess(ref ctx));
        }