a few more Vector<T> experiments

tests/ImageSharp.Benchmarks/General/Vectorization/MulFloat.cs

@@ -24,7 +24,7 @@ namespace ImageSharp.Benchmarks.General.Vectorization
 
             for (int i = 0; i < this.InputSize; i++)
             {
-                this.input[i] = (uint)i;
+                this.input[i] = i;
             }
         }
 
@@ -39,7 +39,7 @@ namespace ImageSharp.Benchmarks.General.Vectorization
         }
 
         [Benchmark]
-        public void Simd()
+        public void SimdMultiplyByVector()
         {
             Vector<float> v = new Vector<float>(this.testValue);
 
@@ -50,5 +50,18 @@ namespace ImageSharp.Benchmarks.General.Vectorization
                 a.CopyTo(this.result, i);
             }
         }
+
+        [Benchmark]
+        public void SimdMultiplyByScalar()
+        {
+            float v = this.testValue;
+
+            for (int i = 0; i < this.input.Length; i += Vector<uint>.Count)
+            {
+                Vector<float> a = new Vector<float>(this.input, i);
+                a = a * v;
+                a.CopyTo(this.result, i);
+            }
+        }
     }
 }

tests/ImageSharp.Benchmarks/General/Vectorization/VectorFetching.cs

@@ -0,0 +1,90 @@
+namespace ImageSharp.Benchmarks.General.Vectorization
+{
+    using System.Numerics;
+    using System.Runtime.CompilerServices;
+
+    using BenchmarkDotNet.Attributes;
+
+    /// <summary>
+    /// This benchmark compares different methods for fetching memory data into <see cref="Vector{T}"/>
+    /// checking if JIT has limitations. Normally SIMD acceleration should be here for all methods.
+    /// </summary>
+    public class VectorFetching
+    {
+        private float testValue;
+
+        private float[] data;
+
+        [Params(64)]
+        public int InputSize { get; set; }
+        
+        [Setup]
+        public void Setup()
+        {
+            this.data = new float[this.InputSize];
+            this.testValue = 42;
+            
+            for (int i = 0; i < this.InputSize; i++)
+            {
+                this.data[i] = i;
+            }
+        }
+
+        [Benchmark(Baseline = true)]
+        public void Baseline()
+        {
+            float v = this.testValue;
+            for (int i = 0; i < this.data.Length; i++)
+            {
+                this.data[i] = this.data[i] * v;
+            }
+        }
+
+        [Benchmark]
+        public void FetchWithVectorConstructor()
+        {
+            Vector<float> v = new Vector<float>(this.testValue);
+
+            for (int i = 0; i < this.data.Length; i += Vector<uint>.Count)
+            {
+                Vector<float> a = new Vector<float>(this.data, i);
+                a = a * v;
+                a.CopyTo(this.data, i);
+            }
+        }
+
+        [Benchmark]
+        public void FetchWithUnsafeCast()
+        {
+            Vector<float> v = new Vector<float>(this.testValue);
+            ref Vector<float> start = ref Unsafe.As<float, Vector<float>>(ref this.data[0]);
+
+            int n = this.InputSize / Vector<uint>.Count;
+
+            for (int i = 0; i < n; i++)
+            {
+                ref Vector<float> p = ref Unsafe.Add(ref start, i);
+
+                Vector<float> a = p;
+                a = a * v;
+
+                p = a;
+            }
+        }
+
+        [Benchmark]
+        public void FetchWithUnsafeCastNoTempVector()
+        {
+            Vector<float> v = new Vector<float>(this.testValue);
+            ref Vector<float> start = ref Unsafe.As<float, Vector<float>>(ref this.data[0]);
+
+            int n = this.InputSize / Vector<uint>.Count;
+
+            for (int i = 0; i < n; i++)
+            {
+                ref Vector<float> a = ref Unsafe.Add(ref start, i);
+                a = a * v;
+            }
+        }
+    }
+}