We would use the same approach as before: a flag or a customization mechanism within the interface to choose between the two outputs. Affine memory operations would implement this interface. Introduce op interfaces to vectorize memory operations that would produce the output that we want (Vector or Affine ops). The implementation could range from a simple flag + if-else statements to providing a class with customizable call-backs for the generation of the memory operations.

Introduce some customization in the super vectorizer to choose which output we want to produce: Affine memory ops or Vector memory ops. This would require introducing the Affine to Std conversion for vector ops, which would be kind of redundant with the Affine->Vector conversion. Alternatively, convert Vector → Affine → Std → LLVM. This would allow us to reuse the Affine → Vector → LLVM conversion, which are already implemented. I’ve been gathering feedback from community members to address this problem and these are some of the solutions that were proposed:Ĭonvert Vector ops back to Affine after vectorization (Vector → Affine → Vector → LLVM). Since affine analysis is only able to deal with affine memory ops, this basically means that currently there is no way to apply any other Affine optimization after applying vectorization (e.g., affine LICM or unrolling), which is a highly important limitation. However, an important difference with respect to other affine optimizations is that the super vectorizer is producing (memory) operations that are not part of the Affine dialect but the Vector dialect ( ansfer_read & ansfer_write). This is also the case of the affine super vectorizer pass. Many of them make use of affine analysis to address, for example, the legality aspect of the optimizations. We currently have a good variety of optimizations working on the Affine dialect upstream. I would like to share one of the problems I’ve been struggling with when applying optimizations in the affine domain in MLIR.

Super vectorizer 2 review