improving the performance in the case where ignorable characters are uncommon

Author: lemire

README.md

@@ -32,7 +32,7 @@ fully reproducible.
 
 | processor and base freq.      | SimdBase64 (GB/s) | .NET speed (GB/s) | speed up |
 |:----------------|:------------------------|:-------------------|:-------------------|
-| Apple M2 processor (ARM, 3.5 Ghz)   | 6.5                      | 3.8               | 1.7 x |
+| Apple M2 processor (ARM, 3.5 Ghz)   | 10                     | 3.8               | 2.6 x |
 | AWS Graviton 3 (ARM, 2.6 GHz)   | 3.6  | 2.0 | 1.8 x |
 | Intel Ice Lake (2.0 GHz)  | 6.5                      | 3.4              | 1.9 x |
 | AMD EPYC 7R32 (Zen 2, 2.8 GHz)    |  6.8        | 2.9 | 2.3 x |

benchmark/Benchmark.cs

@@ -2,13 +2,9 @@
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Reports;
-using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using System.Text;
-using System.Runtime.InteropServices;
 using BenchmarkDotNet.Columns;
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
 
 namespace SimdUnicodeBenchmarks
 {
@@ -464,7 +460,7 @@ public unsafe void RunOurDecodingBenchmarkWithAllocUTF16(string[] data, int[] le
 
                 if (dataoutput.Length != lengths[i])
                 {
-                    Console.WriteLine($"Error: {dataoutput.Length } != {lengths[i]}");
+                    Console.WriteLine($"Error: {dataoutput.Length} != {lengths[i]}");
 #pragma warning disable CA2201
                     throw new Exception("Error");
                 }

src/Base64.cs

@@ -14,7 +14,8 @@ public static int MaximalBinaryLengthFromBase64<T>(ReadOnlySpan<T> input)
         {
             return Scalar.Base64.MaximalBinaryLengthFromBase64Scalar(input);
         }
-        public static byte[] FromBase64String(string s) {
+        public static byte[] FromBase64String(string s)
+        {
             ReadOnlySpan<char> base64 = s.AsSpan();
             byte[] newBytes = new byte[SimdBase64.Base64.MaximalBinaryLengthFromBase64<char>(base64)];
             int bytesConsumed = 0;

src/Base64ARM.cs

@@ -219,6 +219,74 @@ private static unsafe ulong ToBase64MaskUrl(Block64* b, ref bool error)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             private unsafe static ulong CompressBlock(ref Block64 b, ulong mask, byte* output, byte* tablePtr)
             {
+
+                // if mask is a power of 2, we can use a simpler version
+                if ((mask & (mask - 1)) == 0) // check if mask is a power of 2
+                {
+                    int pos64 = ArmBase.Arm64.LeadingZeroCount(mask);
+                    int pos = pos64 & 0xf;
+                    Vector128<byte> v1 = Vector128.Create((byte)0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+
+
+                    Vector128<byte> v0 = Vector128.Create((byte)(0xe - pos));
+                    switch (pos64 >> 4)
+                    {
+                        case 3:
+                            {
+                                Vector128<byte> v2 = AdvSimd.CompareGreaterThan(v1.AsSByte(), v0.AsSByte()).AsByte();
+                                Vector128<byte> sh = AdvSimd.Subtract(v1, v2);
+                                Vector128<byte> compressed = AdvSimd.Arm64.VectorTableLookup(b.chunk0, sh);
+                                Vector128.Store(compressed, output + 0 * 16);
+                                Vector128.Store(b.chunk1, output + 1 * 16 - 1);
+                                Vector128.Store(b.chunk2, output + 2 * 16 - 1);
+                                Vector128.Store(b.chunk3, output + 3 * 16 - 1);
+
+                            }
+                            break;
+
+                        case 2:
+                            {
+                                Vector128<byte> v2 = AdvSimd.CompareGreaterThan(v1.AsSByte(), v0.AsSByte()).AsByte();
+                                Vector128<byte> sh = AdvSimd.Subtract(v1, v2);
+                                Vector128<byte> compressed = AdvSimd.Arm64.VectorTableLookup(b.chunk1, sh);
+                                Vector128.Store(b.chunk0, output + 0 * 16);
+                                Vector128.Store(compressed, output + 1 * 16);
+                                Vector128.Store(b.chunk2, output + 2 * 16 - 1);
+                                Vector128.Store(b.chunk3, output + 3 * 16 - 1);
+
+                            }
+                            break;
+
+                        case 1:
+                            {
+                                Vector128<byte> v2 = AdvSimd.CompareGreaterThan(v1.AsSByte(), v0.AsSByte()).AsByte();
+                                Vector128<byte> sh = AdvSimd.Subtract(v1, v2);
+                                Vector128<byte> compressed = AdvSimd.Arm64.VectorTableLookup(b.chunk2, sh);
+                                Vector128.Store(b.chunk0, output + 0 * 16);
+                                Vector128.Store(b.chunk1, output + 1 * 16);
+                                Vector128.Store(compressed, output + 2 * 16);
+                                Vector128.Store(b.chunk3, output + 3 * 16 - 1);
+
+                            }
+                            break;
+
+                        case 0:
+                            {
+                                Vector128<byte> v2 = AdvSimd.CompareGreaterThan(v1.AsSByte(), v0.AsSByte()).AsByte();
+                                Vector128<byte> sh = AdvSimd.Subtract(v1, v2);
+                                Vector128<byte> compressed = AdvSimd.Arm64.VectorTableLookup(b.chunk2, sh);
+                                Vector128.Store(b.chunk0, output + 0 * 16);
+                                Vector128.Store(b.chunk1, output + 1 * 16);
+                                Vector128.Store(b.chunk2, output + 2 * 16);
+                                Vector128.Store(compressed, output + 3 * 16);
+                            }
+                            break;
+                    }
+
+
+                    return 63;
+
+                }
                 ulong nmask = ~mask;
                 Compress(b.chunk0, (ushort)mask, output, tablePtr);
                 Compress(b.chunk1, (ushort)(mask >> 16), output + UInt64.PopCount(nmask & 0xFFFF), tablePtr);