improve naming in SimdUtils

6 years ago · ddb73eacd1
8 changed files with 63 additions and 61 deletions
--- a/src/ImageSharp/Common/Helpers/SimdUtils.Avx2Intrinsics.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.Avx2Intrinsics.cs
@ -19,10 +19,10 @@ namespace SixLabors.ImageSharp
            private static ReadOnlySpan<byte> PermuteMaskDeinterleave8x32 => new byte[] { 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 7, 0, 0, 0 };

            /// <summary>
-            /// <see cref="BulkConvertNormalizedFloatToByteClampOverflows"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="NormalizedFloatToByteSaturate"/> as many elements as possible, slicing them down (keeping the remainder).
            /// </summary>
            [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflowsReduce(
+            internal static void NormalizedFloatToByteSaturateReduce(
                ref ReadOnlySpan<float> source,
                ref Span<byte> dest)
            {
@ -35,7 +35,7 @@ namespace SixLabors.ImageSharp

                    if (adjustedCount > 0)
                    {
-                        BulkConvertNormalizedFloatToByteClampOverflows(
+                        NormalizedFloatToByteSaturate(
                            source.Slice(0, adjustedCount),
                            dest.Slice(0, adjustedCount));

@ -46,13 +46,13 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows"/>, which is faster on new .NET runtime.
+            /// Implementation of <see cref="SimdUtils.NormalizedFloatToByteSaturate"/>, which is faster on new .NET runtime.
            /// </summary>
            /// <remarks>
            /// Implementation is based on MagicScaler code:
            /// https://github.com/saucecontrol/PhotoSauce/blob/a9bd6e5162d2160419f0cf743fd4f536c079170b/src/MagicScaler/Magic/Processors/ConvertersFloat.cs#L453-L477
            /// </remarks>
-            internal static void BulkConvertNormalizedFloatToByteClampOverflows(
+            internal static void NormalizedFloatToByteSaturate(
                ReadOnlySpan<float> source,
                Span<byte> dest)
            {
--- a/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.BasicIntrinsics256.cs
@ -21,10 +21,10 @@ namespace SixLabors.ImageSharp

 #if !SUPPORTS_EXTENDED_INTRINSICS
            /// <summary>
-            /// <see cref="BulkConvertByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="ByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
            /// </summary>
            [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertByteToNormalizedFloatReduce(
+            internal static void ByteToNormalizedFloatReduce(
                ref ReadOnlySpan<byte> source,
                ref Span<float> dest)
            {
@ -40,7 +40,7 @@ namespace SixLabors.ImageSharp

                if (adjustedCount > 0)
                {
-                    BulkConvertByteToNormalizedFloat(
+                    ByteToNormalizedFloat(
                        source.Slice(0, adjustedCount),
                        dest.Slice(0, adjustedCount));

@ -50,10 +50,10 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// <see cref="BulkConvertNormalizedFloatToByteClampOverflows"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="NormalizedFloatToByteSaturate"/> as many elements as possible, slicing them down (keeping the remainder).
            /// </summary>
            [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflowsReduce(
+            internal static void NormalizedFloatToByteSaturateReduce(
                ref ReadOnlySpan<float> source,
                ref Span<byte> dest)
            {
@ -69,7 +69,7 @@ namespace SixLabors.ImageSharp

                if (adjustedCount > 0)
                {
-                    BulkConvertNormalizedFloatToByteClampOverflows(source.Slice(0, adjustedCount), dest.Slice(0, adjustedCount));
+                    NormalizedFloatToByteSaturate(source.Slice(0, adjustedCount), dest.Slice(0, adjustedCount));

                    source = source.Slice(adjustedCount);
                    dest = dest.Slice(adjustedCount);
@ -78,15 +78,15 @@ namespace SixLabors.ImageSharp
 #endif

            /// <summary>
-            /// SIMD optimized implementation for <see cref="SimdUtils.BulkConvertByteToNormalizedFloat"/>.
+            /// SIMD optimized implementation for <see cref="SimdUtils.ByteToNormalizedFloat"/>.
            /// Works only with span Length divisible by 8.
            /// Implementation adapted from:
            /// http://lolengine.net/blog/2011/3/20/understanding-fast-float-integer-conversions
            /// http://stackoverflow.com/a/536278
            /// </summary>
-            internal static void BulkConvertByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
+            internal static void ByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
            {
-                VerifyHasVector8(nameof(BulkConvertByteToNormalizedFloat));
+                VerifyHasVector8(nameof(ByteToNormalizedFloat));
                VerifySpanInput(source, dest, 8);

                var bVec = new Vector<float>(256.0f / 255.0f);
@ -124,11 +124,11 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows"/> which is faster on older runtimes.
+            /// Implementation of <see cref="SimdUtils.NormalizedFloatToByteSaturate"/> which is faster on older runtimes.
            /// </summary>
-            internal static void BulkConvertNormalizedFloatToByteClampOverflows(ReadOnlySpan<float> source, Span<byte> dest)
+            internal static void NormalizedFloatToByteSaturate(ReadOnlySpan<float> source, Span<byte> dest)
            {
-                VerifyHasVector8(nameof(BulkConvertNormalizedFloatToByteClampOverflows));
+                VerifyHasVector8(nameof(NormalizedFloatToByteSaturate));
                VerifySpanInput(source, dest, 8);

                if (source.Length == 0)
--- a/src/ImageSharp/Common/Helpers/SimdUtils.ExtendedIntrinsics.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.ExtendedIntrinsics.cs
@ -43,10 +43,10 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// <see cref="BulkConvertByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="ByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
            /// </summary>
            [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertByteToNormalizedFloatReduce(
+            internal static void ByteToNormalizedFloatReduce(
                ref ReadOnlySpan<byte> source,
                ref Span<float> dest)
            {
@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp

                if (adjustedCount > 0)
                {
-                    BulkConvertByteToNormalizedFloat(source.Slice(0, adjustedCount), dest.Slice(0, adjustedCount));
+                    ByteToNormalizedFloat(source.Slice(0, adjustedCount), dest.Slice(0, adjustedCount));

                    source = source.Slice(adjustedCount);
                    dest = dest.Slice(adjustedCount);
@ -70,10 +70,10 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// <see cref="BulkConvertNormalizedFloatToByteClampOverflows"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="NormalizedFloatToByteSaturate"/> as many elements as possible, slicing them down (keeping the remainder).
            /// </summary>
            [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflowsReduce(
+            internal static void NormalizedFloatToByteSaturateReduce(
                ref ReadOnlySpan<float> source,
                ref Span<byte> dest)
            {
@ -89,7 +89,7 @@ namespace SixLabors.ImageSharp

                if (adjustedCount > 0)
                {
-                    BulkConvertNormalizedFloatToByteClampOverflows(
+                    NormalizedFloatToByteSaturate(
                        source.Slice(0, adjustedCount),
                        dest.Slice(0, adjustedCount));

@ -99,9 +99,9 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// Implementation <see cref="SimdUtils.BulkConvertByteToNormalizedFloat"/>, which is faster on new RyuJIT runtime.
+            /// Implementation <see cref="SimdUtils.ByteToNormalizedFloat"/>, which is faster on new RyuJIT runtime.
            /// </summary>
-            internal static void BulkConvertByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
+            internal static void ByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
            {
                VerifySpanInput(source, dest, Vector<byte>.Count);

@ -132,9 +132,9 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows"/>, which is faster on new .NET runtime.
+            /// Implementation of <see cref="SimdUtils.NormalizedFloatToByteSaturate"/>, which is faster on new .NET runtime.
            /// </summary>
-            internal static void BulkConvertNormalizedFloatToByteClampOverflows(
+            internal static void NormalizedFloatToByteSaturate(
                ReadOnlySpan<float> source,
                Span<byte> dest)
            {
--- a/src/ImageSharp/Common/Helpers/SimdUtils.FallbackIntrinsics128.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.FallbackIntrinsics128.cs
@ -19,10 +19,10 @@ namespace SixLabors.ImageSharp
        public static class FallbackIntrinsics128
        {
            /// <summary>
-            /// <see cref="BulkConvertByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="ByteToNormalizedFloat"/> as many elements as possible, slicing them down (keeping the remainder).
            /// </summary>
            [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertByteToNormalizedFloatReduce(
+            internal static void ByteToNormalizedFloatReduce(
                ref ReadOnlySpan<byte> source,
                ref Span<float> dest)
            {
@ -33,7 +33,7 @@ namespace SixLabors.ImageSharp

                if (adjustedCount > 0)
                {
-                    BulkConvertByteToNormalizedFloat(
+                    ByteToNormalizedFloat(
                        source.Slice(0, adjustedCount),
                        dest.Slice(0, adjustedCount));

@ -43,10 +43,10 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// <see cref="BulkConvertNormalizedFloatToByteClampOverflows"/> as many elements as possible, slicing them down (keeping the remainder).
+            /// <see cref="NormalizedFloatToByteSaturate"/> as many elements as possible, slicing them down (keeping the remainder).
            /// </summary>
            [MethodImpl(InliningOptions.ShortMethod)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflowsReduce(
+            internal static void NormalizedFloatToByteSaturateReduce(
                ref ReadOnlySpan<float> source,
                ref Span<byte> dest)
            {
@ -57,7 +57,7 @@ namespace SixLabors.ImageSharp

                if (adjustedCount > 0)
                {
-                    BulkConvertNormalizedFloatToByteClampOverflows(
+                    NormalizedFloatToByteSaturate(
                        source.Slice(0, adjustedCount),
                        dest.Slice(0, adjustedCount));

@ -67,10 +67,10 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertByteToNormalizedFloat"/> using <see cref="Vector4"/>.
+            /// Implementation of <see cref="SimdUtils.ByteToNormalizedFloat"/> using <see cref="Vector4"/>.
            /// </summary>
            [MethodImpl(InliningOptions.ColdPath)]
-            internal static void BulkConvertByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
+            internal static void ByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
            {
                VerifySpanInput(source, dest, 4);

@ -99,10 +99,10 @@ namespace SixLabors.ImageSharp
            }

            /// <summary>
-            /// Implementation of <see cref="SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows"/> using <see cref="Vector4"/>.
+            /// Implementation of <see cref="SimdUtils.NormalizedFloatToByteSaturate"/> using <see cref="Vector4"/>.
            /// </summary>
            [MethodImpl(InliningOptions.ColdPath)]
-            internal static void BulkConvertNormalizedFloatToByteClampOverflows(
+            internal static void NormalizedFloatToByteSaturate(
                ReadOnlySpan<float> source,
                Span<byte> dest)
            {
@ -148,4 +148,4 @@ namespace SixLabors.ImageSharp
            }
        }
    }
-}
+}
--- a/src/ImageSharp/Common/Helpers/SimdUtils.cs
+++ b/src/ImageSharp/Common/Helpers/SimdUtils.cs
@ -61,16 +61,18 @@ namespace SixLabors.ImageSharp
        /// <param name="source">The source span of bytes</param>
        /// <param name="dest">The destination span of floats</param>
        [MethodImpl(InliningOptions.ShortMethod)]
-        internal static void BulkConvertByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
+        internal static void ByteToNormalizedFloat(ReadOnlySpan<byte> source, Span<float> dest)
        {
            DebugGuard.IsTrue(source.Length == dest.Length, nameof(source), "Input spans must be of same length!");

 #if SUPPORTS_EXTENDED_INTRINSICS
-            ExtendedIntrinsics.BulkConvertByteToNormalizedFloatReduce(ref source, ref dest);
+            ExtendedIntrinsics.ByteToNormalizedFloatReduce(ref source, ref dest);
 #else
-            BasicIntrinsics256.BulkConvertByteToNormalizedFloatReduce(ref source, ref dest);
+            BasicIntrinsics256.ByteToNormalizedFloatReduce(ref source, ref dest);
 #endif
-            FallbackIntrinsics128.BulkConvertByteToNormalizedFloatReduce(ref source, ref dest);
+
+            // Also deals with the remainder from previous conversions:
+            FallbackIntrinsics128.ByteToNormalizedFloatReduce(ref source, ref dest);

            // Deal with the remainder:
            if (source.Length > 0)
@ -88,20 +90,20 @@ namespace SixLabors.ImageSharp
        /// <param name="source">The source span of floats</param>
        /// <param name="dest">The destination span of bytes</param>
        [MethodImpl(InliningOptions.ShortMethod)]
-        internal static void BulkConvertNormalizedFloatToByteClampOverflows(ReadOnlySpan<float> source, Span<byte> dest)
+        internal static void NormalizedFloatToByteSaturate(ReadOnlySpan<float> source, Span<byte> dest)
        {
            DebugGuard.IsTrue(source.Length == dest.Length, nameof(source), "Input spans must be of same length!");

 #if SUPPORTS_RUNTIME_INTRINSICS
-            Avx2Intrinsics.BulkConvertNormalizedFloatToByteClampOverflowsReduce(ref source, ref dest);
+            Avx2Intrinsics.NormalizedFloatToByteSaturateReduce(ref source, ref dest);
 #elif SUPPORTS_EXTENDED_INTRINSICS
-            ExtendedIntrinsics.BulkConvertNormalizedFloatToByteClampOverflowsReduce(ref source, ref dest);
+            ExtendedIntrinsics.NormalizedFloatToByteSaturateReduce(ref source, ref dest);
 #else
-            BasicIntrinsics256.BulkConvertNormalizedFloatToByteClampOverflowsReduce(ref source, ref dest);
+            BasicIntrinsics256.NormalizedFloatToByteSaturateReduce(ref source, ref dest);
 #endif

            // Also deals with the remainder from previous conversions:
-            FallbackIntrinsics128.BulkConvertNormalizedFloatToByteClampOverflowsReduce(ref source, ref dest);
+            FallbackIntrinsics128.NormalizedFloatToByteSaturateReduce(ref source, ref dest);

            // Deal with the remainder:
            if (source.Length > 0)
--- a/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.PixelOperations.cs
+++ b/src/ImageSharp/PixelFormats/PixelImplementations/Rgba32.PixelOperations.cs
@ -29,7 +29,7 @@ namespace SixLabors.ImageSharp.PixelFormats
                Guard.DestinationShouldNotBeTooShort(sourcePixels, destinationVectors, nameof(destinationVectors));

                destinationVectors = destinationVectors.Slice(0, sourcePixels.Length);
-                SimdUtils.BulkConvertByteToNormalizedFloat(
+                SimdUtils.ByteToNormalizedFloat(
                    MemoryMarshal.Cast<Rgba32, byte>(sourcePixels),
                    MemoryMarshal.Cast<Vector4, float>(destinationVectors));
                Vector4Converters.ApplyForwardConversionModifiers(destinationVectors, modifiers);
@ -46,7 +46,7 @@ namespace SixLabors.ImageSharp.PixelFormats

                destinationPixels = destinationPixels.Slice(0, sourceVectors.Length);
                Vector4Converters.ApplyBackwardConversionModifiers(sourceVectors, modifiers);
-                SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows(
+                SimdUtils.NormalizedFloatToByteSaturate(
                    MemoryMarshal.Cast<Vector4, float>(sourceVectors),
                    MemoryMarshal.Cast<Rgba32, byte>(destinationPixels));
            }
--- a/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
+++ b/src/ImageSharp/PixelFormats/Utils/Vector4Converters.RgbaCompatible.cs
@ -62,7 +62,7 @@ namespace SixLabors.ImageSharp.PixelFormats.Utils

                // 'destVectors' and 'lastQuarterOfDestBuffer' are overlapping buffers,
                // but we are always reading/writing at different positions:
-                SimdUtils.BulkConvertByteToNormalizedFloat(
+                SimdUtils.ByteToNormalizedFloat(
                    MemoryMarshal.Cast<Rgba32, byte>(lastQuarterOfDestBuffer),
                    MemoryMarshal.Cast<Vector4, float>(destVectors.Slice(0, countWithoutLastItem)));

@ -107,7 +107,7 @@ namespace SixLabors.ImageSharp.PixelFormats.Utils
                {
                    Span<Rgba32> tempSpan = tempBuffer.Memory.Span;

-                    SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows(
+                    SimdUtils.NormalizedFloatToByteSaturate(
                        MemoryMarshal.Cast<Vector4, float>(sourceVectors),
                        MemoryMarshal.Cast<Rgba32, byte>(tempSpan));

--- a/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
+++ b/tests/ImageSharp.Tests/Common/SimdUtilsTests.cs
@ -178,7 +178,7 @@ namespace SixLabors.ImageSharp.Tests.Common
        {
            TestImpl_BulkConvertByteToNormalizedFloat(
                count,
-                (s, d) => SimdUtils.FallbackIntrinsics128.BulkConvertByteToNormalizedFloat(s.Span, d.Span));
+                (s, d) => SimdUtils.FallbackIntrinsics128.ByteToNormalizedFloat(s.Span, d.Span));
        }

        [Theory]
@ -192,7 +192,7 @@ namespace SixLabors.ImageSharp.Tests.Common

            TestImpl_BulkConvertByteToNormalizedFloat(
                count,
-                (s, d) => SimdUtils.BasicIntrinsics256.BulkConvertByteToNormalizedFloat(s.Span, d.Span));
+                (s, d) => SimdUtils.BasicIntrinsics256.ByteToNormalizedFloat(s.Span, d.Span));
        }

        [Theory]
@ -201,7 +201,7 @@ namespace SixLabors.ImageSharp.Tests.Common
        {
            TestImpl_BulkConvertByteToNormalizedFloat(
                count,
-                (s, d) => SimdUtils.ExtendedIntrinsics.BulkConvertByteToNormalizedFloat(s.Span, d.Span));
+                (s, d) => SimdUtils.ExtendedIntrinsics.ByteToNormalizedFloat(s.Span, d.Span));
        }

        [Theory]
@ -210,7 +210,7 @@ namespace SixLabors.ImageSharp.Tests.Common
        {
            TestImpl_BulkConvertByteToNormalizedFloat(
                count,
-                (s, d) => SimdUtils.BulkConvertByteToNormalizedFloat(s.Span, d.Span));
+                (s, d) => SimdUtils.ByteToNormalizedFloat(s.Span, d.Span));
        }

        private static void TestImpl_BulkConvertByteToNormalizedFloat(
@ -232,7 +232,7 @@ namespace SixLabors.ImageSharp.Tests.Common
        {
            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
                count,
-                (s, d) => SimdUtils.FallbackIntrinsics128.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+                (s, d) => SimdUtils.FallbackIntrinsics128.NormalizedFloatToByteSaturate(s.Span, d.Span));
        }

        [Theory]
@ -244,7 +244,7 @@ namespace SixLabors.ImageSharp.Tests.Common
                return;
            }

-            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(count, (s, d) => SimdUtils.BasicIntrinsics256.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(count, (s, d) => SimdUtils.BasicIntrinsics256.NormalizedFloatToByteSaturate(s.Span, d.Span));
        }

        [Theory]
@ -253,7 +253,7 @@ namespace SixLabors.ImageSharp.Tests.Common
        {
            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
                count,
-                (s, d) => SimdUtils.ExtendedIntrinsics.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+                (s, d) => SimdUtils.ExtendedIntrinsics.NormalizedFloatToByteSaturate(s.Span, d.Span));
        }

        [Theory]
@ -290,7 +290,7 @@ namespace SixLabors.ImageSharp.Tests.Common

            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
                count,
-                (s, d) => SimdUtils.Avx2Intrinsics.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+                (s, d) => SimdUtils.Avx2Intrinsics.NormalizedFloatToByteSaturate(s.Span, d.Span));
        }

 #endif
@ -299,7 +299,7 @@ namespace SixLabors.ImageSharp.Tests.Common
        [MemberData(nameof(ArbitraryArraySizes))]
        public void BulkConvertNormalizedFloatToByteClampOverflows(int count)
        {
-            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(count, (s, d) => SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span));
+            TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(count, (s, d) => SimdUtils.NormalizedFloatToByteSaturate(s.Span, d.Span));

            // For small values, let's stress test the implementation a bit:
            if (count > 0 && count < 10)
@ -308,7 +308,7 @@ namespace SixLabors.ImageSharp.Tests.Common
                {
                    TestImpl_BulkConvertNormalizedFloatToByteClampOverflows(
                        count,
-                        (s, d) => SimdUtils.BulkConvertNormalizedFloatToByteClampOverflows(s.Span, d.Span),
+                        (s, d) => SimdUtils.NormalizedFloatToByteSaturate(s.Span, d.Span),
                        i + 42);
                }
            }