[release/7.0] Ensure that the result for PowMod is fully initialized (#74672)

github-actions[bot] · tannergooding · web-flow · commit 2fc5cc95d658 · 2022-08-28T14:21:35.000-07:00
* Adding a regression test for dotnet/performance#2575 * Ensure that the result span is fully initialized. Co-authored-by: Tanner Gooding <tagoo@outlook.com>
diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigIntegerCalculator.PowMod.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigIntegerCalculator.PowMod.cs
@@ -35,7 +35,9 @@ stackalloc uint[StackAllocThreshold]
             value.CopyTo(valueCopy);
             valueCopy.Slice(value.Length).Clear();
 
-            PowCore(valueCopy, value.Length, temp, power, bits).CopyTo(bits);
+            Span<uint> result = PowCore(valueCopy, value.Length, temp, power, bits);
+            result.CopyTo(bits);
+            bits.Slice(result.Length).Clear();
 
             if (tempFromPool != null)
                 ArrayPool<uint>.Shared.Return(tempFromPool);
@@ -50,19 +52,19 @@ private static Span<uint> PowCore(Span<uint> value, int valueLength, Span<uint>
             Debug.Assert(value.Length == temp.Length);
 
             result[0] = 1;
-            int bitsLength = 1;
+            int resultLength = 1;
 
             // The basic pow algorithm using square-and-multiply.
             while (power != 0)
             {
                 if ((power & 1) == 1)
-                    bitsLength = MultiplySelf(ref result, bitsLength, value.Slice(0, valueLength), ref temp);
+                    resultLength = MultiplySelf(ref result, resultLength, value.Slice(0, valueLength), ref temp);
                 if (power != 1)
                     valueLength = SquareSelf(ref value, valueLength, ref temp);
                 power >>= 1;
             }
 
-            return result;
+            return result.Slice(0, resultLength);
         }
 
         private static int MultiplySelf(ref Span<uint> left, int leftLength, ReadOnlySpan<uint> right, ref Span<uint> temp)
@@ -313,7 +315,9 @@ private static void PowCore(Span<uint> value, int valueLength,
 
             if (modulus.Length < ReducerThreshold)
             {
-                PowCore(value, valueLength, power, modulus, bits, 1, temp).CopyTo(bits);
+                Span<uint> result = PowCore(value, valueLength, power, modulus, bits, 1, temp);
+                result.CopyTo(bits);
+                bits.Slice(result.Length).Clear();
             }
             else
             {
@@ -349,7 +353,9 @@ stackalloc uint[StackAllocThreshold]
                 if (rFromPool != null)
                     ArrayPool<uint>.Shared.Return(rFromPool);
 
-                PowCore(value, valueLength, power, reducer, bits, 1, temp).CopyTo(bits);
+                Span<uint> result = PowCore(value, valueLength, power, reducer, bits, 1, temp);
+                result.CopyTo(bits);
+                bits.Slice(result.Length).Clear();
 
                 if (muFromPool != null)
                     ArrayPool<uint>.Shared.Return(muFromPool);
@@ -369,7 +375,9 @@ private static void PowCore(Span<uint> value, int valueLength,
 
             if (modulus.Length < ReducerThreshold)
             {
-                PowCore(value, valueLength, power, modulus, bits, 1, temp).CopyTo(bits);
+                Span<uint> result = PowCore(value, valueLength, power, modulus, bits, 1, temp);
+                result.CopyTo(bits);
+                bits.Slice(result.Length).Clear();
             }
             else
             {
@@ -405,7 +413,9 @@ stackalloc uint[StackAllocThreshold]
                 if (rFromPool != null)
                     ArrayPool<uint>.Shared.Return(rFromPool);
 
-                PowCore(value, valueLength, power, reducer, bits, 1, temp).CopyTo(bits);
+                Span<uint> result = PowCore(value, valueLength, power, reducer, bits, 1, temp);
+                result.CopyTo(bits);
+                bits.Slice(result.Length).Clear();
 
                 if (muFromPool != null)
                     ArrayPool<uint>.Shared.Return(muFromPool);
@@ -472,7 +482,7 @@ private static Span<uint> PowCore(Span<uint> value, int valueLength,
                 power >>= 1;
             }
 
-            return result;
+            return result.Slice(0, resultLength);
         }
 
         private static Span<uint> PowCore(Span<uint> value, int valueLength,
@@ -531,7 +541,7 @@ private static Span<uint> PowCore(Span<uint> value, int valueLength,
                 power >>= 1;
             }
 
-            return result;
+            return result.Slice(0, resultLength);
         }
     }
 }
diff --git a/src/libraries/System.Runtime.Numerics/tests/BigInteger/modpow.cs b/src/libraries/System.Runtime.Numerics/tests/BigInteger/modpow.cs
@@ -275,7 +275,7 @@ public static void ModPowAxiom()
         }
 
         [Fact]
-        public static void RegressionIssue70330()
+        public static void RegressionIssueRuntime70330()
         {
             byte[] tempByteArray1 = { 226, 32 };
             byte[] tempByteArray2 = { 113 };
@@ -286,6 +286,19 @@ public static void RegressionIssue70330()
             );
         }
 
