cleanup

Author: Nick-Nuon

src/UTF8.cs

@@ -10,12 +10,6 @@ namespace SimdUnicode
     public static class UTF8
     {
 
-        public static void ToString(Vector128<byte> v)
-        {
-            Span<byte> b = stackalloc byte[16];
-            v.CopyTo(b);
-            // Console .WriteLine(Convert.ToHexString(b));
-        }
 
         // Returns &inputBuffer[inputLength] if the input buffer is valid.
         /// <summary>
@@ -42,11 +36,10 @@ public static void ToString(Vector128<byte> v)
             {
                 return GetPointerToFirstInvalidByteAvx512(pInputBuffer, inputLength);
             }*/
-            // if (Ssse3.IsSupported)
-            // {
-            //     return GetPointerToFirstInvalidByteSse(pInputBuffer, inputLength);
-            // }
-            // return GetPointerToFirstInvalidByteScalar(pInputBuffer, inputLength);
+            if (Ssse3.IsSupported)
+            {
+                return GetPointerToFirstInvalidByteSse(pInputBuffer, inputLength,out Utf16CodeUnitCountAdjustment, out ScalarCodeUnitCountAdjustment);
+            }
 
             return GetPointerToFirstInvalidByteScalar(pInputBuffer, inputLength, out Utf16CodeUnitCountAdjustment, out ScalarCodeUnitCountAdjustment);
 
@@ -480,7 +473,6 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
 
         public unsafe static byte* GetPointerToFirstInvalidByteSse(byte* pInputBuffer, int inputLength, out int utf16CodeUnitCountAdjustment, out int scalarCountAdjustment)
         {
-            // Console .WriteLine("-------------------Calling function--------------------");
             int processedLength = 0;
             if (pInputBuffer == null || inputLength <= 0)
             {
@@ -510,7 +502,6 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
 
                 if (processedLength + 16 < inputLength)
                 {
-                    // Console .WriteLine("-------SIMD kicking in-------");
                     Vector128<byte> prevInputBlock = Vector128<byte>.Zero;
 
                     Vector128<byte> maxValue = Vector128.Create(
@@ -591,23 +582,17 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
                     int n4 = 0; // number of 4-byte sequences that start in this block        
                     for (; processedLength + 16 <= inputLength; processedLength += 16)
                     {
-                        // Console .WriteLine($"Processing {processedLength} bytes", processedLength);
 
                         Vector128<byte> currentBlock = Avx.LoadVector128(pInputBuffer + processedLength);
                         int mask = Sse42.MoveMask(currentBlock);
-                        // ToString (currentBlock);
-                        // // Console .WriteLine($"{mask}");
                         if (mask == 0)
                         {
                             // We have an ASCII block, no need to process it, but
                             // we need to check if the previous block was incomplete.
                             // 
 
-                            // Console .WriteLine("Found all ASCII");
-                            // ToString(prevIncomplete);
                             if (!Sse41.TestZ(prevIncomplete, prevIncomplete))
                             {
-                                // // Console .WriteLine($"Found all-ascii but previous is incomplete.Triggering Rewind");
                                 int off = processedLength >= 3 ? processedLength - 3 : processedLength;
                                 byte* invalidBytePointer = SimdUnicode.UTF8.SimpleRewindAndValidateWithErrors(16 - 3, pInputBuffer + processedLength - 3, inputLength - processedLength + 3);
                                 // So the code is correct up to invalidBytePointer
@@ -627,7 +612,6 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
                         }
                         else // Contains non-ASCII characters, we need to do non-trivial processing
                         {
-                            // Console .WriteLine("Contains ASCII characters, firing standard SIMD routine");
                             // Use SubtractSaturate to effectively compare if bytes in block are greater than markers.
                             // Contains non-ASCII characters, we need to do non-trivial processing
                             Vector128<byte> prev1 = Ssse3.AlignRight(currentBlock, prevInputBlock, (byte)(16 - 1));
@@ -638,8 +622,6 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
                             Vector128<byte> prev2 = Ssse3.AlignRight(currentBlock, prevInputBlock, (byte)(16 - 2));
                             Vector128<byte> prev3 = Ssse3.AlignRight(currentBlock, prevInputBlock, (byte)(16 - 3));
                             prevInputBlock = currentBlock;
-                            // // Console .WriteLine("PrevIncomplete:");
-                            // ToString(prevIncomplete);
 
                             Vector128<byte> isThirdByte = Sse2.SubtractSaturate(prev2, thirdByte);
                             Vector128<byte> isFourthByte = Sse2.SubtractSaturate(prev3, fourthByte);
@@ -649,7 +631,6 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
 
                             if (!Sse42.TestZ(error, error))
                             {
-                                // Console .WriteLine($"Found error! rewinding...");
 
                                 byte* invalidBytePointer;
                                 if (processedLength == 0)
@@ -686,7 +667,6 @@ private unsafe static (int utfadjust, int scalaradjust) calculateErrorPathadjust
                         asciibytes += (int)(16 - Popcnt.PopCount((uint)mask));
                     }
 
-                    // Console .WriteLine($"-----SIMD finished , calling scalar:");
 
                     // We may still have an error.
                     if (processedLength < inputLength || !Sse42.TestZ(prevIncomplete, prevIncomplete))