Convert pointer methods to modern .NET Core APIs - Complete Conversion with Unsafe.As Optimization

.github/workflows/CI.yml

@@ -48,6 +48,13 @@ jobs:
         working-directory: test/${{ env.ProjectName }}.Tests
         run: dotnet test -c Release
 
+      - name: Run tests (Disable AVX)
+        if: matrix.os != 'macos-latest'
+        working-directory: test/${{ env.ProjectName }}.Tests
+        run: dotnet test -c Release
+        env:
+          DOTNET_EnableAVX: 0
+
   build:
     needs: [check_format, test]
     if: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/') }}

Directory.Build.props

@@ -6,7 +6,6 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <IsPackable>false</IsPackable>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Authors>HMBSbige</Authors>
     <Copyright>Copyright © HMBSbige</Copyright>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>

src/CryptoBase/CryptoBase.csproj

@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IsPackable>true</IsPackable>
     <Description>A fast crypto library for .NET.</Description>
   </PropertyGroup>

src/CryptoBase/Digests/CRC32/Crc32Table.cs

@@ -13,10 +13,11 @@ private Crc32Table(uint poly)
 
 		for (uint i = 0; i < 256; ++i)
 		{
-			var res = i;
-			for (var j = 0; j < 16; ++j)
+			uint res = i;
+
+			for (int j = 0; j < 16; ++j)
 			{
-				for (var k = 0; k < 8; ++k)
+				for (int k = 0; k < 8; ++k)
 				{
 					res = (res & 1) == 1 ? poly ^ res >> 1 : res >> 1;
 				}
@@ -28,32 +29,33 @@ private Crc32Table(uint poly)
 
 	public uint Append(uint crc, ReadOnlySpan<byte> source)
 	{
-		var offset = 0;
-		var length = source.Length;
-		var crcLocal = uint.MaxValue ^ crc;
+		int offset = 0;
+		int length = source.Length;
+		uint crcLocal = uint.MaxValue ^ crc;
+
+		uint[] table = _table;
 
-		var table = _table;
 		while (length >= 16)
 		{
-			var a = table[3 * 256 + source[offset + 12]]
-				^ table[2 * 256 + source[offset + 13]]
-				^ table[1 * 256 + source[offset + 14]]
-				^ table[0 * 256 + source[offset + 15]];
-
-			var b = table[7 * 256 + source[offset + 8]]
-				^ table[6 * 256 + source[offset + 9]]
-				^ table[5 * 256 + source[offset + 10]]
-				^ table[4 * 256 + source[offset + 11]];
-
-			var c = table[11 * 256 + source[offset + 4]]
-				^ table[10 * 256 + source[offset + 5]]
-				^ table[9 * 256 + source[offset + 6]]
-				^ table[8 * 256 + source[offset + 7]];
-
-			var d = table[15 * 256 + ((byte)crcLocal ^ source[offset])]
-				^ table[14 * 256 + ((byte)(crcLocal >> 8) ^ source[offset + 1])]
-				^ table[13 * 256 + ((byte)(crcLocal >> 16) ^ source[offset + 2])]
-				^ table[12 * 256 + (crcLocal >> 24 ^ source[offset + 3])];
+			uint a = table[3 * 256 + source[offset + 12]]
+					^ table[2 * 256 + source[offset + 13]]
+					^ table[1 * 256 + source[offset + 14]]
+					^ table[0 * 256 + source[offset + 15]];
+
+			uint b = table[7 * 256 + source[offset + 8]]
+					^ table[6 * 256 + source[offset + 9]]
+					^ table[5 * 256 + source[offset + 10]]
+					^ table[4 * 256 + source[offset + 11]];
+
+			uint c = table[11 * 256 + source[offset + 4]]
+					^ table[10 * 256 + source[offset + 5]]
+					^ table[9 * 256 + source[offset + 6]]
+					^ table[8 * 256 + source[offset + 7]];
+
+			uint d = table[15 * 256 + ((byte)crcLocal ^ source[offset])]
+					^ table[14 * 256 + ((byte)(crcLocal >> 8) ^ source[offset + 1])]
+					^ table[13 * 256 + ((byte)(crcLocal >> 16) ^ source[offset + 2])]
+					^ table[12 * 256 + (crcLocal >> 24 ^ source[offset + 3])];
 
 			crcLocal = d ^ c ^ b ^ a;
 			offset += 16;

src/CryptoBase/Digests/CRC32/Crc32X86.cs

@@ -36,15 +36,12 @@ public void UpdateFinal(ReadOnlySpan<byte> origin, Span<byte> destination)
 		GetHash(destination);
 	}
 
-	public unsafe void Update(ReadOnlySpan<byte> source)
+	public void Update(ReadOnlySpan<byte> source)
 	{
 		if (source.Length >= 64)
 		{
-			fixed (byte* p = source)
-			{
-				_state = Update(p, source.Length, _state);
-				source = source[^(source.Length % 0x10)..];
-			}
+			_state = Update(source, _state);
+			source = source.Slice(source.Length - source.Length % 0x10);
 		}
 
 		_state = ~Crc32Table.Crc32.Append(~_state, source);
@@ -62,24 +59,26 @@ public void Reset()
 	}
 
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
-	private static unsafe uint Update(byte* buffer, int length, uint crc)
+	private static uint Update(ReadOnlySpan<byte> buffer, uint crc)
 	{
-		var x1 = Sse2.LoadVector128(buffer).AsUInt64();
-		var x2 = Sse2.LoadVector128(buffer + 0x10).AsUInt64();
-		var x3 = Sse2.LoadVector128(buffer + 0x20).AsUInt64();
-		var x4 = Sse2.LoadVector128(buffer + 0x30).AsUInt64();
-		var vCrc = Vector128.CreateScalar(crc).AsUInt64();
+		int length = buffer.Length;
+
+		ref Vector128<ulong> x1 = ref Unsafe.As<byte, Vector128<ulong>>(ref MemoryMarshal.GetReference(buffer));
+		ref Vector128<ulong> x2 = ref Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(0x10));
+		ref Vector128<ulong> x3 = ref Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(0x20));
+		ref Vector128<ulong> x4 = ref Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(0x30));
+		Vector128<ulong> vCrc = Vector128.CreateScalar(crc).AsUInt64();
 		x1 = Sse2.Xor(x1, vCrc);
 
 		length -= 0x40;
-		buffer += 0x40;
+		int offset = 0x40;
 
 		while (length >= 0x40)
 		{
-			var t1 = Pclmulqdq.CarrylessMultiply(x1, K1K2, 0x11);
-			var t2 = Pclmulqdq.CarrylessMultiply(x2, K1K2, 0x11);
-			var t3 = Pclmulqdq.CarrylessMultiply(x3, K1K2, 0x11);
-			var t4 = Pclmulqdq.CarrylessMultiply(x4, K1K2, 0x11);
+			Vector128<ulong> t1 = Pclmulqdq.CarrylessMultiply(x1, K1K2, 0x11);
+			Vector128<ulong> t2 = Pclmulqdq.CarrylessMultiply(x2, K1K2, 0x11);
+			Vector128<ulong> t3 = Pclmulqdq.CarrylessMultiply(x3, K1K2, 0x11);
+			Vector128<ulong> t4 = Pclmulqdq.CarrylessMultiply(x4, K1K2, 0x11);
 
 			x1 = Pclmulqdq.CarrylessMultiply(x1, K1K2, 0x00);
 			x2 = Pclmulqdq.CarrylessMultiply(x2, K1K2, 0x00);
@@ -91,16 +90,19 @@ private static unsafe uint Update(byte* buffer, int length, uint crc)
 			x3 = Sse2.Xor(x3, t3);
 			x4 = Sse2.Xor(x4, t4);
 
-			x1 = Sse2.Xor(x1, Sse2.LoadVector128(buffer).AsUInt64());
-			x2 = Sse2.Xor(x2, Sse2.LoadVector128(buffer + 0x10).AsUInt64());
-			x3 = Sse2.Xor(x3, Sse2.LoadVector128(buffer + 0x20).AsUInt64());
-			x4 = Sse2.Xor(x4, Sse2.LoadVector128(buffer + 0x30).AsUInt64());
+			x1 = Sse2.Xor(x1, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
+			offset += 0x10;
+			x2 = Sse2.Xor(x2, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
+			offset += 0x10;
+			x3 = Sse2.Xor(x3, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
+			offset += 0x10;
+			x4 = Sse2.Xor(x4, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
+			offset += 0x10;
 
 			length -= 0x40;
-			buffer += 0x40;
 		}
 
-		var t = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x11);
+		Vector128<ulong> t = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x11);
 		x1 = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x00);
 		x1 = Sse2.Xor(x1, t);
 		x1 = Sse2.Xor(x1, x2);
@@ -120,13 +122,13 @@ private static unsafe uint Update(byte* buffer, int length, uint crc)
 			t = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x11);
 			x1 = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x00);
 			x1 = Sse2.Xor(x1, t);
