RFR: 8324751: C2 SuperWord: Aliasing Analysis runtime check [v9]

[Christian Hagedorn]

On Thu, 14 Aug 2025 09:52:06 GMT, Emanuel Peter <epeter at openjdk.org> wrote:

>> This is a big patch, but about 3.5k lines are tests. And a large part of the VM changes is comments / proofs.
>> 
>> I am adding a dynamic (runtime) aliasing check to the auto-vectorizer (SuperWord). We use the infrastructure from https://github.com/openjdk/jdk/pull/22016:
>> - Use the auto-vectorization `predicate` when available: we speculate that there is no aliasing, else we trap and re-compile without the predicate.
>> - If the predicate is not available, we use `multiversioning`, i.e. we have a `fast_loop` where there is no aliasing, and hence vectorization. And a `slow_loop` if the check fails, with no vectorization.
>> 
>> --------------------------
>> 
>> **Where to start reviewing**
>> 
>> - `src/hotspot/share/opto/mempointer.hpp`:
>>   - Read the class comment for `MemPointerRawSummand`.
>>   - Familiarize yourself with the `MemPointer Linearity Corrolary`. We need it for the proofs of the aliasing runtime checks.
>> 
>> - `src/hotspot/share/opto/vectorization.cpp`:
>>   - Read the explanations and proofs above `VPointer::can_make_speculative_aliasing_check_with`. It explains how the aliasing runtime check works.
>> 
>> - `src/hotspot/share/opto/vtransform.hpp`:
>>   - Understand the difference between weak and strong edges.
>> 
>> If you need to see some examples, then look at the tests:
>> - `test/hotspot/jtreg/compiler/loopopts/superword/TestAliasing.java`: simple array cases. IR rules that check for vectors and in somecases if we used multiversioning.
>> - `test/micro/org/openjdk/bench/vm/compiler/VectorAliasing.java`: the miro-benchmarks I show below. Simple array cases.
>> - `test/hotspot/jtreg/compiler/loopopts/superword/TestMemorySegmentAliasing.java`: a bit advanced, but similar cases.
>> - `test/hotspot/jtreg/compiler/loopopts/superword/TestAliasingFuzzer.java`: very large and rather compliex. Generates random loops, some with and some without aliasing at runtime. IR verification, but mostly currently only for array cases, MemorySegment cases have some issues (see comments).
>> --------------------------
>> 
>> **Details**
>> 
>> Most fundamentally:
>> - I had to refactor / extend `MemPointer` so that we have access to `MemPointerRawSummand`s.
>> - These raw summands us to reconstruct the `VPointer` at any `iv` value with `VPointer::make_pointer_expression(Node* iv_value)`.
>>    - With the raw summands, a pointer may look like this: `p = base + ConvI2L(x + 2) + ConvI2L(y + 2)`
>>   - With "regular" summands, this gets simplified to `p = base + 4L +ConvI2L(x) + Conv...
>
> Emanuel Peter has updated the pull request incrementally with one additional commit since the last revision:
> 
>   moved swapping up, suggested by Manuel

src/hotspot/share/opto/c2_globals.hpp line 361:

> 359:   product(bool, LoopMultiversioningOptimizeSlowLoop, true, DIAGNOSTIC,      \
> 360:           "When using loop multiversioning, and a speculative runtime"      \
> 361:           "check is added, resume optimization for the stalled slow_loop")  \

Suggestion:

          "When using loop multiversioning, and a speculative runtime"      \
          " check is added, resume optimization for the stalled slow_loop") \

src/hotspot/share/opto/predicates.hpp line 51:

> 49:  *                    - Loop Parse Predicate:             The Parse Predicate added for Loop Predicates.
> 50:  *                    - Profiled Loop Parse Predicate:    The Parse Predicate added for Profiled Loop Predicates.
> 51:  *                    - AutoVectorization Predicate:      The Parse Predicate added for AutoVectorization runtime checks.

Drive-by comment: Can you also add a small section below under "Runtime Predicate" to summarize what an AutoVectorization runtime check is and in what flavors they come? Then we have everything together for future quick reference.

src/hotspot/share/opto/predicates.hpp line 54:

> 52:  *                    - Loop Limit Check Parse Predicate: The Parse Predicate added for a Loop Limit Check Predicate.
> 53:  * - Runtime Predicate: This term is used to refer to a Hoisted Check Predicate (either a Loop Predicate or a Profiled
> 54:  *                      Loop Predicate) or a Loop Limit Check Predicate. These predicates will be checked at runtime while

You should then also update this text, maybe there is more that needs to be updated.

-------------

PR Review Comment: https://git.openjdk.org/jdk/pull/24278#discussion_r2276504360
PR Review Comment: https://git.openjdk.org/jdk/pull/24278#discussion_r2276498769
PR Review Comment: https://git.openjdk.org/jdk/pull/24278#discussion_r2276502729