RFR: 8338023: Support two vector selectFrom API [v4]

[Jatin Bhateja]

On Fri, 23 Aug 2024 05:46:29 GMT, Jatin Bhateja <jbhateja at openjdk.org> wrote:

>> Hi All,
>> 
>> As per the discussion on panama-dev mailing list[1], patch adds the support for following new two vector permutation APIs.
>> 
>> 
>> Declaration:-
>>     Vector<E>.selectFrom(Vector<E> v1, Vector<E> v2)
>> 
>> 
>> Semantics:-
>>     Using index values stored in the lanes of "this" vector, assemble the values stored in first (v1) and second (v2) vector arguments. Thus, first and second vector serves as a table, whose elements are selected based on index value vector. API is applicable to all integral and floating-point types.  The result of this operation is semantically equivalent to expression v1.rearrange(this.toShuffle(), v2). Values held in index vector lanes must lie within valid two vector index range [0, 2*VLEN) else an IndexOutOfBoundException is thrown.  
>> 
>> Summary of changes:
>> -  Java side implementation of new selectFrom API.
>> -  C2 compiler IR and inline expander changes.
>> -  In absence of direct two vector permutation instruction in target ISA, a lowering transformation dismantles new IR into constituent IR supported by target platforms. 
>> -  Optimized x86 backend implementation for AVX512 and legacy target.
>> -  Function tests covering new API.
>> 
>> JMH micro included with this patch shows around 10-15x gain over existing rearrange API :-
>> Test System: Intel(R) Xeon(R) Platinum 8480+ [ Sapphire Rapids Server]
>> 
>> 
>>   Benchmark                                     (size)   Mode  Cnt      Score   Error   Units
>> SelectFromBenchmark.rearrangeFromByteVector     1024  thrpt    2   2041.762          ops/ms
>> SelectFromBenchmark.rearrangeFromByteVector     2048  thrpt    2   1028.550          ops/ms
>> SelectFromBenchmark.rearrangeFromIntVector      1024  thrpt    2    962.605          ops/ms
>> SelectFromBenchmark.rearrangeFromIntVector      2048  thrpt    2    479.004          ops/ms
>> SelectFromBenchmark.rearrangeFromLongVector     1024  thrpt    2    359.758          ops/ms
>> SelectFromBenchmark.rearrangeFromLongVector     2048  thrpt    2    178.192          ops/ms
>> SelectFromBenchmark.rearrangeFromShortVector    1024  thrpt    2   1463.459          ops/ms
>> SelectFromBenchmark.rearrangeFromShortVector    2048  thrpt    2    727.556          ops/ms
>> SelectFromBenchmark.selectFromByteVector        1024  thrpt    2  33254.830          ops/ms
>> SelectFromBenchmark.selectFromByteVector        2048  thrpt    2  17313.174          ops/ms
>> SelectFromBenchmark.selectFromIntVector         1024  thrpt    2  10756.804          ops/ms
>> S...
>
> Jatin Bhateja has updated the pull request incrementally with one additional commit since the last revision:
> 
>   Defaulting to index wrapping scheme.

Hi @rose00 , @PaulSandoz , @sviswa7,

Latest patch removed explicit wrap argument passed to selectFrom API, instead uses wrapping scheme as a mitigation strategy to handle OOB partially wrapped indexes. 

Summarizing the new scheme for index wrapping:-
 - Shuffle always holds indexes in valid vector index range or partially wraps OOB indexes.
 - Following are the shuffle creation intercepts 
       - VectorShuffle.fromArray -  Partially wraps OOB indexes
       - iotaShuffle                      -  Accepts explicit wrap argument to chooses b/w wrapping vs partial wrapping of OOB indexes.
       - Vector.toShuffle              - Partially wraps OOB indexes.   
- Partial wrapping generate -ve indexes for OOB indices after wrapping them into valid index range.
      - Objective is to delegate mitigation strategy to subsequent APIs which can either generate a IndexOutOfBounds exception or  create valid index by adding vector length.
     -  An important point to mention here is that partially wrapped indexing schemes first wraps OOB index  ( index < 0 OR  index >= VECLEN) into valid index range and then subtracts VECLEN from wrapped index to generate a -ve number in [-VECLEN: -1] range.
- With new scheme we are choosing wrapping as a default mitigation strategy hence only client which make effective use of a partially wrapped indexes is two vector re-arrange, which uses it to compute the mask for blending two permuted vectors. 
-  Two vector re-arrange and selectFrom API differ in terms of acceptable index range, while former accepts shuffle indices in single vector index range [0:VECLEN) latter operates on two vector index range [0:2*VECLEN).

Best Regards,
Jatin

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

PR Comment: https://git.openjdk.org/jdk/pull/20508#issuecomment-2306344606