-			x1 = Sse2.Xor(x1, Sse2.LoadVector128(buffer).AsUInt64());
+			x1 = Sse2.Xor(x1, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
 
 			length -= 0x10;
-			buffer += 0x10;
+			offset += 0x10;
 		}
 
-		var r4 = Pclmulqdq.CarrylessMultiply(K3K4, x1, 0x01);
+		Vector128<ulong> r4 = Pclmulqdq.CarrylessMultiply(K3K4, x1, 0x01);
 		x1 = Sse2.ShiftRightLogical128BitLane(x1, 0x08);
 		x1 = Sse2.Xor(x1, r4);
 
@@ -141,7 +143,7 @@ private static unsafe uint Update(byte* buffer, int length, uint crc)
 		x1 = Sse2.And(x1, Mask32);
 		x1 = Pclmulqdq.CarrylessMultiply(x1, RU, 0x00);
 		x1 = Sse2.Xor(x1, t);
-		return x1.AsUInt32().GetElement(1); // pextrd eax, x1, 1
+		return x1.AsUInt32().GetElement(1);// pextrd eax, x1, 1
 	}
 
 	public void Dispose()

src/CryptoBase/Digests/CRC32C/Crc32CX86.cs

@@ -1,9 +1,7 @@
 namespace CryptoBase.Digests.CRC32C;
 
 /// <summary>
