Skip to content
Permalink
Browse files
8277893: Arraycopy stress tests
Backport-of: 29bd73638a22d341767a1266723a7d7263e17093
  • Loading branch information
shipilev committed Mar 16, 2022
1 parent 4f0d711 commit 5d1969bde415556ab13a4d54bbaba6b182d70f82
Showing 12 changed files with 1,154 additions and 1 deletion.
@@ -94,6 +94,9 @@ hotspot_vector_2 = \
compiler/vectorapi/VectorRebracket128Test.java \
-compiler/intrinsics/string/TestStringLatin1IndexOfChar.java

hotspot_compiler_arraycopy = \
compiler/arraycopy/stress

tier1_common = \
sanity/BasicVMTest.java \
gtest/GTestWrapper.java \
@@ -114,7 +117,8 @@ hotspot_not_fast_compiler = \
hotspot_slow_compiler = \
compiler/codegen/aes \
compiler/codecache/stress \
compiler/gcbarriers/PreserveFPRegistersTest.java
compiler/gcbarriers/PreserveFPRegistersTest.java \
:hotspot_compiler_arraycopy

tier1_compiler_1 = \
compiler/arraycopy/ \
@@ -131,6 +135,7 @@ tier1_compiler_1 = \
-compiler/c2/Test6792161.java \
-compiler/c2/Test6603011.java \
-compiler/c2/Test6912517.java \
-:hotspot_slow_compiler

tier1_compiler_2 = \
compiler/classUnloading/ \
@@ -0,0 +1,166 @@
/*
* Copyright (c) 2021, Red Hat, Inc. 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 compiler.arraycopy.stress;

import java.util.Random;

public abstract class AbstractStressArrayCopy {
/**
* Max array size to test. This should be reasonably high to test
* massive vectorized copies, plus cases that cross the cache lines and
* (small) page boundaries. But it should also be reasonably low to
* keep the test costs down.
*
* A rough guideline:
* - AVX-512: 64-byte copies over 32 registers copies roughly 2K per step.
* - AArch64: small pages can be about 64K large
*/
static final int MAX_SIZE = 128*1024 + 1;

/**
* Arrays up to this size would be tested exhaustively: with all combinations
* of source/destination starts and copy lengths. Exercise restraint when bumping
* this value, as the test costs are proportional to N^3 of this setting.
*/
static final int EXHAUSTIVE_SIZES = Integer.getInteger("exhaustiveSizes", 192);

/*
* Larger arrays would fuzzed with this many attempts.
*/
static final int FUZZ_COUNT = Integer.getInteger("fuzzCount", 300);

public static void throwSeedError(int len, int pos) {
throw new RuntimeException("Error after seed: " +
len + " elements, at pos " + pos);
}

public static void throwContentsError(int l, int r, int len, int pos) {
throwError("in contents", l, r, len, pos);
}

public static void throwHeadError(int l, int r, int len, int pos) {
throwError("in head", l, r, len, pos);
}

public static void throwTailError(int l, int r, int len, int pos) {
throwError("in tail", l, r, len, pos);
}

private static void throwError(String phase, int l, int r, int len, int pos) {
throw new RuntimeException("Error " + phase + ": " +
len + " elements, " +
"[" + l + ", " + (l+len) + ") -> " +
"[" + r + ", " + (r+len) + "), " +
"at pos " + pos);
}

protected abstract void testWith(int size, int l, int r, int len);

private void checkBounds(int size, int l, int r, int len) {
if (l >= size) throw new IllegalStateException("l is out of bounds");
if (l + len > size) throw new IllegalStateException("l+len is out of bounds");
if (r >= size) throw new IllegalStateException("r is out of bounds");
if (r + len > size) throw new IllegalStateException("r+len is out of bounds: " + l + " " + r + " " + len + " " + size);
}

private void checkDisjoint(int size, int l, int r, int len) {
if (l == r) throw new IllegalStateException("Not disjoint: l == r");
if (l < r && l + len > r) throw new IllegalStateException("Not disjoint");
if (l > r && r + len > l) throw new IllegalStateException("Not disjoint");
}

private void checkConjoint(int size, int l, int r, int len) {
if (l == r) return; // Definitely conjoint, even with zero len
if (l < r && l + len < r) throw new IllegalStateException("Not conjoint");
if (l > r && r + len < l) throw new IllegalStateException("Not conjoint");
}

public void exhaustiveWith(int size) {
for (int l = 0; l < size; l++) {
for (int r = 0; r < size; r++) {
int maxLen = Math.min(size - l, size - r);
for (int len = 0; len <= maxLen; len++) {
checkBounds(size, l, r, len);
testWith(size, l, r, len);
}
}
}
}

