Added Memory Diagnoser + Agressive inlining

Author: Nick-Nuon

benchmark/Benchmark.cs

@@ -104,6 +104,9 @@ protected void IntroduceError(byte[] utf8, Random random)
 
     }
 
+
+[MemoryDiagnoser]
+
     public class SyntheticBenchmark : BenchmarkBase
     {
 
@@ -403,6 +406,9 @@ public void SIMDUtf8ValidationErrorUtf8()
 
     }
 
+
+[MemoryDiagnoser]
+
     public class RealDataBenchmark : BenchmarkBase
     {
 

src/Ascii.cs

@@ -134,6 +134,7 @@ public static unsafe bool SIMDIsAscii(this ReadOnlySpan<char> s)
             return true;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe nuint GetIndexOfFirstNonAsciiByte(byte* pBuffer, nuint bufferLength)
         {
             byte* buf_orig = pBuffer;

src/UTF8_validation.cs

@@ -2,6 +2,7 @@
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 using System.Linq;
+using System.Runtime.CompilerServices;
 
 
 // C# already have something that is *more or less* equivalent to our C++ simd class:
@@ -11,7 +12,8 @@
 public static class Vector256Extensions
 {
     // Gets the second lane of the current vector and the first lane of the previous vector and returns, then shift it right by an appropriate number of bytes (less than 16, or less than 128 bits)
-    //  Checked
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
     public static Vector256<byte> Prev(this Vector256<byte> current, Vector256<byte> prev, int N = 1)
     {
 
@@ -85,6 +87,7 @@ public static unsafe class Utf8Utility
 
 
         // Returns a pointer to the first invalid byte in the input buffer if it's invalid, or a pointer to the end if it's valid.
+        // [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static byte* GetPointerToFirstInvalidByte(byte* pInputBuffer, int inputLength)
         {
             if (pInputBuffer == null || inputLength <= 0)
@@ -148,6 +151,7 @@ public utf8_checker()
             // The original C++ implementation is much more extensive and assumes a 512 bit stream as well as several implementations
             // In this case I focus solely on AVX2 instructions for prototyping and benchmarking purposes. 
             // This is the simplest least time-consuming implementation. 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 
             public void check_next_input(Vector256<byte> input)
             {
@@ -159,7 +163,6 @@ public void check_next_input(Vector256<byte> input)
                     // Contains non-ASCII characters, process the vector
                     check_utf8_bytes(input, prev_input_block);
                     prev_incomplete = is_incomplete(input);
-
                 }
 
 
@@ -170,7 +173,8 @@ public void check_next_input(Vector256<byte> input)
 
             }
 
-            // Checked
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
             public void check_utf8_bytes(Vector256<byte> input, Vector256<byte> prev_input)
             {
                 Vector256<byte> prev1 = input.Prev(prev_input, 1);
@@ -185,6 +189,7 @@ public void check_utf8_bytes(Vector256<byte> input, Vector256<byte> prev_input)
 
             }
 
+            // [MethodImpl(MethodImplOptions.AggressiveInlining)]
 
             public bool errors()
             {
@@ -193,6 +198,8 @@ public bool errors()
                 return !Avx2.TestZ(error, error);
             }
 
+            // [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
             public void check_eof()
             {
                 // Console.WriteLine("Error Vector before check_eof(): " + VectorToString(error));
@@ -203,6 +210,8 @@ public void check_eof()
 
             }
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
             // This corresponds to section 6.1 e.g Table 6 of the paper e.g. 1-2 bytes
             private Vector256<byte> check_special_cases(Vector256<byte> input, Vector256<byte> prev1)
             {
@@ -267,6 +276,8 @@ private Vector256<byte> check_special_cases(Vector256<byte> input, Vector256<byt
                 return Avx2.And(Avx2.And(byte_1_high, byte_1_low), byte_2_high);
             }
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
             private Vector256<byte> check_multibyte_lengths(Vector256<byte> input, Vector256<byte> prev_input, Vector256<byte> sc)
             {
                 // Console.WriteLine("sc: " + VectorToString(sc));
@@ -289,6 +300,8 @@ private Vector256<byte> check_multibyte_lengths(Vector256<byte> input, Vector256
                 return Avx2.Xor(must23_80, sc);
             }
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
             private Vector256<byte> must_be_2_3_continuation(Vector256<byte> prev2, Vector256<byte> prev3)
             {
                 Vector256<byte> is_third_byte = Avx2.SubtractSaturate(prev2, Vector256.Create((byte)(0b11100000u - 1)));
@@ -303,6 +316,8 @@ private Vector256<byte> must_be_2_3_continuation(Vector256<byte> prev2, Vector25
                 return comparisonResult.AsByte();
             }
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
             private Vector256<byte> is_incomplete(Vector256<byte> input)
             {
                 // Console.WriteLine("Input Vector is_incomplete: " + VectorToString(input));
@@ -321,6 +336,8 @@ private Vector256<byte> is_incomplete(Vector256<byte> input)
                 return result;
             }
 
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+
             private Vector256<byte> SaturatingSubtractUnsigned(Vector256<byte> left, Vector256<byte> right)
             {
                 if (!Avx2.IsSupported)
@@ -336,6 +353,7 @@ private Vector256<byte> SaturatingSubtractUnsigned(Vector256<byte> left, Vector2
                 return subtractionResult.AsByte();
             }
 
+            
             // Helper functions for debugging
             private string VectorToString(Vector256<byte> vector)
             {