-/// Same as <see cref="Crc32X86"/> , but different constants.
-/// Abstraction will cause performance issue!
-/// WTF.NET
+/// Same as <see cref="Crc32X86" /> , but different constants.
 /// </summary>
 public class Crc32CX86 : IHash
 {
@@ -38,15 +36,12 @@ public void UpdateFinal(ReadOnlySpan<byte> origin, Span<byte> destination)
 		GetHash(destination);
 	}
 
-	public unsafe void Update(ReadOnlySpan<byte> source)
+	public void Update(ReadOnlySpan<byte> source)
 	{
 		if (Sse2.IsSupported && Pclmulqdq.IsSupported && source.Length >= 64)
 		{
-			fixed (byte* p = source)
-			{
-				_state = Update(p, source.Length, _state);
-				source = source[^(source.Length % 0x10)..];
-			}
+			_state = Update(source, _state);
+			source = source.Slice(source.Length - source.Length % 0x10);
 		}
 
 		if (Sse42.IsSupported)
@@ -71,24 +66,26 @@ public void Reset()
 	}
 
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
-	private static unsafe uint Update(byte* buffer, int length, uint crc)
+	private static uint Update(ReadOnlySpan<byte> buffer, uint crc)
 	{
-		var x1 = Sse2.LoadVector128(buffer).AsUInt64();
-		var x2 = Sse2.LoadVector128(buffer + 0x10).AsUInt64();
-		var x3 = Sse2.LoadVector128(buffer + 0x20).AsUInt64();
-		var x4 = Sse2.LoadVector128(buffer + 0x30).AsUInt64();
-		var vCrc = Vector128.CreateScalar(crc).AsUInt64();
+		int length = buffer.Length;
+
+		ref Vector128<ulong> x1 = ref Unsafe.As<byte, Vector128<ulong>>(ref MemoryMarshal.GetReference(buffer));
+		ref Vector128<ulong> x2 = ref Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(0x10));
+		ref Vector128<ulong> x3 = ref Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(0x20));
+		ref Vector128<ulong> x4 = ref Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(0x30));
+		Vector128<ulong> vCrc = Vector128.CreateScalar(crc).AsUInt64();
 		x1 = Sse2.Xor(x1, vCrc);
 
 		length -= 0x40;
-		buffer += 0x40;
+		int offset = 0x40;
 
 		while (length >= 0x40)
 		{
-			var t1 = Pclmulqdq.CarrylessMultiply(x1, K1K2, 0x11);
-			var t2 = Pclmulqdq.CarrylessMultiply(x2, K1K2, 0x11);
-			var t3 = Pclmulqdq.CarrylessMultiply(x3, K1K2, 0x11);
-			var t4 = Pclmulqdq.CarrylessMultiply(x4, K1K2, 0x11);
+			Vector128<ulong> t1 = Pclmulqdq.CarrylessMultiply(x1, K1K2, 0x11);
+			Vector128<ulong> t2 = Pclmulqdq.CarrylessMultiply(x2, K1K2, 0x11);
+			Vector128<ulong> t3 = Pclmulqdq.CarrylessMultiply(x3, K1K2, 0x11);
+			Vector128<ulong> t4 = Pclmulqdq.CarrylessMultiply(x4, K1K2, 0x11);
 
 			x1 = Pclmulqdq.CarrylessMultiply(x1, K1K2, 0x00);
 			x2 = Pclmulqdq.CarrylessMultiply(x2, K1K2, 0x00);
@@ -100,16 +97,19 @@ private static unsafe uint Update(byte* buffer, int length, uint crc)
 			x3 = Sse2.Xor(x3, t3);
 			x4 = Sse2.Xor(x4, t4);
 
-			x1 = Sse2.Xor(x1, Sse2.LoadVector128(buffer).AsUInt64());
-			x2 = Sse2.Xor(x2, Sse2.LoadVector128(buffer + 0x10).AsUInt64());
-			x3 = Sse2.Xor(x3, Sse2.LoadVector128(buffer + 0x20).AsUInt64());
-			x4 = Sse2.Xor(x4, Sse2.LoadVector128(buffer + 0x30).AsUInt64());
+			x1 = Sse2.Xor(x1, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
+			offset += 0x10;
+			x2 = Sse2.Xor(x2, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
+			offset += 0x10;
+			x3 = Sse2.Xor(x3, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
+			offset += 0x10;
+			x4 = Sse2.Xor(x4, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
+			offset += 0x10;
 
 			length -= 0x40;
-			buffer += 0x40;
 		}
 
-		var t = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x11);
+		Vector128<ulong> t = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x11);
 		x1 = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x00);
 		x1 = Sse2.Xor(x1, t);
 		x1 = Sse2.Xor(x1, x2);
@@ -129,13 +129,13 @@ private static unsafe uint Update(byte* buffer, int length, uint crc)
 			t = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x11);
 			x1 = Pclmulqdq.CarrylessMultiply(x1, K3K4, 0x00);
 			x1 = Sse2.Xor(x1, t);
