8355719: Reduce memory consumption of BigInteger.pow()

src/java.base/share/classes/java/math/BigInteger.java

@@ -1246,6 +1246,16 @@ else if (val < 0 && val >= -MAX_CONSTANT)
         return new BigInteger(val);
     }
 
+    /**
+     * Constructs a BigInteger with magnitude specified by the long,
+     * which may not be zero, and the signum specified by the int.
+     */
+    private BigInteger(long mag, int signum) {
+        assert mag != 0 && signum != 0;
+        this.signum = signum;
+        this.mag = toMagArray(mag);
+    }
+
     /**
      * Constructs a BigInteger with the specified value, which may not be zero.
      */
@@ -1256,16 +1266,14 @@ private BigInteger(long val) {
         } else {
             signum = 1;
         }
+        mag = toMagArray(val);
+    }
 
-        int highWord = (int)(val >>> 32);
-        if (highWord == 0) {
-            mag = new int[1];
-            mag[0] = (int)val;
-        } else {
-            mag = new int[2];
-            mag[0] = highWord;
-            mag[1] = (int)val;
-        }
+    private static int[] toMagArray(long mag) {
+        int highWord = (int) (mag >>> 32);
+        return highWord == 0
+                ? new int[] { (int) mag }
+                : new int[] { highWord, (int) mag };
     }
 
     /**
@@ -2589,17 +2597,19 @@ public BigInteger pow(int exponent) {
         if (exponent < 0) {
             throw new ArithmeticException("Negative exponent");
         }
-        if (signum == 0) {
-            return (exponent == 0 ? ONE : this);
-        }
+        if (exponent == 0 || this.equals(ONE))
+            return ONE;
 
-        BigInteger partToSquare = this.abs();
+        if (signum == 0)
+            return ZERO;
+
+        BigInteger base = this.abs();
 
         // Factor out powers of two from the base, as the exponentiation of
         // these can be done by left shifts only.
         // The remaining part can then be exponentiated faster.  The
         // powers of two will be multiplied back at the end.
-        int powersOfTwo = partToSquare.getLowestSetBit();
+        int powersOfTwo = base.getLowestSetBit();
         long bitsToShiftLong = (long)powersOfTwo * exponent;
         if (bitsToShiftLong > Integer.MAX_VALUE) {
             reportOverflow();
@@ -2610,8 +2620,8 @@ public BigInteger pow(int exponent) {
 
         // Factor the powers of two out quickly by shifting right, if needed.
         if (powersOfTwo > 0) {
-            partToSquare = partToSquare.shiftRight(powersOfTwo);
-            remainingBits = partToSquare.bitLength();
+            base = base.shiftRight(powersOfTwo);
+            remainingBits = base.bitLength();
             if (remainingBits == 1) {  // Nothing left but +/- 1?
                 if (signum < 0 && (exponent&1) == 1) {
                     return NEGATIVE_ONE.shiftLeft(bitsToShift);
@@ -2620,7 +2630,7 @@ public BigInteger pow(int exponent) {
                 }
             }
         } else {
-            remainingBits = partToSquare.bitLength();
+            remainingBits = base.bitLength();
             if (remainingBits == 1) { // Nothing left but +/- 1?
                 if (signum < 0  && (exponent&1) == 1) {
                     return NEGATIVE_ONE;
@@ -2636,57 +2646,39 @@ public BigInteger pow(int exponent) {
         long scaleFactor = (long)remainingBits * exponent;
 
         // Use slightly different algorithms for small and large operands.
-        // See if the result will safely fit into a long. (Largest 2^63-1)
-        if (partToSquare.mag.length == 1 && scaleFactor <= 62) {
-            // Small number algorithm.  Everything fits into a long.
+        // See if the result will safely fit into an unsigned long. (Largest 2^64-1)
+        if (base.mag.length == 1 && scaleFactor <= Long.SIZE) {
+            // Small number algorithm.  Everything fits into an unsigned long.
             int newSign = (signum <0  && (exponent&1) == 1 ? -1 : 1);
-            long result = 1;
-            long baseToPow2 = partToSquare.mag[0] & LONG_MASK;
-
-            int workingExponent = exponent;
-
-            // Perform exponentiation using repeated squaring trick
-            while (workingExponent != 0) {
-                if ((workingExponent & 1) == 1) {
-                    result = result * baseToPow2;
-                }
-
-                if ((workingExponent >>>= 1) != 0) {
-                    baseToPow2 = baseToPow2 * baseToPow2;
-                }
-            }
+            long result = unsignedLongPow(base.mag[0] & LONG_MASK, exponent);
 
             // Multiply back the powers of two (quickly, by shifting left)
-            if (powersOfTwo > 0) {
-                if (bitsToShift + scaleFactor <= 62) { // Fits in long?
-                    return valueOf((result << bitsToShift) * newSign);
-                } else {
-                    return valueOf(result*newSign).shiftLeft(bitsToShift);
-                }
-            } else {
-                return valueOf(result*newSign);
-            }
+            return powersOfTwo == 0
+                    ? new BigInteger(result, newSign)
+                    : (bitsToShift + scaleFactor <= Long.SIZE  // Fits in long?
+                            ? new BigInteger(result << bitsToShift, newSign)
+                            : new BigInteger(result, newSign).shiftLeft(bitsToShift));
         } else {
             if ((long)bitLength() * exponent / Integer.SIZE > MAX_MAG_LENGTH) {
                 reportOverflow();
             }
 
             // Large number algorithm.  This is basically identical to
-            // the algorithm above, but calls multiply() and square()
+            // the algorithm above, but calls multiply()
             // which may use more efficient algorithms for large numbers.
             BigInteger answer = ONE;
 
-            int workingExponent = exponent;
+            final int expZeros = Integer.numberOfLeadingZeros(exponent);
+            int workingExp = exponent << expZeros;
             // Perform exponentiation using repeated squaring trick
-            while (workingExponent != 0) {
-                if ((workingExponent & 1) == 1) {
-                    answer = answer.multiply(partToSquare);
-                }
+            for (int expLen = Integer.SIZE - expZeros; expLen > 0; expLen--) {
+                answer = answer.multiply(answer);
+                if (workingExp < 0) // leading bit is set
+                    answer = answer.multiply(base);
 
-                if ((workingExponent >>>= 1) != 0) {
-                    partToSquare = partToSquare.square();
-                }
+                workingExp <<= 1;
             }
+
             // Multiply back the (exponentiated) powers of two (quickly,
             // by shifting left)
             if (powersOfTwo > 0) {
@@ -2701,6 +2693,88 @@ public BigInteger pow(int exponent) {
         }
     }
 
+    /**
+     * Computes {@code x^n} using repeated squaring trick.
+     * Assumes {@code x != 0 && x^n < 2^Long.SIZE}.
+     */
+    static long unsignedLongPow(long x, int n) {
+        if (x == 1L)
+            return 1L;
+
+        if (x == 2L)
+            return 1L << n;
+        // Double.PRECISION / bitLength(x) is the largest integer e
+        // such that x^e fits into a double. If e <= 3, we won't use fp arithmetic.
+        // This allows to use fp arithmetic in computePower(), where possible.
+        final int maxExp = Math.max(3, Double.PRECISION / bitLengthForLong(x));
+        final int maxExpLen = bitLengthForInt(maxExp);
+        final long[] powerCache = new long[1 << maxExpLen];
+
+        final int nZeros = Integer.numberOfLeadingZeros(n);
+        n <<= nZeros;
+
+        long pow = 1L;
+        int blockLen;
+        for (int nLen = Integer.SIZE - nZeros; nLen > 0; nLen -= blockLen) {
+            blockLen = Math.min(maxExpLen, nLen);
+            // compute pow^(2^blockLen)
+            if (pow != 1L) {
+                for (int i = 0; i < blockLen; i++)
+                    pow *= pow;
+            }
+
+            // add exp to power's exponent
+            int exp = n >>> -blockLen;
+            if (exp > 0)
+                pow *= computePower(powerCache, x, exp, maxExp);
+
+            n <<= blockLen; // shift to next block of bits
+        }
+
+        return pow;
+    }
+
+    /**
+     * Returns {@code x^exp}. This method is used by {@code unsignedLongPow(long, int)}.
+     * Assumes {@code maxExp == max(3, Double.PRECISION / bitLength(x))}.
+     */
+    private static long computePower(long[] powerCache, long x, int exp, int maxExp) {
+        long xToExp = powerCache[exp];
+        if (xToExp == 0) {
+            if (exp <= maxExp) {
+                // don't use fp arithmetic if exp <= 3
+                xToExp = exp == 1 ? x :
+                        (exp == 2 ? x*x :
+                        (exp == 3 ? x*x*x : (long) Math.pow(x, exp)));
+                powerCache[exp] = xToExp;
+            } else {
+                // adjust exp to fit x^expAdj into a double
+                final int expAdj = exp >>> 1;
+
+                xToExp = powerCache[expAdj << 1];
+                if (xToExp == 0) { // compute x^(expAdj << 1)
+                    xToExp = powerCache[expAdj];
+                    if (xToExp == 0) {  // compute x^expAdj
+                        // don't use fp arithmetic if expAdj <= 3
+                        xToExp = expAdj == 1 ? x :
+                                (expAdj == 2 ? x*x :
+                                (expAdj == 3 ? x*x*x : (long) Math.pow(x, expAdj)));
+                        powerCache[expAdj] = xToExp;
+                    }
+                    xToExp *= xToExp;
+                    powerCache[expAdj << 1] = xToExp;
+                }
+
+                // append exp's rightmost bit to expAdj
+                if ((exp & 1) == 1) {
+                    xToExp *= x;
+                    powerCache[exp] = xToExp;
+                }
+            }
+        }
+        return xToExp;
+    }
+
     /**
      * Returns the integer square root of this BigInteger.  The integer square
      * root of the corresponding mathematical integer {@code n} is the largest