8329273: C2 SuperWord: Some basic MemorySegment IR tests
Reviewed-by: kvn, chagedorn
This commit is contained in:
Emanuel Peter
parent
8032d640c0
commit
c4867c62c4
@ -0,0 +1,810 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (c) 2024, 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
|
||||||
|
* 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.loopopts.superword;
|
||||||
|
|
||||||
|
import compiler.lib.ir_framework.*;
|
||||||
|
import jdk.test.lib.Utils;
|
||||||
|
import java.nio.ByteBuffer;
|
||||||
|
import java.util.Map;
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.Random;
|
||||||
|
import java.lang.foreign.*;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=byte-array
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment ByteArray
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=char-array
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment CharArray
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=short-array
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment ShortArray
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=int-array
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment IntArray
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=long-array
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment LongArray
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=float-array
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment FloatArray
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=double-array
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment DoubleArray
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=byte-buffer
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment ByteBuffer
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=byte-buffer-direct
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment ByteBufferDirect
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* @test id=native
|
||||||
|
* @bug 8329273
|
||||||
|
* @summary Test vectorization of loops over MemorySegment
|
||||||
|
* @library /test/lib /
|
||||||
|
* @run driver compiler.loopopts.superword.TestMemorySegment Native
|
||||||
|
*/
|
||||||
|
|
||||||
|
// FAILS: mixed providers currently do not vectorize. Maybe there is some inlining issue.
|
||||||
|
// /*
|
||||||
|
// * @test id=mixed-array
|
||||||
|
// * @bug 8329273
|
||||||
|
// * @summary Test vectorization of loops over MemorySegment
|
||||||
|
// * @library /test/lib /
|
||||||
|
// * @run driver compiler.loopopts.superword.TestMemorySegment MixedArray
|
||||||
|
// */
|
||||||
|
//
|
||||||
|
// /*
|
||||||
|
// * @test id=MixedBuffer
|
||||||
|
// * @bug 8329273
|
||||||
|
// * @summary Test vectorization of loops over MemorySegment
|
||||||
|
// * @library /test/lib /
|
||||||
|
// * @run driver compiler.loopopts.superword.TestMemorySegment MixedBuffer
|
||||||
|
// */
|
||||||
|
//
|
||||||
|
// /*
|
||||||
|
// * @test id=mixed
|
||||||
|
// * @bug 8329273
|
||||||
|
// * @summary Test vectorization of loops over MemorySegment
|
||||||
|
// * @library /test/lib /
|
||||||
|
// * @run driver compiler.loopopts.superword.TestMemorySegment Mixed
|
||||||
|
// */
|
||||||
|
|
||||||
|
public class TestMemorySegment {
|
||||||
|
public static void main(String[] args) {
|
||||||
|
TestFramework framework = new TestFramework(TestMemorySegmentImpl.class);
|
||||||
|
framework.addFlags("-DmemorySegmentProviderNameForTestVM=" + args[0]);
|
||||||
|
framework.setDefaultWarmup(100);
|
||||||
|
framework.start();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
class TestMemorySegmentImpl {
|
||||||
|
static final int BACKING_SIZE = 1024 * 8;
|
||||||
|
static final Random RANDOM = Utils.getRandomInstance();
|
||||||
|
|
||||||
|
|
||||||
|
interface TestFunction {
|
||||||
|
Object[] run();
|
||||||
|
}
|
||||||
|
|
||||||
|
interface MemorySegmentProvider {
|
||||||
|
MemorySegment newMemorySegment();
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegmentProvider provider;
|
||||||
|
|
||||||
|
static {
|
||||||
|
String providerName = System.getProperty("memorySegmentProviderNameForTestVM");
|
||||||
|
provider = switch (providerName) {
|
||||||
|
case "ByteArray" -> TestMemorySegmentImpl::newMemorySegmentOfByteArray;
|
||||||
|
case "CharArray" -> TestMemorySegmentImpl::newMemorySegmentOfCharArray;
|
||||||
|
case "ShortArray" -> TestMemorySegmentImpl::newMemorySegmentOfShortArray;
|
||||||
|
case "IntArray" -> TestMemorySegmentImpl::newMemorySegmentOfIntArray;
|
||||||
|
case "LongArray" -> TestMemorySegmentImpl::newMemorySegmentOfLongArray;
|
||||||
|
case "FloatArray" -> TestMemorySegmentImpl::newMemorySegmentOfFloatArray;
|
||||||
|
case "DoubleArray" -> TestMemorySegmentImpl::newMemorySegmentOfDoubleArray;
|
||||||
|
case "ByteBuffer" -> TestMemorySegmentImpl::newMemorySegmentOfByteBuffer;
|
||||||
|
case "ByteBufferDirect" -> TestMemorySegmentImpl::newMemorySegmentOfByteBufferDirect;
|
||||||
|
case "Native" -> TestMemorySegmentImpl::newMemorySegmentOfNative;
|
||||||
|
case "MixedArray" -> TestMemorySegmentImpl::newMemorySegmentOfMixedArray;
|
||||||
|
case "MixedBuffer" -> TestMemorySegmentImpl::newMemorySegmentOfMixedBuffer;
|
||||||
|
case "Mixed" -> TestMemorySegmentImpl::newMemorySegmentOfMixed;
|
||||||
|
default -> throw new RuntimeException("Test argument not recognized: " + providerName);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
// List of tests
|
||||||
|
Map<String, TestFunction> tests = new HashMap<>();
|
||||||
|
|
||||||
|
// List of gold, the results from the first run before compilation
|
||||||
|
Map<String, Object[]> golds = new HashMap<>();
|
||||||
|
|
||||||
|
public TestMemorySegmentImpl () {
|
||||||
|
// Generate two MemorySegments as inputs
|
||||||
|
MemorySegment a = newMemorySegment();
|
||||||
|
MemorySegment b = newMemorySegment();
|
||||||
|
fillRandom(a);
|
||||||
|
fillRandom(b);
|
||||||
|
|
||||||
|
// Add all tests to list
|
||||||
|
tests.put("testMemorySegmentBadExitCheck", () -> testMemorySegmentBadExitCheck(copy(a)));
|
||||||
|
tests.put("testIntLoop_iv_byte", () -> testIntLoop_iv_byte(copy(a)));
|
||||||
|
tests.put("testIntLoop_longIndex_intInvar_sameAdr_byte", () -> testIntLoop_longIndex_intInvar_sameAdr_byte(copy(a), 0));
|
||||||
|
tests.put("testIntLoop_longIndex_longInvar_sameAdr_byte", () -> testIntLoop_longIndex_longInvar_sameAdr_byte(copy(a), 0));
|
||||||
|
tests.put("testIntLoop_longIndex_intInvar_byte", () -> testIntLoop_longIndex_intInvar_byte(copy(a), 0));
|
||||||
|
tests.put("testIntLoop_longIndex_longInvar_byte", () -> testIntLoop_longIndex_longInvar_byte(copy(a), 0));
|
||||||
|
tests.put("testIntLoop_intIndex_intInvar_byte", () -> testIntLoop_intIndex_intInvar_byte(copy(a), 0));
|
||||||
|
tests.put("testIntLoop_iv_int", () -> testIntLoop_iv_int(copy(a)));
|
||||||
|
tests.put("testIntLoop_longIndex_intInvar_sameAdr_int", () -> testIntLoop_longIndex_intInvar_sameAdr_int(copy(a), 0));
|
||||||
|
tests.put("testIntLoop_longIndex_longInvar_sameAdr_int", () -> testIntLoop_longIndex_longInvar_sameAdr_int(copy(a), 0));
|
||||||
|
tests.put("testIntLoop_longIndex_intInvar_int", () -> testIntLoop_longIndex_intInvar_int(copy(a), 0));
|
||||||
|
tests.put("testIntLoop_longIndex_longInvar_int", () -> testIntLoop_longIndex_longInvar_int(copy(a), 0));
|
||||||
|
tests.put("testIntLoop_intIndex_intInvar_int", () -> testIntLoop_intIndex_intInvar_int(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_iv_byte", () -> testLongLoop_iv_byte(copy(a)));
|
||||||
|
tests.put("testLongLoop_longIndex_intInvar_sameAdr_byte", () -> testLongLoop_longIndex_intInvar_sameAdr_byte(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_longIndex_longInvar_sameAdr_byte", () -> testLongLoop_longIndex_longInvar_sameAdr_byte(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_longIndex_intInvar_byte", () -> testLongLoop_longIndex_intInvar_byte(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_longIndex_longInvar_byte", () -> testLongLoop_longIndex_longInvar_byte(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_intIndex_intInvar_byte", () -> testLongLoop_intIndex_intInvar_byte(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_iv_int", () -> testLongLoop_iv_int(copy(a)));
|
||||||
|
tests.put("testLongLoop_longIndex_intInvar_sameAdr_int", () -> testLongLoop_longIndex_intInvar_sameAdr_int(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_longIndex_longInvar_sameAdr_int", () -> testLongLoop_longIndex_longInvar_sameAdr_int(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_longIndex_intInvar_int", () -> testLongLoop_longIndex_intInvar_int(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_longIndex_longInvar_int", () -> testLongLoop_longIndex_longInvar_int(copy(a), 0));
|
||||||
|
tests.put("testLongLoop_intIndex_intInvar_int", () -> testLongLoop_intIndex_intInvar_int(copy(a), 0));
|
||||||
|
|
||||||
|
// Compute gold value for all test methods before compilation
|
||||||
|
for (Map.Entry<String,TestFunction> entry : tests.entrySet()) {
|
||||||
|
String name = entry.getKey();
|
||||||
|
TestFunction test = entry.getValue();
|
||||||
|
Object[] gold = test.run();
|
||||||
|
golds.put(name, gold);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
MemorySegment newMemorySegment() {
|
||||||
|
return provider.newMemorySegment();
|
||||||
|
}
|
||||||
|
|
||||||
|
MemorySegment copy(MemorySegment src) {
|
||||||
|
MemorySegment dst = newMemorySegment();
|
||||||
|
MemorySegment.copy(src, 0, dst, 0, src.byteSize());
|
||||||
|
return dst;
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfByteArray() {
|
||||||
|
return MemorySegment.ofArray(new byte[BACKING_SIZE]);
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfCharArray() {
|
||||||
|
return MemorySegment.ofArray(new char[BACKING_SIZE / 2]);
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfShortArray() {
|
||||||
|
return MemorySegment.ofArray(new short[BACKING_SIZE / 2]);
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfIntArray() {
|
||||||
|
return MemorySegment.ofArray(new int[BACKING_SIZE / 4]);
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfLongArray() {
|
||||||
|
return MemorySegment.ofArray(new long[BACKING_SIZE / 8]);
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfFloatArray() {
|
||||||
|
return MemorySegment.ofArray(new float[BACKING_SIZE / 4]);
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfDoubleArray() {
|
||||||
|
return MemorySegment.ofArray(new double[BACKING_SIZE / 8]);
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfByteBuffer() {
|
||||||
|
return MemorySegment.ofBuffer(ByteBuffer.allocate(BACKING_SIZE));
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfByteBufferDirect() {
|
||||||
|
return MemorySegment.ofBuffer(ByteBuffer.allocateDirect(BACKING_SIZE));
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfNative() {
|
||||||
|
// Auto arena: GC decides when there is no reference to the MemorySegment,
|
||||||
|
// and then it deallocates the backing memory.
|
||||||
|
return Arena.ofAuto().allocate(BACKING_SIZE, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfMixedArray() {
|
||||||
|
switch(RANDOM.nextInt(7)) {
|
||||||
|
case 0 -> { return newMemorySegmentOfByteArray(); }
|
||||||
|
case 1 -> { return newMemorySegmentOfCharArray(); }
|
||||||
|
case 2 -> { return newMemorySegmentOfShortArray(); }
|
||||||
|
case 3 -> { return newMemorySegmentOfIntArray(); }
|
||||||
|
case 4 -> { return newMemorySegmentOfLongArray(); }
|
||||||
|
case 5 -> { return newMemorySegmentOfFloatArray(); }
|
||||||
|
default -> { return newMemorySegmentOfDoubleArray(); }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfMixedBuffer() {
|
||||||
|
switch (RANDOM.nextInt(2)) {
|
||||||
|
case 0 -> { return newMemorySegmentOfByteBuffer(); }
|
||||||
|
default -> { return newMemorySegmentOfByteBufferDirect(); }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static MemorySegment newMemorySegmentOfMixed() {
|
||||||
|
switch (RANDOM.nextInt(3)) {
|
||||||
|
case 0 -> { return newMemorySegmentOfMixedArray(); }
|
||||||
|
case 1 -> { return newMemorySegmentOfMixedBuffer(); }
|
||||||
|
default -> { return newMemorySegmentOfNative(); }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void fillRandom(MemorySegment data) {
|
||||||
|
for (int i = 0; i < (int)data.byteSize(); i += 8) {
|
||||||
|
data.set(ValueLayout.JAVA_LONG_UNALIGNED, i, RANDOM.nextLong());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void verify(String name, Object[] gold, Object[] result) {
|
||||||
|
if (gold.length != result.length) {
|
||||||
|
throw new RuntimeException("verify " + name + ": not the same number of outputs: gold.length = " +
|
||||||
|
gold.length + ", result.length = " + result.length);
|
||||||
|
}
|
||||||
|
for (int i = 0; i < gold.length; i++) {
|
||||||
|
Object g = gold[i];
|
||||||
|
Object r = result[i];
|
||||||
|
if (g == r) {
|
||||||
|
throw new RuntimeException("verify " + name + ": should be two separate objects (with identical content):" +
|
||||||
|
" gold[" + i + "] == result[" + i + "]");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!(g instanceof MemorySegment && r instanceof MemorySegment)) {
|
||||||
|
throw new RuntimeException("verify " + name + ": only MemorySegment supported, i=" + i);
|
||||||
|
}
|
||||||
|
|
||||||
|
MemorySegment mg = (MemorySegment)g;
|
||||||
|
MemorySegment mr = (MemorySegment)r;
|
||||||
|
|
||||||
|
if (mg.byteSize() != mr.byteSize()) {
|
||||||
|
throw new RuntimeException("verify " + name + ": MemorySegment must have same byteSize:" +
|
||||||
|
" gold[" + i + "].byteSize = " + mg.byteSize() +
|
||||||
|
" result[" + i + "].byteSize = " + mr.byteSize());
|
||||||
|
}
|
||||||
|
|
||||||
|
for (int j = 0; j < (int)mg.byteSize(); j++) {
|
||||||
|
byte vg = mg.get(ValueLayout.JAVA_BYTE, j);
|
||||||
|
byte vr = mr.get(ValueLayout.JAVA_BYTE, j);
|
||||||
|
if (vg != vr) {
|
||||||
|
throw new RuntimeException("verify " + name + ": MemorySegment must have same content:" +
|
||||||
|
" gold[" + i + "][" + j + "] = " + vg +
|
||||||
|
" result[" + i + "][" + j + "] = " + vr);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Run(test = {"testMemorySegmentBadExitCheck",
|
||||||
|
"testIntLoop_iv_byte",
|
||||||
|
"testIntLoop_longIndex_intInvar_sameAdr_byte",
|
||||||
|
"testIntLoop_longIndex_longInvar_sameAdr_byte",
|
||||||
|
"testIntLoop_longIndex_intInvar_byte",
|
||||||
|
"testIntLoop_longIndex_longInvar_byte",
|
||||||
|
"testIntLoop_intIndex_intInvar_byte",
|
||||||
|
"testIntLoop_iv_int",
|
||||||
|
"testIntLoop_longIndex_intInvar_sameAdr_int",
|
||||||
|
"testIntLoop_longIndex_longInvar_sameAdr_int",
|
||||||
|
"testIntLoop_longIndex_intInvar_int",
|
||||||
|
"testIntLoop_longIndex_longInvar_int",
|
||||||
|
"testIntLoop_intIndex_intInvar_int",
|
||||||
|
"testLongLoop_iv_byte",
|
||||||
|
"testLongLoop_longIndex_intInvar_sameAdr_byte",
|
||||||
|
"testLongLoop_longIndex_longInvar_sameAdr_byte",
|
||||||
|
"testLongLoop_longIndex_intInvar_byte",
|
||||||
|
"testLongLoop_longIndex_longInvar_byte",
|
||||||
|
"testLongLoop_intIndex_intInvar_byte",
|
||||||
|
"testLongLoop_iv_int",
|
||||||
|
"testLongLoop_longIndex_intInvar_sameAdr_int",
|
||||||
|
"testLongLoop_longIndex_longInvar_sameAdr_int",
|
||||||
|
"testLongLoop_longIndex_intInvar_int",
|
||||||
|
"testLongLoop_longIndex_longInvar_int",
|
||||||
|
"testLongLoop_intIndex_intInvar_int"})
|
||||||
|
void runTests() {
|
||||||
|
for (Map.Entry<String,TestFunction> entry : tests.entrySet()) {
|
||||||
|
String name = entry.getKey();
|
||||||
|
TestFunction test = entry.getValue();
|
||||||
|
// Recall gold value from before compilation
|
||||||
|
Object[] gold = golds.get(name);
|
||||||
|
// Compute new result
|
||||||
|
Object[] result = test.run();
|
||||||
|
// Compare gold and new result
|
||||||
|
verify(name, gold, result);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "= 0",
|
||||||
|
IRNode.ADD_VB, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS
|
||||||
|
// Exit check: iv < long_limit -> (long)iv < long_limit
|
||||||
|
// Thus, we have an int-iv, but a long-exit-check.
|
||||||
|
// Is not properly recognized by either CountedLoop or LongCountedLoop
|
||||||
|
static Object[] testMemorySegmentBadExitCheck(MemorySegment a) {
|
||||||
|
for (int i = 0; i < a.byteSize(); i++) {
|
||||||
|
long adr = i;
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "> 0",
|
||||||
|
IRNode.ADD_VB, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testIntLoop_iv_byte(MemorySegment a) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize(); i++) {
|
||||||
|
long adr = i;
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "> 0",
|
||||||
|
IRNode.ADD_VB, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testIntLoop_longIndex_intInvar_sameAdr_byte(MemorySegment a, int invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize(); i++) {
|
||||||
|
long adr = (long)(i) + (long)(invar);
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "> 0",
|
||||||
|
IRNode.ADD_VB, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testIntLoop_longIndex_longInvar_sameAdr_byte(MemorySegment a, long invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize(); i++) {
|
||||||
|
long adr = (long)(i) + (long)(invar);
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "= 0",
|
||||||
|
IRNode.ADD_VB, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: invariants are sorted differently, because of differently inserted Cast.
|
||||||
|
// See: JDK-8330274
|
||||||
|
static Object[] testIntLoop_longIndex_intInvar_byte(MemorySegment a, int invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize(); i++) {
|
||||||
|
long adr1 = (long)(i) + (long)(invar);
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr1);
|
||||||
|
long adr2 = (long)(i) + (long)(invar);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr2, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "= 0",
|
||||||
|
IRNode.ADD_VB, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: invariants are sorted differently, because of differently inserted Cast.
|
||||||
|
// See: JDK-8330274
|
||||||
|
static Object[] testIntLoop_longIndex_longInvar_byte(MemorySegment a, long invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize(); i++) {
|
||||||
|
long adr1 = (long)(i) + (long)(invar);
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr1);
|
||||||
|
long adr2 = (long)(i) + (long)(invar);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr2, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "= 0",
|
||||||
|
IRNode.ADD_VB, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: RangeCheck cannot be eliminated because of int_index
|
||||||
|
static Object[] testIntLoop_intIndex_intInvar_byte(MemorySegment a, int invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize(); i++) {
|
||||||
|
int int_index = i + invar;
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, int_index);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, int_index, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "> 0",
|
||||||
|
IRNode.ADD_VI, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIf = {"AlignVector", "false"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testIntLoop_iv_int(MemorySegment a) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize()/4; i++ ) {
|
||||||
|
long adr = 4L * i;
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "> 0",
|
||||||
|
IRNode.ADD_VI, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIf = {"AlignVector", "false"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testIntLoop_longIndex_intInvar_sameAdr_int(MemorySegment a, int invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize()/4; i++) {
|
||||||
|
long adr = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "> 0",
|
||||||
|
IRNode.ADD_VI, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIf = {"AlignVector", "false"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testIntLoop_longIndex_longInvar_sameAdr_int(MemorySegment a, long invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize()/4; i++) {
|
||||||
|
long adr = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "= 0",
|
||||||
|
IRNode.ADD_VI, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: invariants are sorted differently, because of differently inserted Cast.
|
||||||
|
// See: JDK-8330274
|
||||||
|
static Object[] testIntLoop_longIndex_intInvar_int(MemorySegment a, int invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize()/4; i++) {
|
||||||
|
long adr1 = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr1);
|
||||||
|
long adr2 = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr2, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "= 0",
|
||||||
|
IRNode.ADD_VI, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: invariants are sorted differently, because of differently inserted Cast.
|
||||||
|
// See: JDK-8330274
|
||||||
|
static Object[] testIntLoop_longIndex_longInvar_int(MemorySegment a, long invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize()/4; i++) {
|
||||||
|
long adr1 = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr1);
|
||||||
|
long adr2 = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr2, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "= 0",
|
||||||
|
IRNode.ADD_VI, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: RangeCheck cannot be eliminated because of int_index
|
||||||
|
static Object[] testIntLoop_intIndex_intInvar_int(MemorySegment a, int invar) {
|
||||||
|
for (int i = 0; i < (int)a.byteSize()/4; i++) {
|
||||||
|
int int_index = i + invar;
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, 4L * int_index);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, 4L * int_index, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "> 0",
|
||||||
|
IRNode.ADD_VB, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testLongLoop_iv_byte(MemorySegment a) {
|
||||||
|
for (long i = 0; i < a.byteSize(); i++) {
|
||||||
|
long adr = i;
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "> 0",
|
||||||
|
IRNode.ADD_VB, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testLongLoop_longIndex_intInvar_sameAdr_byte(MemorySegment a, int invar) {
|
||||||
|
for (long i = 0; i < a.byteSize(); i++) {
|
||||||
|
long adr = (long)(i) + (long)(invar);
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "> 0",
|
||||||
|
IRNode.ADD_VB, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testLongLoop_longIndex_longInvar_sameAdr_byte(MemorySegment a, long invar) {
|
||||||
|
for (long i = 0; i < a.byteSize(); i++) {
|
||||||
|
long adr = (long)(i) + (long)(invar);
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "= 0",
|
||||||
|
IRNode.ADD_VB, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: invariants are sorted differently, because of differently inserted Cast.
|
||||||
|
// See: JDK-8330274
|
||||||
|
static Object[] testLongLoop_longIndex_intInvar_byte(MemorySegment a, int invar) {
|
||||||
|
for (long i = 0; i < a.byteSize(); i++) {
|
||||||
|
long adr1 = (long)(i) + (long)(invar);
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr1);
|
||||||
|
long adr2 = (long)(i) + (long)(invar);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr2, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "= 0",
|
||||||
|
IRNode.ADD_VB, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: invariants are sorted differently, because of differently inserted Cast.
|
||||||
|
// See: JDK-8330274
|
||||||
|
static Object[] testLongLoop_longIndex_longInvar_byte(MemorySegment a, long invar) {
|
||||||
|
for (long i = 0; i < a.byteSize(); i++) {
|
||||||
|
long adr1 = (long)(i) + (long)(invar);
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, adr1);
|
||||||
|
long adr2 = (long)(i) + (long)(invar);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, adr2, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_B, "= 0",
|
||||||
|
IRNode.ADD_VB, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: RangeCheck cannot be eliminated because of int_index
|
||||||
|
static Object[] testLongLoop_intIndex_intInvar_byte(MemorySegment a, int invar) {
|
||||||
|
for (long i = 0; i < a.byteSize(); i++) {
|
||||||
|
int int_index = (int)(i + invar);
|
||||||
|
byte v = a.get(ValueLayout.JAVA_BYTE, int_index);
|
||||||
|
a.set(ValueLayout.JAVA_BYTE, int_index, (byte)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "> 0",
|
||||||
|
IRNode.ADD_VI, "> 0",
|
||||||
|
IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIf = {"AlignVector", "false"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
static Object[] testLongLoop_iv_int(MemorySegment a) {
|
||||||
|
for (long i = 0; i < a.byteSize()/4; i++ ) {
|
||||||
|
long adr = 4L * i;
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
//@IR(counts = {IRNode.LOAD_VECTOR_I, "> 0",
|
||||||
|
// IRNode.ADD_VI, "> 0",
|
||||||
|
// IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
// applyIfPlatform = {"64-bit", "true"},
|
||||||
|
// applyIf = {"AlignVector", "false"},
|
||||||
|
// applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: for native memory. I think it is because of invariants, but need investigation.
|
||||||
|
// The long -> int loop conversion introduces extra invariants.
|
||||||
|
static Object[] testLongLoop_longIndex_intInvar_sameAdr_int(MemorySegment a, int invar) {
|
||||||
|
for (long i = 0; i < a.byteSize()/4; i++) {
|
||||||
|
long adr = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
//@IR(counts = {IRNode.LOAD_VECTOR_I, "> 0",
|
||||||
|
// IRNode.ADD_VI, "> 0",
|
||||||
|
// IRNode.STORE_VECTOR, "> 0"},
|
||||||
|
// applyIfPlatform = {"64-bit", "true"},
|
||||||
|
// applyIf = {"AlignVector", "false"},
|
||||||
|
// applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: for native memory. I think it is because of invariants, but need investigation.
|
||||||
|
// The long -> int loop conversion introduces extra invariants.
|
||||||
|
static Object[] testLongLoop_longIndex_longInvar_sameAdr_int(MemorySegment a, long invar) {
|
||||||
|
for (long i = 0; i < a.byteSize()/4; i++) {
|
||||||
|
long adr = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "= 0",
|
||||||
|
IRNode.ADD_VI, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: invariants are sorted differently, because of differently inserted Cast.
|
||||||
|
// See: JDK-8330274
|
||||||
|
static Object[] testLongLoop_longIndex_intInvar_int(MemorySegment a, int invar) {
|
||||||
|
for (long i = 0; i < a.byteSize()/4; i++) {
|
||||||
|
long adr1 = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr1);
|
||||||
|
long adr2 = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr2, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "= 0",
|
||||||
|
IRNode.ADD_VI, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: invariants are sorted differently, because of differently inserted Cast.
|
||||||
|
// See: JDK-8330274
|
||||||
|
static Object[] testLongLoop_longIndex_longInvar_int(MemorySegment a, long invar) {
|
||||||
|
for (long i = 0; i < a.byteSize()/4; i++) {
|
||||||
|
long adr1 = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, adr1);
|
||||||
|
long adr2 = 4L * (long)(i) + 4L * (long)(invar);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, adr2, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
@IR(counts = {IRNode.LOAD_VECTOR_I, "= 0",
|
||||||
|
IRNode.ADD_VI, "= 0",
|
||||||
|
IRNode.STORE_VECTOR, "= 0"},
|
||||||
|
applyIfPlatform = {"64-bit", "true"},
|
||||||
|
applyIfCPUFeatureOr = {"sse4.1", "true", "asimd", "true"})
|
||||||
|
// FAILS: RangeCheck cannot be eliminated because of int_index
|
||||||
|
static Object[] testLongLoop_intIndex_intInvar_int(MemorySegment a, int invar) {
|
||||||
|
for (long i = 0; i < a.byteSize()/4; i++) {
|
||||||
|
int int_index = (int)(i + invar);
|
||||||
|
int v = a.get(ValueLayout.JAVA_INT_UNALIGNED, 4L * int_index);
|
||||||
|
a.set(ValueLayout.JAVA_INT_UNALIGNED, 4L * int_index, (int)(v + 1));
|
||||||
|
}
|
||||||
|
return new Object[]{ a };
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue
Block a user