Merge pull request #9 from Reloaded-Project/update-runners-fix-hashcode-bug

Sewer56 · web-flow · commit 86d994ff1c21 · 2025-10-11T03:31:03.000+01:00
Update runners &amp; fix JIT tiering hashcode bug
diff --git a/.github/workflows/build-and-publish.yml b/.github/workflows/build-and-publish.yml
@@ -16,37 +16,37 @@ jobs:
   build:
     strategy:
       matrix:
-        os:
-          - windows-latest
-          - ubuntu-latest
-          - macos-13
-        targetFramework:
-          - net8.0
-          - net7.0
-          - net6.0
-          - net5.0
-          - netcoreapp3.1
-        platform:
-          - x64
         include:
-          - os: windows-latest
-            targetFramework: net48
-            platform: x64
-          - os: windows-latest
-            targetFramework: net48
-            platform: x86
-          - os: windows-latest
-            targetFramework: net7.0
-            platform: x86
-          - os: windows-latest
-            targetFramework: net6.0
-            platform: x86
-          - os: windows-latest
-            targetFramework: net5.0
-            platform: x86
-          - os: windows-latest
-            targetFramework: netcoreapp3.1
-            platform: x86
+          # .NET 8.0 Tests
+          - { os: windows-latest, targetFramework: net8.0, platform: x64 }
+          - { os: ubuntu-latest, targetFramework: net8.0, platform: x64 }
+          - { os: macos-15-intel, targetFramework: net8.0, platform: x64 }
+          
+          # .NET 7.0 Tests
+          - { os: windows-latest, targetFramework: net7.0, platform: x64 }
+          - { os: ubuntu-latest, targetFramework: net7.0, platform: x64 }
+          - { os: macos-15-intel, targetFramework: net7.0, platform: x64 }
+          - { os: windows-latest, targetFramework: net7.0, platform: x86 }
+          
+          # .NET 6.0 Tests
+          - { os: windows-latest, targetFramework: net6.0, platform: x64 }
+          - { os: ubuntu-latest, targetFramework: net6.0, platform: x64 }
+          - { os: macos-15-intel, targetFramework: net6.0, platform: x64 }
+          - { os: windows-latest, targetFramework: net6.0, platform: x86 }
+          
+          # .NET 5.0 Tests (no Ubuntu, libSSL issues)
+          - { os: windows-latest, targetFramework: net5.0, platform: x64 }
+          - { os: macos-15-intel, targetFramework: net5.0, platform: x64 }
+          - { os: windows-latest, targetFramework: net5.0, platform: x86 }
+          
+          # .NET Core 3.1 Tests (no Ubuntu, libSSL issues)
+          - { os: windows-latest, targetFramework: netcoreapp3.1, platform: x64 }
+          - { os: macos-15-intel, targetFramework: netcoreapp3.1, platform: x64 }
+          - { os: windows-latest, targetFramework: netcoreapp3.1, platform: x86 }
+          
+          # .NET Framework 4.8 Tests (Windows only)
+          - { os: windows-latest, targetFramework: net48, platform: x64 }
+          - { os: windows-latest, targetFramework: net48, platform: x86 }
     
     runs-on: ${{ matrix.os }}
     steps:
diff --git a/src/Reloaded.Memory/Internals/Algorithms/UnstableStringHash.cs b/src/Reloaded.Memory/Internals/Algorithms/UnstableStringHash.cs
@@ -26,7 +26,11 @@ internal static class UnstableStringHash
     /// </remarks>
     [ExcludeFromCodeCoverage] // "Cannot be accurately measured without multiple architectures. Known good impl." This is still tested tho.
     [SuppressMessage("ReSharper", "InconsistentNaming")]
+#if NET5_0_OR_GREATER
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+#else
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#endif
     internal static unsafe nuint GetHashCodeUnstable(this ReadOnlySpan<char> text)
     {
 #if NET7_0_OR_GREATER
@@ -51,9 +55,7 @@ internal static unsafe nuint GetHashCodeUnstable(this ReadOnlySpan<char> text)
     }
 
     #if NET7_0_OR_GREATER
-#if NET8_0 // Bug in .NET 8 seems to cause this to not re-jit to tier1 till like 200k calls on Linux x64
     [MethodImpl(MethodImplOptions.AggressiveOptimization)]
-#endif
     internal static unsafe UIntPtr UnstableHashVec128(this ReadOnlySpan<char> text)
     {
         fixed (char* src = &text.GetPinnableReference())
@@ -118,9 +120,7 @@ internal static unsafe UIntPtr UnstableHashVec128(this ReadOnlySpan<char> text)
         }
     }
 
-#if NET8_0 // Bug in .NET 8 seems to cause this to not re-jit to tier1 till like 200k calls on Linux x64
     [MethodImpl(MethodImplOptions.AggressiveOptimization)]
