[mlir][vector] Add more tests for ConvertVectorToLLVM (8/n) #111997
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
banach-space
requested review from
dcaballe and
nicolasvasilache
as code owners
banach-space
requested review from
nujaa
and removed request for
nicolasvasilache and
dcaballe
Adds tests with scalable vectors for the Vector-To-LLVM conversion pass.
Covers the following Ops:
* vector.transfer_read
* vector.transfer_write
In addition:
* Tests that test both xfer_read and xfer_write have their names
updated to capture that (e.g. `@transfer_read_1d_mask` ->
`@transfer_read_write_1d_mask`)
* `@transfer_write_1d_scalable_mask` and
`@transfer_read_1d_scalable_mask` are re-written as
`@transfer_read_write_1d_mask_scalable`. This is to make it clear
that this case is meant to complement
`@transfer_read_write_1d_mask`.
* `@transfer_write_tensor` is updated to also test `xfer_read`.
|
@llvm/pr-subscribers-mlir Author: Andrzej Warzyński (banach-space) Changes
Patch is 37.24 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/111997.diff 1 Files Affected:
diff --git a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir
index ae1d6fe8bd1672..a63068efe0ba76 100644
--- a/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir
+++ b/mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir
@@ -2001,6 +2001,37 @@ func.func @vector_fma(%a: vector<8xf32>, %b: vector<2x4xf32>, %c: vector<1x1x1xf
return %0, %1, %2, %3: vector<8xf32>, vector<2x4xf32>, vector<1x1x1xf32>, vector<f32>
}
+func.func @vector_fma_scalable(%a: vector<[8]xf32>, %b: vector<2x[4]xf32>, %c: vector<1x1x[1]xf32>, %d: vector<f32>) -> (vector<[8]xf32>, vector<2x[4]xf32>, vector<1x1x[1]xf32>) {
+ // CHECK-LABEL: @vector_fma_scalable
+ // CHECK-SAME: %[[A:.*]]: vector<[8]xf32>
+ // CHECK-SAME: %[[B:.*]]: vector<2x[4]xf32>
+ // CHECK-SAME: %[[C:.*]]: vector<1x1x[1]xf32>
+ // CHECK: %[[BL:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x[4]xf32> to !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: llvm.intr.fmuladd
+ // CHECK-SAME: (vector<[8]xf32>, vector<[8]xf32>, vector<[8]xf32>) -> vector<[8]xf32>
+ %0 = vector.fma %a, %a, %a : vector<[8]xf32>
+
+ // CHECK: %[[b00:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b01:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b02:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[B0:.*]] = llvm.intr.fmuladd(%[[b00]], %[[b01]], %[[b02]]) :
+ // CHECK-SAME: (vector<[4]xf32>, vector<[4]xf32>, vector<[4]xf32>) -> vector<[4]xf32>
+ // CHECK: llvm.insertvalue %[[B0]], {{.*}}[0] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b10:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b11:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[b12:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<[4]xf32>>
+ // CHECK: %[[B1:.*]] = llvm.intr.fmuladd(%[[b10]], %[[b11]], %[[b12]]) :
+ // CHECK-SAME: (vector<[4]xf32>, vector<[4]xf32>, vector<[4]xf32>) -> vector<[4]xf32>
+ // CHECK: llvm.insertvalue %[[B1]], {{.*}}[1] : !llvm.array<2 x vector<[4]xf32>>
+ %1 = vector.fma %b, %b, %b : vector<2x[4]xf32>
+
+ // CHECK: %[[C0:.*]] = llvm.intr.fmuladd
+ // CHECK-SAME: (vector<[1]xf32>, vector<[1]xf32>, vector<[1]xf32>) -> vector<[1]xf32>
+ %2 = vector.fma %c, %c, %c : vector<1x1x[1]xf32>
+
+ return %0, %1, %2: vector<[8]xf32>, vector<2x[4]xf32>, vector<1x1x[1]xf32>
+}
+
// -----
func.func @reduce_0d_f32(%arg0: vector<f32>) -> f32 {
@@ -2028,6 +2059,17 @@ func.func @reduce_f16(%arg0: vector<16xf16>) -> f16 {
// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f16, vector<16xf16>) -> f16
// CHECK: return %[[V]] : f16
+func.func @reduce_f16_scalable(%arg0: vector<[16]xf16>) -> f16 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xf16> into f16
+ return %0 : f16
+}
+// CHECK-LABEL: @reduce_f16_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf16>)
+// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f16) : f16
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
+// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f16, vector<[16]xf16>) -> f16
+// CHECK: return %[[V]] : f16
+
// -----
func.func @reduce_f32(%arg0: vector<16xf32>) -> f32 {
@@ -2041,6 +2083,17 @@ func.func @reduce_f32(%arg0: vector<16xf32>) -> f32 {
// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<16xf32>) -> f32
// CHECK: return %[[V]] : f32
+func.func @reduce_f32_scalable(%arg0: vector<[16]xf32>) -> f32 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>)
+// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
+// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<[16]xf32>) -> f32
+// CHECK: return %[[V]] : f32
+
// -----
func.func @reduce_f64(%arg0: vector<16xf64>) -> f64 {
@@ -2054,6 +2107,17 @@ func.func @reduce_f64(%arg0: vector<16xf64>) -> f64 {
// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f64, vector<16xf64>) -> f64
// CHECK: return %[[V]] : f64
+func.func @reduce_f64_scalable(%arg0: vector<[16]xf64>) -> f64 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xf64> into f64
+ return %0 : f64
+}
+// CHECK-LABEL: @reduce_f64_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf64>)
+// CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : f64
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
+// CHECK-SAME: <{fastmathFlags = #llvm.fastmath<none>}> : (f64, vector<[16]xf64>) -> f64
+// CHECK: return %[[V]] : f64
+
// -----
func.func @reduce_i8(%arg0: vector<16xi8>) -> i8 {
@@ -2065,6 +2129,15 @@ func.func @reduce_i8(%arg0: vector<16xi8>) -> i8 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
// CHECK: return %[[V]] : i8
+func.func @reduce_i8_scalable(%arg0: vector<[16]xi8>) -> i8 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xi8> into i8
+ return %0 : i8
+}
+// CHECK-LABEL: @reduce_i8_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi8>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
+// CHECK: return %[[V]] : i8
+
// -----
func.func @reduce_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2076,6 +2149,15 @@ func.func @reduce_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <add>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2088,6 +2170,16 @@ func.func @reduce_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.add %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <add>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
+// CHECK: %[[V:.*]] = llvm.add %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_mul_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2099,6 +2191,15 @@ func.func @reduce_mul_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_mul_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <mul>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_mul_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_mul_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2111,6 +2212,16 @@ func.func @reduce_mul_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.mul %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_mul_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <mul>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_mul_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.mul"(%[[A]])
+// CHECK: %[[V:.*]] = llvm.mul %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_fmaximum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
@@ -2123,6 +2234,16 @@ func.func @reduce_fmaximum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
// CHECK: %[[R:.*]] = llvm.intr.maximum(%[[V]], %[[B]]) : (f32, f32) -> f32
// CHECK: return %[[R]] : f32
+func.func @reduce_fmaximum_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {
+ %0 = vector.reduction <maximumf>, %arg0, %arg1 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_fmaximum_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmaximum(%[[A]]) : (vector<[16]xf32>) -> f32
+// CHECK: %[[R:.*]] = llvm.intr.maximum(%[[V]], %[[B]]) : (f32, f32) -> f32
+// CHECK: return %[[R]] : f32
+
// -----
func.func @reduce_fminimum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
@@ -2135,6 +2256,16 @@ func.func @reduce_fminimum_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
// CHECK: %[[R:.*]] = llvm.intr.minimum(%[[V]], %[[B]]) : (f32, f32) -> f32
// CHECK: return %[[R]] : f32
+func.func @reduce_fminimum_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {
+ %0 = vector.reduction <minimumf>, %arg0, %arg1 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_fminimum_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fminimum(%[[A]]) : (vector<[16]xf32>) -> f32
+// CHECK: %[[R:.*]] = llvm.intr.minimum(%[[V]], %[[B]]) : (f32, f32) -> f32
+// CHECK: return %[[R]] : f32
+
// -----
func.func @reduce_fmax_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
@@ -2147,6 +2278,16 @@ func.func @reduce_fmax_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
// CHECK: %[[R:.*]] = llvm.intr.maxnum(%[[V]], %[[B]]) : (f32, f32) -> f32
// CHECK: return %[[R]] : f32
+func.func @reduce_fmax_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {
+ %0 = vector.reduction <maxnumf>, %arg0, %arg1 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_fmax_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmax(%[[A]]) : (vector<[16]xf32>) -> f32
+// CHECK: %[[R:.*]] = llvm.intr.maxnum(%[[V]], %[[B]]) : (f32, f32) -> f32
+// CHECK: return %[[R]] : f32
+
// -----
func.func @reduce_fmin_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
@@ -2159,6 +2300,16 @@ func.func @reduce_fmin_f32(%arg0: vector<16xf32>, %arg1: f32) -> f32 {
// CHECK: %[[R:.*]] = llvm.intr.minnum(%[[V]], %[[B]]) : (f32, f32) -> f32
// CHECK: return %[[R]] : f32
+func.func @reduce_fmin_f32_scalable(%arg0: vector<[16]xf32>, %arg1: f32) -> f32 {
+ %0 = vector.reduction <minnumf>, %arg0, %arg1 : vector<[16]xf32> into f32
+ return %0 : f32
+}
+// CHECK-LABEL: @reduce_fmin_f32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xf32>, %[[B:.*]]: f32)
+// CHECK: %[[V:.*]] = llvm.intr.vector.reduce.fmin(%[[A]]) : (vector<[16]xf32>) -> f32
+// CHECK: %[[R:.*]] = llvm.intr.minnum(%[[V]], %[[B]]) : (f32, f32) -> f32
+// CHECK: return %[[R]] : f32
+
// -----
func.func @reduce_minui_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2170,6 +2321,15 @@ func.func @reduce_minui_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_minui_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <minui>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_minui_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_minui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2183,6 +2343,17 @@ func.func @reduce_minui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_minui_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <minui>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_minui_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.umin"(%[[A]])
+// CHECK: %[[S:.*]] = llvm.icmp "ule" %[[ACC]], %[[R]]
+// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_maxui_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2194,6 +2365,15 @@ func.func @reduce_maxui_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_maxui_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <maxui>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_maxui_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_maxui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2207,6 +2387,17 @@ func.func @reduce_maxui_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_maxui_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <maxui>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_maxui_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.umax"(%[[A]])
+// CHECK: %[[S:.*]] = llvm.icmp "uge" %[[ACC]], %[[R]]
+// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_minsi_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2218,6 +2409,15 @@ func.func @reduce_minsi_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_minsi_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <minsi>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_minsi_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_minsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2231,6 +2431,17 @@ func.func @reduce_minsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_minsi_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <minsi>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_minsi_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.smin"(%[[A]])
+// CHECK: %[[S:.*]] = llvm.icmp "sle" %[[ACC]], %[[R]]
+// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_maxsi_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2242,6 +2453,15 @@ func.func @reduce_maxsi_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_maxsi_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <maxsi>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_maxsi_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_maxsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2255,6 +2475,17 @@ func.func @reduce_maxsi_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_maxsi_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <maxsi>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_maxsi_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.smax"(%[[A]])
+// CHECK: %[[S:.*]] = llvm.icmp "sge" %[[ACC]], %[[R]]
+// CHECK: %[[V:.*]] = llvm.select %[[S]], %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_and_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2266,6 +2497,15 @@ func.func @reduce_and_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_and_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <and>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_and_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_and_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2278,6 +2518,16 @@ func.func @reduce_and_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.and %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_and_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <and>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_and_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.and"(%[[A]])
+// CHECK: %[[V:.*]] = llvm.and %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_or_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2289,6 +2539,15 @@ func.func @reduce_or_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_or_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <or>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_or_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_or_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
@@ -2301,6 +2560,16 @@ func.func @reduce_or_acc_i32(%arg0: vector<16xi32>, %arg1 : i32) -> i32 {
// CHECK: %[[V:.*]] = llvm.or %[[ACC]], %[[R]]
// CHECK: return %[[V]] : i32
+func.func @reduce_or_acc_i32_scalable(%arg0: vector<[16]xi32>, %arg1 : i32) -> i32 {
+ %0 = vector.reduction <or>, %arg0, %arg1 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_or_acc_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>, %[[ACC:.*]]: i32)
+// CHECK: %[[R:.*]] = "llvm.intr.vector.reduce.or"(%[[A]])
+// CHECK: %[[V:.*]] = llvm.or %[[ACC]], %[[R]]
+// CHECK: return %[[V]] : i32
+
// -----
func.func @reduce_xor_i32(%arg0: vector<16xi32>) -> i32 {
@@ -2312,6 +2581,15 @@ func.func @reduce_xor_i32(%arg0: vector<16xi32>) -> i32 {
// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.xor"(%[[A]])
// CHECK: return %[[V]] : i32
+func.func @reduce_xor_i32_scalable(%arg0: vector<[16]xi32>) -> i32 {
+ %0 = vector.reduction <xor>, %arg0 : vector<[16]xi32> into i32
+ return %0 : i32
+}
+// CHECK-LABEL: @reduce_xor_i32_scalable(
+// CHECK-SAME: %[[A:.*]]: vector<[16]xi32>)
+// CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.xor"(%[[A]])
+// CHECK: ret...
[truncated]
|
banach-space
force-pushed
the
andrzej/extend_vector_to_llvm_test_8
branch
from
455a109 to
b260218
Compare
banach-space
changed the title
javedabsar1
requested changes
Oct 14, 2024
| // CHECK-SAME: %[[BASE:.*]]: index) -> vector<[17]xf32> | ||
| // CHECK: %[[C7:.*]] = arith.constant 7.0 | ||
| // | ||
| // 1. Let dim be the memref dimension, compute the in-bound index (dim - offset) |
There was a problem hiding this comment.
I like this commenting style of explaining sections of CHECKS.
| // | ||
| // 1. Let dim be the memref dimension, compute the in-bound index (dim - offset) | ||
| // CHECK: %[[C0:.*]] = arith.constant 0 : index | ||
| // CHECK: %[[DIM:.*]] = memref.dim %[[MEM]], %[[C0]] : memref<?xf32> |
There was a problem hiding this comment.
nit. commiting to tab space before ' CHECK' reduces readability for long lines unnecessarily. maybe reduce to ' CHECK'.
There was a problem hiding this comment.
This is actually just replicating the format of the previous test. So, if I was to update one, I'd need to update the other. But I really want to avoid the churn (there's been a lot of that already 😅 ).
| @@ -2377,7 +2377,7 @@ func.func @matrix_ops_index(%A: vector<64xindex>, %B: vector<48xindex>) -> vecto | |||
|
|
|||
| // ----- | |||
|
|
|||
| func.func @transfer_read_1d(%A : memref<?xf32>, %base: index) -> vector<17xf32> { | |||
| func.func @transfer_read_write_1d(%A : memref<?xf32>, %base: index) -> vector<17xf32> { | |||
There was a problem hiding this comment.
This file has become too big. Would you consider separating 'vector-transer-to-llvm.mlir like existing vector-mask-to-llvm ?
There was a problem hiding this comment.
Great suggestion, see the latest commit :)
Create a dedicated file for xfer tests
…8/n) Add missing tests in vector-xfer-to-llvm.mlir, remove duplicates from vector-mask-to-llvm.mlir
DanielCChen
pushed a commit
to DanielCChen/llvm-project
that referenced
this pull request
Oct 16, 2024
) Adds tests with scalable vectors for the Vector-To-LLVM conversion pass. Covers the following Ops: * `vector.transfer_read`, * `vector.transfer_write`. In addition: * Duplicate tests from "vector-mask-to-llvm.mlir" are removed. * Tests for xfer_read/xfer_write are moved to a newly created test file, "vector-xfer-to-llvm.mlir". This follows an existing pattern among VectorToLLVM conversion tests. * Tests that test both xfer_read and xfer_write have their names updated to capture that (e.g. @transfer_read_1d_mask -> @transfer_read_write_1d_mask) * @transfer_write_1d_scalable_mask and @transfer_read_1d_scalable_mask are re-written as @transfer_read_write_1d_mask_scalable. This is to make it clear that this case is meant to complement @transfer_read_write_1d_mask. * @transfer_write_tensor is updated to also test xfer_read.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Adds tests with scalable vectors for the Vector-To-LLVM conversion pass.
Covers the following Ops:
In addition:
"vector-xfer-to-llvm.mlir". This follows an existing pattern among
VectorToLLVM conversion tests.
updated to capture that (e.g.
@transfer_read_1d_mask->@transfer_read_write_1d_mask)@transfer_write_1d_scalable_maskand@transfer_read_1d_scalable_maskare re-written as@transfer_read_write_1d_mask_scalable. This is to make it clearthat this case is meant to complement
@transfer_read_write_1d_mask.@transfer_write_tensoris updated to also testxfer_read.