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

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

34
test/micro/org/openjdk/bench/java/lang/StringConstructor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2018, 2023, 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
@ -28,47 +28,53 @@ import org.openjdk.jmh.annotations.*;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;
@Fork(5)
@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 5)
@Measurement(iterations = 10, time = 5)
@Warmup(iterations = 5, time = 3)
@Measurement(iterations = 5, time = 3)
@Fork(3)
public class StringConstructor {
@Param({"7", "64"})
public int size;
// Offset to use for ranged newStrings
@Param("1")
public int offset;
private byte[] array;
@Setup
public void setup() {
array = "".getBytes(StandardCharsets.UTF_8);
if (offset > size) {
offset = size;
}
array = "a".repeat(size).getBytes(StandardCharsets.UTF_8);
}
@Benchmark
public String newStringFromArray() {
return new String(array);
return new String(array);
}
@Benchmark
public String newStringFromArrayWithCharset() {
return new String(array, StandardCharsets.UTF_8);
return new String(array, StandardCharsets.UTF_8);
}
@Benchmark
public String newStringFromArrayWithCharsetName() throws Exception {
return new String(array, StandardCharsets.UTF_8.name());
return new String(array, StandardCharsets.UTF_8.name());
}
@Benchmark
public String newStringFromRangedArray() {
return new String(array, 0, 0);
return new String(array, offset, array.length - offset);
}
@Benchmark
public String newStringFromRangedArrayWithCharset() {
return new String(array, 0, 0, StandardCharsets.UTF_8);
return new String(array, offset, array.length - offset, StandardCharsets.UTF_8);
}
@Benchmark
public String newStringFromRangedArrayWithCharsetName() throws Exception {
return new String(array, 0, 0, StandardCharsets.UTF_8.name());
}
}