RFR: 8310308: IR Framework: check for type and size of vector nodes [v2]
Christian Hagedorn
chagedorn at openjdk.org
Wed Jun 28 13:09:34 UTC 2023
On Wed, 28 Jun 2023 08:31:37 GMT, Emanuel Peter <epeter at openjdk.org> wrote:
>> For some changes to `SuperWord`, and maybe auto-vectorization in general, I want to strengthen the IR Framework.
>>
>> **Motivation**
>> I want to not just find the relevant IR nodes, but also assert that they have the maximal length that they could have on the respective platform (given the CPU features and `MaxVectorSize`). Without this verification it is possible that a future change leads to a regression where we still vectorize but at shorter vector widths as before - leading to performance loss.
>>
>> **How to use it**
>>
>> All `IRNode`s in `test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java` that are created with `vectorNode` are now all matched with their `type` and `size`. The regex might now look something like this:
>>
>> `"(\d+(\s){2}(VectorCastF2X.*)+(\s){2}===.*vector[A-Za-z][8]:{int})"`
>> which would match with IR nodes dumped like that:
>> `1150 VectorCastF2X === _ 1151 [[ 1146 ]] #vectory[8]:{int} ...`
>>
>> The goal was to keep it simple and straight forward. In most cases, you can just use the nodes as before, and implicitly we now check for maximal size automatically. However, in some cases we want to ensure there is no or only a limited number of nodes (`failOn` or comparison `<` or `<=` or `=0`) - in those cases we usually want to make sure there is not any node of any size, so we match with any size by default. The size can also explicitly be constrained using `IRNode.VECTOR_SIZE`.
>>
>> Some examples:
>> 1. `@IR(counts = {IRNode.LOAD_VI, " >0 "})` -> search for a `LoadVector` node with `type` `int`, and maximal `size` possible on the machine (limited by CPU features and `MaxVectorSize`). This is the most common use case.
>> 2. `@IR(failOn = { IRNode.LOAD_VL, IRNode.STORE_VECTOR })` -> fail if there is a `LoadVector` with type `long`, of `any` size.
>> 3. `@IR(counts = { IRNode.XOR_VI, IRNode.VECTOR_SIZE_4, " > 0 "})` -> find at least one `XorV` node with type `int` and exactly `4` elements. Useful for VectorAPI when the vector species is fixed.
>> 4. `@IR(counts = { IRNode.LOAD_VD, IRNode.VECTOR_SIZE + "min(4, max_double)", " >0 " })` -> search for a `LoadVector` node with `type` `double`, and `size` exactly equals to `min(4, max_double)` (so 4 elements, or if the hardware allows fewer `doubles`, then that number).
>> 5. `@IR(counts = { IRNode.ABS_VF, IRNode.VECTOR_SIZE + "min(LoopMaxUnroll, max_float)", ">= 1" })` -> find at least one `AbsV` nodes with type `float`, and the `size` exactly equals to the smaller of `LoopMaxUnroll` o...
>
> Emanuel Peter has updated the pull request incrementally with one additional commit since the last revision:
>
> revert to ANY for TestAutoVectorization2DArray.java
This is a great enhancement! Thanks for working on that.
I have left some comments in the IR framework code (will also have a look at the test updates later) but here are some more general comments:
- We should provide some better description when misusing the new features. Example:
@IR(counts = {IRNode.LOAD_VL, IRNode.VECTOR_SIZE + "min(4)", ">0"})
@IR(counts = {IRNode.LOAD_VL, IRNode.VECTOR_SIZE + "min()", ">0"})
Output:
- Provided invalid value "_ at min(4)" after comparator "=", node IRNode.LOAD_VL, in count string "_ at min(4)" for IR rule 2 at private static long compiler.loopopts.superword.TestGeneralizedReductions.testReductionOnPartiallyUnrolledLoopWithSwappedInputs(long[]).
- Provided invalid value "_ at min()" after comparator "=", node IRNode.LOAD_VL, in count string "_ at min()" for IR rule 3 at private static long compiler.loopopts.superword.TestGeneralizedReductions.testReductionOnPartiallyUnrolledLoopWithSwappedInputs(long[]).
We could give the user some more information about what's wrong here. You might want to play around with other wrong usages of the new features and check if the format violation is precise enough. You could also add these wrong usages to `TestBadFormat.java`.
- We should have a (sanity) test that explicitely uses `IRNode.VECTOR_SIZE_ANY` and `IRNode.VECTOR_SIZE_MAX`.
- We should also make sure to have some sanity tests for all the different variations that are now possible with the new features (if not already covered by your updated tests).
test/hotspot/jtreg/compiler/c2/TestMinMaxSubword.java line 64:
> 62: // should not generate vectorized Min/Max nodes for them.
> 63: @Test
> 64: @IR(failOn = {IRNode.MIN_VI, IRNode.MIN_VF, IRNode.MIN_VD})
We could think about keeping generic vector nodes that match any type and restrict their usage to `failOn` constraints.
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 77:
> 75: * be directly specified in {@link #vectorNode}. For IR rules that are looking for a
> 76: * non-zero count of this node, the size is assumed to be the maximal number of elements
> 77: * that can fit in a vector of the specified type. This depends on the VM flag MaxVectorSize
Suggestion:
When using `{@link IR#counts()}` with a non-zero count, the size is assumed...
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 79:
> 77: * that can fit in a vector of the specified type. This depends on the VM flag MaxVectorSize
> 78: * and CPU features. For IR rules that are looking for zero such nodes, or use failOn,
> 79: * there we match for any {@link #VECTOR_SIZE_ANY} size. This should be helpful in most cases
Suggestion:
When using `{@link IR#failOn} or `{@link IR#counts}` with a zero count, we match...
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 84:
> 82: * to specify the size with {@link #VECTOR_SIZE}, followed by a size tag or comma separated
> 83: * list of sizes.
> 84: * </ul>
Can you also add a description of the new matching features to the [README](https://github.com/openjdk/jdk/blob/master/test/hotspot/jtreg/compiler/lib/ir_framework/README.md)? Maybe you can also add some examples there and/or at [IRExample.java](https://github.com/openjdk/jdk/blob/master/test/hotspot/jtreg/testlibrary_tests/ir_framework/examples/IRExample.java).
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 167:
> 165: public static final String ABS_VB = VECTOR_PREFIX + "ABS_VB" + POSTFIX;
> 166: static {
> 167: vectorNode(ABS_VB, "AbsVB", "byte");
I suggest to use private String constants for all the primitive types used with vector nodes.
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 249:
> 247: public static final String ADD_REDUCTION_VD = PREFIX + "ADD_REDUCTION_VD" + POSTFIX;
> 248: static {
> 249: beforeMatchingNameRegex(ADD_REDUCTION_VD, "AddReductionVD");
Shouldn't add reduction nodes only be created in Superword?
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 683:
> 681: }
> 682:
> 683: public static final String LOAD_VB = VECTOR_PREFIX + "LOAD_VB" + POSTFIX;
I suggest to keep `VECTOR` (i.e. `LOAD_VECTOR_B`) because the IR node is called `LoadVector` (while it is okay to abbreviate `AND_V` because the IR node is also called `AndV`). This makes it easier to find this `IRNode` entry when someone wants to write an IR rule with a `LoadVector`.
Same for `VectorBlend`, `VectorMaskCmp` etc. below.
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 1591:
> 1589: public static final String VECTOR_CAST_B2S = VECTOR_PREFIX + "VECTOR_CAST_B2S" + POSTFIX;
> 1590: static {
> 1591: vectorNode(VECTOR_CAST_B2S, "VectorCastB2", "short");
Since we match substrings it's not wrong but I think we should specify the complete IR node name here (was "wrong" before):
Suggestion:
vectorNode(VECTOR_CAST_B2S, "VectorCastB2", "short");
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 1596:
> 1594: public static final String VECTOR_CAST_B2I = VECTOR_PREFIX + "VECTOR_CAST_B2I" + POSTFIX;
> 1595: static {
> 1596: vectorNode(VECTOR_CAST_B2I, "VectorCastB2", "int");
Suggestion:
vectorNode(VECTOR_CAST_B2I, "VectorCastB2X", "int");
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 1601:
> 1599: public static final String VECTOR_CAST_B2L = VECTOR_PREFIX + "VECTOR_CAST_B2L" + POSTFIX;
> 1600: static {
> 1601: vectorNode(VECTOR_CAST_B2L, "VectorCastB2", "long");
Suggestion:
vectorNode(VECTOR_CAST_B2L, "VectorCastB2X", "long");
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 1606:
> 1604: public static final String VECTOR_CAST_B2F = VECTOR_PREFIX + "VECTOR_CAST_B2F" + POSTFIX;
> 1605: static {
> 1606: vectorNode(VECTOR_CAST_B2F, "VectorCastB2", "float");
Suggestion:
vectorNode(VECTOR_CAST_B2F, "VectorCastB2X", "float");
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 1611:
> 1609: public static final String VECTOR_CAST_B2D = VECTOR_PREFIX + "VECTOR_CAST_B2D" + POSTFIX;
> 1610: static {
> 1611: vectorNode(VECTOR_CAST_B2D, "VectorCastB2", "double");
Suggestion:
vectorNode(VECTOR_CAST_B2D, "VectorCastB2X", "double");
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 1974:
> 1972: }
> 1973:
> 1974: public static final String COMPRESS_BITSVI = VECTOR_PREFIX + "COMPRESS_BITSVI" + POSTFIX;
Was inconsistent before but I suggest to add a `_`:
Suggestion:
public static final String COMPRESS_BITSVI = VECTOR_PREFIX + "COMPRESS_BITS_VI" + POSTFIX;
Same below and for `EXPAND_BITSV`.
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 2099:
> 2097: */
> 2098: private static void vectorNode(String irNodePlaceholder, String irNodeRegex, String typeString) {
> 2099: TestFramework.check(isVectorIRNode(irNodePlaceholder), "vectorNode: failed prefix check for irNodePlaceholder " + irNodePlaceholder + " -> did you use VECTOR_PREFIX?");
You might want to wrap this long line.
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 2248:
> 2246: String regex = "";
> 2247: for (int i = 0; i < sizes.length; i++) {
> 2248: int s = 0;
Suggestion:
int size = 0;
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 2250:
> 2248: int s = 0;
> 2249: try {
> 2250: s = Integer.parseInt(sizes[i]);
We should also check if the size is a reasonable number (i.e. a positive multiple of 2 and maybe an upper limit(?)) and report a format violation if that is not the case as for example in:
@IR(counts = {IRNode.ADD_VI, IRNode.VECTOR_SIZE + "3,-2", "1"})
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 2269:
> 2267: if (sizeTagString.startsWith("min(")) {
> 2268: TestFormat.checkNoReport(sizeTagString.endsWith(")"), "Vector node size \"min(...)\" must end with \")\" \"" + sizeTagString + "\"");
> 2269: String[] tags = sizeTagString.substring(4,sizeTagString.length() - 1).split(",");
Suggestion:
String[] tags = sizeTagString.substring(4, sizeTagString.length() - 1).split(",");
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 2271:
> 2269: String[] tags = sizeTagString.substring(4,sizeTagString.length() - 1).split(",");
> 2270: TestFormat.checkNoReport(tags.length > 1, "Vector node size \"min(...)\" must have at least 2 comma separated arguments, got \"" + sizeTagString + "\"");
> 2271: int min_val = 1024;
Suggestion:
int minVal = 1024;
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 2290:
> 2288: return String.valueOf(getMaxElementsForType(typeString, vmInfo));
> 2289: case "max_byte":
> 2290: return parseVectorNodeSizeTag("max_for_type", "byte", vmInfo);
Can't we directly return `String.valueOf(getMaxElementsForType("byte", vmInfo))` here? Also above on L2273 because it does not seem that we allow nested `min(min(..))`.
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 2307:
> 2305: default:
> 2306: return sizeTagString;
> 2307: }
Might be better to extract this and the `min()` parsing to separate methods.
test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java line 2334:
> 2332: if (avx512 && (typeString.equals("byte") || typeString.equals("short") || typeString.equals("char"))) {
> 2333: maxBytes = avx512bw ? 64 : 32;
> 2334: }
Could be guarded with `Platform.isX64() || Platform.isX86()` and extracted to a separate method.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/IRRule.java line 51:
> 49: this.ruleId = ruleId;
> 50: this.irAnno = irAnno;
> 51: this.matcher = new MatchableMatcher(new CompilePhaseIRRuleBuilder(irAnno, compilation).build(vmInfo));
For consistency, I would move `vmInfo` directly into the `CompilePhaseIRRuleBuilder` constructor.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/checkattribute/parsing/CheckAttributeReader.java line 72:
> 70: return userPostfix;
> 71: } else if (IRNode.isVectorIRNode(node)) {
> 72: String irNode = IRNode.getIRNodeAccessString(node);
Unused and can be removed.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/checkattribute/parsing/CheckAttributeReader.java line 74:
> 72: String irNode = IRNode.getIRNodeAccessString(node);
> 73: if (iterator.hasNext()) {
> 74: String maybe_vt = iterator.next();
In Java, we should avoid underlines for local variables and non-static-final fields and use camal-case, i.e. `maybeVt` or `maybeVT`. There are some other places in this patch where you should change that. And it might be better to avoid abbreviations and use "vector type" since it might not be evidently clear in the context of this class.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/checkattribute/parsing/CheckAttributeReader.java line 81:
> 79: iterator.previous();
> 80: }
> 81: return CheckAttributeString.invalid();
I suggest to move this to a separate method and the composite reading as well.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/checkattribute/parsing/RawIRNode.java line 62:
> 60: if (IRNode.isVectorIRNode(node)) {
> 61: String type = IRNode.getVectorNodeType(node);
> 62: TestFormat.checkNoReport(IRNode.getTypeSizeInBytes(type) > 0, "Vector node's type must have valid type, got \"" + type + "\" for \"" + node + "\"");
You might want to move the error message to a new line to avoid long lines.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/checkattribute/parsing/RawIRNode.java line 71:
> 69: size = vectorSizeDefault;
> 70: }
> 71: String size_regex = IRNode.parseVectorNodeSize(size, type, vmInfo);
Suggestion:
String sizeRegex = IRNode.parseVectorNodeSize(size, type, vmInfo);
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/checkattribute/parsing/RawIRNode.java line 72:
> 70: }
> 71: String size_regex = IRNode.parseVectorNodeSize(size, type, vmInfo);
> 72: nodeRegex = nodeRegex.replaceAll(IRNode.IS_REPLACED, "vector[A-Za-z]\\\\[" + size_regex + "\\\\]:\\\\{" + type + "\\\\}");
You could move this to a separate method.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/constraint/raw/RawCountsConstraint.java line 59:
> 57: private boolean expectMaxSizeForVectorNode() {
> 58: switch (comparison.getComparator()) {
> 59: case "<":
You should indent the `case` statements. You can use the [enhanced switch](https://openjdk.org/jeps/361) style with arrows:
case "<" -> {
...
}
Same for other places where you used `switch`.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/constraint/raw/RawCountsConstraint.java line 60:
> 58: switch (comparison.getComparator()) {
> 59: case "<":
> 60: TestFormat.checkNoReport(comparison.getGivenValue() > 1, "Node count comparison \"<" + comparison.getGivenValue() + "\" should be rewritten as \"=0\"");
Generally, you should only use `checkNoReport()` if it would not make sense to continue at this point because the state is broken (i.e. reading a value that does not exist and then operating on it). But for these kind of violations, where the user just passed something meaningless that has no further impact on the processing of this and other values, you can use `checkNoThrow()` which records the failure. After all the `Matchable` objects are created, we will report all collected violations with `throwIfAnyFailures()` here:
https://github.com/openjdk/jdk/blob/c3f10e847999ec254893de5a1a5de32fd07f715a/test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/TestClassParser.java#L69-L74
Maybe you want to check all usages of `checkNoReport()` again and change to `checkNoThrow()` whenever possible (when bulk reporting the violations, it makes it easier for the user to fix them all at once). Sometimes, I also throw and catch `TestFormatExceptions` because I want to continue to check for more violations.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/constraint/raw/RawCountsConstraint.java line 75:
> 73: return true; // max
> 74: case "!=":
> 75: TestFormat.checkNoReport(false, "Not-equal comparator not supported for node count: \"" + comparison.getComparator() + "\". Please rewrite the rule.");
You can directly use `throw new TestFormatException(string)`. `checkNoReport()` is just a shortcut for
if (!condition) {
throw new TestFormatException(string)
}
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/irrule/constraint/raw/RawCountsConstraint.java line 86:
> 84: public Constraint parse(CompilePhase compilePhase, String compilationOutput, VMInfo vmInfo) {
> 85: TestFramework.check(compilePhase != CompilePhase.DEFAULT, "must not be default");
> 86: String vectorSizeTag = expectMaxSizeForVectorNode() ? "max_for_type" : "any";
We could think about using IR framework internal static final fields for `max_for_type` and `any` as these strings are used at other places as well.
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/IREncodingParser.java line 49:
> 47: private static final Pattern IR_ENCODING_PATTERN =
> 48: Pattern.compile("(?<=" + IREncodingPrinter.START + "\r?\n).*\\R([\\s\\S]*)(?=" + IREncodingPrinter.END + ")");
> 49: private static final Pattern VMINFO_PATTERN =
Suggestion:
private static final Pattern VM_INFO_PATTERN =
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/VMInfo.java line 45:
> 43: }
> 44:
> 45: public String getString(String key, String otherwise) {
Suggestion:
public String getStringValue(String key, String otherwise) {
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/VMInfo.java line 52:
> 50: }
> 51:
> 52: public long getLong(String key, long otherwise) {
Suggestion:
public long getLongValue(String key, long otherwise) {
test/hotspot/jtreg/compiler/lib/ir_framework/driver/irmatching/parser/VMInfo.java line 62:
> 60:
> 61: public boolean hasCPUFeature(String feature) {
> 62: TestFramework.check(isKey("cpuFeatures"), "VMInfo does not contain cpuFeatures");
I suggest to add this verification to the constructor and also verify that you find `MaxVectorSize` and `LoopMaxUnroll` since you are always emitting those. By doing so, I think you can also remove the `otherwise` values above because you should always find a valid value for the keys.
test/hotspot/jtreg/compiler/lib/ir_framework/test/IREncodingPrinter.java line 48:
> 46: public static final String END = "----- END -----";
> 47: public static final int NO_RULE_APPLIED = -1;
> 48: public static final String START_VMINFO = "##### IRMatchingVMInfo - used by TestFramework #####";
Suggestion:
public static final String START_VM_INFO = "##### IRMatchingVMInfo - used by TestFramework #####";
test/hotspot/jtreg/compiler/lib/ir_framework/test/IREncodingPrinter.java line 49:
> 47: public static final int NO_RULE_APPLIED = -1;
> 48: public static final String START_VMINFO = "##### IRMatchingVMInfo - used by TestFramework #####";
> 49: public static final String END_VMINFO = "----- END VMInfo -----";
Suggestion:
public static final String END_VM_INFO = "----- END VMInfo -----";
test/hotspot/jtreg/compiler/lib/ir_framework/test/IREncodingPrinter.java line 383:
> 381: vmInfo.append("LoopMaxUnroll:" + loopMaxUnroll).append(System.lineSeparator());
> 382: vmInfo.append(END_VMINFO);
> 383: TestFrameworkSocket.write(vmInfo.toString(), "VMInfo");
I suggest to move the VM info encoding printing to a separate class `VMInfoPrinter`.
-------------
PR Review: https://git.openjdk.org/jdk/pull/14539#pullrequestreview-1502511643
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245058120
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245062957
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245063866
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245065891
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245054479
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245070302
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245073737
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245088533
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245088670
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245088952
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245087849
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245089379
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245092449
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245093404
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245139571
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245142927
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245098394
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245098919
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245162632
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245161059
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245164715
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244839933
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244904824
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244848292
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244842478
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244896029
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245096303
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244907381
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244889074
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244870683
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244854900
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244909322
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244911325
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245036479
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245036586
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1245034003
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244911665
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244911898
PR Review Comment: https://git.openjdk.org/jdk/pull/14539#discussion_r1244932302
More information about the hotspot-compiler-dev
mailing list