public void fuzzWith(Random rand, int size) {
// Some basic checks first
testWith(size, 0, 1, 1);
testWith(size, 0, 1, size-1);

// Test disjoint:
for (int c = 0; c < FUZZ_COUNT; c++) {
int l = rand.nextInt(size / 2);
int len = rand.nextInt((size - l) / 2);
int r = (l + len + 1) + rand.nextInt(size - 2*len - l - 1);

checkBounds(size, l, r, len);
checkDisjoint(size, l, r, len);

testWith(size, l, r, len);
testWith(size, r, l, len);
}

// Test conjoint:
for (int c = 0; c < FUZZ_COUNT; c++) {
int l = rand.nextInt(size);
int len = rand.nextInt(size - l);
int r = Math.min(l + (len > 0 ? rand.nextInt(len) : 0), size - len);

checkBounds(size, l, r, len);
checkConjoint(size, l, r, len);

testWith(size, l, r, len);
testWith(size, r, l, len);
}
}

public void run(Random rand) {
// Exhaustive on all small arrays
for (int size = 1; size <= EXHAUSTIVE_SIZES; size++) {
exhaustiveWith(size);
}

// Fuzz powers of ten
for (int size = 10; size < MAX_SIZE; size *= 10) {
if (size <= EXHAUSTIVE_SIZES) continue;
fuzzWith(rand, size - 1);
fuzzWith(rand, size);
fuzzWith(rand, size + 1);
}

// Fuzz powers of two
for (int size = 2; size < MAX_SIZE; size *= 2) {
if (size <= EXHAUSTIVE_SIZES) continue;
fuzzWith(rand, size - 1);
fuzzWith(rand, size);
fuzzWith(rand, size + 1);
}
}

}
@@ -0,0 +1,85 @@
/*
* Copyright (c) 2021, Red Hat, Inc. 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 compiler.arraycopy.stress;

import java.util.Arrays;
import java.util.Random;
import jdk.test.lib.Utils;

public class StressBooleanArrayCopy extends AbstractStressArrayCopy {

private static final boolean[] orig = new boolean[MAX_SIZE];
private static final boolean[] test = new boolean[MAX_SIZE];

protected void testWith(int size, int l, int r, int len) {
// Seed the test from the original
System.arraycopy(orig, 0, test, 0, size);

// Check the seed is correct
{
int m = Arrays.mismatch(test, 0, size,
orig, 0, size);
if (m != -1) {
throwSeedError(size, m);
}
}

// Perform the tested copy
System.arraycopy(test, l, test, r, len);

// Check the copy has proper contents
{
int m = Arrays.mismatch(test, r, r+len,
orig, l, l+len);
if (m != -1) {
throwContentsError(l, r, len, r+m);
}
}

// Check anything else was not affected: head and tail
{
int m = Arrays.mismatch(test, 0, r,
orig, 0, r);
if (m != -1) {
throwHeadError(l, r, len, m);
}
}
{
int m = Arrays.mismatch(test, r + len, size,
orig, r + len, size);
if (m != -1) {
throwTailError(l, r, len, m);
}
}
}

public static void main(String... args) {
Random rand = Utils.getRandomInstance();
for (int c = 0; c < orig.length; c++) {
orig[c] = rand.nextBoolean();
}
new StressBooleanArrayCopy().run(rand);
}

}
@@ -0,0 +1,85 @@
/*
* Copyright (c) 2021, Red Hat, Inc. 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 compiler.arraycopy.stress;

import java.util.Arrays;
import java.util.Random;
import jdk.test.lib.Utils;

public class StressByteArrayCopy extends AbstractStressArrayCopy {

private static final byte[] orig = new byte[MAX_SIZE];
private static final byte[] test = new byte[MAX_SIZE];

protected void testWith(int size, int l, int r, int len) {
// Seed the test from the original
System.arraycopy(orig, 0, test, 0, size);

// Check the seed is correct
{
int m = Arrays.mismatch(test, 0, size,
orig, 0, size);
if (m != -1) {
throwSeedError(size, m);
}
}

// Perform the tested copy
System.arraycopy(test, l, test, r, len);

// Check the copy has proper contents
{
int m = Arrays.mismatch(test, r, r+len,
orig, l, l+len);
if (m != -1) {
throwContentsError(l, r, len, r+m);
}
}

// Check anything else was not affected: head and tail
{
int m = Arrays.mismatch(test, 0, r,
orig, 0, r);
if (m != -1) {
throwHeadError(l, r, len, m);
}
}
{
int m = Arrays.mismatch(test, r + len, size,
orig, r + len, size);
if (m != -1) {
throwTailError(l, r, len, m);
}
}
}

public static void main(String... args) {
Random rand = Utils.getRandomInstance();
for (int c = 0; c < orig.length; c++) {
orig[c] = (byte)rand.nextInt();
}
new StressByteArrayCopy().run(rand);
}

}

1 comment on commit 5d1969b

@openjdk-notifier
Copy link

@openjdk-notifier openjdk-notifier bot commented on 5d1969b Mar 16, 2022

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Please sign in to comment.