Skip to content

Commit d6820d1

Browse files
fabioromano1rgiulietti
fabioromano1
authored and
rgiulietti
committedOct 2, 2024
8336274: MutableBigInteger.leftShift(int) optimization
Reviewed-by: rgiulietti
1 parent a4ca626 commit d6820d1

File tree

3 files changed

+451
-53
lines changed

3 files changed

+451
-53
lines changed
 

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

+80-53
Original file line numberDiff line numberDiff line change
@@ -597,44 +597,52 @@ void leftShift(int n) {
597597
*/
598598
if (intLen == 0)
599599
return;
600+
600601
int nInts = n >>> 5;
601-
int nBits = n&0x1F;
602-
int bitsInHighWord = BigInteger.bitLengthForInt(value[offset]);
602+
int nBits = n & 0x1F;
603+
int leadingZeros = Integer.numberOfLeadingZeros(value[offset]);
603604

604605
// If shift can be done without moving words, do so
605-
if (n <= (32-bitsInHighWord)) {
606+
if (n <= leadingZeros) {
606607
primitiveLeftShift(nBits);
607608
return;
608609
}
609610

610-
int newLen = intLen + nInts +1;
611-
if (nBits <= (32-bitsInHighWord))
612-
newLen--;
613-
if (value.length < newLen) {
614-
// The array must grow
615-
int[] result = new int[newLen];
616-
for (int i=0; i < intLen; i++)
617-
result[i] = value[offset+i];
618-
setValue(result, newLen);
619-
} else if (value.length - offset >= newLen) {
620-
// Use space on right
621-
for(int i=0; i < newLen - intLen; i++)
622-
value[offset+intLen+i] = 0;
611+
int newLen = intLen + nInts;
612+
if (nBits > leadingZeros)
613+
newLen++;
614+
615+
int[] result;
616+
final int newOffset;
617+
if (value.length < newLen) { // The array must grow
618+
result = new int[newLen];
619+
newOffset = 0;
623620
} else {
624-
// Must use space on left
625-
for (int i=0; i < intLen; i++)
626-
value[i] = value[offset+i];
627-
for (int i=intLen; i < newLen; i++)
628-
value[i] = 0;
629-
offset = 0;
621+
result = value;
622+
newOffset = value.length - offset >= newLen ? offset : 0;
630623
}
624+
625+
int trailingZerosPos = newOffset + intLen;
626+
if (nBits != 0) {
627+
// Do primitive shift directly for speed
628+
if (nBits <= leadingZeros) {
629+
primitiveLeftShift(nBits, result, newOffset); // newOffset <= offset
630+
} else {
631+
int lastInt = value[offset + intLen - 1];
632+
primitiveRightShift(32 - nBits, result, newOffset); // newOffset <= offset
633+
result[trailingZerosPos++] = lastInt << nBits;
634+
}
635+
} else if (result != value || newOffset != offset) {
636+
System.arraycopy(value, offset, result, newOffset, intLen);
637+
}
638+
639+
// Add trailing zeros
640+
if (result == value)
641+
Arrays.fill(result, trailingZerosPos, newOffset + newLen, 0);
642+
643+
value = result;
631644
intLen = newLen;
632-
if (nBits == 0)
633-
return;
634-
if (nBits <= (32-bitsInHighWord))
635-
primitiveLeftShift(nBits);
636-
else
637-
primitiveRightShift(32 -nBits);
645+
offset = newOffset;
638646
}
639647

640648
/**
@@ -698,31 +706,61 @@ private int mulsubBorrow(int[] q, int[] a, int x, int len, int offset) {
698706
* less than 32.
699707
* Assumes that intLen > 0, n > 0 for speed
700708
*/
701-
private final void primitiveRightShift(int n) {
709+
private void primitiveRightShift(int n) {
710+
primitiveRightShift(n, value, offset);
711+
}
712+
713+
/**
714+
* Right shift this MutableBigInteger n bits, where n is
715+
* less than 32, placing the result in the specified array.
716+
* Assumes that intLen > 0, n > 0 for speed.
717+
* The result can be the value array of this MutableBigInteger,
718+
* but for speed the copy is not performed safely, so, in that case
719+
* the caller has to make sure that
720+
* {@code (resFrom <= offset || resFrom >= offset + intLen)}.
721+
*/
722+
private void primitiveRightShift(int n, int[] result, int resFrom) {
702723
int[] val = value;
703724
int n2 = 32 - n;
704-
for (int i=offset+intLen-1, c=val[i]; i > offset; i--) {
705-
int b = c;
706-
c = val[i-1];
707-
val[i] = (c << n2) | (b >>> n);
725+
726+
int b = val[offset];
727+
result[resFrom] = b >>> n;
728+
for (int i = 1; i < intLen; i++) {
729+
int c = b;
730+
b = val[offset + i];
731+
result[resFrom + i] = (c << n2) | (b >>> n);
708732
}
709-
val[offset] >>>= n;
710733
}
711734

712735
/**
713736
* Left shift this MutableBigInteger n bits, where n is
714737
* less than 32.
715738
* Assumes that intLen > 0, n > 0 for speed
716739
*/
717-
private final void primitiveLeftShift(int n) {
740+
private void primitiveLeftShift(int n) {
741+
primitiveLeftShift(n, value, offset);
742+
}
743+
744+
/**
745+
* Left shift this MutableBigInteger n bits, where n is
746+
* less than 32, placing the result in the specified array.
747+
* Assumes that intLen > 0, n > 0 for speed.
748+
* The result can be the value array of this MutableBigInteger,
749+
* but for speed the copy is not performed safely, so, in that case
750+
* the caller has to make sure that
751+
* {@code (resFrom <= offset || resFrom >= offset + intLen)}.
752+
*/
753+
private void primitiveLeftShift(int n, int[] result, int resFrom) {
718754
int[] val = value;
719755
int n2 = 32 - n;
720-
for (int i=offset, c=val[i], m=i+intLen-1; i < m; i++) {
721-
int b = c;
722-
c = val[i+1];
723-
val[i] = (b << n) | (c >>> n2);
756+
final int m = intLen - 1;
757+
int b = val[offset];
758+
for (int i = 0; i < m; i++) {
759+
int c = val[offset + i + 1];
760+
result[resFrom + i] = (b << n) | (c >>> n2);
761+
b = c;
724762
}
725-
val[offset+intLen-1] <<= n;
763+
result[resFrom + m] = b << n;
726764
}
727765

728766
/**
@@ -1511,17 +1549,6 @@ long divide(long v, MutableBigInteger quotient) {
15111549
}
15121550
}
15131551

1514-
private static void copyAndShift(int[] src, int srcFrom, int srcLen, int[] dst, int dstFrom, int shift) {
1515-
int n2 = 32 - shift;
1516-
int c=src[srcFrom];
1517-
for (int i=0; i < srcLen-1; i++) {
1518-
int b = c;
1519-
c = src[++srcFrom];
1520-
dst[dstFrom+i] = (b << shift) | (c >>> n2);
1521-
}
1522-
dst[dstFrom+srcLen-1] = c << shift;
1523-
}
1524-
15251552
/**
15261553
* Divide this MutableBigInteger by the divisor.
15271554
* The quotient will be placed into the provided quotient object &
@@ -1539,13 +1566,13 @@ private MutableBigInteger divideMagnitude(MutableBigInteger div,
15391566
MutableBigInteger rem; // Remainder starts as dividend with space for a leading zero
15401567
if (shift > 0) {
15411568
divisor = new int[dlen];
1542-
copyAndShift(div.value,div.offset,dlen,divisor,0,shift);
1569+
div.primitiveLeftShift(shift, divisor, 0);
15431570
if (Integer.numberOfLeadingZeros(value[offset]) >= shift) {
15441571
int[] remarr = new int[intLen + 1];
15451572
rem = new MutableBigInteger(remarr);
15461573
rem.intLen = intLen;
15471574
rem.offset = 1;
1548-
copyAndShift(value,offset,intLen,remarr,1,shift);
1575+
this.primitiveLeftShift(shift, remarr, 1);
15491576
} else {
15501577
int[] remarr = new int[intLen + 2];
15511578
rem = new MutableBigInteger(remarr);

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

+191
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,191 @@
1+
/*
2+
* Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
3+
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+
*
5+
* This code is free software; you can redistribute it and/or modify it
6+
* under the terms of the GNU General Public License version 2 only, as
7+
* published by the Free Software Foundation.
8+
*
9+
* This code is distributed in the hope that it will be useful, but WITHOUT
10+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12+
* version 2 for more details (a copy is included in the LICENSE file that
13+
* accompanied this code).
14+
*
15+
* You should have received a copy of the GNU General Public License version
16+
* 2 along with this work; if not, write to the Free Software Foundation,
17+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18+
*
19+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20+
* or visit www.oracle.com if you need additional information or have any
21+
* questions.
22+
*/
23+
24+
import jdk.test.lib.RandomFactory;
25+
import org.junit.jupiter.params.ParameterizedTest;
26+
import org.junit.jupiter.params.provider.MethodSource;
27+
import org.junit.jupiter.params.provider.Arguments;
28+
29+
import java.math.BigInteger;
30+
import java.math.MutableBigIntegerBox;
31+
import java.util.Arrays;
32+
import java.util.Random;
33+
34+
import static org.junit.jupiter.api.Assertions.assertEquals;
35+
import static java.math.MutableBigIntegerBox.*;
36+
37+
/**
38+
* @test
39+
* @bug 8336274
40+
* @summary Tests for correctness of MutableBigInteger.leftShift(int)
41+
* @library /test/lib
42+
* @build jdk.test.lib.RandomFactory
43+
* @build java.base/java.math.MutableBigIntegerBox
44+
* @key randomness
45+
* @run junit MutableBigIntegerShiftTests
46+
*/
47+
public class MutableBigIntegerShiftTests {
48+
49+
private static final int ORDER_SMALL = 60;
50+
private static final int ORDER_MEDIUM = 100;
51+
52+
private static final Random random = RandomFactory.getRandom();
53+
54+
private static int[] orders() {
55+
return new int[] { ORDER_SMALL, ORDER_MEDIUM };
56+
}
57+
58+
@ParameterizedTest
59+
@MethodSource("orders")
60+
public void shift(int order) {
61+
for (int i = 0; i < 100; i++) {
62+
test(fetchNumber(order), random.nextInt(200));
63+
}
64+
}
65+
66+
@ParameterizedTest
67+
@MethodSource("pathTargetedCases")
68+
public void test(MutableBigIntegerBox x, int n) {
69+
leftShiftAssertions(x, n);
70+
}
71+
72+
private static Arguments[] pathTargetedCases() {
73+
return new Arguments[] {
74+
// intLen == 0
75+
Arguments.of(MutableBigIntegerBox.ZERO,
76+
random.nextInt(33)),
77+
// intLen != 0 && n <= leadingZeros
78+
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
79+
random.nextInt(1, 17)),
80+
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits == 0
81+
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32) }),
82+
32),
83+
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length < newLen && nBits != 0
84+
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16) }),
85+
32 + random.nextInt(1, 17)),
86+
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
87+
// && newOffset != offset
88+
Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 32) }, 1, 1),
89+
32),
90+
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits == 0
91+
// && newOffset == offset
92+
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 32), random.nextInt() }, 0, 1),
93+
32),
94+
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
95+
// && newOffset != offset
96+
Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L, 1L << 16) }, 1, 1),
97+
32 + random.nextInt(1, 17)),
98+
// intLen != 0 && n > leadingZeros && nBits <= leadingZeros && value.length >= newLen && nBits != 0
99+
// && newOffset == offset
100+
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L, 1L << 16), random.nextInt() }, 0, 1),
101+
32 + random.nextInt(1, 17)),
102+
// intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length < newLen
103+
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32) }),
104+
random.nextInt(17, 32)),
105+
// intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset != offset
106+
Arguments.of(new MutableBigIntegerBox(new int[] { random.nextInt(), (int) random.nextLong(1L << 15, 1L << 32) }, 1, 1),
107+
random.nextInt(17, 32)),
108+
// intLen != 0 && n > leadingZeros && nBits > leadingZeros && value.length >= newLen && newOffset == offset
109+
Arguments.of(new MutableBigIntegerBox(new int[] { (int) random.nextLong(1L << 15, 1L << 32), random.nextInt() }, 0, 1),
110+
random.nextInt(17, 32)),
111+
};
112+
}
113+
114+
private static void leftShiftAssertions(MutableBigIntegerBox x, int n) {
115+
MutableBigIntegerBox xShifted = x.shiftLeft(n);
116+
assertEquals(x.multiply(new MutableBigIntegerBox(BigInteger.TWO.pow(n))), xShifted);
117+
assertEquals(x, xShifted.shiftRight(n));
118+
}
119+
120+
/*
121+
* Get a random or boundary-case number. This is designed to provide
122+
* a lot of numbers that will find failure points, such as max sized
123+
* numbers, empty MutableBigIntegers, etc.
124+
*
125+
* If order is less than 2, order is changed to 2.
126+
*/
127+
private static MutableBigIntegerBox fetchNumber(int order) {
128+
int numType = random.nextInt(8);
129+
MutableBigIntegerBox result = null;
130+
if (order < 2) order = 2;
131+
132+
int[] val;
133+
switch (numType) {
134+
case 0: // Empty
135+
result = MutableBigIntegerBox.ZERO;
136+
break;
137+
138+
case 1: // One
139+
result = MutableBigIntegerBox.ONE;
140+
break;
141+
142+
case 2: // All bits set in number
143+
int numInts = (order + 31) >> 5;
144+
int[] fullBits = new int[numInts];
145+
Arrays.fill(fullBits, -1);
146+
147+
fullBits[0] &= -1 >>> -order;
148+
result = new MutableBigIntegerBox(fullBits);
149+
break;
150+
151+
case 3: // One bit in number
152+
result = MutableBigIntegerBox.ONE.shiftLeft(random.nextInt(order));
153+
break;
154+
155+
case 4: // Random bit density
156+
val = new int[(order + 31) >> 5];
157+
int iterations = random.nextInt(order);
158+
for (int i = 0; i < iterations; i++) {
159+
int bitIdx = random.nextInt(order);
160+
val[bitIdx >> 5] |= 1 << bitIdx;
161+
}
162+
result = new MutableBigIntegerBox(val);
163+
break;
164+
case 5: // Runs of consecutive ones and zeros
165+
result = ZERO;
166+
int remaining = order;
167+
int bit = random.nextInt(2);
168+
while (remaining > 0) {
169+
int runLength = Math.min(remaining, random.nextInt(order));
170+
result = result.shiftLeft(runLength);
171+
if (bit > 0)
172+
result = result.add(ONE.shiftLeft(runLength).subtract(ONE));
173+
remaining -= runLength;
174+
bit = 1 - bit;
175+
}
176+
break;
177+
case 6: // random bits with trailing space
178+
int len = random.nextInt((order + 31) >> 5) + 1;
179+
int offset = random.nextInt(len);
180+
val = new int[len << 1];
181+
for (int i = 0; i < val.length; i++)
182+
val[i] = random.nextInt();
183+
result = new MutableBigIntegerBox(val, offset, len);
184+
break;
185+
default: // random bits
186+
result = new MutableBigIntegerBox(new BigInteger(order, random));
187+
}
188+
189+
return result;
190+
}
191+
}

