[llvm] [LV][VPlan] Add initial support for CSA vectorization (PR #121222)

[Mel Chen via llvm-commits]

Mel-Chen wrote:

> > Ideally, the vectorizer should select the best vectorization approach in the following order:
> > 
> > 1. Try `RecurKind::AnyOf` (select between invariants)
> > 2. If not applicable, try `RecurKind::FindLastIV` (select from a monotonic increasing sequence)
> > 3. If not applicable, try `RecurKind::FindLast` (select from a set of  variables)
> > 4. If none apply, then it cannot be vectorized.
> 
> Curious about there need for both FindLast and FindLastIV. The desired output may be some function of the last IV found, and this function may be applied after the loop or folded into the loop along with the reduction if preferred (similar to two invariants per boolean AnyOf), but the canonical reduction pattern for both is presumably that of finding the last iteration?

The reason for distinguishing FindLastIV from FindLast is similar to the distinction between AnyOf and FindLast.

Under specific conditions—such as AnyOf for two invariants or FindLastIV for a monotonic sequence—we can achieve better vectorization performance by using the lower-cost AnyOf or FindLastIV instead of always using FindLast.

While it is possible to initially classify all non-min/max select reductions as FindLast and later refine them into AnyOf or FindLastIV, I don’t see any clear advantage in doing so.

Instead, performing a precise classification of AnyOf, FindLastIV, and FindLast during the legality check allows the target to determine whether to apply in-loop or out-of-loop reduction based on the specific reduction kind after in-loop non-min/max select reductions are supported in the future.

> * Reduction: cyclic, non-induction (non-addition chain or addition chain with varying step). A {value(i)} sequence of values all of the same type (integer, floating point or boolean) is computed one per iteration i, independent of other iterations, and reduced to a single value of this type by repeatedly applying a binary operator to value(i) and the reduction phi.
>   
>   * Select Reduction: the reduction result may be an element of the sequence being reduced if this binary operator selects one of its two operands. This is the case for Min/Max reductions and arguably also for `AnyOf` - which can use a `select value(i) ? value(i) : phi` as its binary reduction operator. Note that if AnyOf returns false, all value(i)'s are false, so any value(i) can be considered selected.
>   * Selected Index: the resulting value(i) of a select reduction can be complemented with its corresponding iteration i. This is the case for Min/Max-with-index and also for `FindLast` - corresponding to AnyOf-with-index, returning the last iteration i for which value(i) is true, if any.
> 
> There may be additional recurrences to consider?

I'm currently considering adding MinMaxRecurrence to better support min/max with index idioms.

The current reduction analysis does not allow internal loop users outside the recurrence chain, nor does it allow the recurrence chain without external users. This does not align well with the conditions of min/max reduction in min/max with index, which is why I'm not satisfied with my previous implementation.

Other than the MinMaxRecurrence I'm planning, I haven't thought of any additional recurrences to consider.



https://github.com/llvm/llvm-project/pull/121222