1// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py 2// RUN: mlir-opt %s -sparsification | FileCheck %s 3 4#DV = #sparse_tensor.encoding<{ dimLevelType = [ "dense" ] }> 5#SV = #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ] }> 6 7#trait1 = { 8 indexing_maps = [ 9 affine_map<(i) -> (i)>, // a 10 affine_map<(i) -> (i)> // x (out) 11 ], 12 iterator_types = ["parallel"], 13 doc = "x(i) = a(i) OP b" 14} 15 16// CHECK-LABEL: func @add_d( 17// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 18// CHECK-SAME: %[[VAL_1:.*]]: f32, 19// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 20// CHECK: %[[VAL_3:.*]] = constant 32 : index 21// CHECK: %[[VAL_4:.*]] = constant 0 : index 22// CHECK: %[[VAL_5:.*]] = constant 1 : index 23// CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 24// CHECK: %[[VAL_7:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 25// CHECK: %[[VAL_8:.*]] = memref.alloc() : memref<32xf32> 26// CHECK: memref.copy %[[VAL_7]], %[[VAL_8]] : memref<32xf32> to memref<32xf32> 27// CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { 28// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf32> 29// CHECK: %[[VAL_11:.*]] = addf %[[VAL_10]], %[[VAL_1]] : f32 30// CHECK: memref.store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32> 31// CHECK: } 32// CHECK: %[[VAL_12:.*]] = memref.tensor_load %[[VAL_8]] : memref<32xf32> 33// CHECK: return %[[VAL_12]] : tensor<32xf32> 34// CHECK: } 35func @add_d(%arga: tensor<32xf32, #DV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> { 36 %0 = linalg.generic #trait1 37 ins(%arga: tensor<32xf32, #DV>) 38 outs(%argx: tensor<32xf32>) { 39 ^bb(%a: f32, %x: f32): 40 %0 = addf %a, %argb : f32 41 linalg.yield %0 : f32 42 } -> tensor<32xf32> 43 return %0 : tensor<32xf32> 44} 45 46// CHECK-LABEL: func @mul_d( 47// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 48// CHECK-SAME: %[[VAL_1:.*]]: f32, 49// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 50// CHECK: %[[VAL_3:.*]] = constant 32 : index 51// CHECK: %[[VAL_4:.*]] = constant 0 : index 52// CHECK: %[[VAL_5:.*]] = constant 1 : index 53// CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 54// CHECK: %[[VAL_7:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 55// CHECK: %[[VAL_8:.*]] = memref.alloc() : memref<32xf32> 56// CHECK: memref.copy %[[VAL_7]], %[[VAL_8]] : memref<32xf32> to memref<32xf32> 57// CHECK: scf.for %[[VAL_9:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { 58// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_9]]] : memref<?xf32> 59// CHECK: %[[VAL_11:.*]] = mulf %[[VAL_10]], %[[VAL_1]] : f32 60// CHECK: memref.store %[[VAL_11]], %[[VAL_8]]{{\[}}%[[VAL_9]]] : memref<32xf32> 61// CHECK: } 62// CHECK: %[[VAL_12:.*]] = memref.tensor_load %[[VAL_8]] : memref<32xf32> 63// CHECK: return %[[VAL_12]] : tensor<32xf32> 64// CHECK: } 65func @mul_d(%arga: tensor<32xf32, #DV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> { 66 %0 = linalg.generic #trait1 67 ins(%arga: tensor<32xf32, #DV>) 68 outs(%argx: tensor<32xf32>) { 69 ^bb(%a: f32, %x: f32): 70 %0 = mulf %a, %argb : f32 71 linalg.yield %0 : f32 72 } -> tensor<32xf32> 73 return %0 : tensor<32xf32> 74} 75 76// CHECK-LABEL: func @add_s( 77// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 78// CHECK-SAME: %[[VAL_1:.*]]: f32, 79// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 80// CHECK-DAG: %[[VAL_3:.*]] = constant 32 : index 81// CHECK-DAG: %[[VAL_4:.*]] = constant 0 : index 82// CHECK-DAG: %[[VAL_5:.*]] = constant true 83// CHECK-DAG: %[[VAL_6:.*]] = constant 1 : index 84// CHECK: %[[VAL_7:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_4]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 85// CHECK: %[[VAL_8:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_4]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 86// CHECK: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 87// CHECK: %[[VAL_10:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 88// CHECK: %[[VAL_11:.*]] = memref.alloc() : memref<32xf32> 89// CHECK: memref.copy %[[VAL_10]], %[[VAL_11]] : memref<32xf32> to memref<32xf32> 90// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex> 91// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> 92// CHECK: %[[VAL_14:.*]]:2 = scf.while (%[[VAL_15:.*]] = %[[VAL_12]], %[[VAL_16:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) { 93// CHECK: %[[VAL_17:.*]] = cmpi ult, %[[VAL_15]], %[[VAL_13]] : index 94// CHECK: scf.condition(%[[VAL_17]]) %[[VAL_15]], %[[VAL_16]] : index, index 95// CHECK: } do { 96// CHECK: ^bb0(%[[VAL_18:.*]]: index, %[[VAL_19:.*]]: index): 97// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xindex> 98// CHECK: %[[VAL_21:.*]] = cmpi eq, %[[VAL_20]], %[[VAL_19]] : index 99// CHECK: scf.if %[[VAL_21]] { 100// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_18]]] : memref<?xf32> 101// CHECK: %[[VAL_23:.*]] = addf %[[VAL_22]], %[[VAL_1]] : f32 102// CHECK: memref.store %[[VAL_23]], %[[VAL_11]]{{\[}}%[[VAL_19]]] : memref<32xf32> 103// CHECK: } else { 104// CHECK: scf.if %[[VAL_5]] { 105// CHECK: memref.store %[[VAL_1]], %[[VAL_11]]{{\[}}%[[VAL_19]]] : memref<32xf32> 106// CHECK: } else { 107// CHECK: } 108// CHECK: } 109// CHECK: %[[VAL_24:.*]] = cmpi eq, %[[VAL_20]], %[[VAL_19]] : index 110// CHECK: %[[VAL_25:.*]] = addi %[[VAL_18]], %[[VAL_6]] : index 111// CHECK: %[[VAL_26:.*]] = select %[[VAL_24]], %[[VAL_25]], %[[VAL_18]] : index 112// CHECK: %[[VAL_27:.*]] = addi %[[VAL_19]], %[[VAL_6]] : index 113// CHECK: scf.yield %[[VAL_26]], %[[VAL_27]] : index, index 114// CHECK: } 115// CHECK: scf.for %[[VAL_28:.*]] = %[[VAL_29:.*]]#1 to %[[VAL_3]] step %[[VAL_6]] { 116// CHECK: memref.store %[[VAL_1]], %[[VAL_11]]{{\[}}%[[VAL_28]]] : memref<32xf32> 117// CHECK: } 118// CHECK: %[[VAL_30:.*]] = memref.tensor_load %[[VAL_11]] : memref<32xf32> 119// CHECK: return %[[VAL_30]] : tensor<32xf32> 120// CHECK: } 121func @add_s(%arga: tensor<32xf32, #SV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> { 122 %0 = linalg.generic #trait1 123 ins(%arga: tensor<32xf32, #SV>) 124 outs(%argx: tensor<32xf32>) { 125 ^bb(%a: f32, %x: f32): 126 %0 = addf %a, %argb : f32 127 linalg.yield %0 : f32 128 } -> tensor<32xf32> 129 return %0 : tensor<32xf32> 130} 131 132// CHECK-LABEL: func @repeated_add_s( 133// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 134// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>) -> tensor<32xf32> { 135// CHECK: %[[VAL_2:.*]] = constant 0 : index 136// CHECK: %[[VAL_3:.*]] = constant 1 : index 137// CHECK: %[[VAL_4:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_2]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 138// CHECK: %[[VAL_5:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_2]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 139// CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 140// CHECK: %[[VAL_7:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32xf32> 141// CHECK: %[[VAL_8:.*]] = memref.alloc() : memref<32xf32> 142// CHECK: memref.copy %[[VAL_7]], %[[VAL_8]] : memref<32xf32> to memref<32xf32> 143// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> 144// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> 145// CHECK: scf.for %[[VAL_11:.*]] = %[[VAL_9]] to %[[VAL_10]] step %[[VAL_3]] { 146// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_11]]] : memref<?xindex> 147// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32> 148// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32> 149// CHECK: %[[VAL_15:.*]] = addf %[[VAL_13]], %[[VAL_14]] : f32 150// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32> 151// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_11]]] : memref<?xf32> 152// CHECK: %[[VAL_18:.*]] = addf %[[VAL_16]], %[[VAL_17]] : f32 153// CHECK: %[[VAL_19:.*]] = addf %[[VAL_15]], %[[VAL_18]] : f32 154// CHECK: memref.store %[[VAL_19]], %[[VAL_8]]{{\[}}%[[VAL_12]]] : memref<32xf32> 155// CHECK: } 156// CHECK: %[[VAL_20:.*]] = memref.tensor_load %[[VAL_8]] : memref<32xf32> 157// CHECK: return %[[VAL_20]] : tensor<32xf32> 158// CHECK: } 159func @repeated_add_s(%arga: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> { 160 %0 = linalg.generic #trait1 161 ins(%arga: tensor<32xf32, #SV>) 162 outs(%argx: tensor<32xf32>) { 163 ^bb(%a: f32, %x: f32): 164 %0 = addf %a, %a : f32 // same tensor 165 %1 = addf %a, %a : f32 // should yield 166 %2 = addf %0, %1 : f32 // one guard 167 linalg.yield %2 : f32 168 } -> tensor<32xf32> 169 return %0 : tensor<32xf32> 170} 171 172// CHECK-LABEL: func @mul_s( 173// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 174// CHECK-SAME: %[[VAL_1:.*]]: f32, 175// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 176// CHECK: %[[VAL_3:.*]] = constant 0 : index 177// CHECK: %[[VAL_4:.*]] = constant 1 : index 178// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 179// CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 180// CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 181// CHECK: %[[VAL_8:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 182// CHECK: %[[VAL_9:.*]] = memref.alloc() : memref<32xf32> 183// CHECK: memref.copy %[[VAL_8]], %[[VAL_9]] : memref<32xf32> to memref<32xf32> 184// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> 185// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> 186// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_4]] { 187// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_12]]] : memref<?xindex> 188// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_12]]] : memref<?xf32> 189// CHECK: %[[VAL_15:.*]] = mulf %[[VAL_14]], %[[VAL_1]] : f32 190// CHECK: memref.store %[[VAL_15]], %[[VAL_9]]{{\[}}%[[VAL_13]]] : memref<32xf32> 191// CHECK: } 192// CHECK: %[[VAL_16:.*]] = memref.tensor_load %[[VAL_9]] : memref<32xf32> 193// CHECK: return %[[VAL_16]] : tensor<32xf32> 194// CHECK: } 195func @mul_s(%arga: tensor<32xf32, #SV>, %argb: f32, %argx: tensor<32xf32>) -> tensor<32xf32> { 196 %0 = linalg.generic #trait1 197 ins(%arga: tensor<32xf32, #SV>) 198 outs(%argx: tensor<32xf32>) { 199 ^bb(%a: f32, %x: f32): 200 %0 = mulf %a, %argb : f32 201 linalg.yield %0 : f32 202 } -> tensor<32xf32> 203 return %0 : tensor<32xf32> 204} 205 206#trait2 = { 207 indexing_maps = [ 208 affine_map<(i) -> (i)>, // a 209 affine_map<(i) -> (i)>, // b 210 affine_map<(i) -> (i)> // x (out) 211 ], 212 iterator_types = ["parallel"], 213 doc = "x(i) = a(i) OP b(i)" 214} 215 216// CHECK-LABEL: func @add_dd( 217// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 218// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>, 219// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 220// CHECK: %[[VAL_3:.*]] = constant 32 : index 221// CHECK: %[[VAL_4:.*]] = constant 0 : index 222// CHECK: %[[VAL_5:.*]] = constant 1 : index 223// CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 224// CHECK: %[[VAL_7:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32xf32> 225// CHECK: %[[VAL_8:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 226// CHECK: %[[VAL_9:.*]] = memref.alloc() : memref<32xf32> 227// CHECK: memref.copy %[[VAL_8]], %[[VAL_9]] : memref<32xf32> to memref<32xf32> 228// CHECK: scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { 229// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xf32> 230// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32> 231// CHECK: %[[VAL_13:.*]] = addf %[[VAL_11]], %[[VAL_12]] : f32 232// CHECK: memref.store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32> 233// CHECK: } 234// CHECK: %[[VAL_14:.*]] = memref.tensor_load %[[VAL_9]] : memref<32xf32> 235// CHECK: return %[[VAL_14]] : tensor<32xf32> 236// CHECK: } 237func @add_dd(%arga: tensor<32xf32, #DV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> { 238 %0 = linalg.generic #trait2 239 ins(%arga, %argb: tensor<32xf32, #DV>, tensor<32xf32>) 240 outs(%argx: tensor<32xf32>) { 241 ^bb(%a: f32, %b: f32, %x: f32): 242 %0 = addf %a, %b : f32 243 linalg.yield %0 : f32 244 } -> tensor<32xf32> 245 return %0 : tensor<32xf32> 246} 247 248// CHECK-LABEL: func @mul_dd( 249// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 250// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>, 251// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 252// CHECK: %[[VAL_3:.*]] = constant 32 : index 253// CHECK: %[[VAL_4:.*]] = constant 0 : index 254// CHECK: %[[VAL_5:.*]] = constant 1 : index 255// CHECK: %[[VAL_6:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 256// CHECK: %[[VAL_7:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32xf32> 257// CHECK: %[[VAL_8:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 258// CHECK: %[[VAL_9:.*]] = memref.alloc() : memref<32xf32> 259// CHECK: memref.copy %[[VAL_8]], %[[VAL_9]] : memref<32xf32> to memref<32xf32> 260// CHECK: scf.for %[[VAL_10:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { 261// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_10]]] : memref<?xf32> 262// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_10]]] : memref<32xf32> 263// CHECK: %[[VAL_13:.*]] = mulf %[[VAL_11]], %[[VAL_12]] : f32 264// CHECK: memref.store %[[VAL_13]], %[[VAL_9]]{{\[}}%[[VAL_10]]] : memref<32xf32> 265// CHECK: } 266// CHECK: %[[VAL_14:.*]] = memref.tensor_load %[[VAL_9]] : memref<32xf32> 267// CHECK: return %[[VAL_14]] : tensor<32xf32> 268// CHECK: } 269func @mul_dd(%arga: tensor<32xf32, #DV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> { 270 %0 = linalg.generic #trait2 271 ins(%arga, %argb: tensor<32xf32, #DV>, tensor<32xf32>) 272 outs(%argx: tensor<32xf32>) { 273 ^bb(%a: f32, %b: f32, %x: f32): 274 %0 = mulf %a, %b : f32 275 linalg.yield %0 : f32 276 } -> tensor<32xf32> 277 return %0 : tensor<32xf32> 278} 279 280// CHECK-LABEL: func @add_ds( 281// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32>, 282// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 283// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 284// CHECK-DAG: %[[VAL_3:.*]] = constant 32 : index 285// CHECK-DAG: %[[VAL_4:.*]] = constant 0 : index 286// CHECK-DAG: %[[VAL_5:.*]] = constant true 287// CHECK-DAG: %[[VAL_6:.*]] = constant 1 : index 288// CHECK: %[[VAL_7:.*]] = memref.buffer_cast %[[VAL_0]] : memref<32xf32> 289// CHECK: %[[VAL_8:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_4]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 290// CHECK: %[[VAL_9:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_4]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 291// CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 292// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 293// CHECK: %[[VAL_12:.*]] = memref.alloc() : memref<32xf32> 294// CHECK: memref.copy %[[VAL_11]], %[[VAL_12]] : memref<32xf32> to memref<32xf32> 295// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> 296// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_6]]] : memref<?xindex> 297// CHECK: %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) { 298// CHECK: %[[VAL_18:.*]] = cmpi ult, %[[VAL_16]], %[[VAL_14]] : index 299// CHECK: scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index 300// CHECK: } do { 301// CHECK: ^bb0(%[[VAL_19:.*]]: index, %[[VAL_20:.*]]: index): 302// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_19]]] : memref<?xindex> 303// CHECK: %[[VAL_22:.*]] = cmpi eq, %[[VAL_21]], %[[VAL_20]] : index 304// CHECK: scf.if %[[VAL_22]] { 305// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_20]]] : memref<32xf32> 306// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_19]]] : memref<?xf32> 307// CHECK: %[[VAL_25:.*]] = addf %[[VAL_23]], %[[VAL_24]] : f32 308// CHECK: memref.store %[[VAL_25]], %[[VAL_12]]{{\[}}%[[VAL_20]]] : memref<32xf32> 309// CHECK: } else { 310// CHECK: scf.if %[[VAL_5]] { 311// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_20]]] : memref<32xf32> 312// CHECK: memref.store %[[VAL_26]], %[[VAL_12]]{{\[}}%[[VAL_20]]] : memref<32xf32> 313// CHECK: } else { 314// CHECK: } 315// CHECK: } 316// CHECK: %[[VAL_27:.*]] = cmpi eq, %[[VAL_21]], %[[VAL_20]] : index 317// CHECK: %[[VAL_28:.*]] = addi %[[VAL_19]], %[[VAL_6]] : index 318// CHECK: %[[VAL_29:.*]] = select %[[VAL_27]], %[[VAL_28]], %[[VAL_19]] : index 319// CHECK: %[[VAL_30:.*]] = addi %[[VAL_20]], %[[VAL_6]] : index 320// CHECK: scf.yield %[[VAL_29]], %[[VAL_30]] : index, index 321// CHECK: } 322// CHECK: scf.for %[[VAL_31:.*]] = %[[VAL_32:.*]]#1 to %[[VAL_3]] step %[[VAL_6]] { 323// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_31]]] : memref<32xf32> 324// CHECK: memref.store %[[VAL_33]], %[[VAL_12]]{{\[}}%[[VAL_31]]] : memref<32xf32> 325// CHECK: } 326// CHECK: %[[VAL_34:.*]] = memref.tensor_load %[[VAL_12]] : memref<32xf32> 327// CHECK: return %[[VAL_34]] : tensor<32xf32> 328// CHECK: } 329func @add_ds(%arga: tensor<32xf32>, %argb: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> { 330 %0 = linalg.generic #trait2 331 ins(%arga, %argb: tensor<32xf32>, tensor<32xf32, #SV>) 332 outs(%argx: tensor<32xf32>) { 333 ^bb(%a: f32, %b: f32, %x: f32): 334 %0 = addf %a, %b : f32 335 linalg.yield %0 : f32 336 } -> tensor<32xf32> 337 return %0 : tensor<32xf32> 338} 339 340// CHECK-LABEL: func @mul_ds( 341// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32>, 342// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 343// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 344// CHECK: %[[VAL_3:.*]] = constant 0 : index 345// CHECK: %[[VAL_4:.*]] = constant 1 : index 346// CHECK: %[[VAL_5:.*]] = memref.buffer_cast %[[VAL_0]] : memref<32xf32> 347// CHECK: %[[VAL_6:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 348// CHECK: %[[VAL_7:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 349// CHECK: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 350// CHECK: %[[VAL_9:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 351// CHECK: %[[VAL_10:.*]] = memref.alloc() : memref<32xf32> 352// CHECK: memref.copy %[[VAL_9]], %[[VAL_10]] : memref<32xf32> to memref<32xf32> 353// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_3]]] : memref<?xindex> 354// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> 355// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] { 356// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex> 357// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_14]]] : memref<32xf32> 358// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_13]]] : memref<?xf32> 359// CHECK: %[[VAL_17:.*]] = mulf %[[VAL_15]], %[[VAL_16]] : f32 360// CHECK: memref.store %[[VAL_17]], %[[VAL_10]]{{\[}}%[[VAL_14]]] : memref<32xf32> 361// CHECK: } 362// CHECK: %[[VAL_18:.*]] = memref.tensor_load %[[VAL_10]] : memref<32xf32> 363// CHECK: return %[[VAL_18]] : tensor<32xf32> 364// CHECK: } 365func @mul_ds(%arga: tensor<32xf32>, %argb: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> { 366 %0 = linalg.generic #trait2 367 ins(%arga, %argb: tensor<32xf32>, tensor<32xf32, #SV>) 368 outs(%argx: tensor<32xf32>) { 369 ^bb(%a: f32, %b: f32, %x: f32): 370 %0 = mulf %a, %b : f32 371 linalg.yield %0 : f32 372 } -> tensor<32xf32> 373 return %0 : tensor<32xf32> 374} 375 376// CHECK-LABEL: func @add_sd( 377// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 378// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>, 379// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 380// CHECK-DAG: %[[VAL_3:.*]] = constant 32 : index 381// CHECK-DAG: %[[VAL_4:.*]] = constant 0 : index 382// CHECK-DAG: %[[VAL_5:.*]] = constant true 383// CHECK-DAG: %[[VAL_6:.*]] = constant 1 : index 384// CHECK: %[[VAL_7:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_4]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 385// CHECK: %[[VAL_8:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_4]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 386// CHECK: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 387// CHECK: %[[VAL_10:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32xf32> 388// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 389// CHECK: %[[VAL_12:.*]] = memref.alloc() : memref<32xf32> 390// CHECK: memref.copy %[[VAL_11]], %[[VAL_12]] : memref<32xf32> to memref<32xf32> 391// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_4]]] : memref<?xindex> 392// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> 393// CHECK: %[[VAL_15:.*]]:2 = scf.while (%[[VAL_16:.*]] = %[[VAL_13]], %[[VAL_17:.*]] = %[[VAL_4]]) : (index, index) -> (index, index) { 394// CHECK: %[[VAL_18:.*]] = cmpi ult, %[[VAL_16]], %[[VAL_14]] : index 395// CHECK: scf.condition(%[[VAL_18]]) %[[VAL_16]], %[[VAL_17]] : index, index 396// CHECK: } do { 397// CHECK: ^bb0(%[[VAL_19:.*]]: index, %[[VAL_20:.*]]: index): 398// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_19]]] : memref<?xindex> 399// CHECK: %[[VAL_22:.*]] = cmpi eq, %[[VAL_21]], %[[VAL_20]] : index 400// CHECK: scf.if %[[VAL_22]] { 401// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_19]]] : memref<?xf32> 402// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<32xf32> 403// CHECK: %[[VAL_25:.*]] = addf %[[VAL_23]], %[[VAL_24]] : f32 404// CHECK: memref.store %[[VAL_25]], %[[VAL_12]]{{\[}}%[[VAL_20]]] : memref<32xf32> 405// CHECK: } else { 406// CHECK: scf.if %[[VAL_5]] { 407// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<32xf32> 408// CHECK: memref.store %[[VAL_26]], %[[VAL_12]]{{\[}}%[[VAL_20]]] : memref<32xf32> 409// CHECK: } else { 410// CHECK: } 411// CHECK: } 412// CHECK: %[[VAL_27:.*]] = cmpi eq, %[[VAL_21]], %[[VAL_20]] : index 413// CHECK: %[[VAL_28:.*]] = addi %[[VAL_19]], %[[VAL_6]] : index 414// CHECK: %[[VAL_29:.*]] = select %[[VAL_27]], %[[VAL_28]], %[[VAL_19]] : index 415// CHECK: %[[VAL_30:.*]] = addi %[[VAL_20]], %[[VAL_6]] : index 416// CHECK: scf.yield %[[VAL_29]], %[[VAL_30]] : index, index 417// CHECK: } 418// CHECK: scf.for %[[VAL_31:.*]] = %[[VAL_32:.*]]#1 to %[[VAL_3]] step %[[VAL_6]] { 419// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_31]]] : memref<32xf32> 420// CHECK: memref.store %[[VAL_33]], %[[VAL_12]]{{\[}}%[[VAL_31]]] : memref<32xf32> 421// CHECK: } 422// CHECK: %[[VAL_34:.*]] = memref.tensor_load %[[VAL_12]] : memref<32xf32> 423// CHECK: return %[[VAL_34]] : tensor<32xf32> 424// CHECK: } 425func @add_sd(%arga: tensor<32xf32, #SV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> { 426 %0 = linalg.generic #trait2 427 ins(%arga, %argb: tensor<32xf32, #SV>, tensor<32xf32>) 428 outs(%argx: tensor<32xf32>) { 429 ^bb(%a: f32, %b: f32, %x: f32): 430 %0 = addf %a, %b : f32 431 linalg.yield %0 : f32 432 } -> tensor<32xf32> 433 return %0 : tensor<32xf32> 434} 435 436// CHECK-LABEL: func @mul_sd( 437// CHECK-SAME: %[[VAL_0:.*]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 438// CHECK-SAME: %[[VAL_1:.*]]: tensor<32xf32>, 439// CHECK-SAME: %[[VAL_2:.*]]: tensor<32xf32>) -> tensor<32xf32> { 440// CHECK: %[[VAL_3:.*]] = constant 0 : index 441// CHECK: %[[VAL_4:.*]] = constant 1 : index 442// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 443// CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 444// CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 445// CHECK: %[[VAL_8:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32xf32> 446// CHECK: %[[VAL_9:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 447// CHECK: %[[VAL_10:.*]] = memref.alloc() : memref<32xf32> 448// CHECK: memref.copy %[[VAL_9]], %[[VAL_10]] : memref<32xf32> to memref<32xf32> 449// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> 450// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> 451// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] { 452// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex> 453// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xf32> 454// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_14]]] : memref<32xf32> 455// CHECK: %[[VAL_17:.*]] = mulf %[[VAL_15]], %[[VAL_16]] : f32 456// CHECK: memref.store %[[VAL_17]], %[[VAL_10]]{{\[}}%[[VAL_14]]] : memref<32xf32> 457// CHECK: } 458// CHECK: %[[VAL_18:.*]] = memref.tensor_load %[[VAL_10]] : memref<32xf32> 459// CHECK: return %[[VAL_18]] : tensor<32xf32> 460// CHECK: } 461func @mul_sd(%arga: tensor<32xf32, #SV>, %argb: tensor<32xf32>, %argx: tensor<32xf32>) -> tensor<32xf32> { 462 %0 = linalg.generic #trait2 463 ins(%arga, %argb: tensor<32xf32, #SV>, tensor<32xf32>) 464 outs(%argx: tensor<32xf32>) { 465 ^bb(%a: f32, %b: f32, %x: f32): 466 %0 = mulf %a, %b : f32 467 linalg.yield %0 : f32 468 } -> tensor<32xf32> 469 return %0 : tensor<32xf32> 470} 471 472// CHECK-LABEL: func @add_ss( 473// CHECK-SAME: %[[VAL_0:.*0]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 474// CHECK-SAME: %[[VAL_1:.*1]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 475// CHECK-SAME: %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> { 476// CHECK: %[[VAL_3:.*]] = constant 0 : index 477// CHECK: %[[VAL_4:.*]] = constant 1 : index 478// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 479// CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 480// CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 481// CHECK: %[[VAL_8:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 482// CHECK: %[[VAL_9:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 483// CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 484// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 485// CHECK: %[[VAL_12:.*]] = memref.alloc() : memref<32xf32> 486// CHECK: memref.copy %[[VAL_11]], %[[VAL_12]] : memref<32xf32> to memref<32xf32> 487// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> 488// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> 489// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex> 490// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> 491// CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) { 492// CHECK: %[[VAL_20:.*]] = cmpi ult, %[[VAL_18]], %[[VAL_14]] : index 493// CHECK: %[[VAL_21:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_16]] : index 494// CHECK: %[[VAL_22:.*]] = and %[[VAL_20]], %[[VAL_21]] : i1 495// CHECK: scf.condition(%[[VAL_22]]) %[[VAL_18]], %[[VAL_19]] : index, index 496// CHECK: } do { 497// CHECK: ^bb0(%[[VAL_23:.*]]: index, %[[VAL_24:.*]]: index): 498// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_23]]] : memref<?xindex> 499// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_24]]] : memref<?xindex> 500// CHECK: %[[VAL_27:.*]] = cmpi ult, %[[VAL_26]], %[[VAL_25]] : index 501// CHECK: %[[VAL_28:.*]] = select %[[VAL_27]], %[[VAL_26]], %[[VAL_25]] : index 502// CHECK: %[[VAL_29:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_28]] : index 503// CHECK: %[[VAL_30:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_28]] : index 504// CHECK: %[[VAL_31:.*]] = and %[[VAL_29]], %[[VAL_30]] : i1 505// CHECK: scf.if %[[VAL_31]] { 506// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_23]]] : memref<?xf32> 507// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_24]]] : memref<?xf32> 508// CHECK: %[[VAL_34:.*]] = addf %[[VAL_32]], %[[VAL_33]] : f32 509// CHECK: memref.store %[[VAL_34]], %[[VAL_12]]{{\[}}%[[VAL_28]]] : memref<32xf32> 510// CHECK: } else { 511// CHECK: %[[VAL_35:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_28]] : index 512// CHECK: scf.if %[[VAL_35]] { 513// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_23]]] : memref<?xf32> 514// CHECK: memref.store %[[VAL_36]], %[[VAL_12]]{{\[}}%[[VAL_28]]] : memref<32xf32> 515// CHECK: } else { 516// CHECK: %[[VAL_37:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_28]] : index 517// CHECK: scf.if %[[VAL_37]] { 518// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_24]]] : memref<?xf32> 519// CHECK: memref.store %[[VAL_38]], %[[VAL_12]]{{\[}}%[[VAL_28]]] : memref<32xf32> 520// CHECK: } else { 521// CHECK: } 522// CHECK: } 523// CHECK: } 524// CHECK: %[[VAL_39:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_28]] : index 525// CHECK: %[[VAL_40:.*]] = addi %[[VAL_23]], %[[VAL_4]] : index 526// CHECK: %[[VAL_41:.*]] = select %[[VAL_39]], %[[VAL_40]], %[[VAL_23]] : index 527// CHECK: %[[VAL_42:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_28]] : index 528// CHECK: %[[VAL_43:.*]] = addi %[[VAL_24]], %[[VAL_4]] : index 529// CHECK: %[[VAL_44:.*]] = select %[[VAL_42]], %[[VAL_43]], %[[VAL_24]] : index 530// CHECK: scf.yield %[[VAL_41]], %[[VAL_44]] : index, index 531// CHECK: } 532// CHECK: scf.for %[[VAL_45:.*]] = %[[VAL_46:.*]]#0 to %[[VAL_14]] step %[[VAL_4]] { 533// CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_45]]] : memref<?xindex> 534// CHECK: %[[VAL_48:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_45]]] : memref<?xf32> 535// CHECK: memref.store %[[VAL_48]], %[[VAL_12]]{{\[}}%[[VAL_47]]] : memref<32xf32> 536// CHECK: } 537// CHECK: scf.for %[[VAL_49:.*]] = %[[VAL_50:.*]]#1 to %[[VAL_16]] step %[[VAL_4]] { 538// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_49]]] : memref<?xindex> 539// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_49]]] : memref<?xf32> 540// CHECK: memref.store %[[VAL_52]], %[[VAL_12]]{{\[}}%[[VAL_51]]] : memref<32xf32> 541// CHECK: } 542// CHECK: %[[VAL_53:.*]] = memref.tensor_load %[[VAL_12]] : memref<32xf32> 543// CHECK: return %[[VAL_53]] : tensor<32xf32> 544// CHECK: } 545func @add_ss(%arga: tensor<32xf32, #SV>, %argb: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> { 546 %0 = linalg.generic #trait2 547 ins(%arga, %argb: tensor<32xf32, #SV>, tensor<32xf32, #SV>) 548 outs(%argx: tensor<32xf32>) { 549 ^bb(%a: f32, %b: f32, %x: f32): 550 %0 = addf %a, %b : f32 551 linalg.yield %0 : f32 552 } -> tensor<32xf32> 553 return %0 : tensor<32xf32> 554} 555 556// CHECK-LABEL: func @mul_ss( 557// CHECK-SAME: %[[VAL_0:.*0]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 558// CHECK-SAME: %[[VAL_1:.*1]]: tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 559// CHECK-SAME: %[[VAL_2:.*2]]: tensor<32xf32>) -> tensor<32xf32> { 560// CHECK: %[[VAL_3:.*]] = constant 0 : index 561// CHECK: %[[VAL_4:.*]] = constant 1 : index 562// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 563// CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 564// CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 565// CHECK: %[[VAL_8:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 566// CHECK: %[[VAL_9:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_3]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 567// CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<32xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 568// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32xf32> 569// CHECK: %[[VAL_12:.*]] = memref.alloc() : memref<32xf32> 570// CHECK: memref.copy %[[VAL_11]], %[[VAL_12]] : memref<32xf32> to memref<32xf32> 571// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> 572// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> 573// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex> 574// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> 575// CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) { 576// CHECK: %[[VAL_20:.*]] = cmpi ult, %[[VAL_18]], %[[VAL_14]] : index 577// CHECK: %[[VAL_21:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_16]] : index 578// CHECK: %[[VAL_22:.*]] = and %[[VAL_20]], %[[VAL_21]] : i1 579// CHECK: scf.condition(%[[VAL_22]]) %[[VAL_18]], %[[VAL_19]] : index, index 580// CHECK: } do { 581// CHECK: ^bb0(%[[VAL_23:.*]]: index, %[[VAL_24:.*]]: index): 582// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_23]]] : memref<?xindex> 583// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_24]]] : memref<?xindex> 584// CHECK: %[[VAL_27:.*]] = cmpi ult, %[[VAL_26]], %[[VAL_25]] : index 585// CHECK: %[[VAL_28:.*]] = select %[[VAL_27]], %[[VAL_26]], %[[VAL_25]] : index 586// CHECK: %[[VAL_29:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_28]] : index 587// CHECK: %[[VAL_30:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_28]] : index 588// CHECK: %[[VAL_31:.*]] = and %[[VAL_29]], %[[VAL_30]] : i1 589// CHECK: scf.if %[[VAL_31]] { 590// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_23]]] : memref<?xf32> 591// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_24]]] : memref<?xf32> 592// CHECK: %[[VAL_34:.*]] = mulf %[[VAL_32]], %[[VAL_33]] : f32 593// CHECK: memref.store %[[VAL_34]], %[[VAL_12]]{{\[}}%[[VAL_28]]] : memref<32xf32> 594// CHECK: } else { 595// CHECK: } 596// CHECK: %[[VAL_35:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_28]] : index 597// CHECK: %[[VAL_36:.*]] = addi %[[VAL_23]], %[[VAL_4]] : index 598// CHECK: %[[VAL_37:.*]] = select %[[VAL_35]], %[[VAL_36]], %[[VAL_23]] : index 599// CHECK: %[[VAL_38:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_28]] : index 600// CHECK: %[[VAL_39:.*]] = addi %[[VAL_24]], %[[VAL_4]] : index 601// CHECK: %[[VAL_40:.*]] = select %[[VAL_38]], %[[VAL_39]], %[[VAL_24]] : index 602// CHECK: scf.yield %[[VAL_37]], %[[VAL_40]] : index, index 603// CHECK: } 604// CHECK: %[[VAL_41:.*]] = memref.tensor_load %[[VAL_12]] : memref<32xf32> 605// CHECK: return %[[VAL_41]] : tensor<32xf32> 606// CHECK: } 607func @mul_ss(%arga: tensor<32xf32, #SV>, %argb: tensor<32xf32, #SV>, %argx: tensor<32xf32>) -> tensor<32xf32> { 608 %0 = linalg.generic #trait2 609 ins(%arga, %argb: tensor<32xf32, #SV>, tensor<32xf32, #SV>) 610 outs(%argx: tensor<32xf32>) { 611 ^bb(%a: f32, %b: f32, %x: f32): 612 %0 = mulf %a, %b : f32 613 linalg.yield %0 : f32 614 } -> tensor<32xf32> 615 return %0 : tensor<32xf32> 616} 617 618// CHECK-LABEL: func @two_way_inv( 619// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 620// CHECK-SAME: %[[VAL_1:.*1]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 621// CHECK-SAME: %[[VAL_2:.*2]]: f32, 622// CHECK-SAME: %[[VAL_3:.*3]]: tensor<16xf32>) -> tensor<16xf32> { 623// CHECK: %[[VAL_4:.*]] = constant 0 : index 624// CHECK: %[[VAL_5:.*]] = constant 1 : index 625// CHECK: %[[VAL_6:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 626// CHECK: %[[VAL_7:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 627// CHECK: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 628// CHECK: %[[VAL_9:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 629// CHECK: %[[VAL_10:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 630// CHECK: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 631// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_3]] : memref<16xf32> 632// CHECK: %[[VAL_13:.*]] = memref.alloc() : memref<16xf32> 633// CHECK: memref.copy %[[VAL_12]], %[[VAL_13]] : memref<16xf32> to memref<16xf32> 634// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> 635// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> 636// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex> 637// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex> 638// CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]]) : (index, index) -> (index, index) { 639// CHECK: %[[VAL_21:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_15]] : index 640// CHECK: %[[VAL_22:.*]] = cmpi ult, %[[VAL_20]], %[[VAL_17]] : index 641// CHECK: %[[VAL_23:.*]] = and %[[VAL_21]], %[[VAL_22]] : i1 642// CHECK: scf.condition(%[[VAL_23]]) %[[VAL_19]], %[[VAL_20]] : index, index 643// CHECK: } do { 644// CHECK: ^bb0(%[[VAL_24:.*]]: index, %[[VAL_25:.*]]: index): 645// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_24]]] : memref<?xindex> 646// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_25]]] : memref<?xindex> 647// CHECK: %[[VAL_28:.*]] = cmpi ult, %[[VAL_27]], %[[VAL_26]] : index 648// CHECK: %[[VAL_29:.*]] = select %[[VAL_28]], %[[VAL_27]], %[[VAL_26]] : index 649// CHECK: %[[VAL_30:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_29]] : index 650// CHECK: %[[VAL_31:.*]] = cmpi eq, %[[VAL_27]], %[[VAL_29]] : index 651// CHECK: %[[VAL_32:.*]] = and %[[VAL_30]], %[[VAL_31]] : i1 652// CHECK: scf.if %[[VAL_32]] { 653// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_24]]] : memref<?xf32> 654// CHECK: %[[VAL_34:.*]] = mulf %[[VAL_33]], %[[VAL_2]] : f32 655// CHECK: %[[VAL_35:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_25]]] : memref<?xf32> 656// CHECK: %[[VAL_36:.*]] = mulf %[[VAL_35]], %[[VAL_2]] : f32 657// CHECK: %[[VAL_37:.*]] = addf %[[VAL_34]], %[[VAL_36]] : f32 658// CHECK: memref.store %[[VAL_37]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32> 659// CHECK: } else { 660// CHECK: %[[VAL_38:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_29]] : index 661// CHECK: scf.if %[[VAL_38]] { 662// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_24]]] : memref<?xf32> 663// CHECK: %[[VAL_40:.*]] = mulf %[[VAL_39]], %[[VAL_2]] : f32 664// CHECK: memref.store %[[VAL_40]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32> 665// CHECK: } else { 666// CHECK: %[[VAL_41:.*]] = cmpi eq, %[[VAL_27]], %[[VAL_29]] : index 667// CHECK: scf.if %[[VAL_41]] { 668// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_25]]] : memref<?xf32> 669// CHECK: %[[VAL_43:.*]] = mulf %[[VAL_42]], %[[VAL_2]] : f32 670// CHECK: memref.store %[[VAL_43]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32> 671// CHECK: } else { 672// CHECK: } 673// CHECK: } 674// CHECK: } 675// CHECK: %[[VAL_44:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_29]] : index 676// CHECK: %[[VAL_45:.*]] = addi %[[VAL_24]], %[[VAL_5]] : index 677// CHECK: %[[VAL_46:.*]] = select %[[VAL_44]], %[[VAL_45]], %[[VAL_24]] : index 678// CHECK: %[[VAL_47:.*]] = cmpi eq, %[[VAL_27]], %[[VAL_29]] : index 679// CHECK: %[[VAL_48:.*]] = addi %[[VAL_25]], %[[VAL_5]] : index 680// CHECK: %[[VAL_49:.*]] = select %[[VAL_47]], %[[VAL_48]], %[[VAL_25]] : index 681// CHECK: scf.yield %[[VAL_46]], %[[VAL_49]] : index, index 682// CHECK: } 683// CHECK: scf.for %[[VAL_50:.*]] = %[[VAL_51:.*]]#0 to %[[VAL_15]] step %[[VAL_5]] { 684// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_50]]] : memref<?xindex> 685// CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_50]]] : memref<?xf32> 686// CHECK: %[[VAL_54:.*]] = mulf %[[VAL_53]], %[[VAL_2]] : f32 687// CHECK: memref.store %[[VAL_54]], %[[VAL_13]]{{\[}}%[[VAL_52]]] : memref<16xf32> 688// CHECK: } 689// CHECK: scf.for %[[VAL_55:.*]] = %[[VAL_56:.*]]#1 to %[[VAL_17]] step %[[VAL_5]] { 690// CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_55]]] : memref<?xindex> 691// CHECK: %[[VAL_58:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_55]]] : memref<?xf32> 692// CHECK: %[[VAL_59:.*]] = mulf %[[VAL_58]], %[[VAL_2]] : f32 693// CHECK: memref.store %[[VAL_59]], %[[VAL_13]]{{\[}}%[[VAL_57]]] : memref<16xf32> 694// CHECK: } 695// CHECK: %[[VAL_60:.*]] = memref.tensor_load %[[VAL_13]] : memref<16xf32> 696// CHECK: return %[[VAL_60]] : tensor<16xf32> 697// CHECK: } 698func @two_way_inv(%arga: tensor<16xf32, #SV>, %argb: tensor<16xf32, #SV>, %argc: f32, %argx: tensor<16xf32>) -> tensor<16xf32> { 699 // Kernel "x(i) = a(i) * c + b(i) * c". 700 %0 = linalg.generic #trait2 701 ins(%arga, %argb: tensor<16xf32, #SV>, tensor<16xf32, #SV>) 702 outs(%argx: tensor<16xf32>) { 703 ^bb(%a: f32, %b: f32, %x: f32): 704 %0 = mulf %a, %argc : f32 705 %1 = mulf %b, %argc : f32 706 %2 = addf %0, %1 : f32 707 linalg.yield %2 : f32 708 } -> tensor<16xf32> 709 return %0 : tensor<16xf32> 710} 711 712// CHECK-LABEL: func @two_way_inv_alt( 713// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 714// CHECK-SAME: %[[VAL_1:.*1]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 715// CHECK-SAME: %[[VAL_2:.*2]]: f32, 716// CHECK-SAME: %[[VAL_3:.*3]]: tensor<16xf32>) -> tensor<16xf32> { 717// CHECK: %[[VAL_4:.*]] = constant 0 : index 718// CHECK: %[[VAL_5:.*]] = constant 1 : index 719// CHECK: %[[VAL_6:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 720// CHECK: %[[VAL_7:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 721// CHECK: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 722// CHECK: %[[VAL_9:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 723// CHECK: %[[VAL_10:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 724// CHECK: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 725// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_3]] : memref<16xf32> 726// CHECK: %[[VAL_13:.*]] = memref.alloc() : memref<16xf32> 727// CHECK: memref.copy %[[VAL_12]], %[[VAL_13]] : memref<16xf32> to memref<16xf32> 728// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> 729// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> 730// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex> 731// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex> 732// CHECK: %[[VAL_18:.*]]:2 = scf.while (%[[VAL_19:.*]] = %[[VAL_14]], %[[VAL_20:.*]] = %[[VAL_16]]) : (index, index) -> (index, index) { 733// CHECK: %[[VAL_21:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_15]] : index 734// CHECK: %[[VAL_22:.*]] = cmpi ult, %[[VAL_20]], %[[VAL_17]] : index 735// CHECK: %[[VAL_23:.*]] = and %[[VAL_21]], %[[VAL_22]] : i1 736// CHECK: scf.condition(%[[VAL_23]]) %[[VAL_19]], %[[VAL_20]] : index, index 737// CHECK: } do { 738// CHECK: ^bb0(%[[VAL_24:.*]]: index, %[[VAL_25:.*]]: index): 739// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_24]]] : memref<?xindex> 740// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_25]]] : memref<?xindex> 741// CHECK: %[[VAL_28:.*]] = cmpi ult, %[[VAL_27]], %[[VAL_26]] : index 742// CHECK: %[[VAL_29:.*]] = select %[[VAL_28]], %[[VAL_27]], %[[VAL_26]] : index 743// CHECK: %[[VAL_30:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_29]] : index 744// CHECK: %[[VAL_31:.*]] = cmpi eq, %[[VAL_27]], %[[VAL_29]] : index 745// CHECK: %[[VAL_32:.*]] = and %[[VAL_30]], %[[VAL_31]] : i1 746// CHECK: scf.if %[[VAL_32]] { 747// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_24]]] : memref<?xf32> 748// CHECK: %[[VAL_34:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_25]]] : memref<?xf32> 749// CHECK: %[[VAL_35:.*]] = addf %[[VAL_33]], %[[VAL_34]] : f32 750// CHECK: %[[VAL_36:.*]] = mulf %[[VAL_35]], %[[VAL_2]] : f32 751// CHECK: memref.store %[[VAL_36]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32> 752// CHECK: } else { 753// CHECK: %[[VAL_37:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_29]] : index 754// CHECK: scf.if %[[VAL_37]] { 755// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_24]]] : memref<?xf32> 756// CHECK: %[[VAL_39:.*]] = mulf %[[VAL_38]], %[[VAL_2]] : f32 757// CHECK: memref.store %[[VAL_39]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32> 758// CHECK: } else { 759// CHECK: %[[VAL_40:.*]] = cmpi eq, %[[VAL_27]], %[[VAL_29]] : index 760// CHECK: scf.if %[[VAL_40]] { 761// CHECK: %[[VAL_41:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_25]]] : memref<?xf32> 762// CHECK: %[[VAL_42:.*]] = mulf %[[VAL_41]], %[[VAL_2]] : f32 763// CHECK: memref.store %[[VAL_42]], %[[VAL_13]]{{\[}}%[[VAL_29]]] : memref<16xf32> 764// CHECK: } else { 765// CHECK: } 766// CHECK: } 767// CHECK: } 768// CHECK: %[[VAL_43:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_29]] : index 769// CHECK: %[[VAL_44:.*]] = addi %[[VAL_24]], %[[VAL_5]] : index 770// CHECK: %[[VAL_45:.*]] = select %[[VAL_43]], %[[VAL_44]], %[[VAL_24]] : index 771// CHECK: %[[VAL_46:.*]] = cmpi eq, %[[VAL_27]], %[[VAL_29]] : index 772// CHECK: %[[VAL_47:.*]] = addi %[[VAL_25]], %[[VAL_5]] : index 773// CHECK: %[[VAL_48:.*]] = select %[[VAL_46]], %[[VAL_47]], %[[VAL_25]] : index 774// CHECK: scf.yield %[[VAL_45]], %[[VAL_48]] : index, index 775// CHECK: } 776// CHECK: scf.for %[[VAL_49:.*]] = %[[VAL_50:.*]]#0 to %[[VAL_15]] step %[[VAL_5]] { 777// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_49]]] : memref<?xindex> 778// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_49]]] : memref<?xf32> 779// CHECK: %[[VAL_53:.*]] = mulf %[[VAL_52]], %[[VAL_2]] : f32 780// CHECK: memref.store %[[VAL_53]], %[[VAL_13]]{{\[}}%[[VAL_51]]] : memref<16xf32> 781// CHECK: } 782// CHECK: scf.for %[[VAL_54:.*]] = %[[VAL_55:.*]]#1 to %[[VAL_17]] step %[[VAL_5]] { 783// CHECK: %[[VAL_56:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_54]]] : memref<?xindex> 784// CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_54]]] : memref<?xf32> 785// CHECK: %[[VAL_58:.*]] = mulf %[[VAL_57]], %[[VAL_2]] : f32 786// CHECK: memref.store %[[VAL_58]], %[[VAL_13]]{{\[}}%[[VAL_56]]] : memref<16xf32> 787// CHECK: } 788// CHECK: %[[VAL_59:.*]] = memref.tensor_load %[[VAL_13]] : memref<16xf32> 789// CHECK: return %[[VAL_59]] : tensor<16xf32> 790// CHECK: } 791func @two_way_inv_alt(%arga: tensor<16xf32, #SV>, 792 %argb: tensor<16xf32, #SV>, %argc: f32, %argx: tensor<16xf32>) -> tensor<16xf32> { 793 // Same kernel, but now expressed as "x(i) = (a(i) + b(i)) * c". 794 %0 = linalg.generic #trait2 795 ins(%arga, %argb: tensor<16xf32, #SV>, tensor<16xf32, #SV>) 796 outs(%argx: tensor<16xf32>) { 797 ^bb(%a: f32, %b: f32, %x: f32): 798 %0 = addf %a, %b : f32 799 %1 = mulf %0, %argc : f32 800 linalg.yield %1 : f32 801 } -> tensor<16xf32> 802 return %0 : tensor<16xf32> 803} 804 805#trait_sum_reduction = { 806 indexing_maps = [ 807 affine_map<(i) -> (i)>, // a 808 affine_map<(i) -> ()> // x (scalar out) 809 ], 810 iterator_types = ["reduction"], 811 doc = "x += SUM_i a(i)" 812} 813 814// CHECK-LABEL: func @sum_reduction( 815// CHECK-SAME: %[[VAL_0:.*]]: tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 816// CHECK-SAME: %[[VAL_1:.*]]: tensor<f32>) -> tensor<f32> { 817// CHECK: %[[VAL_2:.*]] = constant 0 : index 818// CHECK: %[[VAL_3:.*]] = constant 1 : index 819// CHECK: %[[VAL_4:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_2]] : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 820// CHECK: %[[VAL_5:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 821// CHECK: %[[VAL_6:.*]] = memref.buffer_cast %[[VAL_1]] : memref<f32> 822// CHECK: %[[VAL_7:.*]] = memref.alloc() : memref<f32> 823// CHECK: memref.copy %[[VAL_6]], %[[VAL_7]] : memref<f32> to memref<f32> 824// CHECK: %[[VAL_8:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_2]]] : memref<?xindex> 825// CHECK: %[[VAL_9:.*]] = memref.load %[[VAL_4]]{{\[}}%[[VAL_3]]] : memref<?xindex> 826// CHECK: %[[VAL_10:.*]] = memref.load %[[VAL_7]][] : memref<f32> 827// CHECK: %[[VAL_11:.*]] = scf.for %[[VAL_12:.*]] = %[[VAL_8]] to %[[VAL_9]] step %[[VAL_3]] iter_args(%[[VAL_13:.*]] = %[[VAL_10]]) -> (f32) { 828// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_12]]] : memref<?xf32> 829// CHECK: %[[VAL_15:.*]] = addf %[[VAL_13]], %[[VAL_14]] : f32 830// CHECK: scf.yield %[[VAL_15]] : f32 831// CHECK: } 832// CHECK: memref.store %[[VAL_16:.*]], %[[VAL_7]][] : memref<f32> 833// CHECK: %[[VAL_17:.*]] = memref.tensor_load %[[VAL_7]] : memref<f32> 834// CHECK: return %[[VAL_17]] : tensor<f32> 835// CHECK: } 836func @sum_reduction(%arga: tensor<?xf32, #SV>, %argx: tensor<f32>) -> tensor<f32> { 837 %0 = linalg.generic #trait_sum_reduction 838 ins(%arga: tensor<?xf32, #SV>) 839 outs(%argx: tensor<f32>) { 840 ^bb(%a: f32, %x: f32): 841 %0 = addf %x, %a : f32 842 linalg.yield %0 : f32 843 } -> tensor<f32> 844 return %0 : tensor<f32> 845} 846 847#trait_sum_reduction2 = { 848 indexing_maps = [ 849 affine_map<(i) -> (i)>, // a 850 affine_map<(i) -> (i)>, // b 851 affine_map<(i)-> ()> // x (scalar out) 852 ], 853 iterator_types = ["reduction"], 854 doc = "x += SUM_i a(i) + b(i)" 855} 856 857// CHECK-LABEL: func @sum_reduction_ss( 858// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 859// CHECK-SAME: %[[VAL_1:.*1]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 860// CHECK-SAME: %[[VAL_2:.*2]]: tensor<f32>) -> tensor<f32> { 861// CHECK: %[[VAL_3:.*]] = constant 0 : index 862// CHECK: %[[VAL_4:.*]] = constant 1 : index 863// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 864// CHECK: %[[VAL_6:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 865// CHECK: %[[VAL_7:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 866// CHECK: %[[VAL_8:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_3]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 867// CHECK: %[[VAL_9:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_3]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 868// CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 869// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<f32> 870// CHECK: %[[VAL_12:.*]] = memref.alloc() : memref<f32> 871// CHECK: memref.copy %[[VAL_11]], %[[VAL_12]] : memref<f32> to memref<f32> 872// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> 873// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> 874// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<?xindex> 875// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<?xindex> 876// CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_13]], %[[VAL_19:.*]] = %[[VAL_15]]) : (index, index) -> (index, index) { 877// CHECK: %[[VAL_20:.*]] = cmpi ult, %[[VAL_18]], %[[VAL_14]] : index 878// CHECK: %[[VAL_21:.*]] = cmpi ult, %[[VAL_19]], %[[VAL_16]] : index 879// CHECK: %[[VAL_22:.*]] = and %[[VAL_20]], %[[VAL_21]] : i1 880// CHECK: scf.condition(%[[VAL_22]]) %[[VAL_18]], %[[VAL_19]] : index, index 881// CHECK: } do { 882// CHECK: ^bb0(%[[VAL_23:.*]]: index, %[[VAL_24:.*]]: index): 883// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_23]]] : memref<?xindex> 884// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_24]]] : memref<?xindex> 885// CHECK: %[[VAL_27:.*]] = cmpi ult, %[[VAL_26]], %[[VAL_25]] : index 886// CHECK: %[[VAL_28:.*]] = select %[[VAL_27]], %[[VAL_26]], %[[VAL_25]] : index 887// CHECK: %[[VAL_29:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_28]] : index 888// CHECK: %[[VAL_30:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_28]] : index 889// CHECK: %[[VAL_31:.*]] = and %[[VAL_29]], %[[VAL_30]] : i1 890// CHECK: scf.if %[[VAL_31]] { 891// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_12]][] : memref<f32> 892// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_23]]] : memref<?xf32> 893// CHECK: %[[VAL_34:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_24]]] : memref<?xf32> 894// CHECK: %[[VAL_35:.*]] = addf %[[VAL_33]], %[[VAL_34]] : f32 895// CHECK: %[[VAL_36:.*]] = addf %[[VAL_32]], %[[VAL_35]] : f32 896// CHECK: memref.store %[[VAL_36]], %[[VAL_12]][] : memref<f32> 897// CHECK: } else { 898// CHECK: %[[VAL_37:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_28]] : index 899// CHECK: scf.if %[[VAL_37]] { 900// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_12]][] : memref<f32> 901// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_23]]] : memref<?xf32> 902// CHECK: %[[VAL_40:.*]] = addf %[[VAL_38]], %[[VAL_39]] : f32 903// CHECK: memref.store %[[VAL_40]], %[[VAL_12]][] : memref<f32> 904// CHECK: } else { 905// CHECK: %[[VAL_41:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_28]] : index 906// CHECK: scf.if %[[VAL_41]] { 907// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_12]][] : memref<f32> 908// CHECK: %[[VAL_43:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_24]]] : memref<?xf32> 909// CHECK: %[[VAL_44:.*]] = addf %[[VAL_42]], %[[VAL_43]] : f32 910// CHECK: memref.store %[[VAL_44]], %[[VAL_12]][] : memref<f32> 911// CHECK: } else { 912// CHECK: } 913// CHECK: } 914// CHECK: } 915// CHECK: %[[VAL_45:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_28]] : index 916// CHECK: %[[VAL_46:.*]] = addi %[[VAL_23]], %[[VAL_4]] : index 917// CHECK: %[[VAL_47:.*]] = select %[[VAL_45]], %[[VAL_46]], %[[VAL_23]] : index 918// CHECK: %[[VAL_48:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_28]] : index 919// CHECK: %[[VAL_49:.*]] = addi %[[VAL_24]], %[[VAL_4]] : index 920// CHECK: %[[VAL_50:.*]] = select %[[VAL_48]], %[[VAL_49]], %[[VAL_24]] : index 921// CHECK: scf.yield %[[VAL_47]], %[[VAL_50]] : index, index 922// CHECK: } 923// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_12]][] : memref<f32> 924// CHECK: %[[VAL_52:.*]] = scf.for %[[VAL_53:.*]] = %[[VAL_54:.*]]#0 to %[[VAL_14]] step %[[VAL_4]] iter_args(%[[VAL_55:.*]] = %[[VAL_51]]) -> (f32) { 925// CHECK: %[[VAL_56:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_53]]] : memref<?xf32> 926// CHECK: %[[VAL_57:.*]] = addf %[[VAL_55]], %[[VAL_56]] : f32 927// CHECK: scf.yield %[[VAL_57]] : f32 928// CHECK: } 929// CHECK: %[[VAL_58:.*]] = scf.for %[[VAL_59:.*]] = %[[VAL_60:.*]]#1 to %[[VAL_16]] step %[[VAL_4]] iter_args(%[[VAL_61:.*]] = %[[VAL_62:.*]]) -> (f32) { 930// CHECK: %[[VAL_63:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_59]]] : memref<?xf32> 931// CHECK: %[[VAL_64:.*]] = addf %[[VAL_61]], %[[VAL_63]] : f32 932// CHECK: scf.yield %[[VAL_64]] : f32 933// CHECK: } 934// CHECK: memref.store %[[VAL_65:.*]], %[[VAL_12]][] : memref<f32> 935// CHECK: %[[VAL_66:.*]] = memref.tensor_load %[[VAL_12]] : memref<f32> 936// CHECK: return %[[VAL_66]] : tensor<f32> 937// CHECK: } 938func @sum_reduction_ss(%arga: tensor<16xf32, #SV>, 939 %argb: tensor<16xf32, #SV>, 940 %argx: tensor<f32>) -> tensor<f32> { 941 // Just for testing. This case would be better expressed 942 // as two separate reductions kernels. 943 %0 = linalg.generic #trait_sum_reduction2 944 ins(%arga, %argb: tensor<16xf32, #SV>, tensor<16xf32, #SV>) 945 outs(%argx: tensor<f32>) { 946 ^bb(%a: f32, %b: f32, %x: f32): 947 %0 = addf %a, %b : f32 948 %1 = addf %x, %0 : f32 949 linalg.yield %1 : f32 950 } -> tensor<f32> 951 return %0 : tensor<f32> 952} 953 954#trait_sum_reduction_inv = { 955 indexing_maps = [ 956 affine_map<(i) -> (i)>, // a 957 affine_map<(i) -> ()>, // b 958 affine_map<(i) -> (i)>, // c 959 affine_map<(i) -> ()> // x (out) 960 ], 961 iterator_types = ["reduction"], 962 doc = "x += SUM_i a(i) * b + c(i)" 963} 964 965// CHECK-LABEL: func @sum_reduction_inv( 966// CHECK-SAME: %[[VAL_0:.*0]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 967// CHECK-SAME: %[[VAL_1:.*1]]: tensor<f32>, 968// CHECK-SAME: %[[VAL_2:.*2]]: tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 969// CHECK-SAME: %[[VAL_3:.*3]]: tensor<f32>) -> tensor<f32> { 970// CHECK: %[[VAL_4:.*]] = constant 0 : index 971// CHECK: %[[VAL_5:.*]] = constant 1 : index 972// CHECK: %[[VAL_6:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 973// CHECK: %[[VAL_7:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 974// CHECK: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 975// CHECK: %[[VAL_9:.*]] = memref.buffer_cast %[[VAL_1]] : memref<f32> 976// CHECK: %[[VAL_10:.*]] = sparse_tensor.pointers %[[VAL_2]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 977// CHECK: %[[VAL_11:.*]] = sparse_tensor.indices %[[VAL_2]], %[[VAL_4]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 978// CHECK: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<16xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 979// CHECK: %[[VAL_13:.*]] = memref.buffer_cast %[[VAL_3]] : memref<f32> 980// CHECK: %[[VAL_14:.*]] = memref.alloc() : memref<f32> 981// CHECK: memref.copy %[[VAL_13]], %[[VAL_14]] : memref<f32> to memref<f32> 982// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_9]][] : memref<f32> 983// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> 984// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> 985// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<?xindex> 986// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_5]]] : memref<?xindex> 987// CHECK: %[[VAL_20:.*]]:2 = scf.while (%[[VAL_21:.*]] = %[[VAL_16]], %[[VAL_22:.*]] = %[[VAL_18]]) : (index, index) -> (index, index) { 988// CHECK: %[[VAL_23:.*]] = cmpi ult, %[[VAL_21]], %[[VAL_17]] : index 989// CHECK: %[[VAL_24:.*]] = cmpi ult, %[[VAL_22]], %[[VAL_19]] : index 990// CHECK: %[[VAL_25:.*]] = and %[[VAL_23]], %[[VAL_24]] : i1 991// CHECK: scf.condition(%[[VAL_25]]) %[[VAL_21]], %[[VAL_22]] : index, index 992// CHECK: } do { 993// CHECK: ^bb0(%[[VAL_26:.*]]: index, %[[VAL_27:.*]]: index): 994// CHECK: %[[VAL_28:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_26]]] : memref<?xindex> 995// CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_27]]] : memref<?xindex> 996// CHECK: %[[VAL_30:.*]] = cmpi ult, %[[VAL_29]], %[[VAL_28]] : index 997// CHECK: %[[VAL_31:.*]] = select %[[VAL_30]], %[[VAL_29]], %[[VAL_28]] : index 998// CHECK: %[[VAL_32:.*]] = cmpi eq, %[[VAL_28]], %[[VAL_31]] : index 999// CHECK: %[[VAL_33:.*]] = cmpi eq, %[[VAL_29]], %[[VAL_31]] : index 1000// CHECK: %[[VAL_34:.*]] = and %[[VAL_32]], %[[VAL_33]] : i1 1001// CHECK: scf.if %[[VAL_34]] { 1002// CHECK: %[[VAL_35:.*]] = memref.load %[[VAL_14]][] : memref<f32> 1003// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_26]]] : memref<?xf32> 1004// CHECK: %[[VAL_37:.*]] = mulf %[[VAL_36]], %[[VAL_15]] : f32 1005// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_27]]] : memref<?xf32> 1006// CHECK: %[[VAL_39:.*]] = addf %[[VAL_37]], %[[VAL_38]] : f32 1007// CHECK: %[[VAL_40:.*]] = addf %[[VAL_35]], %[[VAL_39]] : f32 1008// CHECK: memref.store %[[VAL_40]], %[[VAL_14]][] : memref<f32> 1009// CHECK: } else { 1010// CHECK: %[[VAL_41:.*]] = cmpi eq, %[[VAL_28]], %[[VAL_31]] : index 1011// CHECK: scf.if %[[VAL_41]] { 1012// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_14]][] : memref<f32> 1013// CHECK: %[[VAL_43:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_26]]] : memref<?xf32> 1014// CHECK: %[[VAL_44:.*]] = mulf %[[VAL_43]], %[[VAL_15]] : f32 1015// CHECK: %[[VAL_45:.*]] = addf %[[VAL_42]], %[[VAL_44]] : f32 1016// CHECK: memref.store %[[VAL_45]], %[[VAL_14]][] : memref<f32> 1017// CHECK: } else { 1018// CHECK: %[[VAL_46:.*]] = cmpi eq, %[[VAL_29]], %[[VAL_31]] : index 1019// CHECK: scf.if %[[VAL_46]] { 1020// CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_14]][] : memref<f32> 1021// CHECK: %[[VAL_48:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_27]]] : memref<?xf32> 1022// CHECK: %[[VAL_49:.*]] = addf %[[VAL_47]], %[[VAL_48]] : f32 1023// CHECK: memref.store %[[VAL_49]], %[[VAL_14]][] : memref<f32> 1024// CHECK: } else { 1025// CHECK: } 1026// CHECK: } 1027// CHECK: } 1028// CHECK: %[[VAL_50:.*]] = cmpi eq, %[[VAL_28]], %[[VAL_31]] : index 1029// CHECK: %[[VAL_51:.*]] = addi %[[VAL_26]], %[[VAL_5]] : index 1030// CHECK: %[[VAL_52:.*]] = select %[[VAL_50]], %[[VAL_51]], %[[VAL_26]] : index 1031// CHECK: %[[VAL_53:.*]] = cmpi eq, %[[VAL_29]], %[[VAL_31]] : index 1032// CHECK: %[[VAL_54:.*]] = addi %[[VAL_27]], %[[VAL_5]] : index 1033// CHECK: %[[VAL_55:.*]] = select %[[VAL_53]], %[[VAL_54]], %[[VAL_27]] : index 1034// CHECK: scf.yield %[[VAL_52]], %[[VAL_55]] : index, index 1035// CHECK: } 1036// CHECK: %[[VAL_56:.*]] = memref.load %[[VAL_14]][] : memref<f32> 1037// CHECK: %[[VAL_57:.*]] = scf.for %[[VAL_58:.*]] = %[[VAL_59:.*]]#0 to %[[VAL_17]] step %[[VAL_5]] iter_args(%[[VAL_60:.*]] = %[[VAL_56]]) -> (f32) { 1038// CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_58]]] : memref<?xf32> 1039// CHECK: %[[VAL_62:.*]] = mulf %[[VAL_61]], %[[VAL_15]] : f32 1040// CHECK: %[[VAL_63:.*]] = addf %[[VAL_60]], %[[VAL_62]] : f32 1041// CHECK: scf.yield %[[VAL_63]] : f32 1042// CHECK: } 1043// CHECK: %[[VAL_64:.*]] = scf.for %[[VAL_65:.*]] = %[[VAL_66:.*]]#1 to %[[VAL_19]] step %[[VAL_5]] iter_args(%[[VAL_67:.*]] = %[[VAL_68:.*]]) -> (f32) { 1044// CHECK: %[[VAL_69:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_65]]] : memref<?xf32> 1045// CHECK: %[[VAL_70:.*]] = addf %[[VAL_67]], %[[VAL_69]] : f32 1046// CHECK: scf.yield %[[VAL_70]] : f32 1047// CHECK: } 1048// CHECK: memref.store %[[VAL_71:.*]], %[[VAL_14]][] : memref<f32> 1049// CHECK: %[[VAL_72:.*]] = memref.tensor_load %[[VAL_14]] : memref<f32> 1050// CHECK: return %[[VAL_72]] : tensor<f32> 1051// CHECK: } 1052func @sum_reduction_inv(%arga: tensor<16xf32, #SV>, 1053 %argb: tensor<f32>, 1054 %argc: tensor<16xf32, #SV>, 1055 %argx: tensor<f32>) -> tensor<f32> { 1056 // Just for testing. This case would be better expressed 1057 // as two separate reductions kernels. 1058 %0 = linalg.generic #trait_sum_reduction_inv 1059 ins(%arga, %argb, %argc : tensor<16xf32, #SV>, tensor<f32>, tensor<16xf32, #SV>) 1060 outs(%argx: tensor<f32>) { 1061 ^bb(%a: f32, %b: f32, %c: f32, %x: f32): 1062 %0 = mulf %a, %b : f32 1063 %1 = addf %0, %c : f32 1064 %2 = addf %x, %1 : f32 1065 linalg.yield %2 : f32 1066 } -> tensor<f32> 1067 return %0 : tensor<f32> 1068} 1069 1070#trait_four_tensors = { 1071 indexing_maps = [ 1072 affine_map<(i) -> (i)>, // A 1073 affine_map<(i) -> (i)>, // B 1074 affine_map<(i) -> (i)>, // C 1075 affine_map<(i) -> (i)>, // D 1076 affine_map<(i) -> (i)> // X (out) 1077 ], 1078 iterator_types = ["parallel"], 1079 doc = "X(i) = A(i) + B(i) + C(i) + D(i)" 1080} 1081 1082// CHECK-LABEL: func @four_tensors_op( 1083// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?xf64>, 1084// CHECK-SAME: %[[VAL_1:.*1]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 1085// CHECK-SAME: %[[VAL_2:.*2]]: tensor<?xf64>, 1086// CHECK-SAME: %[[VAL_3:.*3]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 1087// CHECK-SAME: %[[VAL_4:.*]]: tensor<?xf64>) -> tensor<?xf64> { 1088// CHECK-DAG: %[[VAL_5:.*]] = constant 0 : index 1089// CHECK-DAG: %[[VAL_6:.*]] = constant true 1090// CHECK-DAG: %[[VAL_7:.*]] = constant 1 : index 1091// CHECK: %[[VAL_8:.*]] = memref.buffer_cast %[[VAL_0]] : memref<?xf64> 1092// CHECK: %[[VAL_9:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_5]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1093// CHECK: %[[VAL_10:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_5]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1094// CHECK: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf64> 1095// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_2]] : memref<?xf64> 1096// CHECK: %[[VAL_13:.*]] = sparse_tensor.pointers %[[VAL_3]], %[[VAL_5]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1097// CHECK: %[[VAL_14:.*]] = sparse_tensor.indices %[[VAL_3]], %[[VAL_5]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1098// CHECK: %[[VAL_15:.*]] = sparse_tensor.values %[[VAL_3]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf64> 1099// CHECK: %[[VAL_16:.*]] = tensor.dim %[[VAL_4]], %[[VAL_5]] : tensor<?xf64> 1100// CHECK: %[[VAL_17:.*]] = memref.buffer_cast %[[VAL_4]] : memref<?xf64> 1101// CHECK: %[[VAL_18:.*]] = memref.alloc(%[[VAL_16]]) : memref<?xf64> 1102// CHECK: memref.copy %[[VAL_17]], %[[VAL_18]] : memref<?xf64> to memref<?xf64> 1103// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex> 1104// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex> 1105// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_5]]] : memref<?xindex> 1106// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_7]]] : memref<?xindex> 1107// CHECK: %[[VAL_23:.*]]:3 = scf.while (%[[VAL_24:.*]] = %[[VAL_19]], %[[VAL_25:.*]] = %[[VAL_21]], %[[VAL_26:.*]] = %[[VAL_5]]) : (index, index, index) -> (index, index, index) { 1108// CHECK: %[[VAL_27:.*]] = cmpi ult, %[[VAL_24]], %[[VAL_20]] : index 1109// CHECK: %[[VAL_28:.*]] = cmpi ult, %[[VAL_25]], %[[VAL_22]] : index 1110// CHECK: %[[VAL_29:.*]] = and %[[VAL_27]], %[[VAL_28]] : i1 1111// CHECK: scf.condition(%[[VAL_29]]) %[[VAL_24]], %[[VAL_25]], %[[VAL_26]] : index, index, index 1112// CHECK: } do { 1113// CHECK: ^bb0(%[[VAL_30:.*]]: index, %[[VAL_31:.*]]: index, %[[VAL_32:.*]]: index): 1114// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_30]]] : memref<?xindex> 1115// CHECK: %[[VAL_34:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_31]]] : memref<?xindex> 1116// CHECK: %[[VAL_35:.*]] = cmpi eq, %[[VAL_33]], %[[VAL_32]] : index 1117// CHECK: %[[VAL_36:.*]] = cmpi eq, %[[VAL_34]], %[[VAL_32]] : index 1118// CHECK: %[[VAL_37:.*]] = and %[[VAL_35]], %[[VAL_36]] : i1 1119// CHECK: scf.if %[[VAL_37]] { 1120// CHECK: %[[VAL_38:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1121// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_30]]] : memref<?xf64> 1122// CHECK: %[[VAL_40:.*]] = addf %[[VAL_38]], %[[VAL_39]] : f64 1123// CHECK: %[[VAL_41:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1124// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_31]]] : memref<?xf64> 1125// CHECK: %[[VAL_43:.*]] = addf %[[VAL_41]], %[[VAL_42]] : f64 1126// CHECK: %[[VAL_44:.*]] = addf %[[VAL_40]], %[[VAL_43]] : f64 1127// CHECK: memref.store %[[VAL_44]], %[[VAL_18]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1128// CHECK: } else { 1129// CHECK: %[[VAL_45:.*]] = cmpi eq, %[[VAL_33]], %[[VAL_32]] : index 1130// CHECK: scf.if %[[VAL_45]] { 1131// CHECK: %[[VAL_46:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1132// CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_30]]] : memref<?xf64> 1133// CHECK: %[[VAL_48:.*]] = addf %[[VAL_46]], %[[VAL_47]] : f64 1134// CHECK: %[[VAL_49:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1135// CHECK: %[[VAL_50:.*]] = addf %[[VAL_48]], %[[VAL_49]] : f64 1136// CHECK: memref.store %[[VAL_50]], %[[VAL_18]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1137// CHECK: } else { 1138// CHECK: %[[VAL_51:.*]] = cmpi eq, %[[VAL_34]], %[[VAL_32]] : index 1139// CHECK: scf.if %[[VAL_51]] { 1140// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1141// CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1142// CHECK: %[[VAL_54:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_31]]] : memref<?xf64> 1143// CHECK: %[[VAL_55:.*]] = addf %[[VAL_53]], %[[VAL_54]] : f64 1144// CHECK: %[[VAL_56:.*]] = addf %[[VAL_52]], %[[VAL_55]] : f64 1145// CHECK: memref.store %[[VAL_56]], %[[VAL_18]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1146// CHECK: } else { 1147// CHECK: scf.if %[[VAL_6]] { 1148// CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1149// CHECK: %[[VAL_58:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1150// CHECK: %[[VAL_59:.*]] = addf %[[VAL_57]], %[[VAL_58]] : f64 1151// CHECK: memref.store %[[VAL_59]], %[[VAL_18]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1152// CHECK: } else { 1153// CHECK: } 1154// CHECK: } 1155// CHECK: } 1156// CHECK: } 1157// CHECK: %[[VAL_60:.*]] = cmpi eq, %[[VAL_33]], %[[VAL_32]] : index 1158// CHECK: %[[VAL_61:.*]] = addi %[[VAL_30]], %[[VAL_7]] : index 1159// CHECK: %[[VAL_62:.*]] = select %[[VAL_60]], %[[VAL_61]], %[[VAL_30]] : index 1160// CHECK: %[[VAL_63:.*]] = cmpi eq, %[[VAL_34]], %[[VAL_32]] : index 1161// CHECK: %[[VAL_64:.*]] = addi %[[VAL_31]], %[[VAL_7]] : index 1162// CHECK: %[[VAL_65:.*]] = select %[[VAL_63]], %[[VAL_64]], %[[VAL_31]] : index 1163// CHECK: %[[VAL_66:.*]] = addi %[[VAL_32]], %[[VAL_7]] : index 1164// CHECK: scf.yield %[[VAL_62]], %[[VAL_65]], %[[VAL_66]] : index, index, index 1165// CHECK: } 1166// CHECK: %[[VAL_67:.*]]:2 = scf.while (%[[VAL_68:.*]] = %[[VAL_69:.*]]#0, %[[VAL_70:.*]] = %[[VAL_69]]#2) : (index, index) -> (index, index) { 1167// CHECK: %[[VAL_71:.*]] = cmpi ult, %[[VAL_68]], %[[VAL_20]] : index 1168// CHECK: scf.condition(%[[VAL_71]]) %[[VAL_68]], %[[VAL_70]] : index, index 1169// CHECK: } do { 1170// CHECK: ^bb0(%[[VAL_72:.*]]: index, %[[VAL_73:.*]]: index): 1171// CHECK: %[[VAL_74:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_72]]] : memref<?xindex> 1172// CHECK: %[[VAL_75:.*]] = cmpi eq, %[[VAL_74]], %[[VAL_73]] : index 1173// CHECK: scf.if %[[VAL_75]] { 1174// CHECK: %[[VAL_76:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_73]]] : memref<?xf64> 1175// CHECK: %[[VAL_77:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_72]]] : memref<?xf64> 1176// CHECK: %[[VAL_78:.*]] = addf %[[VAL_76]], %[[VAL_77]] : f64 1177// CHECK: %[[VAL_79:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_73]]] : memref<?xf64> 1178// CHECK: %[[VAL_80:.*]] = addf %[[VAL_78]], %[[VAL_79]] : f64 1179// CHECK: memref.store %[[VAL_80]], %[[VAL_18]]{{\[}}%[[VAL_73]]] : memref<?xf64> 1180// CHECK: } else { 1181// CHECK: scf.if %[[VAL_6]] { 1182// CHECK: %[[VAL_81:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_73]]] : memref<?xf64> 1183// CHECK: %[[VAL_82:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_73]]] : memref<?xf64> 1184// CHECK: %[[VAL_83:.*]] = addf %[[VAL_81]], %[[VAL_82]] : f64 1185// CHECK: memref.store %[[VAL_83]], %[[VAL_18]]{{\[}}%[[VAL_73]]] : memref<?xf64> 1186// CHECK: } else { 1187// CHECK: } 1188// CHECK: } 1189// CHECK: %[[VAL_84:.*]] = cmpi eq, %[[VAL_74]], %[[VAL_73]] : index 1190// CHECK: %[[VAL_85:.*]] = addi %[[VAL_72]], %[[VAL_7]] : index 1191// CHECK: %[[VAL_86:.*]] = select %[[VAL_84]], %[[VAL_85]], %[[VAL_72]] : index 1192// CHECK: %[[VAL_87:.*]] = addi %[[VAL_73]], %[[VAL_7]] : index 1193// CHECK: scf.yield %[[VAL_86]], %[[VAL_87]] : index, index 1194// CHECK: } 1195// CHECK: %[[VAL_88:.*]]:2 = scf.while (%[[VAL_89:.*]] = %[[VAL_90:.*]]#1, %[[VAL_91:.*]] = %[[VAL_92:.*]]#1) : (index, index) -> (index, index) { 1196// CHECK: %[[VAL_93:.*]] = cmpi ult, %[[VAL_89]], %[[VAL_22]] : index 1197// CHECK: scf.condition(%[[VAL_93]]) %[[VAL_89]], %[[VAL_91]] : index, index 1198// CHECK: } do { 1199// CHECK: ^bb0(%[[VAL_94:.*]]: index, %[[VAL_95:.*]]: index): 1200// CHECK: %[[VAL_96:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_94]]] : memref<?xindex> 1201// CHECK: %[[VAL_97:.*]] = cmpi eq, %[[VAL_96]], %[[VAL_95]] : index 1202// CHECK: scf.if %[[VAL_97]] { 1203// CHECK: %[[VAL_98:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_95]]] : memref<?xf64> 1204// CHECK: %[[VAL_99:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_95]]] : memref<?xf64> 1205// CHECK: %[[VAL_100:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_94]]] : memref<?xf64> 1206// CHECK: %[[VAL_101:.*]] = addf %[[VAL_99]], %[[VAL_100]] : f64 1207// CHECK: %[[VAL_102:.*]] = addf %[[VAL_98]], %[[VAL_101]] : f64 1208// CHECK: memref.store %[[VAL_102]], %[[VAL_18]]{{\[}}%[[VAL_95]]] : memref<?xf64> 1209// CHECK: } else { 1210// CHECK: scf.if %[[VAL_6]] { 1211// CHECK: %[[VAL_103:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_95]]] : memref<?xf64> 1212// CHECK: %[[VAL_104:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_95]]] : memref<?xf64> 1213// CHECK: %[[VAL_105:.*]] = addf %[[VAL_103]], %[[VAL_104]] : f64 1214// CHECK: memref.store %[[VAL_105]], %[[VAL_18]]{{\[}}%[[VAL_95]]] : memref<?xf64> 1215// CHECK: } else { 1216// CHECK: } 1217// CHECK: } 1218// CHECK: %[[VAL_106:.*]] = cmpi eq, %[[VAL_96]], %[[VAL_95]] : index 1219// CHECK: %[[VAL_107:.*]] = addi %[[VAL_94]], %[[VAL_7]] : index 1220// CHECK: %[[VAL_108:.*]] = select %[[VAL_106]], %[[VAL_107]], %[[VAL_94]] : index 1221// CHECK: %[[VAL_109:.*]] = addi %[[VAL_95]], %[[VAL_7]] : index 1222// CHECK: scf.yield %[[VAL_108]], %[[VAL_109]] : index, index 1223// CHECK: } 1224// CHECK: scf.for %[[VAL_110:.*]] = %[[VAL_111:.*]]#1 to %[[VAL_16]] step %[[VAL_7]] { 1225// CHECK: %[[VAL_112:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_110]]] : memref<?xf64> 1226// CHECK: %[[VAL_113:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_110]]] : memref<?xf64> 1227// CHECK: %[[VAL_114:.*]] = addf %[[VAL_112]], %[[VAL_113]] : f64 1228// CHECK: memref.store %[[VAL_114]], %[[VAL_18]]{{\[}}%[[VAL_110]]] : memref<?xf64> 1229// CHECK: } 1230// CHECK: %[[VAL_115:.*]] = memref.tensor_load %[[VAL_18]] : memref<?xf64> 1231// CHECK: return %[[VAL_115]] : tensor<?xf64> 1232// CHECK: } 1233func @four_tensors_op(%arga: tensor<?xf64>, 1234 %argb: tensor<?xf64, #SV>, 1235 %argc: tensor<?xf64>, 1236 %argd: tensor<?xf64, #SV>, 1237 %argx: tensor<?xf64>) -> tensor<?xf64> { 1238 %r = linalg.generic #trait_four_tensors 1239 ins(%arga, %argb, %argc, %argd: tensor<?xf64>, tensor<?xf64, #SV>, tensor<?xf64>, tensor<?xf64, #SV>) 1240 outs(%argx: tensor<?xf64>) { 1241 ^bb(%a: f64, %b: f64, %c: f64, %d: f64, %x: f64): 1242 %0 = addf %a, %b : f64 1243 %1 = addf %c, %d : f64 1244 %2 = addf %0, %1 : f64 1245 linalg.yield %2 : f64 1246 } -> tensor<?xf64> 1247 return %r : tensor<?xf64> 1248} 1249 1250#trait_red3s = { 1251 indexing_maps = [ 1252 affine_map<(i) -> (i)>, 1253 affine_map<(i) -> (i)>, 1254 affine_map<(i) -> (i)>, 1255 affine_map<(i) -> ()> 1256 ], 1257 iterator_types = ["reduction"], 1258 doc = "x += a(i) + b(i) + c(i)" 1259} 1260 1261// CHECK-LABEL: func @red3s( 1262// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 1263// CHECK-SAME: %[[VAL_1:.*1]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 1264// CHECK-SAME: %[[VAL_2:.*2]]: tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 1265// CHECK-SAME: %[[VAL_3:.*3]]: tensor<f64>) -> tensor<f64> { 1266// CHECK: %[[VAL_4:.*]] = constant 0 : index 1267// CHECK: %[[VAL_5:.*]] = constant 1 : index 1268// CHECK: %[[VAL_6:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_4]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1269// CHECK: %[[VAL_7:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_4]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1270// CHECK: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf64> 1271// CHECK: %[[VAL_9:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_4]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1272// CHECK: %[[VAL_10:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_4]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1273// CHECK: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf64> 1274// CHECK: %[[VAL_12:.*]] = sparse_tensor.pointers %[[VAL_2]], %[[VAL_4]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1275// CHECK: %[[VAL_13:.*]] = sparse_tensor.indices %[[VAL_2]], %[[VAL_4]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1276// CHECK: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_2]] : tensor<?xf64, #sparse_tensor.encoding<{ dimLevelType = [ "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf64> 1277// CHECK: %[[VAL_15:.*]] = memref.buffer_cast %[[VAL_3]] : memref<f64> 1278// CHECK: %[[VAL_16:.*]] = memref.alloc() : memref<f64> 1279// CHECK: memref.copy %[[VAL_15]], %[[VAL_16]] : memref<f64> to memref<f64> 1280// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> 1281// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> 1282// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_4]]] : memref<?xindex> 1283// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_5]]] : memref<?xindex> 1284// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_4]]] : memref<?xindex> 1285// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<?xindex> 1286// CHECK: %[[VAL_23:.*]]:3 = scf.while (%[[VAL_24:.*]] = %[[VAL_17]], %[[VAL_25:.*]] = %[[VAL_19]], %[[VAL_26:.*]] = %[[VAL_21]]) : (index, index, index) -> (index, index, index) { 1287// CHECK: %[[VAL_27:.*]] = cmpi ult, %[[VAL_24]], %[[VAL_18]] : index 1288// CHECK: %[[VAL_28:.*]] = cmpi ult, %[[VAL_25]], %[[VAL_20]] : index 1289// CHECK: %[[VAL_29:.*]] = and %[[VAL_27]], %[[VAL_28]] : i1 1290// CHECK: %[[VAL_30:.*]] = cmpi ult, %[[VAL_26]], %[[VAL_22]] : index 1291// CHECK: %[[VAL_31:.*]] = and %[[VAL_29]], %[[VAL_30]] : i1 1292// CHECK: scf.condition(%[[VAL_31]]) %[[VAL_24]], %[[VAL_25]], %[[VAL_26]] : index, index, index 1293// CHECK: } do { 1294// CHECK: ^bb0(%[[VAL_32:.*]]: index, %[[VAL_33:.*]]: index, %[[VAL_34:.*]]: index): 1295// CHECK: %[[VAL_35:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_32]]] : memref<?xindex> 1296// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_33]]] : memref<?xindex> 1297// CHECK: %[[VAL_37:.*]] = cmpi ult, %[[VAL_36]], %[[VAL_35]] : index 1298// CHECK: %[[VAL_38:.*]] = select %[[VAL_37]], %[[VAL_36]], %[[VAL_35]] : index 1299// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_34]]] : memref<?xindex> 1300// CHECK: %[[VAL_40:.*]] = cmpi ult, %[[VAL_39]], %[[VAL_38]] : index 1301// CHECK: %[[VAL_41:.*]] = select %[[VAL_40]], %[[VAL_39]], %[[VAL_38]] : index 1302// CHECK: %[[VAL_42:.*]] = cmpi eq, %[[VAL_35]], %[[VAL_41]] : index 1303// CHECK: %[[VAL_43:.*]] = cmpi eq, %[[VAL_36]], %[[VAL_41]] : index 1304// CHECK: %[[VAL_44:.*]] = and %[[VAL_42]], %[[VAL_43]] : i1 1305// CHECK: %[[VAL_45:.*]] = cmpi eq, %[[VAL_39]], %[[VAL_41]] : index 1306// CHECK: %[[VAL_46:.*]] = and %[[VAL_44]], %[[VAL_45]] : i1 1307// CHECK: scf.if %[[VAL_46]] { 1308// CHECK: %[[VAL_47:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1309// CHECK: %[[VAL_48:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1310// CHECK: %[[VAL_49:.*]] = addf %[[VAL_47]], %[[VAL_48]] : f64 1311// CHECK: %[[VAL_50:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_33]]] : memref<?xf64> 1312// CHECK: %[[VAL_51:.*]] = addf %[[VAL_49]], %[[VAL_50]] : f64 1313// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_34]]] : memref<?xf64> 1314// CHECK: %[[VAL_53:.*]] = addf %[[VAL_51]], %[[VAL_52]] : f64 1315// CHECK: memref.store %[[VAL_53]], %[[VAL_16]][] : memref<f64> 1316// CHECK: } else { 1317// CHECK: %[[VAL_54:.*]] = cmpi eq, %[[VAL_36]], %[[VAL_41]] : index 1318// CHECK: %[[VAL_55:.*]] = cmpi eq, %[[VAL_39]], %[[VAL_41]] : index 1319// CHECK: %[[VAL_56:.*]] = and %[[VAL_54]], %[[VAL_55]] : i1 1320// CHECK: scf.if %[[VAL_56]] { 1321// CHECK: %[[VAL_57:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1322// CHECK: %[[VAL_58:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_33]]] : memref<?xf64> 1323// CHECK: %[[VAL_59:.*]] = addf %[[VAL_57]], %[[VAL_58]] : f64 1324// CHECK: %[[VAL_60:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_34]]] : memref<?xf64> 1325// CHECK: %[[VAL_61:.*]] = addf %[[VAL_59]], %[[VAL_60]] : f64 1326// CHECK: memref.store %[[VAL_61]], %[[VAL_16]][] : memref<f64> 1327// CHECK: } else { 1328// CHECK: %[[VAL_62:.*]] = cmpi eq, %[[VAL_35]], %[[VAL_41]] : index 1329// CHECK: %[[VAL_63:.*]] = cmpi eq, %[[VAL_39]], %[[VAL_41]] : index 1330// CHECK: %[[VAL_64:.*]] = and %[[VAL_62]], %[[VAL_63]] : i1 1331// CHECK: scf.if %[[VAL_64]] { 1332// CHECK: %[[VAL_65:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1333// CHECK: %[[VAL_66:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1334// CHECK: %[[VAL_67:.*]] = addf %[[VAL_65]], %[[VAL_66]] : f64 1335// CHECK: %[[VAL_68:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_34]]] : memref<?xf64> 1336// CHECK: %[[VAL_69:.*]] = addf %[[VAL_67]], %[[VAL_68]] : f64 1337// CHECK: memref.store %[[VAL_69]], %[[VAL_16]][] : memref<f64> 1338// CHECK: } else { 1339// CHECK: %[[VAL_70:.*]] = cmpi eq, %[[VAL_39]], %[[VAL_41]] : index 1340// CHECK: scf.if %[[VAL_70]] { 1341// CHECK: %[[VAL_71:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1342// CHECK: %[[VAL_72:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_34]]] : memref<?xf64> 1343// CHECK: %[[VAL_73:.*]] = addf %[[VAL_71]], %[[VAL_72]] : f64 1344// CHECK: memref.store %[[VAL_73]], %[[VAL_16]][] : memref<f64> 1345// CHECK: } else { 1346// CHECK: %[[VAL_74:.*]] = cmpi eq, %[[VAL_35]], %[[VAL_41]] : index 1347// CHECK: %[[VAL_75:.*]] = cmpi eq, %[[VAL_36]], %[[VAL_41]] : index 1348// CHECK: %[[VAL_76:.*]] = and %[[VAL_74]], %[[VAL_75]] : i1 1349// CHECK: scf.if %[[VAL_76]] { 1350// CHECK: %[[VAL_77:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1351// CHECK: %[[VAL_78:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1352// CHECK: %[[VAL_79:.*]] = addf %[[VAL_77]], %[[VAL_78]] : f64 1353// CHECK: %[[VAL_80:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_33]]] : memref<?xf64> 1354// CHECK: %[[VAL_81:.*]] = addf %[[VAL_79]], %[[VAL_80]] : f64 1355// CHECK: memref.store %[[VAL_81]], %[[VAL_16]][] : memref<f64> 1356// CHECK: } else { 1357// CHECK: %[[VAL_82:.*]] = cmpi eq, %[[VAL_36]], %[[VAL_41]] : index 1358// CHECK: scf.if %[[VAL_82]] { 1359// CHECK: %[[VAL_83:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1360// CHECK: %[[VAL_84:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_33]]] : memref<?xf64> 1361// CHECK: %[[VAL_85:.*]] = addf %[[VAL_83]], %[[VAL_84]] : f64 1362// CHECK: memref.store %[[VAL_85]], %[[VAL_16]][] : memref<f64> 1363// CHECK: } else { 1364// CHECK: %[[VAL_86:.*]] = cmpi eq, %[[VAL_35]], %[[VAL_41]] : index 1365// CHECK: scf.if %[[VAL_86]] { 1366// CHECK: %[[VAL_87:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1367// CHECK: %[[VAL_88:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_32]]] : memref<?xf64> 1368// CHECK: %[[VAL_89:.*]] = addf %[[VAL_87]], %[[VAL_88]] : f64 1369// CHECK: memref.store %[[VAL_89]], %[[VAL_16]][] : memref<f64> 1370// CHECK: } else { 1371// CHECK: } 1372// CHECK: } 1373// CHECK: } 1374// CHECK: } 1375// CHECK: } 1376// CHECK: } 1377// CHECK: } 1378// CHECK: %[[VAL_90:.*]] = cmpi eq, %[[VAL_35]], %[[VAL_41]] : index 1379// CHECK: %[[VAL_91:.*]] = addi %[[VAL_32]], %[[VAL_5]] : index 1380// CHECK: %[[VAL_92:.*]] = select %[[VAL_90]], %[[VAL_91]], %[[VAL_32]] : index 1381// CHECK: %[[VAL_93:.*]] = cmpi eq, %[[VAL_36]], %[[VAL_41]] : index 1382// CHECK: %[[VAL_94:.*]] = addi %[[VAL_33]], %[[VAL_5]] : index 1383// CHECK: %[[VAL_95:.*]] = select %[[VAL_93]], %[[VAL_94]], %[[VAL_33]] : index 1384// CHECK: %[[VAL_96:.*]] = cmpi eq, %[[VAL_39]], %[[VAL_41]] : index 1385// CHECK: %[[VAL_97:.*]] = addi %[[VAL_34]], %[[VAL_5]] : index 1386// CHECK: %[[VAL_98:.*]] = select %[[VAL_96]], %[[VAL_97]], %[[VAL_34]] : index 1387// CHECK: scf.yield %[[VAL_92]], %[[VAL_95]], %[[VAL_98]] : index, index, index 1388// CHECK: } 1389// CHECK: %[[VAL_99:.*]]:2 = scf.while (%[[VAL_100:.*]] = %[[VAL_101:.*]]#1, %[[VAL_102:.*]] = %[[VAL_101]]#2) : (index, index) -> (index, index) { 1390// CHECK: %[[VAL_103:.*]] = cmpi ult, %[[VAL_100]], %[[VAL_20]] : index 1391// CHECK: %[[VAL_104:.*]] = cmpi ult, %[[VAL_102]], %[[VAL_22]] : index 1392// CHECK: %[[VAL_105:.*]] = and %[[VAL_103]], %[[VAL_104]] : i1 1393// CHECK: scf.condition(%[[VAL_105]]) %[[VAL_100]], %[[VAL_102]] : index, index 1394// CHECK: } do { 1395// CHECK: ^bb0(%[[VAL_106:.*]]: index, %[[VAL_107:.*]]: index): 1396// CHECK: %[[VAL_108:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_106]]] : memref<?xindex> 1397// CHECK: %[[VAL_109:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_107]]] : memref<?xindex> 1398// CHECK: %[[VAL_110:.*]] = cmpi ult, %[[VAL_109]], %[[VAL_108]] : index 1399// CHECK: %[[VAL_111:.*]] = select %[[VAL_110]], %[[VAL_109]], %[[VAL_108]] : index 1400// CHECK: %[[VAL_112:.*]] = cmpi eq, %[[VAL_108]], %[[VAL_111]] : index 1401// CHECK: %[[VAL_113:.*]] = cmpi eq, %[[VAL_109]], %[[VAL_111]] : index 1402// CHECK: %[[VAL_114:.*]] = and %[[VAL_112]], %[[VAL_113]] : i1 1403// CHECK: scf.if %[[VAL_114]] { 1404// CHECK: %[[VAL_115:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1405// CHECK: %[[VAL_116:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_106]]] : memref<?xf64> 1406// CHECK: %[[VAL_117:.*]] = addf %[[VAL_115]], %[[VAL_116]] : f64 1407// CHECK: %[[VAL_118:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_107]]] : memref<?xf64> 1408// CHECK: %[[VAL_119:.*]] = addf %[[VAL_117]], %[[VAL_118]] : f64 1409// CHECK: memref.store %[[VAL_119]], %[[VAL_16]][] : memref<f64> 1410// CHECK: } else { 1411// CHECK: %[[VAL_120:.*]] = cmpi eq, %[[VAL_109]], %[[VAL_111]] : index 1412// CHECK: scf.if %[[VAL_120]] { 1413// CHECK: %[[VAL_121:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1414// CHECK: %[[VAL_122:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_107]]] : memref<?xf64> 1415// CHECK: %[[VAL_123:.*]] = addf %[[VAL_121]], %[[VAL_122]] : f64 1416// CHECK: memref.store %[[VAL_123]], %[[VAL_16]][] : memref<f64> 1417// CHECK: } else { 1418// CHECK: %[[VAL_124:.*]] = cmpi eq, %[[VAL_108]], %[[VAL_111]] : index 1419// CHECK: scf.if %[[VAL_124]] { 1420// CHECK: %[[VAL_125:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1421// CHECK: %[[VAL_126:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_106]]] : memref<?xf64> 1422// CHECK: %[[VAL_127:.*]] = addf %[[VAL_125]], %[[VAL_126]] : f64 1423// CHECK: memref.store %[[VAL_127]], %[[VAL_16]][] : memref<f64> 1424// CHECK: } else { 1425// CHECK: } 1426// CHECK: } 1427// CHECK: } 1428// CHECK: %[[VAL_128:.*]] = cmpi eq, %[[VAL_108]], %[[VAL_111]] : index 1429// CHECK: %[[VAL_129:.*]] = addi %[[VAL_106]], %[[VAL_5]] : index 1430// CHECK: %[[VAL_130:.*]] = select %[[VAL_128]], %[[VAL_129]], %[[VAL_106]] : index 1431// CHECK: %[[VAL_131:.*]] = cmpi eq, %[[VAL_109]], %[[VAL_111]] : index 1432// CHECK: %[[VAL_132:.*]] = addi %[[VAL_107]], %[[VAL_5]] : index 1433// CHECK: %[[VAL_133:.*]] = select %[[VAL_131]], %[[VAL_132]], %[[VAL_107]] : index 1434// CHECK: scf.yield %[[VAL_130]], %[[VAL_133]] : index, index 1435// CHECK: } 1436// CHECK: %[[VAL_134:.*]]:2 = scf.while (%[[VAL_135:.*]] = %[[VAL_136:.*]]#0, %[[VAL_137:.*]] = %[[VAL_138:.*]]#1) : (index, index) -> (index, index) { 1437// CHECK: %[[VAL_139:.*]] = cmpi ult, %[[VAL_135]], %[[VAL_18]] : index 1438// CHECK: %[[VAL_140:.*]] = cmpi ult, %[[VAL_137]], %[[VAL_22]] : index 1439// CHECK: %[[VAL_141:.*]] = and %[[VAL_139]], %[[VAL_140]] : i1 1440// CHECK: scf.condition(%[[VAL_141]]) %[[VAL_135]], %[[VAL_137]] : index, index 1441// CHECK: } do { 1442// CHECK: ^bb0(%[[VAL_142:.*]]: index, %[[VAL_143:.*]]: index): 1443// CHECK: %[[VAL_144:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_142]]] : memref<?xindex> 1444// CHECK: %[[VAL_145:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_143]]] : memref<?xindex> 1445// CHECK: %[[VAL_146:.*]] = cmpi ult, %[[VAL_145]], %[[VAL_144]] : index 1446// CHECK: %[[VAL_147:.*]] = select %[[VAL_146]], %[[VAL_145]], %[[VAL_144]] : index 1447// CHECK: %[[VAL_148:.*]] = cmpi eq, %[[VAL_144]], %[[VAL_147]] : index 1448// CHECK: %[[VAL_149:.*]] = cmpi eq, %[[VAL_145]], %[[VAL_147]] : index 1449// CHECK: %[[VAL_150:.*]] = and %[[VAL_148]], %[[VAL_149]] : i1 1450// CHECK: scf.if %[[VAL_150]] { 1451// CHECK: %[[VAL_151:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1452// CHECK: %[[VAL_152:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_142]]] : memref<?xf64> 1453// CHECK: %[[VAL_153:.*]] = addf %[[VAL_151]], %[[VAL_152]] : f64 1454// CHECK: %[[VAL_154:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_143]]] : memref<?xf64> 1455// CHECK: %[[VAL_155:.*]] = addf %[[VAL_153]], %[[VAL_154]] : f64 1456// CHECK: memref.store %[[VAL_155]], %[[VAL_16]][] : memref<f64> 1457// CHECK: } else { 1458// CHECK: %[[VAL_156:.*]] = cmpi eq, %[[VAL_145]], %[[VAL_147]] : index 1459// CHECK: scf.if %[[VAL_156]] { 1460// CHECK: %[[VAL_157:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1461// CHECK: %[[VAL_158:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_143]]] : memref<?xf64> 1462// CHECK: %[[VAL_159:.*]] = addf %[[VAL_157]], %[[VAL_158]] : f64 1463// CHECK: memref.store %[[VAL_159]], %[[VAL_16]][] : memref<f64> 1464// CHECK: } else { 1465// CHECK: %[[VAL_160:.*]] = cmpi eq, %[[VAL_144]], %[[VAL_147]] : index 1466// CHECK: scf.if %[[VAL_160]] { 1467// CHECK: %[[VAL_161:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1468// CHECK: %[[VAL_162:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_142]]] : memref<?xf64> 1469// CHECK: %[[VAL_163:.*]] = addf %[[VAL_161]], %[[VAL_162]] : f64 1470// CHECK: memref.store %[[VAL_163]], %[[VAL_16]][] : memref<f64> 1471// CHECK: } else { 1472// CHECK: } 1473// CHECK: } 1474// CHECK: } 1475// CHECK: %[[VAL_164:.*]] = cmpi eq, %[[VAL_144]], %[[VAL_147]] : index 1476// CHECK: %[[VAL_165:.*]] = addi %[[VAL_142]], %[[VAL_5]] : index 1477// CHECK: %[[VAL_166:.*]] = select %[[VAL_164]], %[[VAL_165]], %[[VAL_142]] : index 1478// CHECK: %[[VAL_167:.*]] = cmpi eq, %[[VAL_145]], %[[VAL_147]] : index 1479// CHECK: %[[VAL_168:.*]] = addi %[[VAL_143]], %[[VAL_5]] : index 1480// CHECK: %[[VAL_169:.*]] = select %[[VAL_167]], %[[VAL_168]], %[[VAL_143]] : index 1481// CHECK: scf.yield %[[VAL_166]], %[[VAL_169]] : index, index 1482// CHECK: } 1483// CHECK: %[[VAL_170:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1484// CHECK: %[[VAL_171:.*]] = scf.for %[[VAL_172:.*]] = %[[VAL_173:.*]]#1 to %[[VAL_22]] step %[[VAL_5]] iter_args(%[[VAL_174:.*]] = %[[VAL_170]]) -> (f64) { 1485// CHECK: %[[VAL_175:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_172]]] : memref<?xf64> 1486// CHECK: %[[VAL_176:.*]] = addf %[[VAL_174]], %[[VAL_175]] : f64 1487// CHECK: scf.yield %[[VAL_176]] : f64 1488// CHECK: } 1489// CHECK: memref.store %[[VAL_177:.*]], %[[VAL_16]][] : memref<f64> 1490// CHECK: %[[VAL_178:.*]]:2 = scf.while (%[[VAL_179:.*]] = %[[VAL_180:.*]]#0, %[[VAL_181:.*]] = %[[VAL_182:.*]]#0) : (index, index) -> (index, index) { 1491// CHECK: %[[VAL_183:.*]] = cmpi ult, %[[VAL_179]], %[[VAL_18]] : index 1492// CHECK: %[[VAL_184:.*]] = cmpi ult, %[[VAL_181]], %[[VAL_20]] : index 1493// CHECK: %[[VAL_185:.*]] = and %[[VAL_183]], %[[VAL_184]] : i1 1494// CHECK: scf.condition(%[[VAL_185]]) %[[VAL_179]], %[[VAL_181]] : index, index 1495// CHECK: } do { 1496// CHECK: ^bb0(%[[VAL_186:.*]]: index, %[[VAL_187:.*]]: index): 1497// CHECK: %[[VAL_188:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_186]]] : memref<?xindex> 1498// CHECK: %[[VAL_189:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_187]]] : memref<?xindex> 1499// CHECK: %[[VAL_190:.*]] = cmpi ult, %[[VAL_189]], %[[VAL_188]] : index 1500// CHECK: %[[VAL_191:.*]] = select %[[VAL_190]], %[[VAL_189]], %[[VAL_188]] : index 1501// CHECK: %[[VAL_192:.*]] = cmpi eq, %[[VAL_188]], %[[VAL_191]] : index 1502// CHECK: %[[VAL_193:.*]] = cmpi eq, %[[VAL_189]], %[[VAL_191]] : index 1503// CHECK: %[[VAL_194:.*]] = and %[[VAL_192]], %[[VAL_193]] : i1 1504// CHECK: scf.if %[[VAL_194]] { 1505// CHECK: %[[VAL_195:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1506// CHECK: %[[VAL_196:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_186]]] : memref<?xf64> 1507// CHECK: %[[VAL_197:.*]] = addf %[[VAL_195]], %[[VAL_196]] : f64 1508// CHECK: %[[VAL_198:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_187]]] : memref<?xf64> 1509// CHECK: %[[VAL_199:.*]] = addf %[[VAL_197]], %[[VAL_198]] : f64 1510// CHECK: memref.store %[[VAL_199]], %[[VAL_16]][] : memref<f64> 1511// CHECK: } else { 1512// CHECK: %[[VAL_200:.*]] = cmpi eq, %[[VAL_189]], %[[VAL_191]] : index 1513// CHECK: scf.if %[[VAL_200]] { 1514// CHECK: %[[VAL_201:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1515// CHECK: %[[VAL_202:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_187]]] : memref<?xf64> 1516// CHECK: %[[VAL_203:.*]] = addf %[[VAL_201]], %[[VAL_202]] : f64 1517// CHECK: memref.store %[[VAL_203]], %[[VAL_16]][] : memref<f64> 1518// CHECK: } else { 1519// CHECK: %[[VAL_204:.*]] = cmpi eq, %[[VAL_188]], %[[VAL_191]] : index 1520// CHECK: scf.if %[[VAL_204]] { 1521// CHECK: %[[VAL_205:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1522// CHECK: %[[VAL_206:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_186]]] : memref<?xf64> 1523// CHECK: %[[VAL_207:.*]] = addf %[[VAL_205]], %[[VAL_206]] : f64 1524// CHECK: memref.store %[[VAL_207]], %[[VAL_16]][] : memref<f64> 1525// CHECK: } else { 1526// CHECK: } 1527// CHECK: } 1528// CHECK: } 1529// CHECK: %[[VAL_208:.*]] = cmpi eq, %[[VAL_188]], %[[VAL_191]] : index 1530// CHECK: %[[VAL_209:.*]] = addi %[[VAL_186]], %[[VAL_5]] : index 1531// CHECK: %[[VAL_210:.*]] = select %[[VAL_208]], %[[VAL_209]], %[[VAL_186]] : index 1532// CHECK: %[[VAL_211:.*]] = cmpi eq, %[[VAL_189]], %[[VAL_191]] : index 1533// CHECK: %[[VAL_212:.*]] = addi %[[VAL_187]], %[[VAL_5]] : index 1534// CHECK: %[[VAL_213:.*]] = select %[[VAL_211]], %[[VAL_212]], %[[VAL_187]] : index 1535// CHECK: scf.yield %[[VAL_210]], %[[VAL_213]] : index, index 1536// CHECK: } 1537// CHECK: %[[VAL_214:.*]] = memref.load %[[VAL_16]][] : memref<f64> 1538// CHECK: %[[VAL_215:.*]] = scf.for %[[VAL_216:.*]] = %[[VAL_217:.*]]#1 to %[[VAL_20]] step %[[VAL_5]] iter_args(%[[VAL_218:.*]] = %[[VAL_214]]) -> (f64) { 1539// CHECK: %[[VAL_219:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_216]]] : memref<?xf64> 1540// CHECK: %[[VAL_220:.*]] = addf %[[VAL_218]], %[[VAL_219]] : f64 1541// CHECK: scf.yield %[[VAL_220]] : f64 1542// CHECK: } 1543// CHECK: %[[VAL_221:.*]] = scf.for %[[VAL_222:.*]] = %[[VAL_223:.*]]#0 to %[[VAL_18]] step %[[VAL_5]] iter_args(%[[VAL_224:.*]] = %[[VAL_225:.*]]) -> (f64) { 1544// CHECK: %[[VAL_226:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_222]]] : memref<?xf64> 1545// CHECK: %[[VAL_227:.*]] = addf %[[VAL_224]], %[[VAL_226]] : f64 1546// CHECK: scf.yield %[[VAL_227]] : f64 1547// CHECK: } 1548// CHECK: memref.store %[[VAL_228:.*]], %[[VAL_16]][] : memref<f64> 1549// CHECK: %[[VAL_229:.*]] = memref.tensor_load %[[VAL_16]] : memref<f64> 1550// CHECK: return %[[VAL_229]] : tensor<f64> 1551// CHECK: } 1552func @red3s(%arga: tensor<?xf64, #SV>, 1553 %argb: tensor<?xf64, #SV>, 1554 %argc: tensor<?xf64, #SV>, %argx: tensor<f64>) ->tensor<f64>{ 1555 %0 = linalg.generic #trait_red3s 1556 ins(%arga, %argb, %argc: tensor<?xf64, #SV>, tensor<?xf64, #SV>, tensor<?xf64, #SV>) 1557 outs(%argx: tensor<f64>) { 1558 ^bb(%a: f64,%b: f64,%c: f64,%x: f64): 1559 %0 = addf %x, %a : f64 1560 %1 = addf %0, %b : f64 1561 %2 = addf %1, %c : f64 1562 linalg.yield %2 : f64 1563 } -> tensor<f64> 1564 return %0 : tensor<f64> 1565} 1566