1048 lines · plain
1// RUN: mlir-opt --verify-each --split-input-file -pass-pipeline="builtin.module(func.func(tosa-to-linalg-named))" %s -verify-diagnostics -o -| FileCheck %s2// RUN: mlir-opt --verify-each --split-input-file -pass-pipeline="builtin.module(func.func(tosa-to-linalg-named{prefer-conv2d-kernel-layout-hwcf=true}))" %s -verify-diagnostics -o -| FileCheck --check-prefix="HWCF" %s3// RUN: mlir-opt --verify-each --split-input-file -pass-pipeline="builtin.module(func.func(tosa-to-linalg-named,cse))" %s -verify-diagnostics -o -| FileCheck --check-prefix="CHECK-CSE" %s4 5// CHECK-LABEL: @matmul6func.func @matmul(%arg0: tensor<1x5x3xf32>, %arg1: tensor<1x3x6xf32>) -> (tensor<1x5x6xf32>) {7 // CHECK: [[C0:%.+]] = arith.constant 08 // CHECK: [[INIT:%.+]] = tensor.empty()9 // CHECK: [[FILLED:%.+]] = linalg.fill ins([[C0]] : f32) outs([[INIT]] : tensor<1x5x6xf32>) -> tensor<1x5x6xf32>10 // CHECK: linalg.batch_matmul ins(%arg0, %arg1 : tensor<1x5x3xf32>, tensor<1x3x6xf32>) outs([[FILLED]] : tensor<1x5x6xf32>) -> tensor<1x5x6xf32>11 %a_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>12 %b_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>13 %0 = tosa.matmul %arg0, %arg1, %a_zp, %b_zp : (tensor<1x5x3xf32>, tensor<1x3x6xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x5x6xf32>14 return %0 : tensor<1x5x6xf32>15}16 17// -----18 19 20// CHECK-LABEL: @matmul_quantized21func.func @matmul_quantized(%arg0: tensor<1x5x3xi8>, %arg1: tensor<1x3x6xi8>) -> (tensor<1x5x6xi32>) {22 // CHECK: [[C0:%.+]] = arith.constant 023 // CHECK: [[INIT:%.+]] = tensor.empty()24 // CHECK: [[FILLED:%.+]] = linalg.fill ins([[C0]] : i32) outs([[INIT]] : tensor<1x5x6xi32>) -> tensor<1x5x6xi32>25 // CHECK: [[ONE:%.+]] = arith.constant 126 // CHECK: [[TWO:%.+]] = arith.constant 227 // CHECK: linalg.quantized_batch_matmul ins(%arg0, %arg1, [[ONE]], [[TWO]] : tensor<1x5x3xi8>, tensor<1x3x6xi8>, i32, i32) outs([[FILLED]] : tensor<1x5x6xi32>) -> tensor<1x5x6xi32>28 %a_zp = "tosa.const"() <{values = dense<1> : tensor<1xi8>}> : () -> tensor<1xi8>29 %b_zp = "tosa.const"() <{values = dense<2> : tensor<1xi8>}> : () -> tensor<1xi8>30 %0 = tosa.matmul %arg0, %arg1, %a_zp, %b_zp : (tensor<1x5x3xi8>, tensor<1x3x6xi8>, tensor<1xi8>, tensor<1xi8>) -> tensor<1x5x6xi32>31 return %0 : tensor<1x5x6xi32>32}33 34// -----35 36// CHECK-LABEL: @matmul_dyn_batch37func.func @matmul_dyn_batch(%arg0: tensor<?x5x3xf32>, %arg1: tensor<?x3x6xf32>) -> (tensor<?x5x6xf32>) {38 // CHECK: %[[C0:.+]] = arith.constant 039 // CHECK: %[[DIM:.+]] = tensor.dim %arg0, %[[C0]]40 // CHECK: %[[C0_0:.+]] = arith.constant 041 // CHECK: %[[INIT:.+]] = tensor.empty(%[[DIM]])42 // CHECK: %[[FILLED:.+]] = linalg.fill ins(%[[C0_0]] : f32) outs(%[[INIT]] : tensor<?x5x6xf32>) -> tensor<?x5x6xf32>43 // CHECK: linalg.batch_matmul ins(%arg0, %arg1 : tensor<?x5x3xf32>, tensor<?x3x6xf32>) outs(%[[FILLED]] : tensor<?x5x6xf32>) -> tensor<?x5x6xf32>44 %a_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>45 %b_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>46 %0 = tosa.matmul %arg0, %arg1, %a_zp, %b_zp : (tensor<?x5x3xf32>, tensor<?x3x6xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<?x5x6xf32>47 return %0 : tensor<?x5x6xf32>48}49 50// -----51 52// CHECK-LABEL: @matmul_dyn_independent_dim53func.func @matmul_dyn_independent_dim(%arg0: tensor<1x5x3xf32>, %arg1: tensor<1x3x?xf32>) -> (tensor<1x5x?xf32>) {54 // CHECK: %[[C2:.+]] = arith.constant 255 // CHECK: %[[DIM:.+]] = tensor.dim %arg1, %[[C2]]56 // CHECK: %[[C0:.+]] = arith.constant 057 // CHECK: %[[INIT:.+]] = tensor.empty(%[[DIM]])58 // CHECK: %[[FILLED:.+]] = linalg.fill ins(%[[C0]] : f32) outs(%[[INIT]] : tensor<1x5x?xf32>) -> tensor<1x5x?xf32>59 // CHECK: linalg.batch_matmul ins(%arg0, %arg1 : tensor<1x5x3xf32>, tensor<1x3x?xf32>) outs(%[[FILLED]] : tensor<1x5x?xf32>) -> tensor<1x5x?xf32>60 %a_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>61 %b_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>62 %0 = tosa.matmul %arg0, %arg1, %a_zp, %b_zp : (tensor<1x5x3xf32>, tensor<1x3x?xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x5x?xf32>63 return %0 : tensor<1x5x?xf32>64}65 66// -----67 68// CHECK-LABEL: @matmul_dyn_independent_dim69func.func @matmul_dyn_independent_dim(%arg0: tensor<1x5x?xf32>, %arg1: tensor<1x?x6xf32>) -> (tensor<1x5x6xf32>) {70 // CHECK: %[[C0:.+]] = arith.constant 071 // CHECK: %[[INIT:.+]] = tensor.empty()72 // CHECK: %[[FILLED:.+]] = linalg.fill ins(%[[C0]] : f32) outs(%[[INIT]] : tensor<1x5x6xf32>) -> tensor<1x5x6xf32>73 // CHECK: linalg.batch_matmul ins(%arg0, %arg1 : tensor<1x5x?xf32>, tensor<1x?x6xf32>) outs(%[[FILLED]] : tensor<1x5x6xf32>) -> tensor<1x5x6xf32>74 %a_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>75 %b_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>76 %0 = tosa.matmul %arg0, %arg1, %a_zp, %b_zp : (tensor<1x5x?xf32>, tensor<1x?x6xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x5x6xf32>77 return %0 : tensor<1x5x6xf32>78}79 80// -----81 82// CHECK-LABEL: @matmul_dyn_output83func.func @matmul_dyn_output(%arg0: tensor<1x1x8xf32>, %arg1: tensor<1x8x1xf32>) -> tensor<?x1x1xf32> {84 // CHECK: %[[C0:.+]] = arith.constant 0 : index85 // CHECK: %[[DIM0:.+]] = tensor.dim %arg0, %[[C0]] : tensor<1x1x8xf32>86 // CHECK: %[[CST:.+]] = arith.constant 0.000000e+00 : f3287 // CHECK: %[[INIT:.+]] = tensor.empty(%[[DIM0]]) : tensor<?x1x1xf32>88 // CHECK: %[[FILLED:.+]] = linalg.fill ins(%[[CST]] : f32) outs(%[[INIT]] : tensor<?x1x1xf32>) -> tensor<?x1x1xf32>89 // CHECK: linalg.batch_matmul ins(%arg0, %arg1 : tensor<1x1x8xf32>, tensor<1x8x1xf32>) outs(%[[FILLED]] : tensor<?x1x1xf32>) -> tensor<?x1x1xf32>90 %a_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>91 %b_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>92 %0 = tosa.matmul %arg0, %arg1, %a_zp, %b_zp : (tensor<1x1x8xf32>, tensor<1x8x1xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<?x1x1xf32>93 return %0 : tensor<?x1x1xf32>94}95 96// -----97 98// CHECK-LABEL: @max_pool99func.func @max_pool(%arg0: tensor<1x6x34x62xf32>) -> () {100 // CHECK-DAG: [[CONST:%.+]] = arith.constant -3.40282347E+38101 // CHECK-DAG: [[INIT:%.+]] = tensor.empty()102 // CHECK-DAG: [[FILL:%.+]] = linalg.fill ins([[CONST]]{{.*}}outs([[INIT]]103 // CHECK-DAG: [[KERNEL:%.+]] = tensor.empty()104 // CHECK: linalg.pooling_nhwc_max {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%arg0, [[KERNEL]] : tensor<1x6x34x62xf32>, tensor<3x3xf32>) outs([[FILL]] : tensor<1x4x32x62xf32>)105 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 0>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>} : (tensor<1x6x34x62xf32>) -> tensor<1x4x32x62xf32>106 return107}108 109// CHECK-LABEL: @max_pool_padded110func.func @max_pool_padded(%arg0: tensor<1x6x34x62xf32>) -> () {111 // CHECK-DAG: [[CONST:%.+]] = arith.constant -3.40282347E+38 : f32112 // CHECK-DAG: [[PAD:%.+]] = tensor.pad %arg0 low[0, 0, 0, 0] high[0, 0, 1, 0]113 // CHECK-DAG: tensor.yield [[CONST]]114 // CHECK-DAG: [[INITVAL:%.+]] = arith.constant -3.40282347E+38 : f32115 // CHECK-DAG: [[INIT:%.+]] = tensor.empty()116 // CHECK-DAG: [[FILL:%.+]] = linalg.fill ins([[INITVAL]]{{.*}}outs([[INIT]]117 // CHECK-DAG: [[KERNEL:%.+]] = tensor.empty()118 // CHECK: linalg.pooling_nhwc_max {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins([[PAD]], [[KERNEL]] : tensor<1x6x35x62xf32>, tensor<3x3xf32>) outs([[FILL]] : tensor<1x4x33x62xf32>)119 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 1>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>} : (tensor<1x6x34x62xf32>) -> tensor<1x4x33x62xf32>120 return121}122 123// CHECK-LABEL: @max_pool_dyn124func.func @max_pool_dyn(%arg0: tensor<?x6x34x62xf32>) -> () {125 // CHECK: %[[C0:.+]] = arith.constant 0126 // CHECK: %[[BATCH:.+]] = tensor.dim %arg0, %[[C0]]127 // CHECK: %[[CONST:.+]] = arith.constant -3.40282347E+38128 // CHECK: %[[INIT:.+]] = tensor.empty(%[[BATCH]])129 // CHECK: %[[FILL:.+]] = linalg.fill ins(%[[CONST]]{{.*}}outs(%[[INIT]]130 // CHECK: %[[KERNEL:.+]] = tensor.empty()131 // CHECK: linalg.pooling_nhwc_max {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%arg0, %[[KERNEL]] : tensor<?x6x34x62xf32>, tensor<3x3xf32>) outs(%[[FILL]] : tensor<?x4x32x62xf32>)132 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 0>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>} : (tensor<?x6x34x62xf32>) -> tensor<?x4x32x62xf32>133 return134}135 136// CHECK-LABEL: @max_pool_i8137func.func @max_pool_i8(%arg0: tensor<1x6x34x62xi8>) -> () {138 // CHECK: arith.constant -128139 // CHECK: linalg.pooling_nhwc_max140 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 0>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>} : (tensor<1x6x34x62xi8>) -> tensor<1x4x32x62xi8>141 return142}143 144// CHECK-LABEL: @max_pool_ui8145func.func @max_pool_ui8(%arg0: tensor<1x6x34x62xui8>) -> tensor<1x4x32x62xui8> {146 // CHECK: builtin.unrealized_conversion_cast {{.*}} : tensor<1x6x34x62xui8> to tensor<1x6x34x62xi8>147 // CHECK: arith.constant 0148 // CHECK: linalg.pooling_nhwc_max_unsigned149 // CHECK-SAME: ins({{.*}} : tensor<1x6x34x62xi8>, tensor<3x3xi8>)150 // CHECK-SAME: outs({{.*}} : tensor<1x4x32x62xi8>)151 // CHECK-SAME: -> tensor<1x4x32x62xi8>152 // CHECK: builtin.unrealized_conversion_cast {{.*}} : tensor<1x4x32x62xi8> to tensor<1x4x32x62xui8>153 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 0>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>} : (tensor<1x6x34x62xui8>) -> tensor<1x4x32x62xui8>154 return %0 : tensor<1x4x32x62xui8>155}156 157// CHECK-LABEL: @max_pool_i16158func.func @max_pool_i16(%arg0: tensor<1x6x34x62xi16>) -> () {159 // CHECK: arith.constant -32768160 // CHECK: linalg.pooling_nhwc_max161 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 0>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>} : (tensor<1x6x34x62xi16>) -> tensor<1x4x32x62xi16>162 return163}164 165// CHECK-LABEL: @max_pool_i32166func.func @max_pool_i32(%arg0: tensor<1x6x34x62xi32>) -> () {167 // CHECK: arith.constant -2147483648168 // CHECK: linalg.pooling_nhwc_max169 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 0>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>} : (tensor<1x6x34x62xi32>) -> tensor<1x4x32x62xi32>170 return171}172 173// CHECK-CSE-LABEL: @max_pool_all_dynamic174func.func @max_pool_all_dynamic(%arg0: tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32> {175 // Batch size176 // CHECK-CSE: %[[C0:.+]] = arith.constant 0 : index177 // CHECK-CSE: %[[BATCH:.+]] = tensor.dim %arg0, %[[C0]] : tensor<?x?x?x?xf32>178 179 // Compute output height180 // CHECK-CSE: %[[C1:.+]] = arith.constant 1 : index181 // CHECK-CSE: %[[IH:.+]] = tensor.dim %arg0, %[[C1]] : tensor<?x?x?x?xf32>182 // CHECK-CSE: %[[C2:.+]] = arith.constant 2 : index183 // CHECK-CSE: %[[PADDED_BEFORE:.+]] = arith.addi %[[IH]], %[[C0]] : index184 // CHECK-CSE: %[[PADDED_AFTER:.+]] = arith.addi %[[PADDED_BEFORE]], %[[C0]] : index185 // CHECK-CSE: %[[SUB_ONE:.+]] = arith.subi %[[C2]], %[[C1]] : index186 // CHECK-CSE: %[[DILATED:.+]] = arith.muli %[[C1]], %[[SUB_ONE]] : index187 // CHECK-CSE: %[[ADD_ONE:.+]] = arith.addi %[[DILATED]], %[[C1]] : index188 // CHECK-CSE: %[[SUBTRACT:.+]] = arith.subi %[[PADDED_AFTER]], %[[ADD_ONE]] : index189 // CHECK-CSE: %[[DIVIDE:.+]] = arith.divui %[[SUBTRACT]], %[[C1]] : index190 // CHECK-CSE: %[[HEIGHT:.+]] = arith.addi %[[DIVIDE]], %[[C1]] : index191 192 // Compute output width193 // CHECK-CSE: %[[IW:.+]] = tensor.dim %arg0, %[[C2]] : tensor<?x?x?x?xf32>194 // CHECK-CSE: %[[C5:.+]] = arith.constant 5 : index195 // CHECK-CSE: %[[PADDED_BEFORE:.+]] = arith.addi %[[IW]], %[[C2]] : index196 // CHECK-CSE: %[[PADDED_AFTER:.+]] = arith.addi %[[PADDED_BEFORE]], %[[C2]] : index197 // CHECK-CSE: %[[SUB_ONE:.+]] = arith.subi %[[C5]], %[[C1]] : index198 // CHECK-CSE: %[[DILATED:.+]] = arith.muli %[[C1]], %[[SUB_ONE]] : index199 // CHECK-CSE: %[[ADD_ONE:.+]] = arith.addi %[[DILATED]], %[[C1]] : index200 // CHECK-CSE: %[[SUBTRACT:.+]] = arith.subi %[[PADDED_AFTER]], %[[ADD_ONE]] : index201 // CHECK-CSE: %[[DIVIDE:.+]] = arith.divui %[[SUBTRACT]], %[[C1]] : index202 // CHECK-CSE: %[[WIDTH:.+]] = arith.addi %14, %[[C1]] : index203 204 // Channel size205 // CHECK-CSE: %[[C3:.+]] = arith.constant 3 : index206 // CHECK-CSE: %[[CHANNEL:.+]] = tensor.dim %arg0, %[[C3]] : tensor<?x?x?x?xf32>207 208 // Pad the input209 // CHECK-CSE: %[[FLOAT_MIN:.+]] = arith.constant -3.40282347E+38 : f32210 // CHECK-CSE: %[[PADDED:.+]] = tensor.pad %arg0 low[0, 0, 2, 0] high[0, 0, 2, 0] {211 // CHECK-CSE: tensor.yield %[[FLOAT_MIN]] : f32212 213 // Allocate the output and fill with minimum value214 // CHECK-CSE: %[[INIT:.+]] = tensor.empty(%[[BATCH]], %[[HEIGHT]], %[[WIDTH]], %[[CHANNEL]]) : tensor<?x?x?x?xf32>215 // CHECK-CSE: %[[FILL:.+]] = linalg.fill ins(%[[FLOAT_MIN]] : f32) outs(%[[INIT]] : tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32>216 // CHECK-CSE: %[[FAKE_WINDOW:.+]] = tensor.empty() : tensor<2x5xf32>217 218 // Compute max pool219 // CHECK-CSE: %[[OUT:.+]] = linalg.pooling_nhwc_max {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%[[PADDED]], %[[FAKE_WINDOW]] : tensor<?x?x?x?xf32>, tensor<2x5xf32>) outs(%[[FILL]] : tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32>220 // CHECK-CSE: return %[[OUT]]221 222 %0 = tosa.max_pool2d %arg0 {kernel = array<i64: 2, 5>, pad = array<i64: 0, 0, 2, 2>, stride = array<i64: 1, 1>} : (tensor<?x?x?x?xf32>) -> tensor<?x?x?x?xf32>223 return %0 : tensor<?x?x?x?xf32>224}225 226// -----227 228// CHECK-LABEL: @avg_pool_f32229func.func @avg_pool_f32(%arg0: tensor<1x6x34x62xf32>) -> (tensor<1x5x33x62xf32>) {230 // Apply padding to the input:231 // CHECK: %[[F0:.+]] = arith.constant 0.000000e+00 : f32232 // CHECK: %[[PAD:.+]] = tensor.pad %arg0 low[0, 1, 1, 0] high[0, 1, 1, 0]233 // CHECK: tensor.yield %[[F0]] : f32234 235 // Fill the pooling target:236 // CHECK: %[[F0:.+]] = arith.constant 0.000000e+00 : f32237 // CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<1x5x33x62xf32>238 // CHECK: %[[FILL:.+]] = linalg.fill ins(%[[F0]] : f32) outs(%[[EMPTY]] : tensor<1x5x33x62xf32>)239 240 // Compute the sum padding:241 // CHECK: %[[KERNEL:.+]] = tensor.empty() : tensor<4x4xf32>242 // CHECK: %[[POOL:.+]] = linalg.pooling_nhwc_sum243 // CHECK-SAME: dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>}244 // CHECK-SAME: ins(%[[PAD]], %[[KERNEL]] : tensor<1x8x36x62xf32>, tensor<4x4xf32>)245 // CHECK-SAME: outs(%[[FILL]] : tensor<1x5x33x62xf32>)246 247 // Compute dimension based constants:248 // CHECK: %[[I1:.+]] = arith.constant 1 : index249 // CHECK: %[[DIM1:.+]] = tensor.dim %[[POOL]], %[[I1]]250 // CHECK: %[[I2:.+]] = arith.constant 2 : index251 // CHECK: %[[DIM2:.+]] = tensor.dim %[[POOL]], %[[I2]]252 // CHECK: %[[ONE:.+]] = arith.constant 1 : index253 // CHECK: %[[HEIGHT:.+]] = arith.subi %[[DIM1]], %[[ONE]] : index254 // CHECK: %[[WIDTH:.+]] = arith.subi %[[DIM2]], %[[ONE]] : index255 256 // Divide the sum pooling by the number of summed values.257 // CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<1x5x33x62xf32>258 // CHECK: %[[GENERIC:.+]] = linalg.generic259 // CHECK-SAME: indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]}260 // CHECK-SAME: ins(%[[POOL]] : tensor<1x5x33x62xf32>)261 // CHECK-SAME: outs(%[[EMPTY]] : tensor<1x5x33x62xf32>)262 // CHECK: ^bb0(%[[IN:.+]]: f32, %{{.+}}: f32)263 // CHECK: %[[ZERO:.+]] = arith.constant 0264 265 // Compute how much of the height does not include padding:266 // CHECK: %[[STRIDE:.+]] = arith.constant 1267 // CHECK: %[[KSIZE:.+]] = arith.constant 4268 // CHECK: %[[START:.+]] = linalg.index 1269 // CHECK: %[[END:.+]] = arith.subi %[[HEIGHT]], %[[START]]270 // CHECK: %[[SRC_START:.+]] = arith.muli %[[START]], %[[STRIDE]]271 // CHECK: %[[SRC_END:.+]] = arith.muli %[[END]], %[[STRIDE]]272 // CHECK: %[[PAD_START:.+]] = arith.constant 1273 // CHECK: %[[START_SUB:.+]] = arith.subi %[[SRC_START]], %[[PAD_START]]274 // CHECK: %[[OFFSET:.+]] = arith.minsi %[[START_SUB]], %[[ZERO]]275 // CHECK: %[[START_OFFSET:.+]] = arith.addi %[[KSIZE]], %[[OFFSET]]276 // CHECK: %[[PAD_END:.+]] = arith.constant 1277 // CHECK: %[[END_SUB:.+]] = arith.subi %[[SRC_END]], %[[PAD_END]]278 // CHECK: %[[OFFSET:.+]] = arith.minsi %[[END_SUB]], %[[ZERO]]279 // CHECK: %[[END_OFFSET:.+]] = arith.addi %[[START_OFFSET]], %[[OFFSET]]280 // CHECK: %[[KHEIGHT:.+]] = arith.maxsi %[[ONE]], %[[END_OFFSET]]281 282 // Compute how much of the width does not include padding:283 // CHECK: %[[STRIDE:.+]] = arith.constant 1284 // CHECK: %[[KSIZE:.+]] = arith.constant 4285 // CHECK: %[[START:.+]] = linalg.index 2286 // CHECK: %[[END:.+]] = arith.subi %[[WIDTH]], %[[START]]287 // CHECK: %[[SRC_START:.+]] = arith.muli %[[START]], %[[STRIDE]]288 // CHECK: %[[SRC_END:.+]] = arith.muli %[[END]], %[[STRIDE]]289 // CHECK: %[[PAD_START:.+]] = arith.constant 1290 // CHECK: %[[START_SUB:.+]] = arith.subi %[[SRC_START]], %[[PAD_START]]291 // CHECK: %[[OFFSET:.+]] = arith.minsi %[[START_SUB]], %[[ZERO]]292 // CHECK: %[[START_OFFSET:.+]] = arith.addi %[[KSIZE]], %[[OFFSET]]293 // CHECK: %[[PAD_END:.+]] = arith.constant 1294 // CHECK: %[[END_SUB:.+]] = arith.subi %[[SRC_END]], %[[PAD_END]]295 // CHECK: %[[OFFSET:.+]] = arith.minsi %[[END_SUB]], %[[ZERO]]296 // CHECK: %[[END_OFFSET:.+]] = arith.addi %[[START_OFFSET]], %[[OFFSET]]297 // CHECK: %[[KWIDTH:.+]] = arith.maxsi %[[ONE]], %[[END_OFFSET]]298 299 // Divide the summed value by the number of values summed.300 // CHECK: %[[COUNT:.+]] = arith.muli %[[KHEIGHT]], %[[KWIDTH]]301 // CHECK: %[[CAST:.+]] = arith.index_cast %[[COUNT]]302 // CHECK: %[[FLT:.+]] = arith.sitofp %[[CAST]]303 // CHECK: %[[DIV:.+]] = arith.divf %[[IN]], %[[FLT]]304 // CHECK: linalg.yield %[[DIV]]305 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>306 %output_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>307 %0 = tosa.avg_pool2d %arg0, %input_zp, %output_zp {acc_type = f32, pad = array<i64: 1, 1, 1, 1>, kernel = array<i64: 4, 4>, stride = array<i64: 1, 1>} : (tensor<1x6x34x62xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x5x33x62xf32>308 return %0 : tensor<1x5x33x62xf32>309}310 311// -----312 313// CHECK-LABEL: @avg_pool_f16_f32acc314// CHECK-SAME: (%[[ARG0:[0-9a-zA-Z_]*]]:315func.func @avg_pool_f16_f32acc(%arg0: tensor<1x6x34x62xf16>) -> (tensor<1x5x33x62xf16>) {316 // Apply padding to the input:317 // CHECK: %[[F0:.+]] = arith.constant 0.000000e+00 : f16318 // CHECK: %[[PAD:.+]] = tensor.pad %arg0 low[0, 1, 1, 0] high[0, 1, 1, 0]319 // CHECK: tensor.yield %[[F0]] : f16320 321 // Fill the pooling target:322 // CHECK: %[[F0:.+]] = arith.constant 0.000000e+00 : f32323 // CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<1x5x33x62xf32>324 // CHECK: %[[FILL:.+]] = linalg.fill ins(%[[F0]] : f32) outs(%[[EMPTY]] : tensor<1x5x33x62xf32>)325 326 // Compute the sum padding:327 // CHECK: %[[KERNEL:.+]] = tensor.empty() : tensor<4x4xf32>328 // CHECK: %[[POOL:.+]] = linalg.pooling_nhwc_sum329 // CHECK-SAME: dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>}330 // CHECK-SAME: ins(%[[PAD]], %[[KERNEL]] : tensor<1x8x36x62xf16>, tensor<4x4xf32>)331 // CHECK-SAME: outs(%[[FILL]] : tensor<1x5x33x62xf32>)332 333 // Compute dimension based constants:334 // CHECK: %[[I1:.+]] = arith.constant 1 : index335 // CHECK: %[[DIM1:.+]] = tensor.dim %[[POOL]], %[[I1]]336 // CHECK: %[[I2:.+]] = arith.constant 2 : index337 // CHECK: %[[DIM2:.+]] = tensor.dim %[[POOL]], %[[I2]]338 // CHECK: %[[ONE:.+]] = arith.constant 1 : index339 // CHECK: %[[HEIGHT:.+]] = arith.subi %[[DIM1]], %[[ONE]] : index340 // CHECK: %[[WIDTH:.+]] = arith.subi %[[DIM2]], %[[ONE]] : index341 342 // Divide the sum pooling by the number of summed values.343 // CHECK: %[[EMPTY:.+]] = tensor.empty() : tensor<1x5x33x62xf16>344 // CHECK: %[[GENERIC:.+]] = linalg.generic345 // CHECK-SAME: indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]}346 // CHECK-SAME: ins(%[[POOL]] : tensor<1x5x33x62xf32>)347 // CHECK-SAME: outs(%[[EMPTY]] : tensor<1x5x33x62xf16>)348 // CHECK: ^bb0(%[[IN:.+]]: f32, %{{.+}}: f16)349 // CHECK: %[[ZERO:.+]] = arith.constant 0350 351 // Compute how much of the height does not include padding:352 // CHECK: %[[STRIDE:.+]] = arith.constant 1353 // CHECK: %[[KSIZE:.+]] = arith.constant 4354 // CHECK: %[[START:.+]] = linalg.index 1355 // CHECK: %[[END:.+]] = arith.subi %[[HEIGHT]], %[[START]]356 // CHECK: %[[SRC_START:.+]] = arith.muli %[[START]], %[[STRIDE]]357 // CHECK: %[[SRC_END:.+]] = arith.muli %[[END]], %[[STRIDE]]358 // CHECK: %[[PAD_START:.+]] = arith.constant 1359 // CHECK: %[[START_SUB:.+]] = arith.subi %[[SRC_START]], %[[PAD_START]]360 // CHECK: %[[OFFSET:.+]] = arith.minsi %[[START_SUB]], %[[ZERO]]361 // CHECK: %[[START_OFFSET:.+]] = arith.addi %[[KSIZE]], %[[OFFSET]]362 // CHECK: %[[PAD_END:.+]] = arith.constant 1363 // CHECK: %[[END_SUB:.+]] = arith.subi %[[SRC_END]], %[[PAD_END]]364 // CHECK: %[[OFFSET:.+]] = arith.minsi %[[END_SUB]], %[[ZERO]]365 // CHECK: %[[END_OFFSET:.+]] = arith.addi %[[START_OFFSET]], %[[OFFSET]]366 // CHECK: %[[KHEIGHT:.+]] = arith.maxsi %[[ONE]], %[[END_OFFSET]]367 368 // Compute how much of the width does not include padding:369 // CHECK: %[[STRIDE:.+]] = arith.constant 1370 // CHECK: %[[KSIZE:.+]] = arith.constant 4371 // CHECK: %[[START:.+]] = linalg.index 2372 // CHECK: %[[END:.+]] = arith.subi %[[WIDTH]], %[[START]]373 // CHECK: %[[SRC_START:.+]] = arith.muli %[[START]], %[[STRIDE]]374 // CHECK: %[[SRC_END:.+]] = arith.muli %[[END]], %[[STRIDE]]375 // CHECK: %[[PAD_START:.+]] = arith.constant 1376 // CHECK: %[[START_SUB:.+]] = arith.subi %[[SRC_START]], %[[PAD_START]]377 // CHECK: %[[OFFSET:.+]] = arith.minsi %[[START_SUB]], %[[ZERO]]378 // CHECK: %[[START_OFFSET:.+]] = arith.addi %[[KSIZE]], %[[OFFSET]]379 // CHECK: %[[PAD_END:.+]] = arith.constant 1380 // CHECK: %[[END_SUB:.+]] = arith.subi %[[SRC_END]], %[[PAD_END]]381 // CHECK: %[[OFFSET:.+]] = arith.minsi %[[END_SUB]], %[[ZERO]]382 // CHECK: %[[END_OFFSET:.+]] = arith.addi %[[START_OFFSET]], %[[OFFSET]]383 // CHECK: %[[KWIDTH:.+]] = arith.maxsi %[[ONE]], %[[END_OFFSET]]384 385 // Divide the summed value by the number of values summed.386 // CHECK: %[[COUNT:.+]] = arith.muli %[[KHEIGHT]], %[[KWIDTH]]387 // CHECK: %[[CAST:.+]] = arith.index_cast %[[COUNT]]388 // CHECK: %[[FLT:.+]] = arith.sitofp %[[CAST]]389 // CHECK: %[[DIV:.+]] = arith.divf %[[IN]], %[[FLT]]390 // CHECK: %[[TRUNC:.+]] = arith.truncf %[[DIV]]391 // CHECK: linalg.yield %[[TRUNC]]392 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf16>}> : () -> tensor<1xf16>393 %output_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf16>}> : () -> tensor<1xf16>394 %0 = tosa.avg_pool2d %arg0, %input_zp, %output_zp {acc_type = f32, pad = array<i64: 1, 1, 1, 1>, kernel = array<i64: 4, 4>, stride = array<i64: 1, 1>} : (tensor<1x6x34x62xf16>, tensor<1xf16>, tensor<1xf16>) -> tensor<1x5x33x62xf16>395 return %0 : tensor<1x5x33x62xf16>396}397 398// -----399 400// CHECK-LABEL: @avg_pool_i8401func.func @avg_pool_i8(%arg0: tensor<1x6x34x62xi8>) -> (tensor<1x5x33x62xi8>) {402 // CHECK: %[[GENERIC:.+]] = linalg.generic403 // CHECK-SAME: indexing_maps = [#map, #map], iterator_types = ["parallel", "parallel", "parallel", "parallel"]}404 // CHECK-SAME: ins(%[[POOL:.+]] : tensor<1x5x33x62xi32>)405 // CHECK-SAME: outs(%[[EMPTY:.+]] : tensor<1x5x33x62xi8>)406 // CHECK: ^bb0(%[[IN:.+]]: i32, %{{.+}}: i8)407 408 // Only different behavior is how the division is performed.409 // First we compute the mul and shift values for average pool:410 // CHECK: %[[COUNT:.+]] = arith.muli %{{[0-9]+}}, %{{[0-9]+}}411 // CHECK: %[[ICAST:.+]] = arith.index_cast %[[COUNT]]412 // CHECK: %[[C1:.+]] = arith.constant 1413 // CHECK: %[[C32:.+]] = arith.constant 32414 // CHECK: %[[ISUB:.+]] = arith.subi %[[ICAST]], %[[C1]]415 // CHECK: %[[CTLZ:.+]] = math.ctlz %[[ISUB]]416 // CHECK: %[[SUB:.+]] = arith.subi %[[C32]], %[[CTLZ]]417 // CHECK: %[[EXT:.+]] = arith.extui %[[SUB]]418 // CHECK: %[[CBIG:.+]] = arith.constant 1073741825419 // CHECK: %[[SHL:.+]] = arith.shli %[[CBIG]], %[[EXT]]420 // CHECK: %[[IEXT:.+]] = arith.extui %[[ICAST]]421 // CHECK: %[[DIV:.+]] = arith.divui %[[SHL]], %[[IEXT]]422 // CHECK: %[[TRUNC_MUL:.+]] = arith.trunci %[[DIV]]423 // CHECK: %[[TRUNC_SHIFT:.+]] = arith.trunci %[[SUB]]424 // CHECK: %[[C30:.+]] = arith.constant 30425 // CHECK: %[[SHIFT:.+]] = arith.addi %[[TRUNC_SHIFT]], %[[C30]] : i8426 // CHECK: %[[SCALED:.+]] = tosa.apply_scale %[[IN]], %[[TRUNC_MUL]], %[[SHIFT]] {rounding_mode = SINGLE_ROUND}427 428 // Perform the normalization.429 // CHECK: %[[CMIN:.+]] = arith.constant -128430 // CHECK: %[[CMAX:.+]] = arith.constant 127431 // CHECK: %[[LOW:.+]] = arith.maxsi %[[CMIN]], %[[SCALED]]432 // CHECK: %[[CLAMP:.+]] = arith.minsi %[[CMAX]], %[[LOW]]433 // CHECK: %[[TRUNC:.+]] = arith.trunci %[[CLAMP]]434 // CHECK: linalg.yield %[[TRUNC]]435 %input_zp = "tosa.const"() <{values = dense<0> : tensor<1xi8>}> : () -> tensor<1xi8>436 %output_zp = "tosa.const"() <{values = dense<0> : tensor<1xi8>}> : () -> tensor<1xi8>437 %0 = tosa.avg_pool2d %arg0, %input_zp, %output_zp {acc_type = i32, pad = array<i64: 1, 1, 1, 1>, kernel = array<i64: 4, 4>, stride = array<i64: 1, 1>} : (tensor<1x6x34x62xi8>, tensor<1xi8>, tensor<1xi8>) -> tensor<1x5x33x62xi8>438 return %0 : tensor<1x5x33x62xi8>439}440 441// -----442 443// CHECK-LABEL: @avg_pool_dyn444func.func @avg_pool_dyn(%arg0: tensor<?x6x34x62xf32>) -> (tensor<?x5x33x62xf32>) {445 // CHECK: %[[C0:.+]] = arith.constant 0 : index446 // CHECK: %[[BATCH:.+]] = tensor.dim %arg0, %[[C0]]447 // CHECK: %[[F0:.+]] = arith.constant 0.000000e+00 : f32448 // CHECK: %[[PADDED:.+]] = tensor.pad %arg0 low[0, 1, 1, 0] high[0, 1, 1, 0]449 // CHECK: tensor.yield %[[F0]]450 // CHECK: %[[F0:.+]] = arith.constant 0.000000e+00 : f32451 // CHECK: %[[EMPTY:.+]] = tensor.empty(%[[BATCH]]) : tensor<?x5x33x62xf32>452 // CHECK: %[[FILL:.+]] = linalg.fill ins(%[[F0]] : f32) outs(%[[EMPTY]] : tensor<?x5x33x62xf32>)453 // CHECK: %[[KERNEL:.+]] = tensor.empty() : tensor<4x4xf32>454 // CHECK: %[[POOL:.+]] = linalg.pooling_nhwc_sum455 // CHECK-SAME: dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>456 // CHECK-SAME: ins(%[[PADDED]], %[[KERNEL]] : tensor<?x8x36x62xf32>, tensor<4x4xf32>)457 // CHECK-SAME: outs(%[[FILL]] : tensor<?x5x33x62xf32>) -> tensor<?x5x33x62xf32>458 // CHECK: %[[EMPTY:.+]] = tensor.empty(%[[BATCH]]) : tensor<?x5x33x62xf32>459 // CHECK: %[[GENERIC:.+]] = linalg.generic460 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>461 %output_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>462 %0 = tosa.avg_pool2d %arg0, %input_zp, %output_zp {acc_type = f32, pad = array<i64: 1, 1, 1, 1>, kernel = array<i64: 4, 4>, stride = array<i64: 1, 1>} : (tensor<?x6x34x62xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<?x5x33x62xf32>463 return %0 : tensor<?x5x33x62xf32>464}465 466// -----467 468// CHECK: #[[$MAP1:.+]] = affine_map<(d0, d1, d2, d3) -> (0)>469// CHECK: #[[$MAP2:.+]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>470 471// CHECK-LABEL: @conv2d_scalar_bias_f32472func.func @conv2d_scalar_bias_f32(%input: tensor<1x49x42x27xf32>, %weights: tensor<28x3x3x27xf32>, %bias: tensor<1xf32>) -> () {473 // CHECK: %[[INIT:.+]] = tensor.empty() : tensor<1x45x40x28xf32>474 // CHECK: %[[BROADCAST:.+]] = linalg.generic {indexing_maps = [#[[$MAP1]], #[[$MAP2]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2 : tensor<1xf32>) outs(%[[INIT]] : tensor<1x45x40x28xf32>) {475 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>476 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>477 %0 = tosa.conv2d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 2, 1>} : (tensor<1x49x42x27xf32>, tensor<28x3x3x27xf32>, tensor<1xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x45x40x28xf32>478 return479}480 481// -----482 483// CHECK: #[[$MAP1:.+]] = affine_map<(d0, d1, d2, d3) -> (d3)>484// CHECK: #[[$MAP2:.+]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>485 486// CHECK-LABEL: @conv2d_i8487func.func @conv2d_i8(%input: tensor<1x49x42x27xi8>, %weights: tensor<28x1x1x27xi8>, %bias: tensor<28xi8>) -> () {488 // HWCF: %[[TRANSPOSE:.+]] = linalg.transpose ins(%arg1 : tensor<28x1x1x27xi8>) outs(%[[TRANSPOSEDINIT:.+]] : tensor<1x1x27x28xi8>) permutation = [1, 2, 3, 0]489 // CHECK: %[[INIT:.+]] = tensor.empty() : tensor<1x49x42x28xi32>490 // CHECK: %[[BROADCAST:.+]] = linalg.generic {indexing_maps = [#[[$MAP1]], #[[$MAP2]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2 : tensor<28xi8>) outs(%[[INIT]] : tensor<1x49x42x28xi32>) {491 // CHECK: arith.extsi492 // CHECK: linalg.yield493 // CHECK: } -> tensor<1x49x42x28xi32>494 // CHECK: linalg.conv_2d_nhwc_fhwc {dilations = dense<[2, 1]> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %arg1 : tensor<1x49x42x27xi8>, tensor<28x1x1x27xi8>) outs(%[[BROADCAST]] : tensor<1x49x42x28xi32>) -> tensor<1x49x42x28xi32>495 // HWCF: linalg.conv_2d_nhwc_hwcf {dilations = dense<[2, 1]> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %[[TRANSPOSE]] : tensor<1x49x42x27xi8>, tensor<1x1x27x28xi8>) outs(%{{[a-zA-Z0-9_]*}} : tensor<1x49x42x28xi32>) -> tensor<1x49x42x28xi32>496 497 %input_zp = "tosa.const"() <{values = dense<0> : tensor<1xi8>}> : () -> tensor<1xi8>498 %weight_zp = "tosa.const"() <{values = dense<0> : tensor<1xi8>}> : () -> tensor<1xi8>499 %0 = tosa.conv2d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = i32, dilation = array<i64: 2, 1>, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>} : (tensor<1x49x42x27xi8>, tensor<28x1x1x27xi8>, tensor<28xi8>, tensor<1xi8>, tensor<1xi8>) -> tensor<1x49x42x28xi32>500 return501}502 503// -----504 505// CHECK: #[[$MAP1:.+]] = affine_map<(d0, d1, d2, d3) -> (d3)>506// CHECK: #[[$MAP2:.+]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>507 508// CHECK-LABEL: @conv2d_f32509func.func @conv2d_f32(%input: tensor<1x49x42x27xf32>, %weights: tensor<28x3x3x27xf32>, %bias: tensor<28xf32>) -> () {510 // HWCF: %[[TRANSPOSE:.+]] = linalg.transpose ins(%arg1 : tensor<28x3x3x27xf32>) outs(%[[TRANSPOSEDINIT:.+]] : tensor<3x3x27x28xf32>) permutation = [1, 2, 3, 0]511 512 // CHECK: %[[INIT:.+]] = tensor.empty() : tensor<1x45x40x28xf32>513 // CHECK: %[[BROADCAST:.+]] = linalg.generic {indexing_maps = [#[[$MAP1]], #[[$MAP2]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2 : tensor<28xf32>) outs(%[[INIT]] : tensor<1x45x40x28xf32>) {514 // CHECK: linalg.yield515 // CHECK: } -> tensor<1x45x40x28xf32>516 // CHECK: linalg.conv_2d_nhwc_fhwc {dilations = dense<[2, 1]> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %arg1 : tensor<1x49x42x27xf32>, tensor<28x3x3x27xf32>) outs(%[[BROADCAST]] : tensor<1x45x40x28xf32>) -> tensor<1x45x40x28xf32>517 518 // HWCF: linalg.conv_2d_nhwc_hwcf {dilations = dense<[2, 1]> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %[[TRANSPOSE]] : tensor<1x49x42x27xf32>, tensor<3x3x27x28xf32>) outs(%{{[a-zA-Z0-9_]*}} : tensor<1x45x40x28xf32>519 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>520 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>521 %0 = tosa.conv2d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 2, 1>} : (tensor<1x49x42x27xf32>, tensor<28x3x3x27xf32>, tensor<28xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x45x40x28xf32>522 return523}524 525// -----526 527// CHECK: #[[$MAP1:.+]] = affine_map<(d0, d1, d2, d3) -> (d3)>528// CHECK: #[[$MAP2:.+]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>529 530// CHECK-LABEL: @conv2d_dyn531func.func @conv2d_dyn(%input: tensor<?x49x42x27xf32>, %weights: tensor<28x3x3x27xf32>, %bias: tensor<28xf32>) -> () {532 // CHECK: %[[C0:.+]] = arith.constant 0 : index533 // CHECK: %[[BATCH:.+]] = tensor.dim %arg0, %[[C0]] : tensor<?x49x42x27xf32>534 // CHECK: %[[INIT:.+]] = tensor.empty(%[[BATCH]]) : tensor<?x45x40x28xf32>535 // CHECK: %[[BROADCAST:.+]] = linalg.generic {indexing_maps = [#map, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2 : tensor<28xf32>) outs(%[[INIT]] : tensor<?x45x40x28xf32>) {536 // CHECK: ^bb0(%[[IN:.+]]: f32, %{{.+}}: f32):537 // CHECK: linalg.yield %[[IN]] : f32538 // CHECK: } -> tensor<?x45x40x28xf32>539 // CHECK: linalg.conv_2d_nhwc_fhwc {dilations = dense<[2, 1]> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %arg1 : tensor<?x49x42x27xf32>, tensor<28x3x3x27xf32>) outs(%[[BROADCAST]] : tensor<?x45x40x28xf32>) -> tensor<?x45x40x28xf32>540 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>541 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>542 %0 = tosa.conv2d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 2, 1>} : (tensor<?x49x42x27xf32>, tensor<28x3x3x27xf32>, tensor<28xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<?x45x40x28xf32>543 return544}545 546// -----547 548// CHECK: #[[$MAP1:.+]] = affine_map<(d0, d1, d2, d3) -> (d3)>549// CHECK: #[[$MAP2:.+]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>550 551// CHECK-LABEL: @conv2d_dyn_w_h552func.func @conv2d_dyn_w_h(%input: tensor<1x?x?x27xf32>, %weights: tensor<28x3x3x27xf32>, %bias: tensor<28xf32>) -> () {553 // Computing output height554 // CHECK: %[[C1:.+]] = arith.constant 1555 // CHECK: %[[H:.+]] = tensor.dim %arg0, %[[C1]]556 // CHECK: %[[C1_0:.+]] = arith.constant 1557 // CHECK: %[[KH:.+]] = tensor.dim %arg1, %[[C1_0]]558 // CHECK: %[[ONE:.+]] = arith.constant 1 : index559 // CHECK: %[[PAD_0:.+]] = arith.constant 0 : index560 // CHECK: %[[ADD_PAD_0:.+]] = arith.addi %[[H]], %[[PAD_0]] : index561 // CHECK: %[[PAD_1:.+]] = arith.constant 0 : index562 // CHECK: %[[ADD_PAD_1:.+]] = arith.addi %[[ADD_PAD_0]], %[[PAD_1]] : index563 // CHECK: %[[SUB_ONE:.+]] = arith.subi %[[KH]], %[[ONE]] : index564 // CHECK: %[[DIL_H:.+]] = arith.constant 2 : index565 // CHECK: %[[DILATED:.+]] = arith.muli %[[DIL_H]], %[[SUB_ONE]] : index566 // CHECK: %[[ADD_ONE:.+]] = arith.addi %[[DILATED]], %[[ONE]] : index567 // CHECK: %[[SUBTRACTED:.+]] = arith.subi %[[ADD_PAD_1]], %[[ADD_ONE]] : index568 // CHECK: %[[STRIDE_H:.+]] = arith.constant 1 : index569 // CHECK: %[[DIVIDED:.+]] = arith.divui %[[SUBTRACTED]], %[[STRIDE_H]] : index570 // CHECK: %[[H_OUT:.+]] = arith.addi %[[DIVIDED]], %[[ONE]] : index571 572 // Computing output width573 // CHECK: %[[C2:.+]] = arith.constant 2574 // CHECK: %[[W:.+]] = tensor.dim %arg0, %[[C2]]575 // CHECK: %[[C2_0:.+]] = arith.constant 2576 // CHECK: %[[KW:.+]] = tensor.dim %arg1, %[[C2_0]]577 // CHECK: %[[ONE_0:.+]] = arith.constant 1 : index578 // CHECK: %[[PAD_2:.+]] = arith.constant 0 : index579 // CHECK: %[[ADD_PAD_2:.+]] = arith.addi %[[W]], %[[PAD_2]] : index580 // CHECK: %[[PAD_3:.+]] = arith.constant 0 : index581 // CHECK: %[[ADD_PAD_3:.+]] = arith.addi %[[ADD_PAD_2]], %[[PAD_3]] : index582 // CHECK: %[[SUB_ONE_0:.+]] = arith.subi %[[KW]], %[[ONE_0]] : index583 // CHECK: %[[DIL_W:.+]] = arith.constant 1 : index584 // CHECK: %[[DILATED_0:.+]] = arith.muli %[[DIL_W]], %[[SUB_ONE_0]] : index585 // CHECK: %[[ADD_ONE_0:.+]] = arith.addi %[[DILATED_0]], %[[ONE_0]] : index586 // CHECK: %[[SUBTRACTED_0:.+]] = arith.subi %[[ADD_PAD_3]], %[[ADD_ONE_0]] : index587 // CHECK: %[[STRIDE_W:.+]] = arith.constant 1 : index588 // CHECK: %[[DIVIDED_0:.+]] = arith.divui %[[SUBTRACTED_0]], %[[STRIDE_W]] : index589 // CHECK: %[[W_OUT:.+]] = arith.addi %[[DIVIDED_0]], %[[ONE_0]] : index590 591 // Running convolution592 // CHECK: %[[INIT:.+]] = tensor.empty(%[[H_OUT]], %[[W_OUT]]) : tensor<1x?x?x28xf32>593 // CHECK: %[[BROADCAST:.+]] = linalg.generic {indexing_maps = [#[[$MAP1]], #[[$MAP2]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2 : tensor<28xf32>) outs(%[[INIT]] : tensor<1x?x?x28xf32>) {594 // CHECK: linalg.yield595 // CHECK: } -> tensor<1x?x?x28xf32>596 // CHECK: linalg.conv_2d_nhwc_fhwc {dilations = dense<[2, 1]> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %arg1 : tensor<1x?x?x27xf32>, tensor<28x3x3x27xf32>) outs(%[[BROADCAST]] : tensor<1x?x?x28xf32>) -> tensor<1x?x?x28xf32>597 598 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>599 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>600 %0 = tosa.conv2d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 2, 1>} : (tensor<1x?x?x27xf32>, tensor<28x3x3x27xf32>, tensor<28xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x?x?x28xf32>601 return602}603 604// -----605 606// CHECK: [[$MAP1:.+]] = affine_map<(d0, d1, d2, d3) -> (d3)>607// CHECK: [[$MAP2:.+]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>608 609func.func @conv2d_dyn_output(%input: tensor<2x6x5x4xf32>, %weights: tensor<4x3x3x4xf32>, %bias: tensor<4xf32>) {610 // %[[C0:.+]] = arith.constant 0 : index611 // %[[DIM0:.+]] = tensor.dim %input, %[[C0]] : tensor<2x6x5x4xf32>612 // %[[INIT_CONV:.+]] = tensor.empty(%[[DIM0]]) : tensor<?x4x3x4xf32>613 // %[[ZERO:.+]] = arith.constant 0.000000e+00 : f32614 // %[[FILL:.+]] = linalg.fill615 // %[[INIT_GENERIC:.+]] = tensor.empty([[DIM0]]) : tensor<?x4x3x4xf32>616 617 // %[[CONV:.+]] = linalg.conv_2d_nhwc_fhwc {dilations = dense<1> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %arg1 : tensor<2x6x5x4xf32>, tensor<4x3x3x4xf32>) outs(%[[INIT_CONV]] : tensor<?x4x3x4xf32>) -> tensor<?x4x3x4xf32>618 // linalg.generic {indexing_maps = [#[[MAP1]], #[[MAP2]], #[[MAP2]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2, %[[CONV]] : tensor<4xf32>, tensor<?x4x3x4xf32>) outs(%[[INIT_GENERIC]] : tensor<?x4x3x4xf32>) {619 // %[[ADD:.+]] = arith.addf620 // linalg.yield %[[ADD]] : f32621 // } -> tensor<?x4x3x4xf32>622 623 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>624 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>625 %0 = tosa.conv2d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, dilation = array<i64: 1, 1>, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>} : (tensor<2x6x5x4xf32>, tensor<4x3x3x4xf32>, tensor<4xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<?x4x3x4xf32>626 return627}628 629// -----630 631// CHECK-LABEL: @conv2d_padded_f32632func.func @conv2d_padded_f32(%input: tensor<1x47x40x28xf32>, %weights: tensor<28x3x3x28xf32>, %bias: tensor<28xf32>) -> () {633 // CHECK: %[[C0:.+]] = arith.constant 0634 // CHECK: tensor.pad %arg0 low[0, 1, 1, 0] high[0, 1, 1, 0]635 // CHECK: tensor.yield %[[C0]]636 // CHECK: linalg.conv_2d_nhwc_fhwc637 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>638 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>639 %0 = tosa.conv2d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 1, 1, 1, 1>, stride = array<i64: 1, 1>, dilation = array<i64: 2, 1>}640 : (tensor<1x47x40x28xf32>, tensor<28x3x3x28xf32>, tensor<28xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x45x40x28xf32>641 return642}643 644// -----645 646// CHECK-LABEL: @conv2d_quant647func.func @conv2d_quant(%arg0 : tensor<1x12x12x1xi8>, %arg1 : tensor<1024x3x3x1xi8>, %arg2 : tensor<1024xi32>) -> () {648 // CHECK: %[[C22:.+]] = arith.constant -22649 // CHECK: tensor.pad %arg0 low[0, 1, 1, 0] high[0, 1, 1, 0]650 // CHECK: tensor.yield %[[C22]]651 // CHECK: linalg.conv_2d_nhwc_fhwc_q652 %input_zp = "tosa.const"() <{values = dense<-22> : tensor<1xi8>}> : () -> tensor<1xi8>653 %weight_zp = "tosa.const"() <{values = dense<42> : tensor<1xi8>}> : () -> tensor<1xi8>654 %0 = tosa.conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = i32, dilation = array<i64: 1, 1>, pad = array<i64: 1, 1, 1, 1>, stride = array<i64: 1, 1>}655 : (tensor<1x12x12x1xi8>, tensor<1024x3x3x1xi8>, tensor<1024xi32>, tensor<1xi8>, tensor<1xi8>) -> tensor<1x12x12x1024xi32>656 return657}658 659// -----660 661// CHECK-LABEL: @conv2d_f16_f32_acc662func.func @conv2d_f16_f32_acc(%input: tensor<1x49x42x27xf16>, %weights: tensor<28x3x3x27xf16>, %bias: tensor<28xf16>) -> () {663 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf16>}> : () -> tensor<1xf16>664 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf16>}> : () -> tensor<1xf16>665 // CHECK: linalg.generic {{{.*}}} ins(%{{.*}} : tensor<28xf16>) outs(%{{.*}} : tensor<1x45x40x28xf32>)666 // CHECK: arith.extf %{{.*}} : f16 to f32667 // CHECK: %[[CONV:.*]] = linalg.conv_2d_nhwc_fhwc {{{.*}}} ins(%{{.*}}, %{{.*}} : tensor<1x49x42x27xf16>, tensor<28x3x3x27xf16>) outs(%{{.*}} : tensor<1x45x40x28xf32>) -> tensor<1x45x40x28xf32>668 // CHECK: tosa.cast %[[CONV]] : (tensor<1x45x40x28xf32>) -> tensor<1x45x40x28xf16>669 %0 = tosa.conv2d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 2, 1>} : (tensor<1x49x42x27xf16>, tensor<28x3x3x27xf16>, tensor<28xf16>, tensor<1xf16>, tensor<1xf16>) -> tensor<1x45x40x28xf16>670 return671}672 673// -----674 675// CHECK: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d3)>676// CHECK: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>677 678// CHECK-LABEL: @depthwise_conv679func.func @depthwise_conv(%arg0 : tensor<1x7x5x3xf32>, %arg1 : tensor<3x1x3x11xf32>, %arg2 : tensor<33xf32>) -> () {680 // CHECK: [[INIT:%.+]] = tensor.empty()681 // CHECK: [[CST0:%.+]] = arith.constant 0682 // CHECK: [[FILL:%.+]] = linalg.fill ins([[CST0]]{{.*}}outs([[INIT]]683 // CHECK: [[OUT:%.+]] = tensor.empty()684 // CHECK: [[DEPTH:%.+]] = linalg.depthwise_conv_2d_nhwc_hwcm {dilations = dense<1> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %arg1 : tensor<1x7x5x3xf32>, tensor<3x1x3x11xf32>) outs([[FILL]] : tensor<1x5x5x3x11xf32>)685 // CHECK: [[COLLAPSED:%.+]] = tensor.collapse_shape [[DEPTH]] {{\[}}[0], [1], [2], [3, 4]]686 // CHECK: [[BIAS:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP1]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2, [[COLLAPSED]] : tensor<33xf32>, tensor<1x5x5x33xf32>) outs([[OUT]] : tensor<1x5x5x33xf32>) {687 // CHECK: ^bb0(%[[ARG3:[0-9a-zA-Z_]+]]: f32, %[[ARG4:[0-9a-zA-Z_]+]]: f32, %[[ARG5:[0-9a-zA-Z_]+]]: f32):688 // CHECK: [[ADD:%.+]] = arith.addf %[[ARG3]], %[[ARG4]] : f32689 // CHECK: linalg.yield [[ADD]] : f32690 // CHECK: } -> tensor<1x5x5x33xf32>691 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>692 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>693 %2 = tosa.depthwise_conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1> } : (tensor<1x7x5x3xf32>, tensor<3x1x3x11xf32>, tensor<33xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x5x5x33xf32>694 return695}696 697// -----698 699// CHECK: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (0)>700// CHECK: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>701 702// CHECK-LABEL: @depthwise_conv_scalar_bias703func.func @depthwise_conv_scalar_bias(%arg0 : tensor<1x7x5x3xf32>, %arg1 : tensor<3x1x3x11xf32>, %arg2 : tensor<1xf32>) -> () {704 // CHECK: [[BIAS:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP1]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2, %{{.*}} : tensor<1xf32>, tensor<1x5x5x33xf32>) outs(%{{.*}} : tensor<1x5x5x33xf32>) {705 // CHECK: ^bb0(%[[ARG3:[0-9a-zA-Z_]+]]: f32, %[[ARG4:[0-9a-zA-Z_]+]]: f32, %{{.*}}: f32):706 // CHECK: [[ADD:%.+]] = arith.addf %[[ARG3]], %[[ARG4]] : f32707 // CHECK: linalg.yield [[ADD]] : f32708 // CHECK: } -> tensor<1x5x5x33xf32>709 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>710 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>711 %2 = tosa.depthwise_conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1> } : (tensor<1x7x5x3xf32>, tensor<3x1x3x11xf32>, tensor<1xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x5x5x33xf32>712 return713}714 715// -----716 717// CHECK: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d3)>718// CHECK: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>719 720// CHECK-LABEL: @depthwise_conv_dyn721func.func @depthwise_conv_dyn(%arg0 : tensor<?x7x5x3xf32>, %arg1 : tensor<3x1x3x11xf32>, %arg2 : tensor<33xf32>) -> () {722 // CHECK: %[[C0:.+]] = arith.constant 0723 // CHECK: %[[BATCH:.+]] = tensor.dim %arg0, %[[C0]]724 // CHECK: %[[INIT:.+]] = tensor.empty(%[[BATCH]])725 // CHECK: %[[CST0:.+]] = arith.constant 0726 // CHECK: %[[FILL:.+]] = linalg.fill727 // CHECK: %[[OUT:.+]] = tensor.empty(%[[BATCH]])728 // CHECK: %[[DEPTH:.+]] = linalg.depthwise_conv_2d_nhwc_hwcm {dilations = dense<1> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %arg1 : tensor<?x7x5x3xf32>, tensor<3x1x3x11xf32>) outs(%[[FILL]] : tensor<?x5x5x3x11xf32>)729 // CHECK: %[[COLLAPSED:.+]] = tensor.collapse_shape %[[DEPTH]] {{\[}}[0], [1], [2], [3, 4]]730 // CHECK: %[[BIAS:.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP1]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2, %[[COLLAPSED]] : tensor<33xf32>, tensor<?x5x5x33xf32>) outs(%[[OUT]] : tensor<?x5x5x33xf32>) {731 // CHECK: ^bb0(%[[ARG3:[0-9a-zA-Z_]+]]: f32, %[[ARG4:[0-9a-zA-Z_]+]]: f32, %[[ARG5:[0-9a-zA-Z_]+]]: f32):732 // CHECK: %[[ADD:.+]] = arith.addf %[[ARG3]], %[[ARG4]] : f32733 // CHECK: linalg.yield %[[ADD]] : f32734 // CHECK: } -> tensor<?x5x5x33xf32>735 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>736 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>737 %2 = tosa.depthwise_conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1> } : (tensor<?x7x5x3xf32>, tensor<3x1x3x11xf32>, tensor<33xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<?x5x5x33xf32>738 return739}740 741// -----742 743// CHECK: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d3)>744// CHECK: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>745 746// CHECK-LABEL: @depthwise_conv_strides747func.func @depthwise_conv_strides(%arg0 : tensor<1x11x9x3xf32>, %arg1 : tensor<3x1x3x11xf32>, %arg2 : tensor<33xf32>) -> () {748 // CHECK: [[INIT:%.+]] = tensor.empty()749 // CHECK: [[CST0:%.+]] = arith.constant 0750 // CHECK: [[FILL:%.+]] = linalg.fill ins([[CST0]]{{.*}}outs([[INIT]]751 // CHECK: [[OUT:%.+]] = tensor.empty()752 // CHECK: [[DEPTH:%.+]] = linalg.depthwise_conv_2d_nhwc_hwcm {dilations = dense<1> : tensor<2xi64>, strides = dense<2> : tensor<2xi64>} ins(%arg0, %arg1 : tensor<1x11x9x3xf32>, tensor<3x1x3x11xf32>) outs([[FILL]] : tensor<1x5x5x3x11xf32>)753 // CHECK: [[COLLAPSED:%.+]] = tensor.collapse_shape [[DEPTH]] {{\[}}[0], [1], [2], [3, 4]]754 // CHECK: [[BIAS:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP1]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2, [[COLLAPSED]] : tensor<33xf32>, tensor<1x5x5x33xf32>) outs([[OUT]] : tensor<1x5x5x33xf32>) {755 // CHECK: ^bb0(%[[ARG3:[0-9a-zA-Z_]+]]: f32, %[[ARG4:[0-9a-zA-Z_]+]]: f32, %[[ARG5:[0-9a-zA-Z_]+]]: f32):756 // CHECK: [[ADD:%.+]] = arith.addf %[[ARG3]], %[[ARG4]] : f32757 // CHECK: linalg.yield [[ADD]] : f32758 // CHECK: } -> tensor<1x5x5x33xf32>759 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>760 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>761 %2 = tosa.depthwise_conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 2, 2>, dilation = array<i64: 1, 1> } : (tensor<1x11x9x3xf32>, tensor<3x1x3x11xf32>, tensor<33xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x5x5x33xf32>762 return763}764 765// -----766 767// CHECK: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d3)>768// CHECK: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>769 770// CHECK-LABEL: @depthwise_conv_quant771func.func @depthwise_conv_quant(%arg0 : tensor<1x12x12x4xi8>, %arg1 : tensor<3x3x4x128xi8>, %arg2 : tensor<512xi32>) -> () {772 // CHECK: [[PADV:%.+]] = arith.constant -128773 // CHECK: [[PAD:%.+]] = tensor.pad %arg0 low[0, 1, 1, 0] high[0, 1, 1, 0]774 // CHECK: tensor.yield [[PADV]]775 776 // CHECK: [[INIT:%.+]] = tensor.empty()777 // CHECK: [[CST0:%.+]] = arith.constant 0778 // CHECK: [[FILL:%.+]] = linalg.fill ins([[CST0]]{{.*}}outs([[INIT]]779 // CHECK: [[OUT:%.+]] = tensor.empty()780 // CHECK: [[C128:%.+]] = arith.constant -128781 // CHECK: [[C42:%.+]] = arith.constant 42782 // CHECK: [[DEPTH:%.+]] = linalg.depthwise_conv_2d_nhwc_hwcm_q {dilations = dense<1> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins([[PAD]], %arg1, [[C128]], [[C42]] : tensor<1x14x14x4xi8>, tensor<3x3x4x128xi8>, i32, i32) outs([[FILL]] : tensor<1x12x12x4x128xi32>)783 // CHECK: [[COLLAPSED:%.+]] = tensor.collapse_shape [[DEPTH]] {{\[}}[0], [1], [2], [3, 4]]784 // CHECK: [[BIAS:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP1]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2, [[COLLAPSED]] : tensor<512xi32>, tensor<1x12x12x512xi32>) outs([[OUT]] : tensor<1x12x12x512xi32>) {785 // CHECK: ^bb0(%[[ARG3:[0-9a-zA-Z_]+]]: i32, %[[ARG4:[0-9a-zA-Z_]+]]: i32, %[[ARG5:[0-9a-zA-Z_]+]]: i32):786 // CHECK: [[ADD:%.+]] = arith.addi %[[ARG3]], %[[ARG4]] : i32787 // CHECK: linalg.yield [[ADD]] : i32788 // CHECK: } -> tensor<1x12x12x512xi32>789 %input_zp = "tosa.const"() <{values = dense<-128> : tensor<1xi8>}> : () -> tensor<1xi8>790 %weight_zp = "tosa.const"() <{values = dense<42> : tensor<1xi8>}> : () -> tensor<1xi8>791 %0 = tosa.depthwise_conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = i32, pad = array<i64: 1, 1, 1, 1>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1> } : (tensor<1x12x12x4xi8>, tensor<3x3x4x128xi8>, tensor<512xi32>, tensor<1xi8>, tensor<1xi8>) -> tensor<1x12x12x512xi32>792 return793}794 795// -----796 797// CHECK: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d3)>798// CHECK: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>799 800// CHECK-LABEL: @depthwise_conv_quant_dilations801func.func @depthwise_conv_quant_dilations(%arg0 : tensor<1x14x14x4xi8>, %arg1 : tensor<3x3x4x128xi8>, %arg2 : tensor<512xi32>) -> () {802 // CHECK: [[INIT:%.+]] = tensor.empty()803 // CHECK: [[CST0:%.+]] = arith.constant 0804 // CHECK: [[FILL:%.+]] = linalg.fill ins([[CST0]]{{.*}}outs([[INIT]]805 // CHECK: [[OUT:%.+]] = tensor.empty()806 // CHECK: [[C128:%.+]] = arith.constant -128807 // CHECK: [[C42:%.+]] = arith.constant 42808 // CHECK: [[DEPTH:%.+]] = linalg.depthwise_conv_2d_nhwc_hwcm_q {dilations = dense<2> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %arg1, [[C128]], [[C42]] : tensor<1x14x14x4xi8>, tensor<3x3x4x128xi8>, i32, i32) outs([[FILL]] : tensor<1x10x10x4x128xi32>)809 // CHECK: [[COLLAPSED:%.+]] = tensor.collapse_shape [[DEPTH]] {{\[}}[0], [1], [2], [3, 4]]810 // CHECK: [[BIAS:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP1]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2, [[COLLAPSED]] : tensor<512xi32>, tensor<1x10x10x512xi32>) outs([[OUT]] : tensor<1x10x10x512xi32>) {811 // CHECK: ^bb0(%[[ARG3:[0-9a-zA-Z_]+]]: i32, %[[ARG4:[0-9a-zA-Z_]+]]: i32, %[[ARG5:[0-9a-zA-Z_]+]]: i32):812 // CHECK: [[ADD:%.+]] = arith.addi %[[ARG3]], %[[ARG4]] : i32813 // CHECK: linalg.yield [[ADD]] : i32814 // CHECK: } -> tensor<1x10x10x512xi32>815 %input_zp = "tosa.const"() <{values = dense<-128> : tensor<1xi8>}> : () -> tensor<1xi8>816 %weight_zp = "tosa.const"() <{values = dense<42> : tensor<1xi8>}> : () -> tensor<1xi8>817 %0 = tosa.depthwise_conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = i32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 2, 2> } : (tensor<1x14x14x4xi8>, tensor<3x3x4x128xi8>, tensor<512xi32>, tensor<1xi8>, tensor<1xi8>) -> tensor<1x10x10x512xi32>818 return819}820 821// CHECK-LABEL: @depthwise_conv2d_dyn_w_h822func.func @depthwise_conv2d_dyn_w_h(%arg0: tensor<2x?x?x3xf32>, %arg1: tensor<3x6x3x5xf32>, %arg2: tensor<15xf32>) {823 // CHECK: arith.addi824 // CHECK: arith.subi825 // CHECK: arith.muli826 // CHECK: arith.divui827 // CHECK: %[[PADDED:.+]] = tensor.pad %arg0 low[0, 1, 3, 0] high[0, 2, 4, 0] {828 // CHECK: ^bb0(%[[ARG3:[0-9a-zA-Z_]+]]: index, %[[ARG4:[0-9a-zA-Z_]+]]: index, %[[ARG5:[0-9a-zA-Z_]+]]: index, %[[ARG6:[0-9a-zA-Z_]+]]: index):829 // CHECK: tensor.yield %cst : f32830 // CHECK: } : tensor<2x?x?x3xf32> to tensor<2x?x?x3xf32>831 // CHECK: %[[CONV:.+]] = linalg.depthwise_conv_2d_nhwc_hwcm {dilations = dense<[2, 1]> : tensor<2xi64>, strides = dense<[1, 2]> : tensor<2xi64>} ins(%[[PADDED]], %arg1 : tensor<2x?x?x3xf32>, tensor<3x6x3x5xf32>) outs(%{{.*}} : tensor<2x?x?x3x5xf32>) -> tensor<2x?x?x3x5xf32>832 // CHECK: %[[COLLAPSED:.+]] = tensor.collapse_shape %[[CONV]] {{\[}}[0], [1], [2], [3, 4]]833 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>834 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>835 %0 = tosa.depthwise_conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 1, 2, 3, 4>, dilation = array<i64: 2, 1>, stride = array<i64: 1, 2>} : (tensor<2x?x?x3xf32>, tensor<3x6x3x5xf32>, tensor<15xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<2x?x?x15xf32>836 return837}838 839// -----840 841// CHECK: #[[$MAP0:.*]] = affine_map<(d0, d1, d2, d3) -> (d3)>842// CHECK: #[[$MAP1:.*]] = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>843 844// CHECK-LABEL: @depthwise_int_conv_zero_zp845func.func @depthwise_int_conv_zero_zp(%arg0 : tensor<1x7x5x3xi8>, %arg1 : tensor<3x1x3x11xi8>, %arg2 : tensor<33xi32>) -> () {846 // CHECK: [[INIT:%.+]] = tensor.empty()847 // CHECK: [[CST0:%.+]] = arith.constant 0848 // CHECK: [[FILL:%.+]] = linalg.fill ins([[CST0]]{{.*}}outs([[INIT]]849 // CHECK: [[OUT:%.+]] = tensor.empty()850 // CHECK: [[DEPTH:%.+]] = linalg.depthwise_conv_2d_nhwc_hwcm {dilations = dense<1> : tensor<2xi64>, strides = dense<1> : tensor<2xi64>} ins(%arg0, %arg1 : tensor<1x7x5x3xi8>, tensor<3x1x3x11xi8>) outs([[FILL]] : tensor<1x5x5x3x11xi32>)851 // CHECK: [[COLLAPSED:%.+]] = tensor.collapse_shape [[DEPTH]] {{\[}}[0], [1], [2], [3, 4]]852 // CHECK: [[BIAS:%.+]] = linalg.generic {indexing_maps = [#[[$MAP0]], #[[$MAP1]], #[[$MAP1]]], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%arg2, [[COLLAPSED]] : tensor<33xi32>, tensor<1x5x5x33xi32>) outs([[OUT]] : tensor<1x5x5x33xi32>) {853 // CHECK: ^bb0(%[[ARG3:[0-9a-zA-Z_]+]]: i32, %[[ARG4:[0-9a-zA-Z_]+]]: i32, %[[ARG5:[0-9a-zA-Z_]+]]: i32):854 // CHECK: [[ADD:%.+]] = arith.addi %[[ARG3]], %[[ARG4]] : i32855 // CHECK: linalg.yield [[ADD]] : i32856 // CHECK: } -> tensor<1x5x5x33xi32>857 %input_zp = "tosa.const"() <{values = dense<0> : tensor<1xi8>}> : () -> tensor<1xi8>858 %weight_zp = "tosa.const"() <{values = dense<0> : tensor<1xi8>}> : () -> tensor<1xi8>859 %2 = tosa.depthwise_conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = i32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1> } : (tensor<1x7x5x3xi8>, tensor<3x1x3x11xi8>, tensor<33xi32>, tensor<1xi8>, tensor<1xi8>) -> tensor<1x5x5x33xi32>860 return861}862 863// -----864 865// CHECK-LABEL: @depthwise_conv2d_f16_f32_acc866func.func @depthwise_conv2d_f16_f32_acc(%arg0 : tensor<1x7x5x3xf16>, %arg1 : tensor<3x1x3x11xf16>, %arg2 : tensor<33xf16>) -> () {867 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf16>}> : () -> tensor<1xf16>868 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf16>}> : () -> tensor<1xf16>869 // CHECK: %[[CONV:.*]] = linalg.depthwise_conv_2d_nhwc_hwcm {{{.*}}} ins(%{{.*}}, %{{.*}} : tensor<1x7x5x3xf16>, tensor<3x1x3x11xf16>) outs(%{{.*}} : tensor<1x5x5x3x11xf32>) -> tensor<1x5x5x3x11xf32>870 // CHECK: tosa.cast %[[CONV]] : (tensor<1x5x5x3x11xf32>) -> tensor<1x5x5x3x11xf16>871 %2 = tosa.depthwise_conv2d %arg0, %arg1, %arg2, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0>, stride = array<i64: 1, 1>, dilation = array<i64: 1, 1> } : (tensor<1x7x5x3xf16>, tensor<3x1x3x11xf16>, tensor<33xf16>, tensor<1xf16>, tensor<1xf16>) -> tensor<1x5x5x33xf16>872 return873}874 875// -----876 877// CHECK: #[[$MAP1:.+]] = affine_map<(d0, d1, d2, d3, d4) -> (d4)>878// CHECK: #[[$MAP2:.+]] = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>879 880// CHECK-LABEL: @conv3d_f32881func.func @conv3d_f32(%input: tensor<1x49x48x47x27xf32>, %weights: tensor<43x3x4x5x27xf32>, %bias: tensor<43xf32>) -> () {882 // CHECK-DAG: %[[TRANSPOSE:.+]] = linalg.transpose ins(%arg1 : tensor<43x3x4x5x27xf32>) outs(%[[TRANSPOSEDINIT:.+]] : tensor<3x4x5x27x43xf32>) permutation = [1, 2, 3, 4, 0]883 // CHECK-DAG: %[[INIT:.+]] = tensor.empty() : tensor<1x47x45x43x43xf32>884 // CHECK: %[[BROADCAST:.+]] = linalg.generic885 // CHECK-SAME: {indexing_maps = [#[[$MAP1]], #[[$MAP2]]], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]}886 // CHECK-SAME: ins(%arg2 : tensor<43xf32>) outs(%[[INIT]] : tensor<1x47x45x43x43xf32>) {887 // CHECK: ^bb0(%[[IN:.+]]: f32, %[[OUT:.+]]: f32):888 // CHECK: linalg.yield %[[IN]] : f32889 // CHECK: } -> tensor<1x47x45x43x43xf32>890 // CHECK: linalg.conv_3d_ndhwc_dhwcf891 // CHECK-SAME: {dilations = dense<1> : tensor<3xi64>, strides = dense<1> : tensor<3xi64>}892 // CHECK-SAME: ins(%arg0, %[[TRANSPOSE]] : tensor<1x49x48x47x27xf32>, tensor<3x4x5x27x43xf32>)893 // CHECK-SAME: outs(%[[BROADCAST]] : tensor<1x47x45x43x43xf32>) -> tensor<1x47x45x43x43xf32>894 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>895 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>896 %0 = tosa.conv3d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0, 0, 0>, stride = array<i64: 1, 1, 1>, dilation = array<i64: 1, 1, 1>} : (tensor<1x49x48x47x27xf32>, tensor<43x3x4x5x27xf32>, tensor<43xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x47x45x43x43xf32>897 return898}899 900// -----901 902// CHECK: #[[$MAP1:.+]] = affine_map<(d0, d1, d2, d3, d4) -> (0)>903// CHECK: #[[$MAP2:.+]] = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>904 905// CHECK-LABEL: @conv3d_scalar_bias_f32906func.func @conv3d_scalar_bias_f32(%input: tensor<1x49x48x47x27xf32>, %weights: tensor<28x3x4x5x27xf32>, %bias: tensor<1xf32>) -> () {907 // CHECK: %[[INIT:.+]] = tensor.empty() : tensor<1x47x45x43x28xf32>908 // CHECK: %[[BROADCAST:.+]] = linalg.generic909 // CHECK-SAME: {indexing_maps = [#[[$MAP1]], #[[$MAP2]]], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]}910 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>911 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf32>}> : () -> tensor<1xf32>912 %0 = tosa.conv3d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0, 0, 0>, stride = array<i64: 1, 1, 1>, dilation = array<i64: 1, 1, 1>} : (tensor<1x49x48x47x27xf32>, tensor<28x3x4x5x27xf32>, tensor<1xf32>, tensor<1xf32>, tensor<1xf32>) -> tensor<1x47x45x43x28xf32>913 return914}915 916// -----917 918// CHECK: #[[$MAP1:.+]] = affine_map<(d0, d1, d2, d3, d4) -> (d4)>919// CHECK: #[[$MAP2:.+]] = affine_map<(d0, d1, d2, d3, d4) -> (d0, d1, d2, d3, d4)>920 921// CHECK-LABEL: @conv3d_i8922func.func @conv3d_i8(%input: tensor<1x49x48x47x27xi8>, %weights: tensor<43x3x4x5x27xi8>, %bias: tensor<43xi32>) -> () {923 // CHECK-DAG: %[[TRANSPOSE:.+]] = linalg.transpose ins(%arg1 : tensor<43x3x4x5x27xi8>) outs(%[[TRANSPOSEDINIT:.+]] : tensor<3x4x5x27x43xi8>) permutation = [1, 2, 3, 4, 0]924 // CHECK-DAG: %[[INIT:.+]] = tensor.empty() : tensor<1x47x45x43x43xi32>925 // CHECK: %[[BROADCAST:.+]] = linalg.generic926 // CHECK-SAME: {indexing_maps = [#[[$MAP1]], #[[$MAP2]]], iterator_types = ["parallel", "parallel", "parallel", "parallel", "parallel"]}927 // CHECK-SAME: ins(%arg2 : tensor<43xi32>)928 // CHECK-SAME: outs(%[[INIT]] : tensor<1x47x45x43x43xi32>) {929 // CHECK: ^bb0(%[[IN:.+]]: i32, %[[OUT:.+]]: i32):930 // CHECK: linalg.yield %[[IN]] : i32931 // CHECK: } -> tensor<1x47x45x43x43xi32>932 // CHECK: %[[IZP:.+]] = arith.constant -128 : i32933 // CHECK: %[[FZP:.+]] = arith.constant 42 : i32934 // CHECK: linalg.conv_3d_ndhwc_dhwcf_q935 // CHECK-SAME: {dilations = dense<1> : tensor<3xi64>, strides = dense<1> : tensor<3xi64>}936 // CHECK-SAME: ins(%arg0, %[[TRANSPOSE]], %[[IZP]], %[[FZP]] : tensor<1x49x48x47x27xi8>, tensor<3x4x5x27x43xi8>, i32, i32)937 // CHECK-SAME: outs(%[[BROADCAST]] : tensor<1x47x45x43x43xi32>) -> tensor<1x47x45x43x43xi32>938 939 %input_zp = "tosa.const"() <{values = dense<-128> : tensor<1xi8>}> : () -> tensor<1xi8>940 %weight_zp = "tosa.const"() <{values = dense<42> : tensor<1xi8>}> : () -> tensor<1xi8>941 %0 = tosa.conv3d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = i32, pad = array<i64: 0, 0, 0, 0, 0, 0>, stride = array<i64: 1, 1, 1>, dilation = array<i64: 1, 1, 1>} : (tensor<1x49x48x47x27xi8>, tensor<43x3x4x5x27xi8>, tensor<43xi32>, tensor<1xi8>, tensor<1xi8>) -> tensor<1x47x45x43x43xi32>942 return943}944 945// -----946 947// CHECK-LABEL: @conv3d_f16_f32_acc948func.func @conv3d_f16_f32_acc(%input: tensor<1x49x48x47x27xf16>, %weights: tensor<43x3x4x5x27xf16>, %bias: tensor<43xf16>) -> () {949 %input_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf16>}> : () -> tensor<1xf16>950 %weight_zp = "tosa.const"() <{values = dense<0.0> : tensor<1xf16>}> : () -> tensor<1xf16>951 // CHECK: linalg.generic {{{.*}}} ins(%{{.*}} : tensor<43xf16>) outs(%{{.*}} : tensor<1x47x45x43x43xf32>)952 // CHECK: arith.extf %{{.*}} : f16 to f32953 // CHECK: %[[CONV:.*]] = linalg.conv_3d_ndhwc_dhwcf {{{.*}}} ins(%{{.*}}, %{{.*}} : tensor<1x49x48x47x27xf16>, tensor<3x4x5x27x43xf16>) outs(%{{.*}} : tensor<1x47x45x43x43xf32>) -> tensor<1x47x45x43x43xf32>954 // CHECK: tosa.cast %[[CONV]] : (tensor<1x47x45x43x43xf32>) -> tensor<1x47x45x43x43xf16>955 %0 = tosa.conv3d %input, %weights, %bias, %input_zp, %weight_zp {acc_type = f32, pad = array<i64: 0, 0, 0, 0, 0, 0>, stride = array<i64: 1, 1, 1>, dilation = array<i64: 1, 1, 1>} : (tensor<1x49x48x47x27xf16>, tensor<43x3x4x5x27xf16>, tensor<43xf16>, tensor<1xf16>, tensor<1xf16>) -> tensor<1x47x45x43x43xf16>956 return957}958 959// -----960 961// CHECK-LABEL: @test_transpose962// CHECK-SAME: (%[[ARG0:.+]]: tensor<1x2x3xi32>)963func.func @test_transpose(%arg0: tensor<1x2x3xi32>) -> () {964 // CHECK: %[[INIT:.+]] = tensor.empty() : tensor<2x3x1xi32>965 // CHECK: %[[TRANSPOSE:.+]] = linalg.transpose ins(%[[ARG0]] : tensor<1x2x3xi32>) outs(%[[INIT]] : tensor<2x3x1xi32>) permutation = [1, 2, 0]966 %1 = tosa.transpose %arg0 {perms = array<i32: 1, 2, 0>}: (tensor<1x2x3xi32>) -> tensor<2x3x1xi32>967 return968}969 970// -----971 972// CHECK-LABEL: @test_transpose_dyn973// CHECK-SAME: (%[[ARG0:.+]]: tensor<1x?x3x4xi32>)974func.func @test_transpose_dyn(%arg0: tensor<1x?x3x4xi32>) -> () {975 // CHECK: %[[C1:.+]] = arith.constant 1976 // CHECK: %[[DIM:.+]] = tensor.dim %[[ARG0]], %[[C1]]977 // CHECK: %[[INIT:.+]] = tensor.empty(%[[DIM]]) : tensor<?x4x1x3xi32>978 // CHECK: %[[TRANSPOSE:.+]] = linalg.transpose ins(%[[ARG0]] : tensor<1x?x3x4xi32>) outs(%[[INIT]] : tensor<?x4x1x3xi32>) permutation = [1, 3, 0, 2]979 %1 = tosa.transpose %arg0 {perms = array<i32: 1, 3, 0, 2>}: (tensor<1x?x3x4xi32>) -> tensor<?x4x1x3xi32>980 return981}982 983// -----984 985// CHECK-LABEL: @test_transpose_dyn_multiple_2d986// CHECK-SAME: (%[[ARG0:.+]]: tensor<?x?xf32>)987func.func @test_transpose_dyn_multiple_2d(%arg0: tensor<?x?xf32>) -> () {988 // CHECK-DAG: %[[C0:.+]] = arith.constant 0989 // CHECK-DAG: %[[DIM0:.+]] = tensor.dim %[[ARG0]], %[[C0]]990 // CHECK-DAG: %[[C1:.+]] = arith.constant 1991 // CHECK-DAG: %[[DIM1:.+]] = tensor.dim %[[ARG0]], %[[C1]]992 // CHECK: %[[INIT:.+]] = tensor.empty(%[[DIM1]], %[[DIM0]])993 // CHECK: %[[TRANSPOSE:.+]] = linalg.transpose ins(%[[ARG0]] : tensor<?x?xf32>) outs(%[[INIT]] : tensor<?x?xf32>) permutation = [1, 0]994 %1 = tosa.transpose %arg0 {perms = array<i32: 1, 0>}: (tensor<?x?xf32>) -> tensor<?x?xf32>995 return996}997 998// -----999 1000// CHECK-LABEL: @test_transpose_dyn_multiple_3d1001// CHECK-SAME: (%[[ARG0:.+]]: tensor<?x?x?xf32>)1002func.func @test_transpose_dyn_multiple_3d(%arg0: tensor<?x?x?xf32>) {1003 // CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index1004 // CHECK-DAG: %[[DIM0:.*]] = tensor.dim %[[ARG0]], %[[C0]] : tensor<?x?x?xf32>1005 // CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index1006 // CHECK-DAG: %[[DIM1:.*]] = tensor.dim %[[ARG0]], %[[C1]] : tensor<?x?x?xf32>1007 // CHECK-DAG: %[[C2:.*]] = arith.constant 2 : index1008 // CHECK-DAG: %[[DIM2:.*]] = tensor.dim %[[ARG0]], %[[C2]] : tensor<?x?x?xf32>1009 // CHECK: %[[INIT:.*]] = tensor.empty(%[[DIM2]], %[[DIM0]], %[[DIM1]]) : tensor<?x?x?xf32>1010 // CHECK: %[[TRANSPOSE:.*]] = linalg.transpose ins(%[[ARG0]] : tensor<?x?x?xf32>) outs(%[[INIT]] : tensor<?x?x?xf32>) permutation = [2, 0, 1]1011 %1 = "tosa.transpose"(%arg0) {perms = array<i32: 2, 0, 1>} : (tensor<?x?x?xf32>) -> tensor<?x?x?xf32>1012 return1013}1014 1015// -----1016 1017// CHECK-LABEL: @max_pool2d_nan_propagate1018func.func @max_pool2d_nan_propagate(%arg0: tensor<1x6x34x62xf32>) -> (tensor<1x4x32x62xf32>) {1019 // CHECK: linalg.pooling_nhwc_max1020 // CHECK-NOT: linalg.generic1021 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 0>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>, nan_mode = PROPAGATE} : (tensor<1x6x34x62xf32>) -> tensor<1x4x32x62xf32>1022 return %0 : tensor<1x4x32x62xf32>1023}1024 1025// -----1026 1027// CHECK-LABEL: @max_pool2d_nan_ignore_int1028func.func @max_pool2d_nan_ignore_int(%arg0: tensor<1x6x34x62xi8>) -> (tensor<1x4x32x62xi8>) {1029 // CHECK: linalg.pooling_nhwc_max1030 // CHECK-NOT: linalg.generic1031 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 0>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>, nan_mode = IGNORE} : (tensor<1x6x34x62xi8>) -> tensor<1x4x32x62xi8>1032 return %0: tensor<1x4x32x62xi8>1033}1034 1035// -----1036 1037// CHECK-LABEL: @max_pool2d_nan_ignore1038func.func @max_pool2d_nan_ignore(%arg0: tensor<1x6x34x62xf32>) -> (tensor<1x4x32x62xf32>) {1039 // CHECK-NOT: linalg.pooling_nhwc_max1040 // CHECK: linalg.generic1041 // CHECK: arith.maximumf1042 // CHECK: arith.cmpf uno1043 // CHECK: arith.select1044 // CHECK: linalg.yield1045 %0 = tosa.max_pool2d %arg0 {pad = array<i64: 0, 0, 0, 0>, kernel = array<i64: 3, 3>, stride = array<i64: 1, 1>, nan_mode = IGNORE} : (tensor<1x6x34x62xf32>) -> tensor<1x4x32x62xf32>1046 return %0: tensor<1x4x32x62xf32>1047}1048