-#endif
     internal static unsafe UIntPtr UnstableHashVec256(this ReadOnlySpan<char> text)
     {
         fixed (char* src = &text.GetPinnableReference())
diff --git a/src/Reloaded.Memory/Internals/Algorithms/UnstableStringHashLower.cs b/src/Reloaded.Memory/Internals/Algorithms/UnstableStringHashLower.cs
@@ -30,7 +30,11 @@ internal static class UnstableStringHashLower
     /// </remarks>
     [ExcludeFromCodeCoverage] // "Cannot be accurately measured without multiple architectures. Known good impl." This is still tested tho.
     [SuppressMessage("ReSharper", "InconsistentNaming")]
+#if NET5_0_OR_GREATER
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+#else
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
+#endif
     internal static unsafe nuint GetHashCodeUnstableLower(this ReadOnlySpan<char> text)
     {
 #if NET7_0_OR_GREATER
@@ -99,9 +103,7 @@ internal static unsafe nuint GetHashCodeUnstableLowerSlow(this ReadOnlySpan<char
     }
 
     #if NET7_0_OR_GREATER
-    #if NET8_0 // Bug in .NET 8 seems to cause this to not re-jit to tier1 till like 200k calls on Linux x64
     [MethodImpl(MethodImplOptions.AggressiveOptimization)]
-    #endif
     internal static unsafe UIntPtr UnstableHashVec128Lower(this ReadOnlySpan<char> text)
     {
         fixed (char* src = &text.GetPinnableReference())
@@ -222,9 +224,7 @@ internal static unsafe UIntPtr UnstableHashVec128Lower(this ReadOnlySpan<char> t
             return GetHashCodeUnstableLowerSlow(text);
     }
 
-#if NET8_0 // Bug in .NET 8 seems to cause this to not re-jit to tier1 till like 200k calls on Linux x64
     [MethodImpl(MethodImplOptions.AggressiveOptimization)]
-#endif
     internal static unsafe UIntPtr UnstableHashVec256Lower(this ReadOnlySpan<char> text)
     {
         fixed (char* src = &text.GetPinnableReference())

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,11 @@ internal static class UnstableStringHash`
`26`	`26`	`/// </remarks>`
`27`	`27`	`[ExcludeFromCodeCoverage] // "Cannot be accurately measured without multiple architectures. Known good impl." This is still tested tho.`
`28`	`28`	`[SuppressMessage("ReSharper", "InconsistentNaming")]`
	`29`	`+#if NET5_0_OR_GREATER`
	`30`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining \| MethodImplOptions.AggressiveOptimization)]`
	`31`	`+#else`
`29`	`32`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`33`	`+#endif`
`30`	`34`	`internal static unsafe nuint GetHashCodeUnstable(this ReadOnlySpan<char> text)`
`31`	`35`	`{`
`32`	`36`	`#if NET7_0_OR_GREATER`
`@@ -51,9 +55,7 @@ internal static unsafe nuint GetHashCodeUnstable(this ReadOnlySpan<char> text)`
`51`	`55`	`}`
`52`	`56`
`53`	`57`	`#if NET7_0_OR_GREATER`
`54`		`-#if NET8_0 // Bug in .NET 8 seems to cause this to not re-jit to tier1 till like 200k calls on Linux x64`
`55`	`58`	`[MethodImpl(MethodImplOptions.AggressiveOptimization)]`
`56`		`-#endif`
`57`	`59`	`internal static unsafe UIntPtr UnstableHashVec128(this ReadOnlySpan<char> text)`
`58`	`60`	`{`
`59`	`61`	`fixed (char* src = &text.GetPinnableReference())`
`@@ -118,9 +120,7 @@ internal static unsafe UIntPtr UnstableHashVec128(this ReadOnlySpan<char> text)`
`118`	`120`	`}`
`119`	`121`	`}`
`120`	`122`
`121`		`-#if NET8_0 // Bug in .NET 8 seems to cause this to not re-jit to tier1 till like 200k calls on Linux x64`
`122`	`123`	`[MethodImpl(MethodImplOptions.AggressiveOptimization)]`
`123`		`-#endif`
`124`	`124`	`internal static unsafe UIntPtr UnstableHashVec256(this ReadOnlySpan<char> text)`
`125`	`125`	`{`
`126`	`126`	`fixed (char* src = &text.GetPinnableReference())`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,11 @@ internal static class UnstableStringHashLower`
`30`	`30`	`/// </remarks>`
`31`	`31`	`[ExcludeFromCodeCoverage] // "Cannot be accurately measured without multiple architectures. Known good impl." This is still tested tho.`
`32`	`32`	`[SuppressMessage("ReSharper", "InconsistentNaming")]`
	`33`	`+#if NET5_0_OR_GREATER`
	`34`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining \| MethodImplOptions.AggressiveOptimization)]`
	`35`	`+#else`
`33`	`36`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`37`	`+#endif`
`34`	`38`	`internal static unsafe nuint GetHashCodeUnstableLower(this ReadOnlySpan<char> text)`
`35`	`39`	`{`
`36`	`40`	`#if NET7_0_OR_GREATER`
`@@ -99,9 +103,7 @@ internal static unsafe nuint GetHashCodeUnstableLowerSlow(this ReadOnlySpan<char`
`99`	`103`	`}`
`100`	`104`
`101`	`105`	`#if NET7_0_OR_GREATER`
`102`		`- #if NET8_0 // Bug in .NET 8 seems to cause this to not re-jit to tier1 till like 200k calls on Linux x64`
`103`	`106`	`[MethodImpl(MethodImplOptions.AggressiveOptimization)]`
`104`		`- #endif`
`105`	`107`	`internal static unsafe UIntPtr UnstableHashVec128Lower(this ReadOnlySpan<char> text)`
`106`	`108`	`{`
`107`	`109`	`fixed (char* src = &text.GetPinnableReference())`
`@@ -222,9 +224,7 @@ internal static unsafe UIntPtr UnstableHashVec128Lower(this ReadOnlySpan<char> t`
`222`	`224`	`return GetHashCodeUnstableLowerSlow(text);`
`223`	`225`	`}`
`224`	`226`
`225`		`-#if NET8_0 // Bug in .NET 8 seems to cause this to not re-jit to tier1 till like 200k calls on Linux x64`
`226`	`227`	`[MethodImpl(MethodImplOptions.AggressiveOptimization)]`
`227`		`-#endif`
`228`	`228`	`internal static unsafe UIntPtr UnstableHashVec256Lower(this ReadOnlySpan<char> text)`
`229`	`229`	`{`
`230`	`230`	`fixed (char* src = &text.GetPinnableReference())`