< prev index next > test/hotspot/jtreg/compiler/c2/irTests/TestVectorizationMismatchedAccess.java
Print this page
}
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
// might get fixed with JDK-8325155.
public static void testByteLong1a(byte[] dest, long[] src) {
for (int i = 0; i < src.length; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 16 + 8*i -> always B_adr = base + 12 + 8*i -> never
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> no vectorization
}
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: address has ConvL2I for cast of long to address, not supported.
public static void testByteLong1b(byte[] dest, long[] src) {
for (int i = 0; i < src.length; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 16 + 8*i -> always B_adr = base + 12 + 8*i -> never
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> no vectorization
}
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"})
public static void testByteLong1c(byte[] dest, long[] src) {
long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)
for (int i = 0; i < src.length - 8; i++) {
UNSAFE.putLongUnaligned(dest, base + 8 * i, handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 64 + 8*i -> always B_adr = base + 64 + 8*i -> always
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> vectorize
}
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
// 32-bit: address has ConvL2I for cast of long to address, not supported.
public static void testByteLong1d(byte[] dest, long[] src) {
long base = 64; // make sure it is big enough and 8 byte aligned (required for 32-bit)
for (int i = 0; i < src.length - 8; i++) {
UNSAFE.putLongUnaligned(dest, base + 8L * i, handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 64 + 8*i -> always B_adr = base + 64 + 8*i -> always
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> vectorize
}
}
@Run(test = {"testByteLong1a", "testByteLong1b", "testByteLong1c", "testByteLong1d"})
public static void testByteLong1_runner() {
testByteLong1d(byteArray, longArray);
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
// might get fixed with JDK-8325155.
public static void testByteLong2a(byte[] dest, long[] src) {
for (int i = 1; i < src.length; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 16 + 8*(i-1) -> always B_adr = base + 12 + 8*(i-1) -> never
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> no vectorization
}
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: address has ConvL2I for cast of long to address, not supported.
public static void testByteLong2b(byte[] dest, long[] src) {
for (int i = 1; i < src.length; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i - 1), handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 16 + 8*(i-1) -> always B_adr = base + 12 + 8*(i-1) -> never
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> no vectorization
}
}
@Run(test = {"testByteLong2a", "testByteLong2b"})
public static void testByteLong2_runner() {
runAndVerify(() -> testByteLong2b(byteArray, longArray), -8);
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
// might get fixed with JDK-8325155.
public static void testByteLong3a(byte[] dest, long[] src) {
for (int i = 0; i < src.length - 1; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + 1), handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 16 + 8*(i+1) -> always B_adr = base + 12 + 8*(i+1) -> never
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> no vectorization
}
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: address has ConvL2I for cast of long to address, not supported.
public static void testByteLong3b(byte[] dest, long[] src) {
for (int i = 0; i < src.length - 1; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + 1), handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 16 + 8*(i+1) -> always B_adr = base + 12 + 8*(i+1) -> never
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> no vectorization
}
}
@Run(test = {"testByteLong3a", "testByteLong3b"})
public static void testByteLong3_runner() {
runAndVerify(() -> testByteLong4b(byteArray, longArray, 0, size), 0);
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
// might get fixed with JDK-8325155.
public static void testByteLong5a(byte[] dest, long[] src, int start, int stop) {
for (int i = start; i < stop; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i + baseOffset), handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 16 + 8*(i+x) -> always B_adr = base + 12 + 8*(i+x) -> never
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> no vectorization
}
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: address has ConvL2I for cast of long to address, not supported.
public static void testByteLong5b(byte[] dest, long[] src, int start, int stop) {
for (int i = start; i < stop; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i + baseOffset), handleByteOrder(src[i]));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // B_adr = base + 16 + 8*(i+x) -> always B_adr = base + 12 + 8*(i+x) -> never
- // L_adr = base + 16 + 8*i -> always L_adr = base + 16 + 8*i -> always
- // -> vectorize -> no vectorization
}
}
@Run(test = {"testByteLong5a", "testByteLong5b"})
public static void testByteLong5_runner() {
runAndVerify(() -> testByteLong5b(byteArray, longArray, 0, size-1), 8);
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
// might get fixed with JDK-8325155.
public static void testByteByte1a(byte[] dest, byte[] src) {
for (int i = 0; i < src.length / 8; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i, UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // src_adr = base + 16 + 8*i -> always src_adr = base + 12 + 8*i -> never
- // dst_adr = base + 16 + 8*i -> always dst_adr = base + 12 + 8*i -> never
- // -> vectorize -> no vectorization
}
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: address has ConvL2I for cast of long to address, not supported.
public static void testByteByte1b(byte[] dest, byte[] src) {
for (int i = 0; i < src.length / 8; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i, UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // src_adr = base + 16 + 8*i -> always src_adr = base + 12 + 8*i -> never
- // dst_adr = base + 16 + 8*i -> always dst_adr = base + 12 + 8*i -> never
- // -> vectorize -> no vectorization
}
}
@Run(test = {"testByteByte1a", "testByteByte1b"})
public static void testByteByte1_runner() {
runAndVerify2(() -> testByteByte1b(byteArray, byteArray), 0);
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: offsets are badly aligned (UNSAFE.ARRAY_BYTE_BASE_OFFSET is 4 byte aligned, but not 8 byte aligned).
// might get fixed with JDK-8325155.
public static void testByteByte2a(byte[] dest, byte[] src) {
for (int i = 1; i < src.length / 8; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * (i - 1), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8 * i));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // src_adr = base + 16 + 8*i -> always src_adr = base + 12 + 8*i -> never
- // dst_adr = base + 16 + 8*(i-1) -> always dst_adr = base + 12 + 8*(i-1) -> never
- // -> vectorize -> no vectorization
}
}
@Test
@IR(counts = { IRNode.LOAD_VECTOR_L, ">=1", IRNode.STORE_VECTOR, ">=1" },
- applyIfOr = {"UseCompactObjectHeaders", "false", "AlignVector", "false"},
applyIfCPUFeatureOr = {"sse2", "true", "asimd", "true", "rvv", "true"},
applyIfPlatform = {"64-bit", "true"})
// 32-bit: address has ConvL2I for cast of long to address, not supported.
public static void testByteByte2b(byte[] dest, byte[] src) {
for (int i = 1; i < src.length / 8; i++) {
UNSAFE.putLongUnaligned(dest, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * (i - 1), UNSAFE.getLongUnaligned(src, UNSAFE.ARRAY_BYTE_BASE_OFFSET + 8L * i));
- // With AlignVector, we need 8-byte alignment of vector loads/stores.
- // UseCompactObjectHeaders=false UseCompactObjectHeaders=true
- // src_adr = base + 16 + 8*i -> always src_adr = base + 12 + 8*i -> never
- // dst_adr = base + 16 + 8*(i-1) -> always dst_adr = base + 12 + 8*(i-1) -> never
- // -> vectorize -> no vectorization
}
}
@Run(test = {"testByteByte2a", "testByteByte2b"})
public static void testByteByte2_runner() {
< prev index next >