MLIR letter-D vector items are represented because (n-1)-D arrays of 1-D vectors whenever paid down to LLVM

Brand new implication of the bodily HW limits toward coding design are that one never list dynamically all over equipment files: an enroll file can be essentially not be listed dynamically. The reason being the newest sign in count is fixed and another often should unroll explicitly to locate fixed check in number otherwise wade because of memory. This is certainly a regulation common in order to CUDA programmers: when saying a personal float a ; and you can then indexing with a working worthy of results in thus-titled local recollections usage (i.e. roundtripping to memories).

Implication towards codegen ¶

That it introduces the consequences toward static vs dynamic indexing chatted about in earlier times: extractelement , insertelement and shufflevector into n-D vectors in MLIR just support fixed indicator. Dynamic indicator are just offered into the most slight step one-D vector not the fresh outside (n-1)-D . To many other cases, specific load / stores are needed.

1. Loops up to vector beliefs try secondary addressing of vector viewpoints, they must run-on direct load / store functions more than n-D vector versions.
2. Just after a keen letter-D vector style of was piled to the a keen SSA value (that will or might not are now living in n data, which have otherwise instead spilling, whenever eventually lower), it San Diego escort service could be unrolled so you’re able to shorter k-D vector products and processes one to match new HW. This level of MLIR codegen is related to check in allocation and you can spilling one to occur far later on regarding LLVM pipe.
3. HW will get support >1-D vectors with intrinsics for secondary handling within these vectors. These may become directed thanks to specific vector_cast operations of MLIR k-D vector models and operations so you’re able to LLVM step one-D vectors + intrinsics.

Instead, i argue that actually reducing to help you good linearized abstraction hides away the new codegen complexities regarding memories accesses giving a false impression regarding enchanting vibrant indexing all over files. As an alternative we love to create those individuals very specific inside the MLIR and you may enable it to be codegen to explore tradeoffs. Additional HW will demand various other tradeoffs on the systems employed in tips 1., dos. and you will step three.

Choices generated during the MLIR level can get implications at the an effective much afterwards phase when you look at the LLVM (after check in allocation). We do not envision to expose concerns associated with acting off check in allocation and you will spilling so you’re able to MLIR clearly. Instead, for each target will establish some “good” target surgery and you will letter-D vector versions, for the will cost you you to definitely PatterRewriters within MLIR top was able to target. Like costs at MLIR peak might be conceptual and used having positions, not to possess real efficiency modeling. Down the road such as for instance will set you back could well be discovered.

Implication into Lowering so you can Accelerators ¶

To target accelerators that support higher dimensional vectors natively, we can start from either 1-D or n-D vectors in MLIR and use vector.cast to flatten the most minor dimensions to 1-D vector where K is an appropriate constant. Then, the existing lowering to LLVM-IR immediately applies, with extensions for accelerator-specific intrinsics.

It is the role of an Accelerator-specific vector dialect (see codegen flow in the figure above) to lower the vector.cast . Accelerator -> LLVM lowering would then consist of a bunch of Accelerator -> Accelerator rewrites to perform the casts composed with Accelerator -> LLVM conversions + intrinsics that operate on 1-D vector .

Some of those rewrites may need extra handling, especially if a reduction is involved. For example, vector.cast %0: vector to vector when K != K1 * … * Kn and some arbitrary irregular vector.cast %0: vector<4x4x17xf32> to vector may introduce masking and intra-vector shuffling that may not be worthwhile or even feasible, i.e. infinite cost.

However vector.cast %0: vector to vector when K = K1 * … * Kn should be close to a noop.