RFR: 8340786: Introduce Predicate classes with predicate iterators and visitors for simplified walking

[Christian Hagedorn]

On Tue, 24 Sep 2024 14:19:41 GMT, Christian Hagedorn <chagedorn at openjdk.org> wrote:

> This patch introduces new predicate classes which implement a new `Predicate` interface. These classes represent the different predicates in the C2 IR. They are used in combination with new predicate iterator and visitors classes to provide an easy way to walk and process predicates in the IR.
> 
> ### Predicate Interfaces and Implementing Classes 
> - `Predicate` interface is implemented by four predicate classes:
>   - `ParsePredicate` (existing class)
>   - `RuntimePredicate` (existing and updated class)
>   - `TemplateAssertionPredicate` (new class)
>   - `InitializedAssertionPredicate` (new class, renamed old `InitializedAssertionPredicate` class to `InitializedAssertionPredicateCreator`)
> 
> ### Predicate Iterator with Visitor classes
> There is a new `PredicateIterator` class which can be used to iterate through the predicates of a loop. For each predicate, a `PredicateVisitor` can be applied. The user can implement the `PredicateIterator` interface and override the default do-nothing implementations to the specific needs of the code. I've done this for a couple of places in the code by defining new visitors:
> - `ParsePredicateUsefulMarker`: This visitor marks all Parse Predicates as useful. 
>   - Replaces the old now retired `ParsePredicateIterator`.
> - `DominatedPredicates`: This visitor checks the dominance relation to an `early` node when trying to figure out the latest legal placement for a node. The goal is to skip as many predicates as possible to avoid interference with Loop Predication and/or creating a Loop Limit Check Predicate. 
>   - Replaces the old now retired `PredicateEntryIterator`.
> - `Predicates::dump()`: Newly added dumping code for the predicates above a loop which uses a new `PredicatePrinter` visitor. This helps debugging issues with predicates.
> 
> #### To Be Replaced soon
> There are a couple of places where we use similar code to walk predicates and apply some transformation/modifications to the IR. The goal is to replace these locations with the new visitors as well. This will incrementally be done with the next couple of PRs.
> 
> ### More Information
> More information about specific classes and changes can be found as code comments and PR comments.
> 
> Thanks,
> Christian

src/hotspot/share/opto/loopTransform.cpp line 1467:

> 1465:   assert(assertion_predicate_has_loop_opaque_node(template_assertion_predicate),
> 1466:          "must find OpaqueLoop* nodes for Template Assertion Predicate");
> 1467:   InitializedAssertionPredicateCreator initialized_assertion_predicate(template_assertion_predicate, new_init,

Needed to rename `InitializedAssertionPredicate` -> `InitializedAssertionPredicateCreator` to distinguish from the newly added `InitializedAssertionPredicate` class:
- `InitializedAssertionPredicate`: Represent an already existing Initialized Assertion Predicate in the IR.
- `InitializedAssertionPredicateCreator`: Class to create the IR nodes to represent an Initialized Assertion Predicate (one could return an `InitailizedAssertionPredicate` instance after the creation but that is not used/needed at the moment.)

src/hotspot/share/opto/loopnode.cpp line 4325:

> 4323:   }
> 4324:   add_useless_parse_predicates_to_igvn_worklist();
> 4325: }

`PredicateIterator` + ``ParsePredicateUsefulMarker` combo to replace this class.

src/hotspot/share/opto/loopnode.cpp line 6381:

> 6379:   while( early != legal ) {     // While not at earliest legal
> 6380:     if (legal->is_Start() && !early->is_Root()) {
> 6381: #ifdef ASSERT

`PredicateIterator` + ``DominatedPredicates` combo to replace this class.

src/hotspot/share/opto/predicates.cpp line 171:

> 169: // Walk over all Regular Predicates of this block (if any) and return the first node not belonging to the block
> 170: // anymore (i.e. entry to the first Regular Predicate in this block if any or `regular_predicate_proj` otherwise).
> 171: Node* PredicateBlock::skip_regular_predicates(Node* regular_predicate_proj, Deoptimization::DeoptReason deopt_reason) {

Replaced by new `RegularPredicateBlock` class which does the skipping.

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

> 562:   // Walk over all predicates of this block (if any) and apply the given 'predicate_visitor' to each predicate.
> 563:   // Returns the entry to the earliest predicate.
> 564:   Node* for_each(PredicateVisitor& predicate_visitor) const {

The goal is eventually to only have this method which does the check for what kind of predicate we face in the graph and replace all other places where we do these kind of checks together with visitors.

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

> 613: // Class to walk over all predicates starting at a node, which usually is the loop entry node, and following the inputs.
> 614: // At each predicate, a PredicateVisitor is applied which the user can implement freely.
> 615: class PredicateIterator : public StackObj {

Calling structure `PredicateIterator` -> `PredicateBlockIterator` -> `RegularPredicateBlockIterator`.

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

PR Review Comment: https://git.openjdk.org/jdk/pull/21161#discussion_r1773455619
PR Review Comment: https://git.openjdk.org/jdk/pull/21161#discussion_r1773456683
PR Review Comment: https://git.openjdk.org/jdk/pull/21161#discussion_r1773457164
PR Review Comment: https://git.openjdk.org/jdk/pull/21161#discussion_r1773521651
PR Review Comment: https://git.openjdk.org/jdk/pull/21161#discussion_r1773528603
PR Review Comment: https://git.openjdk.org/jdk/pull/21161#discussion_r1773529729