‎test/jdk/java/math/BigInteger/java.base/java/math/MutableBigIntegerBox.java

+180
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,180 @@
1+
/*
2+
* Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
3+
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+
*
5+
* This code is free software; you can redistribute it and/or modify it
6+
* under the terms of the GNU General Public License version 2 only, as
7+
* published by the Free Software Foundation.
8+
*
9+
* This code is distributed in the hope that it will be useful, but WITHOUT
10+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12+
* version 2 for more details (a copy is included in the LICENSE file that
13+
* accompanied this code).
14+
*
15+
* You should have received a copy of the GNU General Public License version
16+
* 2 along with this work; if not, write to the Free Software Foundation,
17+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18+
*
19+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20+
* or visit www.oracle.com if you need additional information or have any
21+
* questions.
22+
*/
23+
24+
package java.math;
25+
26+
import java.util.Arrays;
27+
28+
/**
29+
* A class for tests.
30+
*/
31+
public class MutableBigIntegerBox {
32+
33+
/**
34+
* Constant zero
35+
*/
36+
public static final MutableBigIntegerBox ZERO = new MutableBigIntegerBox(new MutableBigInteger());
37+
38+
/**
39+
* Constant one
40+
*/
41+
public static final MutableBigIntegerBox ONE = new MutableBigIntegerBox(MutableBigInteger.ONE);
42+
43+
/**
44+
* Constant two
45+
*/
46+
public static final MutableBigIntegerBox TWO = new MutableBigIntegerBox(new MutableBigInteger(2));
47+
48+
private MutableBigInteger val;
49+
50+
MutableBigIntegerBox(MutableBigInteger val) {
51+
this.val = val;
52+
}
53+
54+
/**
55+
* Construct MutableBigIntegerBox from magnitude, starting from
56+
* offset and with a length of intLen ints.
57+
* The value is normalized.
58+
* @param mag the magnitude
59+
* @param offset the offset where the value starts
60+
* @param intLen the length of the value, in int words.
61+
*/
62+
public MutableBigIntegerBox(int[] mag, int offset, int intLen) {
63+
this(new MutableBigInteger(mag));
64+
val.offset = offset;
65+
val.intLen = intLen;
66+
val.normalize();
67+
}
68+
69+
/**
70+
* Construct MutableBigIntegerBox from magnitude.
71+
* The value is normalized.
72+
* @param mag the magnitude
73+
*/
74+
public MutableBigIntegerBox(int[] mag) {
75+
this(mag, 0, mag.length);
76+
}
77+
78+
/**
79+
* Construct MutableBigIntegerBox from BigInteger val
80+
* @param val the value
81+
*/
82+
public MutableBigIntegerBox(BigInteger val) {
83+
this(val.mag);
84+
}
85+
86+
/**
87+
* Returns the bit length of this MutableBigInteger value
88+
* @return the bit length of this MutableBigInteger value
89+
*/
90+
public long bitLength() {
91+
return val.bitLength();
92+
}
93+
94+
/**
95+
* Return {@code this << n}
96+
* @return {@code this << n}
97+
* @param n the shift
98+
*/
99+
public MutableBigIntegerBox shiftLeft(int n) {
100+
MutableBigIntegerBox res = new MutableBigIntegerBox(val.value.clone(), val.offset, val.intLen);
101+
res.val.safeLeftShift(n);
102+
return res;
103+
}
104+
105+
/**
106+
* Return {@code this >> n}
107+
* @return {@code this >> n}
108+
* @param n the shift
109+
*/
110+
public MutableBigIntegerBox shiftRight(int n) {
111+
MutableBigInteger res = new MutableBigInteger(val);
112+
res.safeRightShift(n);
113+
return new MutableBigIntegerBox(res);
114+
}
115+
116+
/**
117+
* Return this + addend
118+
* @return this + addend
119+
* @param addend the addend
120+
*/
121+
public MutableBigIntegerBox add(MutableBigIntegerBox addend) {
122+
MutableBigInteger res = new MutableBigInteger(val);
123+
res.add(addend.val);
124+
return new MutableBigIntegerBox(res);
125+
}
126+
127+
/**
128+
* Return this - subtraend
129+
* @return this - subtraend
130+
* @param subtraend the subtraend
131+
*/
132+
public MutableBigIntegerBox subtract(MutableBigIntegerBox subtraend) {
133+
MutableBigInteger res = new MutableBigInteger(val);
134+
res.subtract(subtraend.val);
135+
return new MutableBigIntegerBox(res);
136+
}
137+
138+
/**
139+
* Return this * multiplier
140+
* @return this * multiplier
141+
* @param multiplier the multiplier
142+
*/
143+
public MutableBigIntegerBox multiply(MutableBigIntegerBox multiplier) {
144+
MutableBigInteger res = new MutableBigInteger();
145+
if (!(val.isZero() || multiplier.val.isZero()))
146+
val.multiply(multiplier.val, res);
147+
148+
return new MutableBigIntegerBox(res);
149+
}
150+
151+
/**
152+
* Compare the magnitude of two MutableBigIntegers. Returns -1, 0 or 1
153+
* as this is numerically less than, equal to, or greater than {@code b}.
154+
* @return -1, 0 or 1 as this is numerically less than, equal to, or
155+
* greater than {@code b}.
156+
* @param b the value to compare
157+
*/
158+
public int compare(MutableBigIntegerBox b) {
159+
return val.compare(b.val);
160+
}
161+
162+
/**
163+
* Compares this MutableBigIntegerBox with the specified Object for equality.
164+
*
165+
* @param x Object to which this MutableBigIntegerBox is to be compared.
166+
* @return {@code true} if and only if the specified Object is a
167+
* MutableBigIntegerBox whose value is numerically equal to this MutableBigIntegerBox.
168+
*/
169+
@Override
170+
public boolean equals(Object x) {
171+
return (x instanceof MutableBigIntegerBox xInt)
172+
&& Arrays.equals(val.value, val.offset, val.offset + val.intLen,
173+
xInt.val.value, xInt.val.offset, xInt.val.offset + xInt.val.intLen);
174+
}
175+
176+
@Override
177+
public String toString() {
178+
return val.toString();
179+
}
180+
}

0 commit comments

Comments
 (0)
Please sign in to comment.