mirror of
https://github.com/openjdk/jdk.git
synced 2026-04-09 14:38:42 +00:00
435 lines
19 KiB
Java
435 lines
19 KiB
Java
/*
|
|
* Copyright Amazon.com Inc. 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.runtime;
|
|
|
|
import jdk.test.lib.process.OutputAnalyzer;
|
|
import jdk.test.lib.process.ProcessTools;
|
|
import jdk.test.whitebox.WhiteBox;
|
|
import jtreg.SkippedException;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8370947 8381003
|
|
* @summary Test command-line options for UseSingleICacheInvalidation and NeoverseN1ICacheErratumMitigation
|
|
* @library /test/lib
|
|
* @requires os.arch == "aarch64"
|
|
* @requires os.family == "linux"
|
|
* @build jdk.test.whitebox.WhiteBox
|
|
* @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
|
|
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI compiler.runtime.TestDeferredICacheInvalidationCmdOptions
|
|
*/
|
|
|
|
public class TestDeferredICacheInvalidationCmdOptions {
|
|
|
|
// CPU identifiers
|
|
private static final int CPU_ARM = 0x41;
|
|
private static final int NEOVERSE_N1_MODEL = 0xd0c;
|
|
|
|
// Known ARM Neoverse models where we can predict UseSingleICacheInvalidation
|
|
// behavior.
|
|
private static final int[] KNOWN_NEOVERSE_MODELS = {
|
|
NEOVERSE_N1_MODEL,
|
|
0xd40, // Neoverse V1
|
|
0xd49, // Neoverse N2
|
|
0xd4f, // Neoverse V2
|
|
0xd83, // Neoverse V3AE
|
|
0xd84, // Neoverse V3
|
|
0xd8e, // Neoverse N3
|
|
};
|
|
|
|
private static boolean isAffected;
|
|
private static boolean isKnownModel;
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
// This test does not depend on CPU identification — run it first.
|
|
testDisableBothFlags();
|
|
|
|
// Parse CPU features and print CPU info
|
|
parseCPUFeatures();
|
|
|
|
if (!isKnownModel) {
|
|
throw new SkippedException("Unknown CPU model - skipping remaining tests.");
|
|
}
|
|
|
|
if (isAffected) {
|
|
// Detect whether IC IVAU is trapped on this system.
|
|
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
|
|
"-XX:+UnlockDiagnosticVMOptions",
|
|
"-XX:+NeoverseN1ICacheErratumMitigation",
|
|
"-version");
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
|
|
if (output.getExitValue() != 0) {
|
|
// Verify the failure is the expected probe error, not something else.
|
|
output.shouldContain("IC IVAU is not trapped");
|
|
throw new SkippedException("IC IVAU is not trapped - skipping remaining tests.");
|
|
} else {
|
|
System.out.println("IC IVAU trap active.");
|
|
}
|
|
}
|
|
|
|
if (isAffected) {
|
|
// Check defaults on Neoverse N1 pre-r4p1
|
|
testCase_DefaultsOnNeoverseN1();
|
|
|
|
// Check if NeoverseN1ICacheErratumMitigation is set to false on affected CPUs,
|
|
// UseSingleICacheInvalidation is also set to false
|
|
testCase_ExplicitlyDisableErrataAffectsDeferred();
|
|
|
|
// Check JVM error if UseSingleICacheInvalidation=true
|
|
// but NeoverseN1ICacheErratumMitigation=false on affected CPUs
|
|
testCase_ConflictingFlagsOnAffectedCPUs();
|
|
|
|
// Check explicit NeoverseN1ICacheErratumMitigation=true enables UseSingleICacheInvalidation
|
|
testCase_ExplicitlyEnableErrataEnablesDeferred();
|
|
|
|
// Check UseSingleICacheInvalidation=false with NeoverseN1ICacheErratumMitigation=true
|
|
testCase_ConflictingErrataWithoutDeferred();
|
|
} else {
|
|
// Check NeoverseN1ICacheErratumMitigation is false on unaffected CPUs
|
|
testCase_DefaultsOnUnaffectedCPUs();
|
|
|
|
// Check setting NeoverseN1ICacheErratumMitigation=true on unaffected CPU causes an error
|
|
testCase_EnablingErrataOnUnaffectedCPU();
|
|
}
|
|
|
|
System.out.println("All test cases passed!");
|
|
}
|
|
|
|
/**
|
|
* Parse CPU features string from WhiteBox.getCPUFeatures() to extract:
|
|
* - cpuFamily: 0x41 for ARM
|
|
* - cpuVariant: major revision
|
|
* - cpuModel: e.g., 0xd0c for Neoverse N1
|
|
* - cpuRevision: minor revision
|
|
* - cpuModel2: secondary model (if present, in parentheses)
|
|
*
|
|
* Sets the static fields isAffected and isKnownModel, and prints CPU info.
|
|
*
|
|
* Format: 0x%02x:0x%x:0x%03x:%d[(0x%03x)]
|
|
* Example: "0x41:0x3:0xd0c:0" or "0x41:0x3:0xd0c:0(0xd0c)"
|
|
*
|
|
* @throws SkippedException if not running on ARM CPU
|
|
*/
|
|
private static void parseCPUFeatures() {
|
|
WhiteBox wb = WhiteBox.getWhiteBox();
|
|
String cpuFeatures = wb.getCPUFeatures();
|
|
System.out.println("CPU Features string: " + cpuFeatures);
|
|
|
|
if (cpuFeatures == null || cpuFeatures.isEmpty()) {
|
|
throw new RuntimeException("No CPU features available");
|
|
}
|
|
|
|
int commaIndex = cpuFeatures.indexOf(",");
|
|
if (commaIndex == -1) {
|
|
throw new RuntimeException("Unexpected CPU features format (no comma): " + cpuFeatures);
|
|
}
|
|
|
|
String cpuPart = cpuFeatures.substring(0, commaIndex).trim();
|
|
|
|
String[] parts = cpuPart.split(":");
|
|
if (parts.length < 4) {
|
|
throw new RuntimeException("Unexpected CPU features format: " + cpuPart);
|
|
}
|
|
|
|
int cpuFamily = Integer.parseInt(parts[0].substring(2), 16);
|
|
if (cpuFamily != CPU_ARM) {
|
|
throw new SkippedException("Not running on ARM CPU (cpuFamily=0x" + Integer.toHexString(cpuFamily) + ")");
|
|
}
|
|
|
|
int cpuVariant = Integer.parseInt(parts[1].substring(2), 16);
|
|
int cpuModel = Integer.parseInt(parts[2].substring(2), 16);
|
|
int cpuModel2 = 0;
|
|
|
|
int model2Start = parts[3].indexOf("(");
|
|
String revisionStr = parts[3];
|
|
if (model2Start != -1) {
|
|
if (!parts[3].endsWith(")")) {
|
|
throw new RuntimeException("Unexpected CPU features format (missing closing parenthesis): " + parts[3]);
|
|
}
|
|
String model2Str = parts[3].substring(model2Start + 1, parts[3].length() - 1);
|
|
cpuModel2 = Integer.parseInt(model2Str.substring(2), 16);
|
|
revisionStr = parts[3].substring(0, model2Start);
|
|
}
|
|
int cpuRevision = Integer.parseInt(revisionStr);
|
|
|
|
// Neoverse N1 errata 1542419 affects r3p0, r3p1 and r4p0.
|
|
// It is fixed in r4p1 and later revisions.
|
|
if (cpuModel == NEOVERSE_N1_MODEL || cpuModel2 == NEOVERSE_N1_MODEL) {
|
|
isAffected = (cpuVariant == 3 && cpuRevision == 0) ||
|
|
(cpuVariant == 3 && cpuRevision == 1) ||
|
|
(cpuVariant == 4 && cpuRevision == 0);
|
|
}
|
|
|
|
// Check if this is a known Neoverse model.
|
|
isKnownModel = false;
|
|
for (int model : KNOWN_NEOVERSE_MODELS) {
|
|
if (cpuModel == model || cpuModel2 == model) {
|
|
isKnownModel = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
printCPUInfo(cpuFamily, cpuVariant, cpuModel, cpuModel2, cpuRevision);
|
|
}
|
|
|
|
private static void printCPUInfo(int cpuFamily, int cpuVariant, int cpuModel, int cpuModel2, int cpuRevision) {
|
|
boolean isNeoverseN1 = (cpuFamily == CPU_ARM) &&
|
|
(cpuModel == NEOVERSE_N1_MODEL || cpuModel2 == NEOVERSE_N1_MODEL);
|
|
System.out.println("\n=== CPU Information ===");
|
|
System.out.println("CPU Family: 0x" + Integer.toHexString(cpuFamily));
|
|
System.out.println("CPU Variant: 0x" + Integer.toHexString(cpuVariant));
|
|
System.out.println("CPU Model: 0x" + Integer.toHexString(cpuModel));
|
|
if (cpuModel2 != 0) {
|
|
System.out.println("CPU Model2: 0x" + Integer.toHexString(cpuModel2));
|
|
}
|
|
System.out.println("CPU Revision: " + cpuRevision);
|
|
System.out.println("Is Neoverse N1: " + isNeoverseN1);
|
|
System.out.println("Is affected by errata 1542419: " + isAffected);
|
|
System.out.println("Is known model: " + isKnownModel);
|
|
System.out.println("======================\n");
|
|
}
|
|
|
|
/**
|
|
* Test that UseSingleICacheInvalidation and NeoverseN1ICacheErratumMitigation flags
|
|
* can be explicitly set to false on any system.
|
|
*/
|
|
private static void testDisableBothFlags() throws Exception {
|
|
System.out.println("\nTest: Explicitly disable both flags");
|
|
|
|
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
|
|
"-XX:+UnlockDiagnosticVMOptions",
|
|
"-XX:-UseSingleICacheInvalidation",
|
|
"-XX:-NeoverseN1ICacheErratumMitigation",
|
|
"-XX:+PrintFlagsFinal",
|
|
"-version");
|
|
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
output.shouldHaveExitValue(0);
|
|
|
|
String output_str = output.getOutput();
|
|
boolean hasSingleDisabled = output_str.matches("(?s).*bool\\s+UseSingleICacheInvalidation\\s*=\\s*false.*");
|
|
boolean hasErrataDisabled = output_str.matches("(?s).*bool\\s+NeoverseN1ICacheErratumMitigation\\s*=\\s*false.*");
|
|
|
|
System.out.println("UseSingleICacheInvalidation disabled: " + hasSingleDisabled);
|
|
System.out.println("NeoverseN1ICacheErratumMitigation disabled: " + hasErrataDisabled);
|
|
|
|
if (!hasErrataDisabled) {
|
|
throw new RuntimeException("Failed to disable NeoverseN1ICacheErratumMitigation via command line");
|
|
}
|
|
|
|
if (!hasSingleDisabled) {
|
|
throw new RuntimeException("Failed to disable UseSingleICacheInvalidation via command line");
|
|
}
|
|
|
|
System.out.println("Successfully disabled both flags");
|
|
}
|
|
|
|
/**
|
|
* Check defaults on Neoverse N1 affected revisions.
|
|
* UseSingleICacheInvalidation and NeoverseN1ICacheErratumMitigation flags should be true.
|
|
*/
|
|
private static void testCase_DefaultsOnNeoverseN1() throws Exception {
|
|
System.out.println("\nTest: Check defaults on Neoverse N1 affected revisions");
|
|
|
|
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
|
|
"-XX:+UnlockDiagnosticVMOptions",
|
|
"-XX:+PrintFlagsFinal",
|
|
"-version");
|
|
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
output.shouldHaveExitValue(0);
|
|
|
|
String output_str = output.getOutput();
|
|
boolean hasSingleEnabled = output_str.matches("(?s).*bool\\s+UseSingleICacheInvalidation\\s*=\\s*true.*");
|
|
boolean hasErrataEnabled = output_str.matches("(?s).*bool\\s+NeoverseN1ICacheErratumMitigation\\s*=\\s*true.*");
|
|
|
|
System.out.println("UseSingleICacheInvalidation enabled: " + hasSingleEnabled);
|
|
System.out.println("NeoverseN1ICacheErratumMitigation enabled: " + hasErrataEnabled);
|
|
|
|
if (!hasSingleEnabled || !hasErrataEnabled) {
|
|
throw new RuntimeException("On affected Neoverse N1 with trap active, " +
|
|
"UseSingleICacheInvalidation and NeoverseN1ICacheErratumMitigation flags should be enabled by default");
|
|
}
|
|
System.out.println("Correctly enabled on affected Neoverse N1");
|
|
}
|
|
|
|
/**
|
|
* Check NeoverseN1ICacheErratumMitigation is false on unaffected CPUs.
|
|
*/
|
|
private static void testCase_DefaultsOnUnaffectedCPUs() throws Exception {
|
|
System.out.println("\nTest: Check NeoverseN1ICacheErratumMitigation is false on unaffected CPUs");
|
|
|
|
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
|
|
"-XX:+UnlockDiagnosticVMOptions",
|
|
"-XX:+PrintFlagsFinal",
|
|
"-version");
|
|
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
output.shouldHaveExitValue(0);
|
|
|
|
String output_str = output.getOutput();
|
|
boolean hasErrataEnabled = output_str.matches("(?s).*bool\\s+NeoverseN1ICacheErratumMitigation\\s*=\\s*true.*");
|
|
|
|
System.out.println("NeoverseN1ICacheErratumMitigation enabled: " + hasErrataEnabled);
|
|
|
|
if (hasErrataEnabled) {
|
|
throw new RuntimeException("On unaffected CPUs, NeoverseN1ICacheErratumMitigation should be disabled");
|
|
}
|
|
System.out.println("Correctly disabled on unaffected CPU");
|
|
}
|
|
|
|
/**
|
|
* Check if NeoverseN1ICacheErratumMitigation is set to false via cmd on affected CPUs,
|
|
* UseSingleICacheInvalidation is set to false.
|
|
*/
|
|
private static void testCase_ExplicitlyDisableErrataAffectsDeferred() throws Exception {
|
|
System.out.println("\nTest: Explicitly disable NeoverseN1ICacheErratumMitigation, check UseSingleICacheInvalidation");
|
|
|
|
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
|
|
"-XX:+UnlockDiagnosticVMOptions",
|
|
"-XX:-NeoverseN1ICacheErratumMitigation",
|
|
"-XX:+PrintFlagsFinal",
|
|
"-version");
|
|
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
output.shouldHaveExitValue(0);
|
|
|
|
String output_str = output.getOutput();
|
|
boolean hasSingleDisabled = output_str.matches("(?s).*bool\\s+UseSingleICacheInvalidation\\s*=\\s*false.*");
|
|
boolean hasErrataDisabled = output_str.matches("(?s).*bool\\s+NeoverseN1ICacheErratumMitigation\\s*=\\s*false.*");
|
|
|
|
System.out.println("NeoverseN1ICacheErratumMitigation disabled: " + hasErrataDisabled);
|
|
System.out.println("UseSingleICacheInvalidation disabled: " + hasSingleDisabled);
|
|
|
|
if (!hasErrataDisabled) {
|
|
throw new RuntimeException("Failed to disable NeoverseN1ICacheErratumMitigation via command line");
|
|
}
|
|
|
|
if (!hasSingleDisabled) {
|
|
throw new RuntimeException("On affected CPU, disabling NeoverseN1ICacheErratumMitigation should also disable UseSingleICacheInvalidation");
|
|
}
|
|
System.out.println("Correctly synchronized on affected CPU");
|
|
}
|
|
|
|
/**
|
|
* Check JVM reports an error if UseSingleICacheInvalidation is set to true
|
|
* but NeoverseN1ICacheErratumMitigation is set to false on affected CPUs.
|
|
*/
|
|
private static void testCase_ConflictingFlagsOnAffectedCPUs() throws Exception {
|
|
System.out.println("\nTest: Try to set UseSingleICacheInvalidation=true with NeoverseN1ICacheErratumMitigation=false");
|
|
|
|
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
|
|
"-XX:+UnlockDiagnosticVMOptions",
|
|
"-XX:+UseSingleICacheInvalidation",
|
|
"-XX:-NeoverseN1ICacheErratumMitigation",
|
|
"-version");
|
|
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
|
|
if (output.getExitValue() == 0) {
|
|
throw new RuntimeException("On affected CPU, setting UseSingleICacheInvalidation=true " +
|
|
"with NeoverseN1ICacheErratumMitigation=false should cause error");
|
|
}
|
|
output.shouldContain("Error");
|
|
System.out.println("JVM correctly rejected conflicting flags on affected CPU");
|
|
}
|
|
|
|
/**
|
|
* Check explicit NeoverseN1ICacheErratumMitigation=true enables UseSingleICacheInvalidation.
|
|
*/
|
|
private static void testCase_ExplicitlyEnableErrataEnablesDeferred() throws Exception {
|
|
System.out.println("\nTest: Explicitly enable NeoverseN1ICacheErratumMitigation, check UseSingleICacheInvalidation");
|
|
|
|
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
|
|
"-XX:+UnlockDiagnosticVMOptions",
|
|
"-XX:+NeoverseN1ICacheErratumMitigation",
|
|
"-XX:+PrintFlagsFinal",
|
|
"-version");
|
|
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
output.shouldHaveExitValue(0);
|
|
|
|
String output_str = output.getOutput();
|
|
boolean hasSingleEnabled = output_str.matches("(?s).*bool\\s+UseSingleICacheInvalidation\\s*=\\s*true.*");
|
|
boolean hasErrataEnabled = output_str.matches("(?s).*bool\\s+NeoverseN1ICacheErratumMitigation\\s*=\\s*true.*");
|
|
|
|
System.out.println("NeoverseN1ICacheErratumMitigation enabled: " + hasErrataEnabled);
|
|
System.out.println("UseSingleICacheInvalidation enabled: " + hasSingleEnabled);
|
|
|
|
if (!hasErrataEnabled) {
|
|
throw new RuntimeException("Failed to enable NeoverseN1ICacheErratumMitigation via command line");
|
|
}
|
|
|
|
if (!hasSingleEnabled) {
|
|
throw new RuntimeException("On affected CPU, enabling NeoverseN1ICacheErratumMitigation should also enable UseSingleICacheInvalidation");
|
|
}
|
|
System.out.println("Correctly synchronized on affected CPU");
|
|
}
|
|
|
|
/**
|
|
* Check JVM reports an error if UseSingleICacheInvalidation is set to false
|
|
* and NeoverseN1ICacheErratumMitigation is set to true on affected CPUs.
|
|
*/
|
|
private static void testCase_ConflictingErrataWithoutDeferred() throws Exception {
|
|
System.out.println("\nTest: Try to set NeoverseN1ICacheErratumMitigation=true with UseSingleICacheInvalidation=false");
|
|
|
|
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
|
|
"-XX:+UnlockDiagnosticVMOptions",
|
|
"-XX:-UseSingleICacheInvalidation",
|
|
"-XX:+NeoverseN1ICacheErratumMitigation",
|
|
"-XX:+PrintFlagsFinal",
|
|
"-version");
|
|
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
|
|
if (output.getExitValue() == 0) {
|
|
throw new RuntimeException("On affected CPU, setting NeoverseN1ICacheErratumMitigation=true with UseSingleICacheInvalidation=false should cause an error");
|
|
}
|
|
output.shouldContain("Error");
|
|
System.out.println("JVM correctly rejected conflicting flags on affected CPU");
|
|
}
|
|
|
|
/**
|
|
* Check setting NeoverseN1ICacheErratumMitigation=true on unaffected CPU causes an error.
|
|
*/
|
|
private static void testCase_EnablingErrataOnUnaffectedCPU() throws Exception {
|
|
System.out.println("\nTest: Try to set NeoverseN1ICacheErratumMitigation=true on unaffected CPU");
|
|
|
|
ProcessBuilder pb = ProcessTools.createTestJavaProcessBuilder(
|
|
"-XX:+UnlockDiagnosticVMOptions",
|
|
"-XX:+NeoverseN1ICacheErratumMitigation",
|
|
"-version");
|
|
|
|
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
|
|
|
if (output.getExitValue() == 0) {
|
|
throw new RuntimeException("On unaffected CPU, setting NeoverseN1ICacheErratumMitigation=true should cause error");
|
|
}
|
|
output.shouldContain("Error");
|
|
System.out.println("JVM correctly rejected enabling errata flag on unaffected CPU");
|
|
}
|
|
}
|