-			x1 = Sse2.Xor(x1, Sse2.LoadVector128(buffer).AsUInt64());
+			x1 = Sse2.Xor(x1, Unsafe.As<byte, Vector128<ulong>>(ref buffer.GetRef(offset)));
 
 			length -= 0x10;
-			buffer += 0x10;
+			offset += 0x10;
 		}
 
-		var r4 = Pclmulqdq.CarrylessMultiply(K3K4, x1, 0x01);
+		Vector128<ulong> r4 = Pclmulqdq.CarrylessMultiply(K3K4, x1, 0x01);
 		x1 = Sse2.ShiftRightLogical128BitLane(x1, 0x08);
 		x1 = Sse2.Xor(x1, r4);
 
@@ -150,7 +150,7 @@ private static unsafe uint Update(byte* buffer, int length, uint crc)
 		x1 = Sse2.And(x1, Mask32);
 		x1 = Pclmulqdq.CarrylessMultiply(x1, RU, 0x00);
 		x1 = Sse2.Xor(x1, t);
-		return x1.AsUInt32().GetElement(1); // pextrd eax, x1, 1
+		return x1.AsUInt32().GetElement(1);// pextrd eax, x1, 1
 	}
 
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -160,36 +160,36 @@ private void UpdateSse42(ReadOnlySpan<byte> source)
 		{
 			while (source.Length >= 8)
 			{
-				var data = BinaryPrimitives.ReadUInt64LittleEndian(source);
+				ref ulong data = ref Unsafe.As<byte, ulong>(ref MemoryMarshal.GetReference(source));
 				_state = (uint)Sse42.X64.Crc32(_state, data);
-				source = source[8..];
+				source = source.Slice(8);
 			}
 
 			if (source.Length >= 4)
 			{
-				var data = BinaryPrimitives.ReadUInt32LittleEndian(source);
+				ref uint data = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
 				_state = Sse42.Crc32(_state, data);
-				source = source[4..];
+				source = source.Slice(4);
 			}
 		}
 		else
 		{
 			while (source.Length >= 4)
 			{
-				var data = BinaryPrimitives.ReadUInt32LittleEndian(source);
+				ref uint data = ref Unsafe.As<byte, uint>(ref MemoryMarshal.GetReference(source));
 				_state = Sse42.Crc32(_state, data);
-				source = source[4..];
+				source = source.Slice(4);
 			}
 		}
 
 		if (source.Length >= 2)
 		{
-			var data = BinaryPrimitives.ReadUInt16LittleEndian(source);
+			ref ushort data = ref Unsafe.As<byte, ushort>(ref MemoryMarshal.GetReference(source));
 			_state = Sse42.Crc32(_state, data);
-			source = source[2..];
+			source = source.Slice(2);
 		}
 
-		foreach (var b in source)
+		foreach (ref readonly byte b in source)
 		{
 			_state = Sse42.Crc32(_state, b);
 		}

src/CryptoBase/Extensions.cs

@@ -4,6 +4,7 @@ namespace CryptoBase;
 
 public static class Extensions
 {
+	/// <inheritdoc cref="BitOperations.RotateLeft(uint,int)" />
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public static uint RotateLeft(this uint value, int offset)
 	{
@@ -23,7 +24,7 @@ public static int GetDeterministicHashCode<T>(this ReadOnlySpan<T> span) where T
 		{
 			int hash = 5381;
 
-			foreach (T t in span)
+			foreach (ref readonly T t in span)
 			{
 				hash = (hash << 5) + hash ^ t.GetHashCode();
 			}