Optimize Math.Round for arm64 and AwayFromZero for x64

src/libraries/System.Private.CoreLib/src/System/Math.cs

@@ -1299,6 +1299,34 @@ public static double Round(double value, int digits)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double Round(double value, MidpointRounding mode)
         {
+            if (AdvSimd.Arm64.IsSupported)
+            {
+                // Inline the most common cases
+                if (mode == MidpointRounding.ToEven)
+                {
+                    return Round(value);
+                }
+                if (mode == MidpointRounding.AwayFromZero)
+                {
+                    return AdvSimd.Arm64.RoundAwayFromZero(Vector128.CreateScalarUnsafe(value)).ToScalar();
+                }
+            }
+            if (Sse41.IsSupported)
+            {
+                // Inline the most common cases
+                if (mode == MidpointRounding.ToEven)
+                {
+                    return Round(value);
+                }
+                if (mode == MidpointRounding.AwayFromZero)
+                {
+                    Vector128<double> valueVec = Vector128.CreateScalarUnsafe(value);
+                    Vector128<double> tmp = Sse2.And(valueVec, Vector128.Create(0x8000000000000000UL).AsDouble());
+                    tmp = Sse2.Or(tmp, Vector128.Create(0x3fdfffffffffffffUL).AsDouble());
+                    tmp = Sse2.Add(tmp, valueVec);
+                    return Sse41.RoundToZeroScalar(tmp).ToScalar();
+                }
+            }
             return Round(value, 0, mode);
         }
 

src/libraries/System.Private.CoreLib/src/System/MathF.cs

@@ -429,6 +429,35 @@ public static float Round(float x, int digits)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float Round(float x, MidpointRounding mode)
         {
+            if (AdvSimd.IsSupported)
+            {
+                // Inline the most common cases
+                if (mode == MidpointRounding.ToEven)
+                {
+                    return Round(x);
+                }
+                if (mode == MidpointRounding.AwayFromZero)
+                {
+                    return AdvSimd.RoundAwayFromZero(Vector64.CreateScalarUnsafe(x)).ToScalar();
+                }
+            }
+            if (Sse41.IsSupported)
+            {
+                // Inline the most common cases
+                if (mode == MidpointRounding.ToEven)
+                {
+                    return Round(x);
+                }
+                if (mode == MidpointRounding.AwayFromZero)
+                {
+                    Vector128<float> xVec = Vector128.CreateScalarUnsafe(x);
+                    Vector128<float> tmp = Sse.And(xVec, Vector128.Create(0x8000000000000000UL).AsSingle());
+                    tmp = Sse.Or(tmp, Vector128.Create(0x3fdfffffffffffffUL).AsSingle());
+                    tmp = Sse.Add(tmp, xVec);
+                    return Sse41.RoundToZeroScalar(tmp).ToScalar();
+                }
+            }
+
             return Round(x, 0, mode);
         }