Added SIMD-based IndexOf

scripts/PerfHarness/PerfHarness.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp1.0</TargetFramework>
+    <TargetFramework>netcoreapp1.1</TargetFramework>
     <DebugType>portable</DebugType>
     <AssemblyName>PerfHarness</AssemblyName>
     <OutputType>Exe</OutputType>

src/System.Buffers.Experimental/System.Buffers.Experimental.csproj

@@ -13,5 +13,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="System.Buffers" Version="4.3.0" />
+    <PackageReference Include="System.Numerics.Vectors" Version="4.3.0" />
   </ItemGroup>
 </Project>

src/System.Buffers.Experimental/System/Buffers/BufferExtensions.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Sequences;
 using System.Diagnostics;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace System.Buffers
@@ -117,5 +118,107 @@ internal static int IndexOfStraddling(this ReadOnlySpan<byte> first, IReadOnlyMe
 
             return -1;
         }
+
+        static readonly int s_longSize = Vector<ulong>.Count;
+        static readonly int s_byteSize = Vector<byte>.Count;
+
+        public static int IndexOfVectorized(this Span<byte> buffer, byte value)
+        {
+            Debug.Assert(s_longSize == 4 || s_longSize == 2);
+
+            var byteSize = s_byteSize;
+
+            if (buffer.Length < byteSize * 2 || !Vector.IsHardwareAccelerated) return buffer.IndexOf(value);
+
+            Vector<byte> match = new Vector<byte>(value);
+            var vectors = buffer.NonPortableCast<byte, Vector<byte>>();
+            var zero = Vector<byte>.Zero;
+
+            for (int vectorIndex = 0; vectorIndex < vectors.Length; vectorIndex++)
+            {
+                var vector = vectors.GetItem(vectorIndex);
+                var result = Vector.Equals(vector, match);
+                if (result != zero)
+                {
+                    var longer = Vector.AsVectorUInt64(result);
+                    Debug.Assert(s_longSize == 4 || s_longSize == 2);
+
+                    var candidate = longer[0];
+                    if (candidate != 0) return vectorIndex * byteSize + IndexOf(candidate);
+                    candidate = longer[1];
+                    if (candidate != 0) return 8 + vectorIndex * byteSize + IndexOf(candidate);
+                    if (s_longSize == 4)
+                    {
+                        candidate = longer[2];
+                        if (candidate != 0) return 16 + vectorIndex * byteSize + IndexOf(candidate);
+                        candidate = longer[3];
+                        if (candidate != 0) return 24 + vectorIndex * byteSize + IndexOf(candidate);
+                    }
+                }
+            }
+
+            var processed = vectors.Length * byteSize;
+            var index = buffer.Slice(processed).IndexOf(value);
+            if (index == -1) return -1;
+            return index + processed;
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static int IndexOfVectorized(this ReadOnlySpan<byte> buffer, byte value)
+        {
+            Debug.Assert(s_longSize == 4 || s_longSize == 2);
+
+            var byteSize = s_byteSize;
+
+            if (buffer.Length < byteSize * 2 || !Vector.IsHardwareAccelerated) return buffer.IndexOf(value);
+
+            Vector<byte> match = new Vector<byte>(value);
+            var vectors = buffer.NonPortableCast<byte, Vector<byte>>();
+            var zero = Vector<byte>.Zero;
+
+            for (int vectorIndex = 0; vectorIndex < vectors.Length; vectorIndex++)
+            {
+                var vector = vectors[vectorIndex];
+                var result = Vector.Equals(vector, match);
+                if (result != zero)
+                {
+                    var longer = Vector.AsVectorUInt64(result);
+                    var candidate = longer[0];
+                    if (candidate != 0) return vectorIndex * byteSize + IndexOf(candidate);
+                    candidate = longer[1];
+                    if (candidate != 0) return 8 + vectorIndex * byteSize + IndexOf(candidate);
+                    if (s_longSize == 4)
+                    {
+                        candidate = longer[2];
+                        if (candidate != 0) return 16 + vectorIndex * byteSize + IndexOf(candidate);
+                        candidate = longer[3];
+                        if (candidate != 0) return 24 + vectorIndex * byteSize + IndexOf(candidate);
+                    }
+                }
+            }
+
+            var processed = vectors.Length * byteSize;
+            var index = buffer.Slice(processed).IndexOf(value);
+            if (index == -1) return -1;
+            return index + processed;
+        }
+
+        // used by IndexOfVectorized
+        static int IndexOf(ulong next)
+        {
+            // Flag least significant power of two bit
+            var powerOfTwoFlag = (next ^ (next - 1));
+            // Shift all powers of two into the high byte and extract
+            var foundByteIndex = (int)((powerOfTwoFlag * _xorPowerOfTwoToHighByte) >> 57);
+            return foundByteIndex;
+        }
+
+        const ulong _xorPowerOfTwoToHighByte = (0x07ul |
+                                                0x06ul << 8 |
+                                                0x05ul << 16 |
+                                                0x04ul << 24 |
+                                                0x03ul << 32 |
+                                                0x02ul << 40 |
+                                                0x01ul << 48) + 1;
     }
 }