+        [Fact]
+        public static void RegressionIssuePerformance2575()
+        {
+            byte[] tempByteArray1 = { 0x93, 0x30, 0x70, 0xD8, 0x74, 0x0A, 0x70, 0x79, 0x18, 0x5A, 0xCD, 0x2D, 0x39, 0xBF, 0x36, 0xC6, 0x24, 0xDE, 0x4B, 0xD5, 0xC7, 0xB4, 0x56, 0x23, 0xB2, 0xB4, 0xB7, 0x43, 0xE5, 0x05, 0xDD, 0xAF, 0x97, 0x81, 0x67, 0xCB, 0x67, 0xE9, 0x53, 0x5A, 0x00, 0x42, 0x9B, 0x20, 0x56, 0xFA, 0xBE, 0x27, 0x6A, 0x14, 0x36, 0x17, 0x49, 0xC5, 0xAC, 0xDF, 0xDA, 0x4C, 0x26, 0xC0, 0x52, 0x2C, 0x93, 0x13, 0x7D, 0x1E, 0x96, 0xB8, 0x58, 0x6B, 0x5F, 0x3A, 0x8B, 0xF1, 0xD5, 0x84, 0x18, 0x36, 0xCC, 0xB7, 0xF5, 0x90, 0xD9, 0xD1, 0xCE, 0xC5, 0x65, 0xD2, 0xD5, 0x87, 0xF0, 0x1B, 0xC3, 0x92, 0x07, 0xD3, 0xAF, 0x88, 0xA2, 0x38, 0x64, 0x06, 0xCE, 0xFE, 0xB5, 0xFC, 0x8C, 0x58, 0xEF, 0x27, 0xC6, 0xA4, 0x7F, 0x6E, 0xCA, 0xC2, 0x53, 0xC2, 0x44, 0xB7, 0xB8, 0xC3, 0xE2, 0xD0, 0x7A, 0x43, 0x76, 0xF8, 0x00 };
+            byte[] tempByteArray2 = { 0x02, 0xD4, 0x90, 0x93, 0x94, 0x52, 0xEF, 0xC1, 0xDA, 0x1B, 0xD2, 0x39, 0x0D, 0xE3, 0xAD, 0xC1, 0x4C, 0x9B, 0x54, 0xC8, 0x44, 0x7F, 0xED, 0x43, 0xEA, 0x7F, 0xA1, 0x23, 0xFE, 0x84, 0x71, 0x85, 0x93, 0x6E, 0xEC, 0x53, 0x35, 0x10, 0xEB, 0x1C, 0xDA, 0x01, 0x78, 0xA6, 0x71, 0x7E, 0xAB, 0xE0, 0x35, 0x0F, 0x2E, 0xA8, 0x21, 0x30, 0xA5, 0x83, 0xE7, 0x4C, 0xA9, 0x14, 0xB0, 0xCC, 0xC3, 0x56, 0xAA, 0x4C, 0xA5, 0x9E, 0xF6, 0x5A, 0x8B, 0x3C, 0xAF, 0x38, 0xED, 0x43, 0x06, 0x46, 0xD2, 0x6C, 0xD3, 0xC1, 0xED, 0xEE, 0x55, 0xC8, 0x63, 0x63, 0xC9, 0x69, 0x6B, 0xE8, 0x67, 0xD6, 0x6B, 0x0D, 0x3E, 0x22, 0xFC, 0x24, 0xD8, 0x0C, 0xEA, 0xDB, 0x83, 0xF2, 0xF9, 0xE9, 0x43, 0x61, 0x7C, 0xA0, 0x7A, 0x3D, 0x41, 0xEF, 0xDF, 0xD4, 0x00, 0xE1, 0xE9, 0x42, 0xD5, 0x8C, 0xEE, 0xA3, 0xD5, 0xD8, 0x00 };
+            byte[] tempByteArray3 = { 0xDF, 0x05, 0xE4, 0x4A, 0xAD, 0x93, 0xC6, 0xD7, 0x00 };
+            byte[] tempByteArray4 = { 0xC6, 0x57, 0x30, 0x3F, 0xCE, 0x21, 0xA0, 0x3D };
+            VerifyIdentityString(
+                Print(tempByteArray3) + Print(tempByteArray2) + Print(tempByteArray1) + "tModPow",
+                Print(tempByteArray4)
+            );
+        }
+
         [Fact]
         public static void ModPowBoundary()
         {

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,9 @@ stackalloc uint[StackAllocThreshold]`
`35`	`35`	`value.CopyTo(valueCopy);`
`36`	`36`	`valueCopy.Slice(value.Length).Clear();`
`37`	`37`
`38`		`- PowCore(valueCopy, value.Length, temp, power, bits).CopyTo(bits);`
	`38`	`+ Span<uint> result = PowCore(valueCopy, value.Length, temp, power, bits);`
	`39`	`+ result.CopyTo(bits);`
	`40`	`+ bits.Slice(result.Length).Clear();`
`39`	`41`
`40`	`42`	`if (tempFromPool != null)`
`41`	`43`	`ArrayPool<uint>.Shared.Return(tempFromPool);`
`@@ -50,19 +52,19 @@ private static Span<uint> PowCore(Span<uint> value, int valueLength, Span<uint>`
`50`	`52`	`Debug.Assert(value.Length == temp.Length);`
`51`	`53`
`52`	`54`	`result[0] = 1;`
`53`		`- int bitsLength = 1;`
	`55`	`+ int resultLength = 1;`
`54`	`56`
`55`	`57`	`// The basic pow algorithm using square-and-multiply.`
`56`	`58`	`while (power != 0)`
`57`	`59`	`{`
`58`	`60`	`if ((power & 1) == 1)`
`59`		`- bitsLength = MultiplySelf(ref result, bitsLength, value.Slice(0, valueLength), ref temp);`
	`61`	`+ resultLength = MultiplySelf(ref result, resultLength, value.Slice(0, valueLength), ref temp);`
`60`	`62`	`if (power != 1)`
`61`	`63`	`valueLength = SquareSelf(ref value, valueLength, ref temp);`
`62`	`64`	`power >>= 1;`
`63`	`65`	`}`
`64`	`66`
`65`		`- return result;`
	`67`	`+ return result.Slice(0, resultLength);`
`66`	`68`	`}`
`67`	`69`
`68`	`70`	`private static int MultiplySelf(ref Span<uint> left, int leftLength, ReadOnlySpan<uint> right, ref Span<uint> temp)`
`@@ -313,7 +315,9 @@ private static void PowCore(Span<uint> value, int valueLength,`
`313`	`315`
`314`	`316`	`if (modulus.Length < ReducerThreshold)`
`315`	`317`	`{`
`316`		`- PowCore(value, valueLength, power, modulus, bits, 1, temp).CopyTo(bits);`
	`318`	`+ Span<uint> result = PowCore(value, valueLength, power, modulus, bits, 1, temp);`
	`319`	`+ result.CopyTo(bits);`
	`320`	`+ bits.Slice(result.Length).Clear();`
`317`	`321`	`}`
`318`	`322`	`else`
`319`	`323`	`{`
`@@ -349,7 +353,9 @@ stackalloc uint[StackAllocThreshold]`
`349`	`353`	`if (rFromPool != null)`
`350`	`354`	`ArrayPool<uint>.Shared.Return(rFromPool);`
`351`	`355`
`352`		`- PowCore(value, valueLength, power, reducer, bits, 1, temp).CopyTo(bits);`
	`356`	`+ Span<uint> result = PowCore(value, valueLength, power, reducer, bits, 1, temp);`
	`357`	`+ result.CopyTo(bits);`
	`358`	`+ bits.Slice(result.Length).Clear();`
`353`	`359`
`354`	`360`	`if (muFromPool != null)`
`355`	`361`	`ArrayPool<uint>.Shared.Return(muFromPool);`
`@@ -369,7 +375,9 @@ private static void PowCore(Span<uint> value, int valueLength,`
`369`	`375`
`370`	`376`	`if (modulus.Length < ReducerThreshold)`
`371`	`377`	`{`
`372`		`- PowCore(value, valueLength, power, modulus, bits, 1, temp).CopyTo(bits);`
	`378`	`+ Span<uint> result = PowCore(value, valueLength, power, modulus, bits, 1, temp);`
	`379`	`+ result.CopyTo(bits);`
	`380`	`+ bits.Slice(result.Length).Clear();`
`373`	`381`	`}`
`374`	`382`	`else`
`375`	`383`	`{`
`@@ -405,7 +413,9 @@ stackalloc uint[StackAllocThreshold]`
`405`	`413`	`if (rFromPool != null)`
`406`	`414`	`ArrayPool<uint>.Shared.Return(rFromPool);`
`407`	`415`
`408`		`- PowCore(value, valueLength, power, reducer, bits, 1, temp).CopyTo(bits);`
	`416`	`+ Span<uint> result = PowCore(value, valueLength, power, reducer, bits, 1, temp);`
	`417`	`+ result.CopyTo(bits);`
	`418`	`+ bits.Slice(result.Length).Clear();`
`409`	`419`
`410`	`420`	`if (muFromPool != null)`
`411`	`421`	`ArrayPool<uint>.Shared.Return(muFromPool);`
`@@ -472,7 +482,7 @@ private static Span<uint> PowCore(Span<uint> value, int valueLength,`
`472`	`482`	`power >>= 1;`
`473`	`483`	`}`
`474`	`484`
`475`		`- return result;`
	`485`	`+ return result.Slice(0, resultLength);`
`476`	`486`	`}`
`477`	`487`
`478`	`488`	`private static Span<uint> PowCore(Span<uint> value, int valueLength,`
`@@ -531,7 +541,7 @@ private static Span<uint> PowCore(Span<uint> value, int valueLength,`
`531`	`541`	`power >>= 1;`
`532`	`542`	`}`
`533`	`543`
`534`		`- return result;`
	`544`	`+ return result.Slice(0, resultLength);`
`535`	`545`	`}`
`536`	`546`	`}`
`537`	`547`	`}`