Merge pull request #1517 from tkp1n/feature/vectorize-scale-to-dst-block

Vectorize Scale16X16To8X8

src/ImageSharp/Common/Helpers/SimdUtils.HwIntrinsics.cs

@@ -19,6 +19,8 @@ namespace SixLabors.ImageSharp
 
             public static ReadOnlySpan<byte> PermuteMaskEvenOdd8x32 => new byte[] { 0, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0 };
 
+            public static ReadOnlySpan<byte> PermuteMaskSwitchInnerDWords8x32 => new byte[] { 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 6, 0, 0, 0, 7, 0, 0, 0 };
+
             private static ReadOnlySpan<byte> ShuffleMaskPad4Nx16 => new byte[] { 0, 1, 2, 0x80, 3, 4, 5, 0x80, 6, 7, 8, 0x80, 9, 10, 11, 0x80 };
 
             private static ReadOnlySpan<byte> ShuffleMaskSlice4Nx16 => new byte[] { 0, 1, 2, 4, 5, 6, 8, 9, 10, 12, 13, 14, 0x80, 0x80, 0x80, 0x80 };

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.cs

@@ -485,6 +485,57 @@ namespace SixLabors.ImageSharp.Formats.Jpeg.Components
         /// <param name="source">The source block.</param>
         public static unsafe void Scale16X16To8X8(ref Block8x8F destination, ReadOnlySpan<Block8x8F> source)
         {
+#if SUPPORTS_RUNTIME_INTRINSICS
+            if (Avx2.IsSupported)
+            {
+                Scale16X16To8X8Vectorized(ref destination, source);
+                return;
+            }
+#endif
+
+            Scale16X16To8X8Scalar(ref destination, source);
+        }
+
+        private static void Scale16X16To8X8Vectorized(ref Block8x8F destination, ReadOnlySpan<Block8x8F> source)
+        {
+#if SUPPORTS_RUNTIME_INTRINSICS
+            Debug.Assert(Avx2.IsSupported, "AVX2 is required to execute this method");
+
+            var f2 = Vector256.Create(2f);
+            var f025 = Vector256.Create(0.25f);
+            Vector256<int> switchInnerDoubleWords = Unsafe.As<byte, Vector256<int>>(ref MemoryMarshal.GetReference(SimdUtils.HwIntrinsics.PermuteMaskSwitchInnerDWords8x32));
+
+            ref Vector256<float> in1 = ref Unsafe.As<Block8x8F, Vector256<float>>(ref MemoryMarshal.GetReference(source));
+            ref Vector256<float> in2 = ref Unsafe.As<Block8x8F, Vector256<float>>(ref Unsafe.Add(ref MemoryMarshal.GetReference(source), 1));
+            ref Vector256<float> destRef = ref Unsafe.As<Block8x8F, Vector256<float>>(ref destination);
+
+            for (int i = 0; i < 8; i++)
+            {
+                Vector256<float> a = in1;
+                Vector256<float> b = Unsafe.Add(ref in1, 1);
+                Vector256<float> c = in2;
+                Vector256<float> d = Unsafe.Add(ref in2, 1);
+
+                Vector256<float> calc1 = Avx.Shuffle(a, c, 0b10_00_10_00);
+                Vector256<float> calc2 = Avx.Shuffle(a, c, 0b11_01_11_01);
+                Vector256<float> calc3 = Avx.Shuffle(b, d, 0b10_00_10_00);
+                Vector256<float> calc4 = Avx.Shuffle(b, d, 0b11_01_11_01);
+
+                Vector256<float> sum = Avx.Add(Avx.Add(calc1, calc2), Avx.Add(calc3, calc4));
+                Vector256<float> add = Avx.Add(sum, f2);
+                Vector256<float> res = Avx.Multiply(add, f025);
+
+                destRef = Avx2.PermuteVar8x32(res, switchInnerDoubleWords);
+                destRef = ref Unsafe.Add(ref destRef, 1);
+
+                in1 = ref Unsafe.Add(ref in1, 2);
+                in2 = ref Unsafe.Add(ref in2, 2);
+            }
+#endif
+        }
+
+        private static unsafe void Scale16X16To8X8Scalar(ref Block8x8F destination, ReadOnlySpan<Block8x8F> source)
+        {
             for (int i = 0; i < 4; i++)
             {
                 int dstOff = ((i & 2) << 4) | ((i & 1) << 2);

tests/ImageSharp.Benchmarks/Codecs/Jpeg/BlockOperations/Block8x8F_Scale16X16To8X8.cs

@@ -0,0 +1,35 @@
+using System;
+using BenchmarkDotNet.Attributes;
+using SixLabors.ImageSharp.Formats.Jpeg.Components;
+
+namespace SixLabors.ImageSharp.Benchmarks.Format.Jpeg.Components
+{
+    [Config(typeof(Config.HwIntrinsics_SSE_AVX))]
+    public class Block8x8F_Scale16X16To8X8
+    {
+        private Block8x8F source;
+        private readonly Block8x8F[] target = new Block8x8F[4];
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            var random = new Random();
+
+            float[] f = new float[8*8];
+            for (int i = 0; i < f.Length; i++)
+            {
+                f[i] = (float)random.NextDouble();
+            }
+
+            for (int i = 0; i < 4; i++)
+            {
+                this.target[i] = Block8x8F.Load(f);
+            }
+
+            this.source = Block8x8F.Load(f);
+        }
+
+        [Benchmark]
+        public void Scale16X16To8X8() => Block8x8F.Scale16X16To8X8(ref this.source, this.target);
+    }
+}