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

8301958: Reduce Arrays.copyOf/-Range overheads

Browse source 
Reviewed-by: alanb, smarks
This commit is contained in:
Claes Redestad 2023-02-13 11:17:38 +00:00
parent cb8107303e
commit 1f9c110c1f
2 changed files with 188 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

184
src/java.base/share/classes/java/util/Arrays.java
View file

@ -26,6 +26,7 @@
package java.util;
import jdk.internal.util.ArraysSupport;
import jdk.internal.vm.annotation.ForceInline;
import jdk.internal.vm.annotation.IntrinsicCandidate;
import java.io.Serializable;
@ -3534,12 +3535,22 @@ public class Arrays {
* @since 1.6
*/
public static byte[] copyOf(byte[] original, int newLength) {
if (newLength == original.length) {
return copyOf(original);
}
byte[] copy = new byte[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
@ForceInline
private static byte[] copyOf(byte[] original) {
byte[] copy = new byte[original.length];
System.arraycopy(original, 0, copy, 0, original.length);
return copy;
}
/**
* Copies the specified array, truncating or padding with zeros (if necessary)
* so the copy has the specified length. For all indices that are
@ -3558,12 +3569,22 @@ public class Arrays {
* @since 1.6
*/
public static short[] copyOf(short[] original, int newLength) {
if (newLength == original.length) {
return copyOf(original);
}
short[] copy = new short[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
@ForceInline
private static short[] copyOf(short[] original) {
short[] copy = new short[original.length];
System.arraycopy(original, 0, copy, 0, original.length);
return copy;
}
/**
* Copies the specified array, truncating or padding with zeros (if necessary)
* so the copy has the specified length. For all indices that are
@ -3582,12 +3603,22 @@ public class Arrays {
* @since 1.6
*/
public static int[] copyOf(int[] original, int newLength) {
if (newLength == original.length) {
return copyOf(original);
}
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
@ForceInline
private static int[] copyOf(int[] original) {
int[] copy = new int[original.length];
System.arraycopy(original, 0, copy, 0, original.length);
return copy;
}
/**
* Copies the specified array, truncating or padding with zeros (if necessary)
* so the copy has the specified length. For all indices that are
@ -3606,12 +3637,22 @@ public class Arrays {
* @since 1.6
*/
public static long[] copyOf(long[] original, int newLength) {
if (newLength == original.length) {
return copyOf(original);
}
long[] copy = new long[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
@ForceInline
private static long[] copyOf(long[] original) {
long[] copy = new long[original.length];
System.arraycopy(original, 0, copy, 0, original.length);
return copy;
}
/**
* Copies the specified array, truncating or padding with null characters (if necessary)
* so the copy has the specified length. For all indices that are valid
@ -3630,12 +3671,22 @@ public class Arrays {
* @since 1.6
*/
public static char[] copyOf(char[] original, int newLength) {
if (newLength == original.length) {
return copyOf(original);
}
char[] copy = new char[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
@ForceInline
private static char[] copyOf(char[] original) {
char[] copy = new char[original.length];
System.arraycopy(original, 0, copy, 0, original.length);
return copy;
}
/**
* Copies the specified array, truncating or padding with zeros (if necessary)
* so the copy has the specified length. For all indices that are
@ -3654,12 +3705,22 @@ public class Arrays {
* @since 1.6
*/
public static float[] copyOf(float[] original, int newLength) {
if (newLength == original.length) {
return copyOf(original);
}
float[] copy = new float[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
@ForceInline
private static float[] copyOf(float[] original) {
float[] copy = new float[original.length];
System.arraycopy(original, 0, copy, 0, original.length);
return copy;
}
/**
* Copies the specified array, truncating or padding with zeros (if necessary)
* so the copy has the specified length. For all indices that are
@ -3678,12 +3739,22 @@ public class Arrays {
* @since 1.6
*/
public static double[] copyOf(double[] original, int newLength) {
if (newLength == original.length) {
return copyOf(original);
}
double[] copy = new double[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
@ForceInline
private static double[] copyOf(double[] original) {
double[] copy = new double[original.length];
System.arraycopy(original, 0, copy, 0, original.length);
return copy;
}
/**
* Copies the specified array, truncating or padding with {@code false} (if necessary)
* so the copy has the specified length. For all indices that are
@ -3702,12 +3773,22 @@ public class Arrays {
* @since 1.6
*/
public static boolean[] copyOf(boolean[] original, int newLength) {
if (newLength == original.length) {
return copyOf(original);
}
boolean[] copy = new boolean[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
@ForceInline
private static boolean[] copyOf(boolean[] original) {
boolean[] copy = new boolean[original.length];
System.arraycopy(original, 0, copy, 0, original.length);
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
@ -3789,6 +3870,13 @@ public class Arrays {
return copy;
}
@ForceInline
private static void checkLength(int from, int to) {
if (to < from) {
throw new IllegalArgumentException(from + " > " + to);
}
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
@ -3816,9 +3904,17 @@ public class Arrays {
* @since 1.6
*/
public static byte[] copyOfRange(byte[] original, int from, int to) {
// Tickle the JIT to fold special cases optimally
if (from != 0 || to != original.length)
return copyOfRangeByte(original, from, to);
else // from == 0 && to == original.length
return copyOf(original);
}
@ForceInline
private static byte[] copyOfRangeByte(byte[] original, int from, int to) {
checkLength(from, to);
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
byte[] copy = new byte[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
@ -3852,9 +3948,17 @@ public class Arrays {
* @since 1.6
*/
public static short[] copyOfRange(short[] original, int from, int to) {
// Tickle the JIT to fold special cases optimally
if (from != 0 || to != original.length)
return copyOfRangeShort(original, from, to);
else // from == 0 && to == original.length
return copyOf(original);
}
@ForceInline
private static short[] copyOfRangeShort(short[] original, int from, int to) {
checkLength(from, to);
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
short[] copy = new short[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
@ -3888,9 +3992,17 @@ public class Arrays {
* @since 1.6
*/
public static int[] copyOfRange(int[] original, int from, int to) {
// Tickle the JIT to fold special cases optimally
if (from != 0 || to != original.length)
return copyOfRangeInt(original, from, to);
else // from == 0 && to == original.length
return copyOf(original);
}
@ForceInline
private static int[] copyOfRangeInt(int[] original, int from, int to) {
checkLength(from, to);
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
int[] copy = new int[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
@ -3924,9 +4036,17 @@ public class Arrays {
* @since 1.6
*/
public static long[] copyOfRange(long[] original, int from, int to) {
// Tickle the JIT to fold special cases optimally
if (from != 0 || to != original.length)
return copyOfRangeLong(original, from, to);
else // from == 0 && to == original.length
return copyOf(original);
}
@ForceInline
private static long[] copyOfRangeLong(long[] original, int from, int to) {
checkLength(from, to);
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
long[] copy = new long[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
@ -3960,9 +4080,17 @@ public class Arrays {
* @since 1.6
*/
public static char[] copyOfRange(char[] original, int from, int to) {
// Tickle the JIT to fold special cases optimally
if (from != 0 || to != original.length)
return copyOfRangeChar(original, from, to);
else // from == 0 && to == original.length
return copyOf(original);
}
@ForceInline
private static char[] copyOfRangeChar(char[] original, int from, int to) {
checkLength(from, to);
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
char[] copy = new char[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
@ -3996,9 +4124,17 @@ public class Arrays {
* @since 1.6
*/
public static float[] copyOfRange(float[] original, int from, int to) {
// Tickle the JIT to fold special cases optimally
if (from != 0 || to != original.length)
return copyOfRangeFloat(original, from, to);
else // from == 0 && to == original.length
return copyOf(original);
}
@ForceInline
private static float[] copyOfRangeFloat(float[] original, int from, int to) {
checkLength(from, to);
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
float[] copy = new float[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
@ -4032,9 +4168,17 @@ public class Arrays {
* @since 1.6
*/
public static double[] copyOfRange(double[] original, int from, int to) {
// Tickle the JIT to fold special cases optimally
if (from != 0 || to != original.length)
return copyOfRangeDouble(original, from, to);
else // from == 0 && to == original.length
return copyOf(original);
}
@ForceInline
private static double[] copyOfRangeDouble(double[] original, int from, int to) {
checkLength(from, to);
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
double[] copy = new double[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
@ -4068,9 +4212,17 @@ public class Arrays {
* @since 1.6
*/
public static boolean[] copyOfRange(boolean[] original, int from, int to) {
// Tickle the JIT to fold special cases optimally
if (from != 0 || to != original.length)
return copyOfRangeBoolean(original, from, to);
else // from == 0 && to == original.length
return copyOf(original);
}
@ForceInline
private static boolean[] copyOfRangeBoolean(boolean[] original, int from, int to) {
checkLength(from, to);
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
boolean[] copy = new boolean[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));