8336274: MutableBigInteger.leftShift(int) optimization

Reviewed-by: rgiulietti

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

@@ -597,44 +597,52 @@ void leftShift(int n) {
          */
         if (intLen == 0)
            return;
+
         int nInts = n >>> 5;
-        int nBits = n&0x1F;
-        int bitsInHighWord = BigInteger.bitLengthForInt(value[offset]);
+        int nBits = n & 0x1F;
+        int leadingZeros = Integer.numberOfLeadingZeros(value[offset]);
 
         // If shift can be done without moving words, do so
-        if (n <= (32-bitsInHighWord)) {
+        if (n <= leadingZeros) {
             primitiveLeftShift(nBits);
             return;
         }
 
-        int newLen = intLen + nInts +1;
-        if (nBits <= (32-bitsInHighWord))
-            newLen--;
-        if (value.length < newLen) {
-            // The array must grow
-            int[] result = new int[newLen];
-            for (int i=0; i < intLen; i++)
-                result[i] = value[offset+i];
-            setValue(result, newLen);
-        } else if (value.length - offset >= newLen) {
-            // Use space on right
-            for(int i=0; i < newLen - intLen; i++)
-                value[offset+intLen+i] = 0;
+        int newLen = intLen + nInts;
+        if (nBits > leadingZeros)
+            newLen++;
+
+        int[] result;
+        final int newOffset;
+        if (value.length < newLen) { // The array must grow
+            result = new int[newLen];
+            newOffset = 0;
         } else {
-            // Must use space on left
-            for (int i=0; i < intLen; i++)
-                value[i] = value[offset+i];
-            for (int i=intLen; i < newLen; i++)
-                value[i] = 0;
-            offset = 0;
+            result = value;
+            newOffset = value.length - offset >= newLen ? offset : 0;
         }
+
+        int trailingZerosPos = newOffset + intLen;
+        if (nBits != 0) {
+            // Do primitive shift directly for speed
+            if (nBits <= leadingZeros) {
+                primitiveLeftShift(nBits, result, newOffset); // newOffset <= offset
+            } else {
+                int lastInt = value[offset + intLen - 1];
+                primitiveRightShift(32 - nBits, result, newOffset); // newOffset <= offset
+                result[trailingZerosPos++] = lastInt << nBits;
+            }
+        } else if (result != value || newOffset != offset) {
+            System.arraycopy(value, offset, result, newOffset, intLen);
+        }
+
+        // Add trailing zeros
+        if (result == value)
+            Arrays.fill(result, trailingZerosPos, newOffset + newLen, 0);
+
+        value = result;
         intLen = newLen;
-        if (nBits == 0)
-            return;
-        if (nBits <= (32-bitsInHighWord))
-            primitiveLeftShift(nBits);
-        else
-            primitiveRightShift(32 -nBits);
+        offset = newOffset;
     }
 
     /**
@@ -698,31 +706,61 @@ private int mulsubBorrow(int[] q, int[] a, int x, int len, int offset) {
      * less than 32.
      * Assumes that intLen > 0, n > 0 for speed
      */
-    private final void primitiveRightShift(int n) {
+    private void primitiveRightShift(int n) {
+        primitiveRightShift(n, value, offset);
+    }
+
+    /**
+     * Right shift this MutableBigInteger n bits, where n is
+     * less than 32, placing the result in the specified array.
+     * Assumes that intLen > 0, n > 0 for speed.
+     * The result can be the value array of this MutableBigInteger,
+     * but for speed the copy is not performed safely, so, in that case
+     * the caller has to make sure that
+     * {@code (resFrom <= offset || resFrom >= offset + intLen)}.
+     */
+    private void primitiveRightShift(int n, int[] result, int resFrom) {
         int[] val = value;
         int n2 = 32 - n;
-        for (int i=offset+intLen-1, c=val[i]; i > offset; i--) {
-            int b = c;
-            c = val[i-1];
-            val[i] = (c << n2) | (b >>> n);
+
+        int b = val[offset];
+        result[resFrom] = b >>> n;
+        for (int i = 1; i < intLen; i++) {
+            int c = b;
+            b = val[offset + i];
+            result[resFrom + i] = (c << n2) | (b >>> n);
         }
-        val[offset] >>>= n;
     }
 
     /**
      * Left shift this MutableBigInteger n bits, where n is
      * less than 32.
      * Assumes that intLen > 0, n > 0 for speed
      */
-    private final void primitiveLeftShift(int n) {
+    private void primitiveLeftShift(int n) {
+        primitiveLeftShift(n, value, offset);
+    }
+
+    /**
+     * Left shift this MutableBigInteger n bits, where n is
+     * less than 32, placing the result in the specified array.
+     * Assumes that intLen > 0, n > 0 for speed.
+     * The result can be the value array of this MutableBigInteger,
+     * but for speed the copy is not performed safely, so, in that case
+     * the caller has to make sure that
+     * {@code (resFrom <= offset || resFrom >= offset + intLen)}.
+     */
+    private void primitiveLeftShift(int n, int[] result, int resFrom) {
         int[] val = value;
         int n2 = 32 - n;
-        for (int i=offset, c=val[i], m=i+intLen-1; i < m; i++) {
-            int b = c;
-            c = val[i+1];
-            val[i] = (b << n) | (c >>> n2);
+        final int m = intLen - 1;
+        int b = val[offset];
+        for (int i = 0; i < m; i++) {
+            int c = val[offset + i + 1];
+            result[resFrom + i] = (b << n) | (c >>> n2);
+            b = c;
         }
-        val[offset+intLen-1] <<= n;
+        result[resFrom + m] = b << n;
     }
 
     /**
@@ -1511,17 +1549,6 @@ long divide(long v, MutableBigInteger quotient) {
         }
     }
 
-    private static void copyAndShift(int[] src, int srcFrom, int srcLen, int[] dst, int dstFrom, int shift) {
-        int n2 = 32 - shift;
-        int c=src[srcFrom];
-        for (int i=0; i < srcLen-1; i++) {
-            int b = c;
-            c = src[++srcFrom];
-            dst[dstFrom+i] = (b << shift) | (c >>> n2);
-        }
-        dst[dstFrom+srcLen-1] = c << shift;
-    }
-
     /**
      * Divide this MutableBigInteger by the divisor.
      * The quotient will be placed into the provided quotient object &
@@ -1539,13 +1566,13 @@ private MutableBigInteger divideMagnitude(MutableBigInteger div,
         MutableBigInteger rem; // Remainder starts as dividend with space for a leading zero
         if (shift > 0) {
             divisor = new int[dlen];
-            copyAndShift(div.value,div.offset,dlen,divisor,0,shift);
+            div.primitiveLeftShift(shift, divisor, 0);
             if (Integer.numberOfLeadingZeros(value[offset]) >= shift) {
                 int[] remarr = new int[intLen + 1];
                 rem = new MutableBigInteger(remarr);
                 rem.intLen = intLen;
                 rem.offset = 1;
-                copyAndShift(value,offset,intLen,remarr,1,shift);
+                this.primitiveLeftShift(shift, remarr, 1);
             } else {
                 int[] remarr = new int[intLen + 2];
                 rem = new MutableBigInteger(remarr);

test/jdk/java/math/BigInteger/MutableBigIntegerShiftTests.java

@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import jdk.test.lib.RandomFactory;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.Arguments;
+
+import java.math.BigInteger;
+import java.math.MutableBigIntegerBox;
+import java.util.Arrays;
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static java.math.MutableBigIntegerBox.*;
+
+/**
+ * @test
+ * @bug 8336274
+ * @summary Tests for correctness of MutableBigInteger.leftShift(int)
+ * @library /test/lib
+ * @build jdk.test.lib.RandomFactory
+ * @build java.base/java.math.MutableBigIntegerBox
+ * @key randomness
+ * @run junit MutableBigIntegerShiftTests
+ */
+public class MutableBigIntegerShiftTests {
+
+    private static final int ORDER_SMALL = 60;
+    private static final int ORDER_MEDIUM = 100;
+
+    private static final Random random = RandomFactory.getRandom();
+
+    private static int[] orders() {
+        return new int[] { ORDER_SMALL, ORDER_MEDIUM };
+    }
+
+    @ParameterizedTest
+    @MethodSource("orders")
+    public void shift(int order) {
+        for (int i = 0; i < 100; i++) {
+            test(fetchNumber(order), random.nextInt(200));
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("pathTargetedCases")
+    public void test(MutableBigIntegerBox x, int n) {
+        leftShiftAssertions(x, n);
+    }
+
+    private static Arguments[] pathTargetedCases() {
+        return new Arguments[] {
+                // intLen == 0
+                Arguments.of(MutableBigIntegerBox.ZERO,
+                        random.nextInt(33)),
+                // intLen != 0 && n <= leadingZeros
+                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
+                        random.nextInt(1, 17)),
+                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits == 0
+                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32) }),
+                        32),
+                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits != 0
+                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
+                        32 + random.nextInt(1, 17)),
+                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
+                // && newOffset != offset
+                Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 32) }, 1, 1),
+                        32),
+                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
+                // && newOffset == offset
+                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32), random.nextInt() }, 0, 1),
+                        32),
+                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
+                // && newOffset != offset
+                Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 16) }, 1, 1),
+                        32 + random.nextInt(1, 17)),
+                // intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
+                // && newOffset == offset
+                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16), random.nextInt() }, 0, 1),
+                        32 + random.nextInt(1, 17)),
+                // intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length < newLen
+                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32) }),
+                        random.nextInt(17, 32)),
+                // intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset != offset
+                Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L << 15, 1L << 32) }, 1, 1),
+                        random.nextInt(17, 32)),
+                // intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset == offset
+                Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32), random.nextInt() }, 0, 1),
+                        random.nextInt(17, 32)),
+        };
+    }
+
+    private static void leftShiftAssertions(MutableBigIntegerBox x, int n) {
+        MutableBigIntegerBox xShifted = x.shiftLeft(n);
+        assertEquals(x.multiply(new MutableBigIntegerBox(BigInteger.TWO.pow(n))), xShifted);
+        assertEquals(x, xShifted.shiftRight(n));
+    }
+
+    /*
+     * Get a random or boundary-case number. This is designed to provide
+     * a lot of numbers that will find failure points, such as max sized
+     * numbers, empty MutableBigIntegers, etc.
+     *
+     * If order is less than 2, order is changed to 2.
+     */
+    private static MutableBigIntegerBox fetchNumber(int order) {
+        int numType = random.nextInt(8);
+        MutableBigIntegerBox result = null;
+        if (order < 2) order = 2;
+
+        int[] val;
+        switch (numType) {
+            case 0: // Empty
+                result = MutableBigIntegerBox.ZERO;
+                break;
+
+            case 1: // One
+                result = MutableBigIntegerBox.ONE;
+                break;
+
+            case 2: // All bits set in number
+                int numInts = (order + 31) >> 5;
+                int[] fullBits = new int[numInts];
+                Arrays.fill(fullBits, -1);
+
+                fullBits[0] &= -1 >>> -order;
+                result = new MutableBigIntegerBox(fullBits);
+                break;
+
+            case 3: // One bit in number
+                result = MutableBigIntegerBox.ONE.shiftLeft(random.nextInt(order));
+                break;
+
+            case 4: // Random bit density
+                val = new int[(order + 31) >> 5];
+                int iterations = random.nextInt(order);
+                for (int i = 0; i < iterations; i++) {
+                    int bitIdx = random.nextInt(order);
+                    val[bitIdx >> 5] |= 1 << bitIdx;
+                }
+                result = new MutableBigIntegerBox(val);
+                break;
+            case 5: // Runs of consecutive ones and zeros
+                result = ZERO;
+                int remaining = order;
+                int bit = random.nextInt(2);
+                while (remaining > 0) {
+                    int runLength = Math.min(remaining, random.nextInt(order));
+                    result = result.shiftLeft(runLength);
+                    if (bit > 0)
+                        result = result.add(ONE.shiftLeft(runLength).subtract(ONE));
+                    remaining -= runLength;
+                    bit = 1 - bit;
+                }
+                break;
+            case 6: // random bits with trailing space
+                int len = random.nextInt((order + 31) >> 5) + 1;
+                int offset = random.nextInt(len);
+                val = new int[len << 1];
+                for (int i = 0; i < val.length; i++)
+                    val[i] = random.nextInt();
+                result = new MutableBigIntegerBox(val, offset, len);
+                break;
+            default: // random bits
+                result = new MutableBigIntegerBox(new BigInteger(order, random));
+        }
+
+        return result;
+    }
+}