tests/Benchmarks/Benchmarks.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <TargetFramework>netcoreapp1.0</TargetFramework>
+    <TargetFramework>netcoreapp1.1</TargetFramework>
     <AllowUnsafeBlocks>False</AllowUnsafeBlocks>
     <AssemblyOriginatorKeyFile>../../tools/test_key.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>

tests/Benchmarks/IndexOf.cs

@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Xunit.Performance;
+using System;
+using System.Buffers;
+using System.Numerics;
+using System.Text;
+
+public class IndexOfBench
+{
+    static int s_bufferLength = 1000;
+    static byte[] s_buffer = new byte[s_bufferLength];
+    static int s_loops = 1000;
+
+    static IndexOfBench() 
+    {
+        s_buffer[s_bufferLength - 100] = 255;
+    }
+
+    [Benchmark]
+    static int SpanIndexOf()
+    {
+        Span<byte> buffer = s_buffer;
+        int index = 0;
+        foreach (var iteration in Benchmark.Iterations)
+        {
+            using (iteration.StartMeasurement())
+            {
+                for(int i=0; i<s_loops; i++) {
+                    index += buffer.IndexOf(255);
+                }
+            }
+        }
+        return index;
+    }
+
+    [Benchmark]
+    static int VectorizedIndexOf()
+    {
+        if(!Vector.IsHardwareAccelerated) return 0;
+
+        Span<byte> buffer = s_buffer;
+        int index = 0;
+        foreach (var iteration in Benchmark.Iterations)
+        {
+            using (iteration.StartMeasurement())
+            {
+                for(int i=0; i<s_loops; i++) {
+                    index += buffer.IndexOfVectorized(255);
+                }
+            }
+        }
+        return index;
+    }
+}
+

tests/System.Buffers.Experimental.Tests/VectorizedOperations.cs

@@ -0,0 +1,64 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+using System.Buffers;
+using Xunit;
+
+namespace System.Buffers.Tests
+{
+    public class VectorizedOperationsTests
+    {
+        [Fact]
+        public void SpanIndexOf()
+        {
+            int len = 10000;
+            byte[] buffer = new byte[len];
+            buffer[0] = 1;
+            buffer[len / 2] = 2;
+            buffer[len - 1] = 3;
+
+            Span<byte> span = buffer;
+            Assert.Equal(0, span.IndexOfVectorized(1));
+            Assert.Equal(len/2, span.IndexOfVectorized(2));
+            Assert.Equal(len-1, span.IndexOfVectorized(3));
+            Assert.Equal(-1, span.IndexOfVectorized(4));
+        }
+
+        [Fact]
+        public void ReadOnlySpanIndexOf()
+        {
+            int len = 10000;
+            byte[] buffer = new byte[len];
+            buffer[0] = 1;
+            buffer[len / 2] = 2;
+            buffer[len - 1] = 3;
+
+            ReadOnlySpan<byte> span = buffer;
+            Assert.Equal(0, span.IndexOfVectorized(1));
+            Assert.Equal(len/2, span.IndexOfVectorized(2));
+            Assert.Equal(len-1, span.IndexOfVectorized(3));
+            Assert.Equal(-1, span.IndexOfVectorized(4));
+        }
+
+        [Fact]
+        public void EmptySpanIndexOf()
+        {
+            int len = 0;
+            byte[] buffer = new byte[len];
+            Span<byte> span = buffer;
+            Assert.Equal(-1, span.IndexOfVectorized(4));
+        }
+
+        [Fact]
+        public void EmptyReadOnlySpanIndexOf()
+        {
+            int len = 10000;
+            byte[] buffer = new byte[len];
+            buffer[0] = 1;
+            buffer[len / 2] = 2;
+            buffer[len - 1] = 3;
+
+            ReadOnlySpan<byte> span = buffer;
+            Assert.Equal(-1, span.IndexOfVectorized(4));
+        }
+    }
+}

tests/System.Text.Formatting.Tests/System.Text.Formatting.Tests.csproj

@@ -16,6 +16,7 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0-preview-20170125-04" />
+    <PackageReference Include="System.Numerics.Vectors" Version="4.3.0" />
     <PackageReference Include="xunit" Version="2.2.0-beta5-build3474" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0-beta5-build1225" />
   </ItemGroup>