archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-26 14:24:46 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

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
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);