[mlir][Vector] NFC - Add test to exercise lowering of vector.transfer to scf

[nicolasvasilache]

Summary

This revision also renames and moves some tests around.

[nicolasvasilache]

Fix test.

[gysit]

mlir/test/Conversion/VectorToSCF/vector-to-scf.mlir

21

nit: is this test intentionally disabled?

[nicolasvasilache]

mlir/test/Conversion/VectorToSCF/vector-to-scf.mlir

21

fixed in 0a7f81a4518ef88d897322985483c2dd48fa577e

mlir/test/Conversion/VectorToSCF/vector-to-scf-mask-and-permutation-map.mlir

 // RUN: mlir-opt %s -convert-vector-to-scf='lower-permutation-maps=true' -split-input-file | FileCheck %s
 
 // Ensure that the permutation map is lowered (by inserting a transpose op)
 // before lowering the vector.transfer_read.
 
 // CHECK-LABEL: func @transfer_read_2d_mask_transposed(
 //   CHECK-DAG:   %[[PADDING:.*]] = constant dense<-4.200000e+01> : vector<9xf32>
 //   CHECK-DAG:   %[[MASK:.*]] = constant dense<{{.*}}> : vector<9x4xi1>
 //       CHECK:   %[[MASK_MEM:.*]] = memref.alloca() : memref<vector<4x9xi1>>
 //       CHECK:   %[[MASK_T:.*]] = vector.transpose %[[MASK]], [1, 0] : vector<9x4xi1> to vector<4x9xi1>
 //       CHECK:   memref.store %[[MASK_T]], %[[MASK_MEM]][] : memref<vector<4x9xi1>>
 //       CHECK:   %[[MASK_CASTED:.*]] = vector.type_cast %[[MASK_MEM]] : memref<vector<4x9xi1>> to memref<4xvector<9xi1>>
 //       CHECK:   scf.for {{.*}} {
 //       CHECK:     scf.if {{.*}} {
 //       CHECK:       %[[MASK_LOADED:.*]] = memref.load %[[MASK_CASTED]][%{{.*}}] : memref<4xvector<9xi1>>
 //       CHECK:       %[[READ:.*]] = vector.transfer_read %{{.*}}, %{{.*}}, %[[MASK_LOADED]] : memref<?x?xf32>, vector<9xf32>
 //       CHECK:       memref.store %[[READ]], %{{.*}} : memref<4xvector<9xf32>>
 //       CHECK:     }
 //       CHECK:   }
 //       CHECK:   %[[RESULT:.*]] = memref.load %{{.*}} : memref<vector<4x9xf32>>
 //       CHECK:   %[[RESULT_T:.*]] = vector.transpose %[[RESULT]], [1, 0] : vector<4x9xf32> to vector<9x4xf32>
 //       CHECK:   return %[[RESULT_T]] : vector<9x4xf32>
 
 // Vector load with mask + transpose.
 func @transfer_read_2d_mask_transposed(
     %A : memref<?x?xf32>, %base1: index, %base2: index) -> (vector<9x4xf32>) {
   %fm42 = constant -42.0: f32
   %mask = constant dense<[[1, 0, 1, 0], [0, 0, 1, 0],
                           [1, 1, 1, 1], [0, 1, 1, 0],
                           [1, 1, 1, 1], [1, 1, 1, 1],
                           [1, 1, 1, 1], [0, 0, 0, 0],
                           [1, 1, 1, 1]]> : vector<9x4xi1>
   %f = vector.transfer_read %A[%base1, %base2], %fm42, %mask
       {permutation_map = affine_map<(d0, d1) -> (d1, d0)>} :
     memref<?x?xf32>, vector<9x4xf32>
   return %f : vector<9x4xf32>
 }

mlir/test/Conversion/VectorToSCF/vector-to-scf.mlir

 // RUN: mlir-opt %s -convert-vector-to-scf -split-input-file -allow-unregistered-dialect | FileCheck %s
 // RUN: mlir-opt %s -convert-vector-to-scf=full-unroll=true -split-input-file -allow-unregistered-dialect | FileCheck %s --check-prefix=FULL-UNROLL
 
+// CHECK-LABEL: func @vector_transfer_ops_0d(
+//  CHECK-SAME:   %[[MEM:.*]]: memref<f32>) {
+func @vector_transfer_ops_0d(%M: memref<f32>) {
+    %f0 = constant 0.0 : f32
+
+//  CHECK: %[[V0:.*]] = constant dense<0{{.*}}> : vector<1xf32>
+//  CHECK: %[[R0:.*]] = scf.for %[[I:.*]] = {{.*}} iter_args(%[[V0_ITER:.*]] = %[[V0]]) -> (vector<1xf32>) {
+//  CHECK:   %[[IDX:.*]] = index_cast %[[I]] : index to i32
+//  CHECK:   %[[S:.*]] = memref.load %[[MEM]][] : memref<f32>
+//  CHECK:   %[[R_ITER:.*]] = vector.insertelement %[[S]], %[[V0_ITER]][%[[IDX]] : i32] : vector<1xf32>
+//  CHECK:   scf.yield %[[R_ITER]] : vector<1xf32>
+    %0 = vector.transfer_read %M[], %f0 {permutation_map = affine_map<(d0)->(0)>} :
+      memref<f32>, vector<1xf32>
+
+//  C-HECK: scf.for %[[J:.*]] = %{{.*}}
+//  C-HECK:   %[[JDX:.*]] = index_cast %[[J]] : index to i32
+//  C-HECK:   %[[SS:.*]] = vector.extractelement %[[R0]][%[[JDX]] : i32] : vector<1xf32>
+//  C-HECK:   memref.store %[[SS]], %[[MEM]][] : memref<f32>
+    vector.transfer_write %0, %M[] {permutation_map = affine_map<(d0)->(0)>} :
+      vector<1xf32>, memref<f32>
+
+    return
+}
+
+// -----
+
 // CHECK-LABEL: func @materialize_read_1d() {
 func @materialize_read_1d() {
   %f0 = constant 0.0: f32
   %A = memref.alloc () : memref<7x42xf32>
   affine.for %i0 = 0 to 7 step 4 {
     affine.for %i1 = 0 to 42 step 4 {
       %f1 = vector.transfer_read %A[%i0, %i1], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>
       %ip1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i1)

mlir/test/Dialect/Vector/vector-transfer-to-vector-load-store.mlir

 // RUN: mlir-opt %s -test-vector-transfer-lowering-patterns -canonicalize -split-input-file | FileCheck %s
 
 // CHECK-LABEL: func @vector_transfer_ops_0d(
 //  CHECK-SAME:   %[[MEM:.*]]: memref<f32>) {
 func @vector_transfer_ops_0d(%M: memref<f32>) {
     %f0 = constant 0.0 : f32
 
 //  CHECK-NEXT:   %[[V:.*]] = memref.load %[[MEM]][] : memref<f32>
     %0 = vector.transfer_read %M[], %f0 {permutation_map = affine_map<(d0)->(0)>} :
       memref<f32>, vector<1xf32>
 
 //  CHECK-NEXT:   memref.store %[[V]], %[[MEM]][] : memref<f32>
     vector.transfer_write %0, %M[] {permutation_map = affine_map<(d0)->(0)>} :
       vector<1xf32>, memref<f32>
-  
     return
 }
 
 // -----
 
 // transfer_read/write are lowered to vector.load/store
 // CHECK-LABEL:   func @transfer_to_load(
 // CHECK-SAME:                                %[[MEM:.*]]: memref<8x8xf32>,