[mlir][linalg] Add vector transfer lowering patters to codegen strategy.

[gysit]

Summary

Add the vector transfer patterns and introduce the max transfer rank option on the codegen strategy.

mlir/include/mlir/Dialect/Linalg/Transforms/CodegenStrategy.h

CodegenStrategy &setEnableHoistRedundantVectorTransfers(bool val) {
     this->lateCodegenStrategyOptions.enableHoistRedundantVectorTransfers = val;
     return *this;
   }
   CodegenStrategy &setEnableHoistRedundantVectorTransfersOnTensor(bool val) {
     this->lateCodegenStrategyOptions
         .enableHoistRedundantVectorTransfersOnTensor = val;
     return *this;
   }
+  CodegenStrategy &setMaxTransferRank(int64_t val) {
+    this->lateCodegenStrategyOptions.maxTransferRank = val;
+    return *this;
+  }
   CodegenStrategy &setEnableVectorTransferPartialRewrite(bool val) {
     this->lateCodegenStrategyOptions.enableVectorTransferPartialRewrite = val;
     return *this;
   }
   CodegenStrategy &setEnableVectorContractLowering(bool val) {
     this->lateCodegenStrategyOptions.enableVectorContractLowering = val;
     return *this;
   }

mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h

 struct LateCodegenStrategyOptions {
   /// Hoisting transformations are always deemed beneficial and must disabled
   /// explicitly.
   bool enableLICM = true;
   bool enableHoistRedundantVectorTransfers = true;
   bool enableHoistRedundantVectorTransfersOnTensor = true;
   /// Vector lowering operations may result in surprising behavior when
   /// composing multiple codegen strategies and must be enabled explicitly.
+  int64_t maxTransferRank = 1;
   bool enableVectorTransferPartialRewrite = false;
   bool enableVectorContractLowering = false;
   bool enableVectorToSCFConversion = false;
 };
 
 /// Options to control the application of enabling transformations.
 /// Hoisting transformations are always deemed beneficial and must be disabled
 /// explicitly.
 struct LinalgEnablingOptions {
   bool enableLICM = true;
   bool enableHoistRedundantVectorTransfers = true;
   bool enableHoistRedundantVectorTransfersOnTensor = true;
 };
 
 /// Vector lowering options control how ops are lowered down to 1-D and scf.for
 /// form.
 struct LinalgVectorLoweringOptions {
+  int64_t maxTransferRank = 1;
   bool enableVectorTransferPartialRewrite = false;
   bool enableVectorContractLowering = false;
   bool enableVectorToSCFConversion = false;
   vector::VectorTransformsOptions vectorTransformOptions;
   VectorTransferToSCFOptions vectorTransferToSCFOptions;
 };
 
 /// Trait to check if T provides a `getOperationName` method.

mlir/lib/Dialect/Linalg/Transforms/CodegenStrategy.cpp

auto filter = (currentState.str() == std::to_string(0))
                       ? linalg::LinalgTransformationFilter(
                             t->filter, ArrayRef<Identifier>{}, nextState)
                       : linalg::LinalgTransformationFilter(
                             t->filter, currentState, nextState);
     t->addToPassPipeline(pm, filter);
     pm.addPass(createLinalgStrategyEnablePass());
   }
   LinalgVectorLoweringOptions vectorLoweringOptions;
+  vectorLoweringOptions.maxTransferRank =
+      lateCodegenStrategyOptions.maxTransferRank;
   vectorLoweringOptions.enableVectorTransferPartialRewrite =
       lateCodegenStrategyOptions.enableVectorTransferPartialRewrite;
   vectorLoweringOptions.enableVectorContractLowering =
       lateCodegenStrategyOptions.enableVectorContractLowering;
   vectorLoweringOptions.enableVectorToSCFConversion =
       lateCodegenStrategyOptions.enableVectorToSCFConversion;
   vectorLoweringOptions.vectorTransformOptions = vectorTransformOptions;
   vectorLoweringOptions.vectorTransferToSCFOptions = vectorToSCFOptions;

mlir/lib/Dialect/Linalg/Transforms/LinalgStrategyPasses.cpp

struct LinalgStrategyLowerVectorsPass
 
   void runOnFunction() override {
     auto funcOp = getFunction();
     if (!anchorFuncName.empty() && funcOp.getName() != anchorFuncName)
       return;
 
     MLIRContext *context = funcOp.getContext();
     RewritePatternSet patterns(context);
+    vector::populateVectorTransferLoweringPatterns(patterns,
+                                                   options.maxTransferRank);
     if (options.enableVectorTransferPartialRewrite) {
       patterns.add<vector::VectorTransferFullPartialRewriter>(
           context, options.vectorTransformOptions);
     }
     if (options.enableVectorContractLowering) {
       patterns.add<ContractionOpToOuterProductOpLowering,
                    ContractionOpToMatmulOpLowering, ContractionOpLowering>(
           options.vectorTransformOptions, context);