stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8336274: MutableBigInteger.leftShift(int) optimization

Browse Source 
Reviewed-by: rgiulietti
This commit is contained in:
fabioromano1 2024-10-02 09:45:43 +00:00 committed by Raffaello Giulietti
parent a4ca6267e1
commit d6820d1324
3 changed files with 451 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
src/java.base/share/classes/java/math/MutableBigInteger.java
View File

@ -597,44 +597,52 @@ class MutableBigInteger {
*/
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,15 +706,30 @@ class MutableBigInteger {
* 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;
}
/**
@ -714,15 +737,30 @@ class MutableBigInteger {
* 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 @@ class MutableBigInteger {
}
}
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 @@ class MutableBigInteger {
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);

191
test/jdk/java/math/BigInteger/MutableBigIntegerShiftTests.java Normal file
View File

@ -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;
}
}

180
test/jdk/java/math/BigInteger/java.base/java/math/MutableBigIntegerBox.java Normal file
View File

@ -0,0 +1,180 @@
/*
* 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.
*/
package java.math;
import java.util.Arrays;
/**
* A class for tests.
*/
public class MutableBigIntegerBox {
/**
* Constant zero
*/
public static final MutableBigIntegerBox ZERO = new MutableBigIntegerBox(new MutableBigInteger());
/**
* Constant one
*/
public static final MutableBigIntegerBox ONE = new MutableBigIntegerBox(MutableBigInteger.ONE);
/**
* Constant two
*/
public static final MutableBigIntegerBox TWO = new MutableBigIntegerBox(new MutableBigInteger(2));
private MutableBigInteger val;
MutableBigIntegerBox(MutableBigInteger val) {
this.val = val;
}
/**
* Construct MutableBigIntegerBox from magnitude, starting from
* offset and with a length of intLen ints.
* The value is normalized.
* @param mag the magnitude
* @param offset the offset where the value starts
* @param intLen the length of the value, in int words.
*/
public MutableBigIntegerBox(int[] mag, int offset, int intLen) {
this(new MutableBigInteger(mag));
val.offset = offset;
val.intLen = intLen;
val.normalize();
}
/**
* Construct MutableBigIntegerBox from magnitude.
* The value is normalized.
* @param mag the magnitude
*/
public MutableBigIntegerBox(int[] mag) {
this(mag, 0, mag.length);
}
/**
* Construct MutableBigIntegerBox from BigInteger val
* @param val the value
*/
public MutableBigIntegerBox(BigInteger val) {
this(val.mag);
}
/**
* Returns the bit length of this MutableBigInteger value
* @return the bit length of this MutableBigInteger value
*/
public long bitLength() {
return val.bitLength();
}
/**
* Return {@code this << n}
* @return {@code this << n}
* @param n the shift
*/
public MutableBigIntegerBox shiftLeft(int n) {
MutableBigIntegerBox res = new MutableBigIntegerBox(val.value.clone(), val.offset, val.intLen);
res.val.safeLeftShift(n);
return res;
}
/**
* Return {@code this >> n}
* @return {@code this >> n}
* @param n the shift
*/
public MutableBigIntegerBox shiftRight(int n) {
MutableBigInteger res = new MutableBigInteger(val);
res.safeRightShift(n);
return new MutableBigIntegerBox(res);
}
/**
* Return this + addend
* @return this + addend
* @param addend the addend
*/
public MutableBigIntegerBox add(MutableBigIntegerBox addend) {
MutableBigInteger res = new MutableBigInteger(val);
res.add(addend.val);
return new MutableBigIntegerBox(res);
}
/**
* Return this - subtraend
* @return this - subtraend
* @param subtraend the subtraend
*/
public MutableBigIntegerBox subtract(MutableBigIntegerBox subtraend) {
MutableBigInteger res = new MutableBigInteger(val);
res.subtract(subtraend.val);
return new MutableBigIntegerBox(res);
}
/**
* Return this * multiplier
* @return this * multiplier
* @param multiplier the multiplier
*/
public MutableBigIntegerBox multiply(MutableBigIntegerBox multiplier) {
MutableBigInteger res = new MutableBigInteger();
if (!(val.isZero() || multiplier.val.isZero()))
val.multiply(multiplier.val, res);
return new MutableBigIntegerBox(res);
}
/**
* Compare the magnitude of two MutableBigIntegers. Returns -1, 0 or 1
* as this is numerically less than, equal to, or greater than {@code b}.
* @return -1, 0 or 1 as this is numerically less than, equal to, or
* greater than {@code b}.
* @param b the value to compare
*/
public int compare(MutableBigIntegerBox b) {
return val.compare(b.val);
}
/**
* Compares this MutableBigIntegerBox with the specified Object for equality.
*
* @param x Object to which this MutableBigIntegerBox is to be compared.
* @return {@code true} if and only if the specified Object is a
* MutableBigIntegerBox whose value is numerically equal to this MutableBigIntegerBox.
*/
@Override
public boolean equals(Object x) {
return (x instanceof MutableBigIntegerBox xInt)
&& Arrays.equals(val.value, val.offset, val.offset + val.intLen,
xInt.val.value, xInt.val.offset, xInt.val.offset + xInt.val.intLen);
}
@Override
public String toString() {
return val.toString();
}
}