From 4f870badeb07c7ccf21adb4a661b581409513c51 Mon Sep 17 00:00:00 2001
From: tahakocal <tahakocalgs@gmail.com>
Date: Tue, 22 Sep 2026 13:16:43 +0300
Subject: [PATCH] Count differing bits a vector at a time for single-byte
 elements

HammingBitDistance is fully scalar, paying one population count per element.
For byte and sbyte spans that is one instruction per byte, which is where the
loop spends its time; wider elements already amortize the population count
over 2, 4 or 8 bytes.

Count single-byte spans with a nibble table instead: exclusive-or a vector of
each input, look up the bit counts of the low and high nibbles, and accumulate
into byte lanes, reducing to a scalar every 31 vectors, before which a lane
holding at most 8 per vector cannot overflow.

Measured on arm64 with Vector128: 2.5x to 2.8x for byte spans of 1KB and
larger. Wider element types keep the scalar loop, where the same vectorized
shape measured slower than the scalar one.
---
 .../TensorPrimitives.HammingDistance.cs       | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.HammingDistance.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.HammingDistance.cs
index c38b60e5f0ac3b..bc51d0f6686766 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.HammingDistance.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.HammingDistance.cs
@@ -24,6 +24,19 @@ public static long HammingBitDistance<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y) w
                 ThrowHelper.ThrowArgument_SpansMustHaveSameLength();
             }
 
+            // Single-byte elements benefit from counting bits a vector at a time: the scalar loop
+            // pays one population count per byte, where the vectorized path covers a whole vector.
+            // Wider elements already amortize the population count over 2, 4 or 8 bytes, and
+            // measured slower when vectorized this way, so they keep the scalar loop.
+            if ((typeof(T) == typeof(byte) || typeof(T) == typeof(sbyte)) &&
+                Vector128.IsHardwareAccelerated &&
+                x.Length >= Vector128<byte>.Count)
+            {
+                return HammingBitDistanceCore(
+                    MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(x)), x.Length),
+                    MemoryMarshal.CreateReadOnlySpan(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(y)), y.Length));
+            }
+
             long count = 0;
             for (int i = 0; i < x.Length; i++)
             {
@@ -33,6 +46,48 @@ public static long HammingBitDistance<T>(ReadOnlySpan<T> x, ReadOnlySpan<T> y) w
             return count;
         }
 
+        /// <summary>Counts the bits that differ between two equal-length byte spans.</summary>
+        private static long HammingBitDistanceCore(ReadOnlySpan<byte> x, ReadOnlySpan<byte> y)
+        {
+            Vector128<byte> nibbleCounts = Vector128.Create((byte)0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4);
+            Vector128<byte> lowMask = Vector128.Create((byte)0x0F);
+
+            long count = 0;
+            int i = 0;
+
+            while (x.Length - i >= Vector128<byte>.Count)
+            {
+                // A byte lane holds at most 8 per vector, so it can absorb 31 vectors before overflowing.
+                int block = Math.Min(31, (x.Length - i) / Vector128<byte>.Count);
+                Vector128<byte> counts = Vector128<byte>.Zero;
+
+                for (int step = 0; step < block; step++)
+                {
+                    Vector128<byte> difference =
+                        Vector128.Create(x.Slice(i, Vector128<byte>.Count)) ^
+                        Vector128.Create(y.Slice(i, Vector128<byte>.Count));
+
+                    counts += Vector128.Shuffle(nibbleCounts, difference & lowMask) +
+                              Vector128.Shuffle(nibbleCounts, (difference >>> 4) & lowMask);
+
+                    i += Vector128<byte>.Count;
+                }
+
+                Vector128<ushort> lower = Vector128.WidenLower(counts);
+                Vector128<ushort> upper = Vector128.WidenUpper(counts);
+                count += Vector128.Sum(
+                    Vector128.WidenLower(lower) + Vector128.WidenUpper(lower) +
+                    Vector128.WidenLower(upper) + Vector128.WidenUpper(upper));
+            }
+
+            for (; i < x.Length; i++)
+            {
+                count += BitOperations.PopCount((uint)(byte)(x[i] ^ y[i]));
+            }
+
+            return count;
+        }
+
         /// <summary>Computes the Hamming distance between two equal-length tensors of values.</summary>
         /// <param name="x">The first tensor, represented as a span.</param>
         /// <param name="y">The second tensor, represented as a span.</param>