add XXHash.Hash64Async()

Author: ssg

src/XXHash.State64.cs

@@ -0,0 +1,93 @@
+// <copyright file="XXHash.State64.cs" company="Sedat Kapanoglu">
+// Copyright (c) 2015-2025 Sedat Kapanoglu
+// MIT License (see LICENSE file for details)
+// </copyright>
+
+using System;
+
+namespace HashDepot;
+
+/// <summary>
+/// State machine for XXHash 32-bit algorithm's streaming functions.
+/// </summary>
+public static partial class XXHash
+{
+    class State64
+    {
+        public const int StripeLength = 32;
+        readonly ulong seed;
+        ulong acc;
+        ulong acc1;
+        ulong acc2;
+        ulong acc3;
+        ulong acc4;
+        int len;
+        bool finalBlockProcessed;
+
+        public State64(ulong seed)
+        {
+            this.seed = seed;
+            (acc1, acc2, acc3, acc4) = initAccumulators64(seed);
+        }
+
+        public void Update(ReadOnlySpan<byte> buffer)
+        {
+            if (finalBlockProcessed)
+            {
+                throw new InvalidOperationException("Update() called after final stripe has been processed.");
+            }
+
+            int bufferSize = buffer.Length;
+
+            // first call?
+            if (len == 0 && bufferSize < StripeLength)
+            {
+                acc = seed + prime64v5;
+                len += bufferSize;
+                acc += (uint)len;
+                acc = processRemaining64(buffer, acc);
+                finalBlockProcessed = true;
+                return;
+            }
+
+            int offset = 0;
+            len += bufferSize;
+
+            for (; bufferSize >= StripeLength; bufferSize -= StripeLength)
+            {
+                int end = offset + StripeLength;
+                acc = processStripe64(
+                    buffer[offset..end],
+                    ref acc1,
+                    ref acc2,
+                    ref acc3,
+                    ref acc4);
+                offset = end;
+            }
+
+            // process the final incomplete stripe
+            if (bufferSize > 0)
+            {
+                acc += (uint)len;
+                acc = processRemaining64(buffer[offset..(offset + bufferSize)], acc);
+                finalBlockProcessed = true;
+            }
+        }
+
+        public ulong Result()
+        {
+            if (len == 0)
+            {
+                acc = seed + prime64v5;
+            }
+
+            if (!finalBlockProcessed)
+            {
+                acc += (uint)len;
+                finalBlockProcessed = true;
+            }
+
+            return avalanche64(acc);
+        }
+    }
+}

src/XXHash.cs

@@ -149,54 +149,38 @@ public static ulong Hash64(ReadOnlySpan<byte> buffer, ulong seed = 0)
     /// <returns>Computed 64-bit hash value.</returns>
     public static ulong Hash64(Stream stream, ulong seed = 0)
     {
-        const int stripeLength = 32;
-        const int readBufferSize = stripeLength * 1024; // 32kb buffer length
-
-        ulong acc;
+        const int readBufferSize = State64.StripeLength * 1024; // 32kb buffer length
 
         var buffer = new byte[readBufferSize].AsSpan();
-        int readBytes = stream.Read(buffer);
-        ulong len = (ulong)readBytes;
-
-        int offset = 0;
-        if (readBytes < stripeLength)
+        var state = new State64(seed);
+        int bytesRead;
+        while ((bytesRead = stream.Read(buffer)) > 0)
         {
-            acc = seed + prime64v5;
-            goto Exit;
+            state.Update(buffer[..bytesRead]);
         }
 
-        var (acc1, acc2, acc3, acc4) = initAccumulators64(seed);
-        do
+        return state.Result();
+    }
+
+    /// <summary>
+    /// Generate a 64-bit xxHash value from a stream.
+    /// </summary>
+    /// <param name="stream">Input stream.</param>
+    /// <param name="seed">Optional seed.</param>
+    /// <returns>Computed 64-bit hash value.</returns>
+    public static async Task<ulong> Hash64Async(Stream stream, ulong seed = 0)
+    {
+        const int readBufferSize = State64.StripeLength * 1024; // 32kb buffer length
+
+        var buffer = new byte[readBufferSize];
+        var state = new State64(seed);
+        int bytesRead;
+        while ((bytesRead = await stream.ReadAsync(buffer)) > 0)
         {
-            do
-            {
-                int end = offset + stripeLength;
-                acc = processStripe64(
-                    buffer[offset..end],
-                    ref acc1,
-                    ref acc2,
-                    ref acc3,
-                    ref acc4);
-                offset = end;
-                readBytes -= stripeLength;
-            }
-            while (readBytes >= stripeLength);
-
-            // read more if the alignment is intact
-            if (readBytes == 0)
-            {
-                readBytes = stream.Read(buffer);
-                offset = 0;
-                len += (ulong)readBytes;
-            }
+            state.Update(buffer.AsSpan(0, bytesRead));
         }
-        while (readBytes >= stripeLength);
 
-    Exit:
-        acc += len;
-        acc = processRemaining64(buffer[offset..(offset + readBytes)], acc);
-
-        return avalanche64(acc);
+        return state.Result();
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]

test/XXHashTest.cs

@@ -72,6 +72,16 @@ public void Hash64_StreamTests(string text, uint seed, uint _, ulong hash64)
         Assert.That(result, Is.EqualTo(hash64));
     }
 
+    [Test]
+    [TestCaseSource(nameof(testVectors))]
+    public async Task Hash64Async_StreamTests(string text, uint seed, uint _, ulong hash64)
+    {
+        var buffer = Encoding.UTF8.GetBytes(text);
+        using var stream = new MemoryStream(buffer);
+        var result = await XXHash.Hash64Async(stream, seed);
+        Assert.That(result, Is.EqualTo(hash64));
+    }
+
     [Test]
     public void Hash32_LongStream_ReturnsExpected()
     {