1// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py 2// RUN: mlir-opt %s -sparsification | FileCheck %s 3 4#Tddd = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ] }> 5#Tdds = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ] }> 6#Tdsd = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ] }> 7#Tdss = #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ] }> 8#Tsdd = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ] }> 9#Tsds = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ] }> 10#Tssd = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ] }> 11#Tsss = #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ] }> 12 13#trait3 = { 14 indexing_maps = [ 15 affine_map<(i,j,k) -> (i,j,k)>, // A 16 affine_map<(i,j,k) -> (i,j,k)>, // B 17 affine_map<(i,j,k) -> (i,j,k)> // X (out) 18 ], 19 iterator_types = ["parallel", "parallel", "parallel"], 20 doc = "X(i,j,k) = A(i,j,k) OP B(i,j,k)" 21} 22 23// CHECK-LABEL: func @add_ddd( 24// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 25// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 26// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 27// CHECK: %[[VAL_3:.*]] = constant 32 : index 28// CHECK: %[[VAL_4:.*]] = constant 16 : index 29// CHECK: %[[VAL_5:.*]] = constant 8 : index 30// CHECK: %[[VAL_6:.*]] = constant 0 : index 31// CHECK: %[[VAL_7:.*]] = constant 1 : index 32// CHECK: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 33// CHECK: %[[VAL_9:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 34// CHECK: %[[VAL_10:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 35// CHECK: %[[VAL_11:.*]] = memref.alloc() : memref<32x16x8xf32> 36// CHECK: linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 37// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_6]] to %[[VAL_3]] step %[[VAL_7]] { 38// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] { 39// CHECK: %[[VAL_14:.*]] = muli %[[VAL_12]], %[[VAL_4]] : index 40// CHECK: %[[VAL_15:.*]] = addi %[[VAL_14]], %[[VAL_13]] : index 41// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] { 42// CHECK: %[[VAL_17:.*]] = muli %[[VAL_15]], %[[VAL_5]] : index 43// CHECK: %[[VAL_18:.*]] = addi %[[VAL_17]], %[[VAL_16]] : index 44// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xf32> 45// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_16]]] : memref<32x16x8xf32> 46// CHECK: %[[VAL_21:.*]] = addf %[[VAL_19]], %[[VAL_20]] : f32 47// CHECK: memref.store %[[VAL_21]], %[[VAL_11]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_16]]] : memref<32x16x8xf32> 48// CHECK: } 49// CHECK: } 50// CHECK: } 51// CHECK: %[[VAL_22:.*]] = memref.tensor_load %[[VAL_11]] : memref<32x16x8xf32> 52// CHECK: return %[[VAL_22]] : tensor<32x16x8xf32> 53// CHECK: } 54func @add_ddd(%arga: tensor<32x16x8xf32, #Tddd>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 55 %0 = linalg.generic #trait3 56 ins(%arga, %argb: tensor<32x16x8xf32, #Tddd>, tensor<32x16x8xf32>) 57 outs(%argx: tensor<32x16x8xf32>) { 58 ^bb(%a: f32, %b: f32, %x: f32): 59 %0 = addf %a, %b : f32 60 linalg.yield %0 : f32 61 } -> tensor<32x16x8xf32> 62 return %0 : tensor<32x16x8xf32> 63} 64 65// CHECK-LABEL: func @mul_ddd( 66// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 67// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 68// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 69// CHECK: %[[VAL_3:.*]] = constant 32 : index 70// CHECK: %[[VAL_4:.*]] = constant 16 : index 71// CHECK: %[[VAL_5:.*]] = constant 8 : index 72// CHECK: %[[VAL_6:.*]] = constant 0 : index 73// CHECK: %[[VAL_7:.*]] = constant 1 : index 74// CHECK: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 75// CHECK: %[[VAL_9:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 76// CHECK: %[[VAL_10:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 77// CHECK: %[[VAL_11:.*]] = memref.alloc() : memref<32x16x8xf32> 78// CHECK: linalg.copy(%[[VAL_10]], %[[VAL_11]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 79// CHECK: scf.for %[[VAL_12:.*]] = %[[VAL_6]] to %[[VAL_3]] step %[[VAL_7]] { 80// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] { 81// CHECK: %[[VAL_14:.*]] = muli %[[VAL_12]], %[[VAL_4]] : index 82// CHECK: %[[VAL_15:.*]] = addi %[[VAL_14]], %[[VAL_13]] : index 83// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] { 84// CHECK: %[[VAL_17:.*]] = muli %[[VAL_15]], %[[VAL_5]] : index 85// CHECK: %[[VAL_18:.*]] = addi %[[VAL_17]], %[[VAL_16]] : index 86// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xf32> 87// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_16]]] : memref<32x16x8xf32> 88// CHECK: %[[VAL_21:.*]] = mulf %[[VAL_19]], %[[VAL_20]] : f32 89// CHECK: memref.store %[[VAL_21]], %[[VAL_11]]{{\[}}%[[VAL_12]], %[[VAL_13]], %[[VAL_16]]] : memref<32x16x8xf32> 90// CHECK: } 91// CHECK: } 92// CHECK: } 93// CHECK: %[[VAL_22:.*]] = memref.tensor_load %[[VAL_11]] : memref<32x16x8xf32> 94// CHECK: return %[[VAL_22]] : tensor<32x16x8xf32> 95// CHECK: } 96func @mul_ddd(%arga: tensor<32x16x8xf32, #Tddd>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 97 %0 = linalg.generic #trait3 98 ins(%arga, %argb: tensor<32x16x8xf32, #Tddd>, tensor<32x16x8xf32>) 99 outs(%argx: tensor<32x16x8xf32>) { 100 ^bb(%a: f32, %b: f32, %x: f32): 101 %0 = mulf %a, %b : f32 102 linalg.yield %0 : f32 103 } -> tensor<32x16x8xf32> 104 return %0 : tensor<32x16x8xf32> 105} 106 107// CHECK-LABEL: func @add_dds( 108// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 109// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 110// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 111// CHECK: %[[VAL_3:.*]] = constant 2 : index 112// CHECK: %[[VAL_4:.*]] = constant 32 : index 113// CHECK: %[[VAL_5:.*]] = constant 16 : index 114// CHECK: %[[VAL_6:.*]] = constant 8 : index 115// CHECK: %[[VAL_7:.*]] = constant 0 : index 116// CHECK: %[[VAL_8:.*]] = constant true 117// CHECK: %[[VAL_9:.*]] = constant 1 : index 118// CHECK: %[[VAL_10:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 119// CHECK: %[[VAL_11:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 120// CHECK: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 121// CHECK: %[[VAL_13:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 122// CHECK: %[[VAL_14:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 123// CHECK: %[[VAL_15:.*]] = memref.alloc() : memref<32x16x8xf32> 124// CHECK: linalg.copy(%[[VAL_14]], %[[VAL_15]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 125// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_9]] { 126// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_9]] { 127// CHECK: %[[VAL_18:.*]] = muli %[[VAL_16]], %[[VAL_5]] : index 128// CHECK: %[[VAL_19:.*]] = addi %[[VAL_18]], %[[VAL_17]] : index 129// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_19]]] : memref<?xindex> 130// CHECK: %[[VAL_21:.*]] = addi %[[VAL_19]], %[[VAL_9]] : index 131// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_21]]] : memref<?xindex> 132// CHECK: %[[VAL_23:.*]]:2 = scf.while (%[[VAL_24:.*]] = %[[VAL_20]], %[[VAL_25:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) { 133// CHECK: %[[VAL_26:.*]] = cmpi ult, %[[VAL_24]], %[[VAL_22]] : index 134// CHECK: scf.condition(%[[VAL_26]]) %[[VAL_24]], %[[VAL_25]] : index, index 135// CHECK: } do { 136// CHECK: ^bb0(%[[VAL_27:.*]]: index, %[[VAL_28:.*]]: index): 137// CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_27]]] : memref<?xindex> 138// CHECK: %[[VAL_30:.*]] = cmpi eq, %[[VAL_29]], %[[VAL_28]] : index 139// CHECK: scf.if %[[VAL_30]] { 140// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_27]]] : memref<?xf32> 141// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_16]], %[[VAL_17]], %[[VAL_28]]] : memref<32x16x8xf32> 142// CHECK: %[[VAL_33:.*]] = addf %[[VAL_31]], %[[VAL_32]] : f32 143// CHECK: memref.store %[[VAL_33]], %[[VAL_15]]{{\[}}%[[VAL_16]], %[[VAL_17]], %[[VAL_28]]] : memref<32x16x8xf32> 144// CHECK: } else { 145// CHECK: scf.if %[[VAL_8]] { 146// CHECK: %[[VAL_34:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_16]], %[[VAL_17]], %[[VAL_28]]] : memref<32x16x8xf32> 147// CHECK: memref.store %[[VAL_34]], %[[VAL_15]]{{\[}}%[[VAL_16]], %[[VAL_17]], %[[VAL_28]]] : memref<32x16x8xf32> 148// CHECK: } else { 149// CHECK: } 150// CHECK: } 151// CHECK: %[[VAL_35:.*]] = cmpi eq, %[[VAL_29]], %[[VAL_28]] : index 152// CHECK: %[[VAL_36:.*]] = addi %[[VAL_27]], %[[VAL_9]] : index 153// CHECK: %[[VAL_37:.*]] = select %[[VAL_35]], %[[VAL_36]], %[[VAL_27]] : index 154// CHECK: %[[VAL_38:.*]] = addi %[[VAL_28]], %[[VAL_9]] : index 155// CHECK: scf.yield %[[VAL_37]], %[[VAL_38]] : index, index 156// CHECK: } 157// CHECK: scf.for %[[VAL_39:.*]] = %[[VAL_40:.*]]#1 to %[[VAL_6]] step %[[VAL_9]] { 158// CHECK: %[[VAL_41:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_16]], %[[VAL_17]], %[[VAL_39]]] : memref<32x16x8xf32> 159// CHECK: memref.store %[[VAL_41]], %[[VAL_15]]{{\[}}%[[VAL_16]], %[[VAL_17]], %[[VAL_39]]] : memref<32x16x8xf32> 160// CHECK: } 161// CHECK: } 162// CHECK: } 163// CHECK: %[[VAL_42:.*]] = memref.tensor_load %[[VAL_15]] : memref<32x16x8xf32> 164// CHECK: return %[[VAL_42]] : tensor<32x16x8xf32> 165// CHECK: } 166func @add_dds(%arga: tensor<32x16x8xf32, #Tdds>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 167 %0 = linalg.generic #trait3 168 ins(%arga, %argb: tensor<32x16x8xf32, #Tdds>, tensor<32x16x8xf32>) 169 outs(%argx: tensor<32x16x8xf32>) { 170 ^bb(%a: f32, %b: f32, %x: f32): 171 %0 = addf %a, %b : f32 172 linalg.yield %0 : f32 173 } -> tensor<32x16x8xf32> 174 return %0 : tensor<32x16x8xf32> 175} 176 177// CHECK-LABEL: func @mul_dds( 178// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 179// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 180// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 181// CHECK: %[[VAL_3:.*]] = constant 2 : index 182// CHECK: %[[VAL_4:.*]] = constant 32 : index 183// CHECK: %[[VAL_5:.*]] = constant 16 : index 184// CHECK: %[[VAL_6:.*]] = constant 0 : index 185// CHECK: %[[VAL_7:.*]] = constant 1 : index 186// CHECK: %[[VAL_8:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 187// CHECK: %[[VAL_9:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 188// CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 189// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 190// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 191// CHECK: %[[VAL_13:.*]] = memref.alloc() : memref<32x16x8xf32> 192// CHECK: linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 193// CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_6]] to %[[VAL_4]] step %[[VAL_7]] { 194// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_6]] to %[[VAL_5]] step %[[VAL_7]] { 195// CHECK: %[[VAL_16:.*]] = muli %[[VAL_14]], %[[VAL_5]] : index 196// CHECK: %[[VAL_17:.*]] = addi %[[VAL_16]], %[[VAL_15]] : index 197// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex> 198// CHECK: %[[VAL_19:.*]] = addi %[[VAL_17]], %[[VAL_7]] : index 199// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_19]]] : memref<?xindex> 200// CHECK: scf.for %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_20]] step %[[VAL_7]] { 201// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_21]]] : memref<?xindex> 202// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_21]]] : memref<?xf32> 203// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_14]], %[[VAL_15]], %[[VAL_22]]] : memref<32x16x8xf32> 204// CHECK: %[[VAL_25:.*]] = mulf %[[VAL_23]], %[[VAL_24]] : f32 205// CHECK: memref.store %[[VAL_25]], %[[VAL_13]]{{\[}}%[[VAL_14]], %[[VAL_15]], %[[VAL_22]]] : memref<32x16x8xf32> 206// CHECK: } 207// CHECK: } 208// CHECK: } 209// CHECK: %[[VAL_26:.*]] = memref.tensor_load %[[VAL_13]] : memref<32x16x8xf32> 210// CHECK: return %[[VAL_26]] : tensor<32x16x8xf32> 211// CHECK: } 212func @mul_dds(%arga: tensor<32x16x8xf32, #Tdds>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 213 %0 = linalg.generic #trait3 214 ins(%arga, %argb: tensor<32x16x8xf32, #Tdds>, tensor<32x16x8xf32>) 215 outs(%argx: tensor<32x16x8xf32>) { 216 ^bb(%a: f32, %b: f32, %x: f32): 217 %0 = mulf %a, %b : f32 218 linalg.yield %0 : f32 219 } -> tensor<32x16x8xf32> 220 return %0 : tensor<32x16x8xf32> 221} 222 223// CHECK-LABEL: func @add_dsd( 224// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 225// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 226// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 227// CHECK: %[[VAL_3:.*]] = constant 32 : index 228// CHECK: %[[VAL_4:.*]] = constant 16 : index 229// CHECK: %[[VAL_5:.*]] = constant 8 : index 230// CHECK: %[[VAL_6:.*]] = constant true 231// CHECK: %[[VAL_7:.*]] = constant 0 : index 232// CHECK: %[[VAL_8:.*]] = constant 1 : index 233// CHECK: %[[VAL_9:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 234// CHECK: %[[VAL_10:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 235// CHECK: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 236// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 237// CHECK: %[[VAL_13:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 238// CHECK: %[[VAL_14:.*]] = memref.alloc() : memref<32x16x8xf32> 239// CHECK: linalg.copy(%[[VAL_13]], %[[VAL_14]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 240// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_7]] to %[[VAL_3]] step %[[VAL_8]] { 241// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_15]]] : memref<?xindex> 242// CHECK: %[[VAL_17:.*]] = addi %[[VAL_15]], %[[VAL_8]] : index 243// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_17]]] : memref<?xindex> 244// CHECK: %[[VAL_19:.*]]:2 = scf.while (%[[VAL_20:.*]] = %[[VAL_16]], %[[VAL_21:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) { 245// CHECK: %[[VAL_22:.*]] = cmpi ult, %[[VAL_20]], %[[VAL_18]] : index 246// CHECK: scf.condition(%[[VAL_22]]) %[[VAL_20]], %[[VAL_21]] : index, index 247// CHECK: } do { 248// CHECK: ^bb0(%[[VAL_23:.*]]: index, %[[VAL_24:.*]]: index): 249// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_23]]] : memref<?xindex> 250// CHECK: %[[VAL_26:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_24]] : index 251// CHECK: scf.if %[[VAL_26]] { 252// CHECK: scf.for %[[VAL_27:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 253// CHECK: %[[VAL_28:.*]] = muli %[[VAL_23]], %[[VAL_5]] : index 254// CHECK: %[[VAL_29:.*]] = addi %[[VAL_28]], %[[VAL_27]] : index 255// CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_29]]] : memref<?xf32> 256// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_15]], %[[VAL_24]], %[[VAL_27]]] : memref<32x16x8xf32> 257// CHECK: %[[VAL_32:.*]] = addf %[[VAL_30]], %[[VAL_31]] : f32 258// CHECK: memref.store %[[VAL_32]], %[[VAL_14]]{{\[}}%[[VAL_15]], %[[VAL_24]], %[[VAL_27]]] : memref<32x16x8xf32> 259// CHECK: } 260// CHECK: } else { 261// CHECK: scf.if %[[VAL_6]] { 262// CHECK: scf.for %[[VAL_33:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 263// CHECK: %[[VAL_34:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_15]], %[[VAL_24]], %[[VAL_33]]] : memref<32x16x8xf32> 264// CHECK: memref.store %[[VAL_34]], %[[VAL_14]]{{\[}}%[[VAL_15]], %[[VAL_24]], %[[VAL_33]]] : memref<32x16x8xf32> 265// CHECK: } 266// CHECK: } else { 267// CHECK: } 268// CHECK: } 269// CHECK: %[[VAL_35:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_24]] : index 270// CHECK: %[[VAL_36:.*]] = addi %[[VAL_23]], %[[VAL_8]] : index 271// CHECK: %[[VAL_37:.*]] = select %[[VAL_35]], %[[VAL_36]], %[[VAL_23]] : index 272// CHECK: %[[VAL_38:.*]] = addi %[[VAL_24]], %[[VAL_8]] : index 273// CHECK: scf.yield %[[VAL_37]], %[[VAL_38]] : index, index 274// CHECK: } 275// CHECK: scf.for %[[VAL_39:.*]] = %[[VAL_40:.*]]#1 to %[[VAL_4]] step %[[VAL_8]] { 276// CHECK: scf.for %[[VAL_41:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 277// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_15]], %[[VAL_39]], %[[VAL_41]]] : memref<32x16x8xf32> 278// CHECK: memref.store %[[VAL_42]], %[[VAL_14]]{{\[}}%[[VAL_15]], %[[VAL_39]], %[[VAL_41]]] : memref<32x16x8xf32> 279// CHECK: } 280// CHECK: } 281// CHECK: } 282// CHECK: %[[VAL_43:.*]] = memref.tensor_load %[[VAL_14]] : memref<32x16x8xf32> 283// CHECK: return %[[VAL_43]] : tensor<32x16x8xf32> 284// CHECK: } 285func @add_dsd(%arga: tensor<32x16x8xf32, #Tdsd>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 286 %0 = linalg.generic #trait3 287 ins(%arga, %argb: tensor<32x16x8xf32, #Tdsd>, tensor<32x16x8xf32>) 288 outs(%argx: tensor<32x16x8xf32>) { 289 ^bb(%a: f32, %b: f32, %x: f32): 290 %0 = addf %a, %b : f32 291 linalg.yield %0 : f32 292 } -> tensor<32x16x8xf32> 293 return %0 : tensor<32x16x8xf32> 294} 295 296// CHECK-LABEL: func @mul_dsd( 297// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 298// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 299// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 300// CHECK: %[[VAL_3:.*]] = constant 32 : index 301// CHECK: %[[VAL_4:.*]] = constant 8 : index 302// CHECK: %[[VAL_5:.*]] = constant 0 : index 303// CHECK: %[[VAL_6:.*]] = constant 1 : index 304// CHECK: %[[VAL_7:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_6]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 305// CHECK: %[[VAL_8:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_6]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 306// CHECK: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 307// CHECK: %[[VAL_10:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 308// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 309// CHECK: %[[VAL_12:.*]] = memref.alloc() : memref<32x16x8xf32> 310// CHECK: linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 311// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] { 312// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_13]]] : memref<?xindex> 313// CHECK: %[[VAL_15:.*]] = addi %[[VAL_13]], %[[VAL_6]] : index 314// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex> 315// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_6]] { 316// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex> 317// CHECK: scf.for %[[VAL_19:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] { 318// CHECK: %[[VAL_20:.*]] = muli %[[VAL_17]], %[[VAL_4]] : index 319// CHECK: %[[VAL_21:.*]] = addi %[[VAL_20]], %[[VAL_19]] : index 320// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_21]]] : memref<?xf32> 321// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_13]], %[[VAL_18]], %[[VAL_19]]] : memref<32x16x8xf32> 322// CHECK: %[[VAL_24:.*]] = mulf %[[VAL_22]], %[[VAL_23]] : f32 323// CHECK: memref.store %[[VAL_24]], %[[VAL_12]]{{\[}}%[[VAL_13]], %[[VAL_18]], %[[VAL_19]]] : memref<32x16x8xf32> 324// CHECK: } 325// CHECK: } 326// CHECK: } 327// CHECK: %[[VAL_25:.*]] = memref.tensor_load %[[VAL_12]] : memref<32x16x8xf32> 328// CHECK: return %[[VAL_25]] : tensor<32x16x8xf32> 329// CHECK: } 330func @mul_dsd(%arga: tensor<32x16x8xf32, #Tdsd>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 331 %0 = linalg.generic #trait3 332 ins(%arga, %argb: tensor<32x16x8xf32, #Tdsd>, tensor<32x16x8xf32>) 333 outs(%argx: tensor<32x16x8xf32>) { 334 ^bb(%a: f32, %b: f32, %x: f32): 335 %0 = mulf %a, %b : f32 336 linalg.yield %0 : f32 337 } -> tensor<32x16x8xf32> 338 return %0 : tensor<32x16x8xf32> 339} 340 341// CHECK-LABEL: func @add_dss( 342// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 343// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 344// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 345// CHECK: %[[VAL_3:.*]] = constant 2 : index 346// CHECK: %[[VAL_4:.*]] = constant 32 : index 347// CHECK: %[[VAL_5:.*]] = constant 16 : index 348// CHECK: %[[VAL_6:.*]] = constant 8 : index 349// CHECK: %[[VAL_7:.*]] = constant true 350// CHECK: %[[VAL_8:.*]] = constant 0 : index 351// CHECK: %[[VAL_9:.*]] = constant 1 : index 352// CHECK: %[[VAL_10:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_9]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 353// CHECK: %[[VAL_11:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_9]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 354// CHECK: %[[VAL_12:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 355// CHECK: %[[VAL_13:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 356// CHECK: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 357// CHECK: %[[VAL_15:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 358// CHECK: %[[VAL_16:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 359// CHECK: %[[VAL_17:.*]] = memref.alloc() : memref<32x16x8xf32> 360// CHECK: linalg.copy(%[[VAL_16]], %[[VAL_17]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 361// CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_8]] to %[[VAL_4]] step %[[VAL_9]] { 362// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_18]]] : memref<?xindex> 363// CHECK: %[[VAL_20:.*]] = addi %[[VAL_18]], %[[VAL_9]] : index 364// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_20]]] : memref<?xindex> 365// CHECK: %[[VAL_22:.*]]:2 = scf.while (%[[VAL_23:.*]] = %[[VAL_19]], %[[VAL_24:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { 366// CHECK: %[[VAL_25:.*]] = cmpi ult, %[[VAL_23]], %[[VAL_21]] : index 367// CHECK: scf.condition(%[[VAL_25]]) %[[VAL_23]], %[[VAL_24]] : index, index 368// CHECK: } do { 369// CHECK: ^bb0(%[[VAL_26:.*]]: index, %[[VAL_27:.*]]: index): 370// CHECK: %[[VAL_28:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_26]]] : memref<?xindex> 371// CHECK: %[[VAL_29:.*]] = cmpi eq, %[[VAL_28]], %[[VAL_27]] : index 372// CHECK: scf.if %[[VAL_29]] { 373// CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_26]]] : memref<?xindex> 374// CHECK: %[[VAL_31:.*]] = addi %[[VAL_26]], %[[VAL_9]] : index 375// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_31]]] : memref<?xindex> 376// CHECK: %[[VAL_33:.*]]:2 = scf.while (%[[VAL_34:.*]] = %[[VAL_30]], %[[VAL_35:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { 377// CHECK: %[[VAL_36:.*]] = cmpi ult, %[[VAL_34]], %[[VAL_32]] : index 378// CHECK: scf.condition(%[[VAL_36]]) %[[VAL_34]], %[[VAL_35]] : index, index 379// CHECK: } do { 380// CHECK: ^bb0(%[[VAL_37:.*]]: index, %[[VAL_38:.*]]: index): 381// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_37]]] : memref<?xindex> 382// CHECK: %[[VAL_40:.*]] = cmpi eq, %[[VAL_39]], %[[VAL_38]] : index 383// CHECK: scf.if %[[VAL_40]] { 384// CHECK: %[[VAL_41:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_37]]] : memref<?xf32> 385// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_18]], %[[VAL_27]], %[[VAL_38]]] : memref<32x16x8xf32> 386// CHECK: %[[VAL_43:.*]] = addf %[[VAL_41]], %[[VAL_42]] : f32 387// CHECK: memref.store %[[VAL_43]], %[[VAL_17]]{{\[}}%[[VAL_18]], %[[VAL_27]], %[[VAL_38]]] : memref<32x16x8xf32> 388// CHECK: } else { 389// CHECK: scf.if %[[VAL_7]] { 390// CHECK: %[[VAL_44:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_18]], %[[VAL_27]], %[[VAL_38]]] : memref<32x16x8xf32> 391// CHECK: memref.store %[[VAL_44]], %[[VAL_17]]{{\[}}%[[VAL_18]], %[[VAL_27]], %[[VAL_38]]] : memref<32x16x8xf32> 392// CHECK: } else { 393// CHECK: } 394// CHECK: } 395// CHECK: %[[VAL_45:.*]] = cmpi eq, %[[VAL_39]], %[[VAL_38]] : index 396// CHECK: %[[VAL_46:.*]] = addi %[[VAL_37]], %[[VAL_9]] : index 397// CHECK: %[[VAL_47:.*]] = select %[[VAL_45]], %[[VAL_46]], %[[VAL_37]] : index 398// CHECK: %[[VAL_48:.*]] = addi %[[VAL_38]], %[[VAL_9]] : index 399// CHECK: scf.yield %[[VAL_47]], %[[VAL_48]] : index, index 400// CHECK: } 401// CHECK: scf.for %[[VAL_49:.*]] = %[[VAL_50:.*]]#1 to %[[VAL_6]] step %[[VAL_9]] { 402// CHECK: %[[VAL_51:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_18]], %[[VAL_27]], %[[VAL_49]]] : memref<32x16x8xf32> 403// CHECK: memref.store %[[VAL_51]], %[[VAL_17]]{{\[}}%[[VAL_18]], %[[VAL_27]], %[[VAL_49]]] : memref<32x16x8xf32> 404// CHECK: } 405// CHECK: } else { 406// CHECK: scf.if %[[VAL_7]] { 407// CHECK: scf.for %[[VAL_52:.*]] = %[[VAL_8]] to %[[VAL_6]] step %[[VAL_9]] { 408// CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_18]], %[[VAL_27]], %[[VAL_52]]] : memref<32x16x8xf32> 409// CHECK: memref.store %[[VAL_53]], %[[VAL_17]]{{\[}}%[[VAL_18]], %[[VAL_27]], %[[VAL_52]]] : memref<32x16x8xf32> 410// CHECK: } 411// CHECK: } else { 412// CHECK: } 413// CHECK: } 414// CHECK: %[[VAL_54:.*]] = cmpi eq, %[[VAL_28]], %[[VAL_27]] : index 415// CHECK: %[[VAL_55:.*]] = addi %[[VAL_26]], %[[VAL_9]] : index 416// CHECK: %[[VAL_56:.*]] = select %[[VAL_54]], %[[VAL_55]], %[[VAL_26]] : index 417// CHECK: %[[VAL_57:.*]] = addi %[[VAL_27]], %[[VAL_9]] : index 418// CHECK: scf.yield %[[VAL_56]], %[[VAL_57]] : index, index 419// CHECK: } 420// CHECK: scf.for %[[VAL_58:.*]] = %[[VAL_59:.*]]#1 to %[[VAL_5]] step %[[VAL_9]] { 421// CHECK: scf.for %[[VAL_60:.*]] = %[[VAL_8]] to %[[VAL_6]] step %[[VAL_9]] { 422// CHECK: %[[VAL_61:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_18]], %[[VAL_58]], %[[VAL_60]]] : memref<32x16x8xf32> 423// CHECK: memref.store %[[VAL_61]], %[[VAL_17]]{{\[}}%[[VAL_18]], %[[VAL_58]], %[[VAL_60]]] : memref<32x16x8xf32> 424// CHECK: } 425// CHECK: } 426// CHECK: } 427// CHECK: %[[VAL_62:.*]] = memref.tensor_load %[[VAL_17]] : memref<32x16x8xf32> 428// CHECK: return %[[VAL_62]] : tensor<32x16x8xf32> 429// CHECK: } 430func @add_dss(%arga: tensor<32x16x8xf32, #Tdss>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 431 %0 = linalg.generic #trait3 432 ins(%arga, %argb: tensor<32x16x8xf32, #Tdss>, tensor<32x16x8xf32>) 433 outs(%argx: tensor<32x16x8xf32>) { 434 ^bb(%a: f32, %b: f32, %x: f32): 435 %0 = addf %a, %b : f32 436 linalg.yield %0 : f32 437 } -> tensor<32x16x8xf32> 438 return %0 : tensor<32x16x8xf32> 439} 440 441// CHECK-LABEL: func @mul_dss( 442// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 443// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 444// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 445// CHECK: %[[VAL_3:.*]] = constant 2 : index 446// CHECK: %[[VAL_4:.*]] = constant 32 : index 447// CHECK: %[[VAL_5:.*]] = constant 0 : index 448// CHECK: %[[VAL_6:.*]] = constant 1 : index 449// CHECK: %[[VAL_7:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_6]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 450// CHECK: %[[VAL_8:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_6]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 451// CHECK: %[[VAL_9:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 452// CHECK: %[[VAL_10:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 453// CHECK: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 454// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 455// CHECK: %[[VAL_13:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 456// CHECK: %[[VAL_14:.*]] = memref.alloc() : memref<32x16x8xf32> 457// CHECK: linalg.copy(%[[VAL_13]], %[[VAL_14]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 458// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] { 459// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_15]]] : memref<?xindex> 460// CHECK: %[[VAL_17:.*]] = addi %[[VAL_15]], %[[VAL_6]] : index 461// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex> 462// CHECK: scf.for %[[VAL_19:.*]] = %[[VAL_16]] to %[[VAL_18]] step %[[VAL_6]] { 463// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_19]]] : memref<?xindex> 464// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_19]]] : memref<?xindex> 465// CHECK: %[[VAL_22:.*]] = addi %[[VAL_19]], %[[VAL_6]] : index 466// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_22]]] : memref<?xindex> 467// CHECK: scf.for %[[VAL_24:.*]] = %[[VAL_21]] to %[[VAL_23]] step %[[VAL_6]] { 468// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_24]]] : memref<?xindex> 469// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_24]]] : memref<?xf32> 470// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_15]], %[[VAL_20]], %[[VAL_25]]] : memref<32x16x8xf32> 471// CHECK: %[[VAL_28:.*]] = mulf %[[VAL_26]], %[[VAL_27]] : f32 472// CHECK: memref.store %[[VAL_28]], %[[VAL_14]]{{\[}}%[[VAL_15]], %[[VAL_20]], %[[VAL_25]]] : memref<32x16x8xf32> 473// CHECK: } 474// CHECK: } 475// CHECK: } 476// CHECK: %[[VAL_29:.*]] = memref.tensor_load %[[VAL_14]] : memref<32x16x8xf32> 477// CHECK: return %[[VAL_29]] : tensor<32x16x8xf32> 478// CHECK: } 479func @mul_dss(%arga: tensor<32x16x8xf32, #Tdss>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 480 %0 = linalg.generic #trait3 481 ins(%arga, %argb: tensor<32x16x8xf32, #Tdss>, tensor<32x16x8xf32>) 482 outs(%argx: tensor<32x16x8xf32>) { 483 ^bb(%a: f32, %b: f32, %x: f32): 484 %0 = mulf %a, %b : f32 485 linalg.yield %0 : f32 486 } -> tensor<32x16x8xf32> 487 return %0 : tensor<32x16x8xf32> 488} 489 490// CHECK-LABEL: func @add_sdd( 491// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 492// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 493// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 494// CHECK: %[[VAL_3:.*]] = constant 32 : index 495// CHECK: %[[VAL_4:.*]] = constant 16 : index 496// CHECK: %[[VAL_5:.*]] = constant 8 : index 497// CHECK: %[[VAL_6:.*]] = constant true 498// CHECK: %[[VAL_7:.*]] = constant 0 : index 499// CHECK: %[[VAL_8:.*]] = constant 1 : index 500// CHECK: %[[VAL_9:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_7]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 501// CHECK: %[[VAL_10:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_7]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 502// CHECK: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 503// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 504// CHECK: %[[VAL_13:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 505// CHECK: %[[VAL_14:.*]] = memref.alloc() : memref<32x16x8xf32> 506// CHECK: linalg.copy(%[[VAL_13]], %[[VAL_14]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 507// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex> 508// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_8]]] : memref<?xindex> 509// CHECK: %[[VAL_17:.*]]:2 = scf.while (%[[VAL_18:.*]] = %[[VAL_15]], %[[VAL_19:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) { 510// CHECK: %[[VAL_20:.*]] = cmpi ult, %[[VAL_18]], %[[VAL_16]] : index 511// CHECK: scf.condition(%[[VAL_20]]) %[[VAL_18]], %[[VAL_19]] : index, index 512// CHECK: } do { 513// CHECK: ^bb0(%[[VAL_21:.*]]: index, %[[VAL_22:.*]]: index): 514// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_21]]] : memref<?xindex> 515// CHECK: %[[VAL_24:.*]] = cmpi eq, %[[VAL_23]], %[[VAL_22]] : index 516// CHECK: scf.if %[[VAL_24]] { 517// CHECK: scf.for %[[VAL_25:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_8]] { 518// CHECK: %[[VAL_26:.*]] = muli %[[VAL_21]], %[[VAL_4]] : index 519// CHECK: %[[VAL_27:.*]] = addi %[[VAL_26]], %[[VAL_25]] : index 520// CHECK: scf.for %[[VAL_28:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 521// CHECK: %[[VAL_29:.*]] = muli %[[VAL_27]], %[[VAL_5]] : index 522// CHECK: %[[VAL_30:.*]] = addi %[[VAL_29]], %[[VAL_28]] : index 523// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_30]]] : memref<?xf32> 524// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_22]], %[[VAL_25]], %[[VAL_28]]] : memref<32x16x8xf32> 525// CHECK: %[[VAL_33:.*]] = addf %[[VAL_31]], %[[VAL_32]] : f32 526// CHECK: memref.store %[[VAL_33]], %[[VAL_14]]{{\[}}%[[VAL_22]], %[[VAL_25]], %[[VAL_28]]] : memref<32x16x8xf32> 527// CHECK: } 528// CHECK: } 529// CHECK: } else { 530// CHECK: scf.if %[[VAL_6]] { 531// CHECK: scf.for %[[VAL_34:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_8]] { 532// CHECK: scf.for %[[VAL_35:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 533// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_22]], %[[VAL_34]], %[[VAL_35]]] : memref<32x16x8xf32> 534// CHECK: memref.store %[[VAL_36]], %[[VAL_14]]{{\[}}%[[VAL_22]], %[[VAL_34]], %[[VAL_35]]] : memref<32x16x8xf32> 535// CHECK: } 536// CHECK: } 537// CHECK: } else { 538// CHECK: } 539// CHECK: } 540// CHECK: %[[VAL_37:.*]] = cmpi eq, %[[VAL_23]], %[[VAL_22]] : index 541// CHECK: %[[VAL_38:.*]] = addi %[[VAL_21]], %[[VAL_8]] : index 542// CHECK: %[[VAL_39:.*]] = select %[[VAL_37]], %[[VAL_38]], %[[VAL_21]] : index 543// CHECK: %[[VAL_40:.*]] = addi %[[VAL_22]], %[[VAL_8]] : index 544// CHECK: scf.yield %[[VAL_39]], %[[VAL_40]] : index, index 545// CHECK: } 546// CHECK: scf.for %[[VAL_41:.*]] = %[[VAL_42:.*]]#1 to %[[VAL_3]] step %[[VAL_8]] { 547// CHECK: scf.for %[[VAL_43:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_8]] { 548// CHECK: scf.for %[[VAL_44:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 549// CHECK: %[[VAL_45:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_41]], %[[VAL_43]], %[[VAL_44]]] : memref<32x16x8xf32> 550// CHECK: memref.store %[[VAL_45]], %[[VAL_14]]{{\[}}%[[VAL_41]], %[[VAL_43]], %[[VAL_44]]] : memref<32x16x8xf32> 551// CHECK: } 552// CHECK: } 553// CHECK: } 554// CHECK: %[[VAL_46:.*]] = memref.tensor_load %[[VAL_14]] : memref<32x16x8xf32> 555// CHECK: return %[[VAL_46]] : tensor<32x16x8xf32> 556// CHECK: } 557func @add_sdd(%arga: tensor<32x16x8xf32, #Tsdd>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 558 %0 = linalg.generic #trait3 559 ins(%arga, %argb: tensor<32x16x8xf32, #Tsdd>, tensor<32x16x8xf32>) 560 outs(%argx: tensor<32x16x8xf32>) { 561 ^bb(%a: f32, %b: f32, %x: f32): 562 %0 = addf %a, %b : f32 563 linalg.yield %0 : f32 564 } -> tensor<32x16x8xf32> 565 return %0 : tensor<32x16x8xf32> 566} 567 568// CHECK-LABEL: func @mul_sdd( 569// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 570// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 571// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 572// CHECK: %[[VAL_3:.*]] = constant 16 : index 573// CHECK: %[[VAL_4:.*]] = constant 8 : index 574// CHECK: %[[VAL_5:.*]] = constant 0 : index 575// CHECK: %[[VAL_6:.*]] = constant 1 : index 576// CHECK: %[[VAL_7:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 577// CHECK: %[[VAL_8:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 578// CHECK: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 579// CHECK: %[[VAL_10:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 580// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 581// CHECK: %[[VAL_12:.*]] = memref.alloc() : memref<32x16x8xf32> 582// CHECK: linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 583// CHECK: %[[VAL_13:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex> 584// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> 585// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_13]] to %[[VAL_14]] step %[[VAL_6]] { 586// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_15]]] : memref<?xindex> 587// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_5]] to %[[VAL_3]] step %[[VAL_6]] { 588// CHECK: %[[VAL_18:.*]] = muli %[[VAL_15]], %[[VAL_3]] : index 589// CHECK: %[[VAL_19:.*]] = addi %[[VAL_18]], %[[VAL_17]] : index 590// CHECK: scf.for %[[VAL_20:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] { 591// CHECK: %[[VAL_21:.*]] = muli %[[VAL_19]], %[[VAL_4]] : index 592// CHECK: %[[VAL_22:.*]] = addi %[[VAL_21]], %[[VAL_20]] : index 593// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_22]]] : memref<?xf32> 594// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_16]], %[[VAL_17]], %[[VAL_20]]] : memref<32x16x8xf32> 595// CHECK: %[[VAL_25:.*]] = mulf %[[VAL_23]], %[[VAL_24]] : f32 596// CHECK: memref.store %[[VAL_25]], %[[VAL_12]]{{\[}}%[[VAL_16]], %[[VAL_17]], %[[VAL_20]]] : memref<32x16x8xf32> 597// CHECK: } 598// CHECK: } 599// CHECK: } 600// CHECK: %[[VAL_26:.*]] = memref.tensor_load %[[VAL_12]] : memref<32x16x8xf32> 601// CHECK: return %[[VAL_26]] : tensor<32x16x8xf32> 602// CHECK: } 603func @mul_sdd(%arga: tensor<32x16x8xf32, #Tsdd>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 604 %0 = linalg.generic #trait3 605 ins(%arga, %argb: tensor<32x16x8xf32, #Tsdd>, tensor<32x16x8xf32>) 606 outs(%argx: tensor<32x16x8xf32>) { 607 ^bb(%a: f32, %b: f32, %x: f32): 608 %0 = mulf %a, %b : f32 609 linalg.yield %0 : f32 610 } -> tensor<32x16x8xf32> 611 return %0 : tensor<32x16x8xf32> 612} 613 614// CHECK-LABEL: func @add_sds( 615// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 616// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 617// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 618// CHECK: %[[VAL_3:.*]] = constant 2 : index 619// CHECK: %[[VAL_4:.*]] = constant 32 : index 620// CHECK: %[[VAL_5:.*]] = constant 16 : index 621// CHECK: %[[VAL_6:.*]] = constant 8 : index 622// CHECK: %[[VAL_7:.*]] = constant true 623// CHECK: %[[VAL_8:.*]] = constant 0 : index 624// CHECK: %[[VAL_9:.*]] = constant 1 : index 625// CHECK: %[[VAL_10:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 626// CHECK: %[[VAL_11:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 627// CHECK: %[[VAL_12:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 628// CHECK: %[[VAL_13:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 629// CHECK: %[[VAL_14:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 630// CHECK: %[[VAL_15:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 631// CHECK: %[[VAL_16:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 632// CHECK: %[[VAL_17:.*]] = memref.alloc() : memref<32x16x8xf32> 633// CHECK: linalg.copy(%[[VAL_16]], %[[VAL_17]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 634// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<?xindex> 635// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_9]]] : memref<?xindex> 636// CHECK: %[[VAL_20:.*]]:2 = scf.while (%[[VAL_21:.*]] = %[[VAL_18]], %[[VAL_22:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { 637// CHECK: %[[VAL_23:.*]] = cmpi ult, %[[VAL_21]], %[[VAL_19]] : index 638// CHECK: scf.condition(%[[VAL_23]]) %[[VAL_21]], %[[VAL_22]] : index, index 639// CHECK: } do { 640// CHECK: ^bb0(%[[VAL_24:.*]]: index, %[[VAL_25:.*]]: index): 641// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_24]]] : memref<?xindex> 642// CHECK: %[[VAL_27:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_25]] : index 643// CHECK: scf.if %[[VAL_27]] { 644// CHECK: scf.for %[[VAL_28:.*]] = %[[VAL_8]] to %[[VAL_5]] step %[[VAL_9]] { 645// CHECK: %[[VAL_29:.*]] = muli %[[VAL_24]], %[[VAL_5]] : index 646// CHECK: %[[VAL_30:.*]] = addi %[[VAL_29]], %[[VAL_28]] : index 647// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_30]]] : memref<?xindex> 648// CHECK: %[[VAL_32:.*]] = addi %[[VAL_30]], %[[VAL_9]] : index 649// CHECK: %[[VAL_33:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_32]]] : memref<?xindex> 650// CHECK: %[[VAL_34:.*]]:2 = scf.while (%[[VAL_35:.*]] = %[[VAL_31]], %[[VAL_36:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { 651// CHECK: %[[VAL_37:.*]] = cmpi ult, %[[VAL_35]], %[[VAL_33]] : index 652// CHECK: scf.condition(%[[VAL_37]]) %[[VAL_35]], %[[VAL_36]] : index, index 653// CHECK: } do { 654// CHECK: ^bb0(%[[VAL_38:.*]]: index, %[[VAL_39:.*]]: index): 655// CHECK: %[[VAL_40:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_38]]] : memref<?xindex> 656// CHECK: %[[VAL_41:.*]] = cmpi eq, %[[VAL_40]], %[[VAL_39]] : index 657// CHECK: scf.if %[[VAL_41]] { 658// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_38]]] : memref<?xf32> 659// CHECK: %[[VAL_43:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_25]], %[[VAL_28]], %[[VAL_39]]] : memref<32x16x8xf32> 660// CHECK: %[[VAL_44:.*]] = addf %[[VAL_42]], %[[VAL_43]] : f32 661// CHECK: memref.store %[[VAL_44]], %[[VAL_17]]{{\[}}%[[VAL_25]], %[[VAL_28]], %[[VAL_39]]] : memref<32x16x8xf32> 662// CHECK: } else { 663// CHECK: scf.if %[[VAL_7]] { 664// CHECK: %[[VAL_45:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_25]], %[[VAL_28]], %[[VAL_39]]] : memref<32x16x8xf32> 665// CHECK: memref.store %[[VAL_45]], %[[VAL_17]]{{\[}}%[[VAL_25]], %[[VAL_28]], %[[VAL_39]]] : memref<32x16x8xf32> 666// CHECK: } else { 667// CHECK: } 668// CHECK: } 669// CHECK: %[[VAL_46:.*]] = cmpi eq, %[[VAL_40]], %[[VAL_39]] : index 670// CHECK: %[[VAL_47:.*]] = addi %[[VAL_38]], %[[VAL_9]] : index 671// CHECK: %[[VAL_48:.*]] = select %[[VAL_46]], %[[VAL_47]], %[[VAL_38]] : index 672// CHECK: %[[VAL_49:.*]] = addi %[[VAL_39]], %[[VAL_9]] : index 673// CHECK: scf.yield %[[VAL_48]], %[[VAL_49]] : index, index 674// CHECK: } 675// CHECK: scf.for %[[VAL_50:.*]] = %[[VAL_51:.*]]#1 to %[[VAL_6]] step %[[VAL_9]] { 676// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_25]], %[[VAL_28]], %[[VAL_50]]] : memref<32x16x8xf32> 677// CHECK: memref.store %[[VAL_52]], %[[VAL_17]]{{\[}}%[[VAL_25]], %[[VAL_28]], %[[VAL_50]]] : memref<32x16x8xf32> 678// CHECK: } 679// CHECK: } 680// CHECK: } else { 681// CHECK: scf.if %[[VAL_7]] { 682// CHECK: scf.for %[[VAL_53:.*]] = %[[VAL_8]] to %[[VAL_5]] step %[[VAL_9]] { 683// CHECK: scf.for %[[VAL_54:.*]] = %[[VAL_8]] to %[[VAL_6]] step %[[VAL_9]] { 684// CHECK: %[[VAL_55:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_25]], %[[VAL_53]], %[[VAL_54]]] : memref<32x16x8xf32> 685// CHECK: memref.store %[[VAL_55]], %[[VAL_17]]{{\[}}%[[VAL_25]], %[[VAL_53]], %[[VAL_54]]] : memref<32x16x8xf32> 686// CHECK: } 687// CHECK: } 688// CHECK: } else { 689// CHECK: } 690// CHECK: } 691// CHECK: %[[VAL_56:.*]] = cmpi eq, %[[VAL_26]], %[[VAL_25]] : index 692// CHECK: %[[VAL_57:.*]] = addi %[[VAL_24]], %[[VAL_9]] : index 693// CHECK: %[[VAL_58:.*]] = select %[[VAL_56]], %[[VAL_57]], %[[VAL_24]] : index 694// CHECK: %[[VAL_59:.*]] = addi %[[VAL_25]], %[[VAL_9]] : index 695// CHECK: scf.yield %[[VAL_58]], %[[VAL_59]] : index, index 696// CHECK: } 697// CHECK: scf.for %[[VAL_60:.*]] = %[[VAL_61:.*]]#1 to %[[VAL_4]] step %[[VAL_9]] { 698// CHECK: scf.for %[[VAL_62:.*]] = %[[VAL_8]] to %[[VAL_5]] step %[[VAL_9]] { 699// CHECK: scf.for %[[VAL_63:.*]] = %[[VAL_8]] to %[[VAL_6]] step %[[VAL_9]] { 700// CHECK: %[[VAL_64:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_60]], %[[VAL_62]], %[[VAL_63]]] : memref<32x16x8xf32> 701// CHECK: memref.store %[[VAL_64]], %[[VAL_17]]{{\[}}%[[VAL_60]], %[[VAL_62]], %[[VAL_63]]] : memref<32x16x8xf32> 702// CHECK: } 703// CHECK: } 704// CHECK: } 705// CHECK: %[[VAL_65:.*]] = memref.tensor_load %[[VAL_17]] : memref<32x16x8xf32> 706// CHECK: return %[[VAL_65]] : tensor<32x16x8xf32> 707// CHECK: } 708func @add_sds(%arga: tensor<32x16x8xf32, #Tsds>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 709 %0 = linalg.generic #trait3 710 ins(%arga, %argb: tensor<32x16x8xf32, #Tsds>, tensor<32x16x8xf32>) 711 outs(%argx: tensor<32x16x8xf32>) { 712 ^bb(%a: f32, %b: f32, %x: f32): 713 %0 = addf %a, %b : f32 714 linalg.yield %0 : f32 715 } -> tensor<32x16x8xf32> 716 return %0 : tensor<32x16x8xf32> 717} 718 719// CHECK-LABEL: func @mul_sds( 720// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 721// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 722// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 723// CHECK: %[[VAL_3:.*]] = constant 2 : index 724// CHECK: %[[VAL_4:.*]] = constant 16 : index 725// CHECK: %[[VAL_5:.*]] = constant 0 : index 726// CHECK: %[[VAL_6:.*]] = constant 1 : index 727// CHECK: %[[VAL_7:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 728// CHECK: %[[VAL_8:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 729// CHECK: %[[VAL_9:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 730// CHECK: %[[VAL_10:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 731// CHECK: %[[VAL_11:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 732// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 733// CHECK: %[[VAL_13:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 734// CHECK: %[[VAL_14:.*]] = memref.alloc() : memref<32x16x8xf32> 735// CHECK: linalg.copy(%[[VAL_13]], %[[VAL_14]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 736// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_5]]] : memref<?xindex> 737// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_6]]] : memref<?xindex> 738// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_15]] to %[[VAL_16]] step %[[VAL_6]] { 739// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_17]]] : memref<?xindex> 740// CHECK: scf.for %[[VAL_19:.*]] = %[[VAL_5]] to %[[VAL_4]] step %[[VAL_6]] { 741// CHECK: %[[VAL_20:.*]] = muli %[[VAL_17]], %[[VAL_4]] : index 742// CHECK: %[[VAL_21:.*]] = addi %[[VAL_20]], %[[VAL_19]] : index 743// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_21]]] : memref<?xindex> 744// CHECK: %[[VAL_23:.*]] = addi %[[VAL_21]], %[[VAL_6]] : index 745// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_23]]] : memref<?xindex> 746// CHECK: scf.for %[[VAL_25:.*]] = %[[VAL_22]] to %[[VAL_24]] step %[[VAL_6]] { 747// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_25]]] : memref<?xindex> 748// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_25]]] : memref<?xf32> 749// CHECK: %[[VAL_28:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_18]], %[[VAL_19]], %[[VAL_26]]] : memref<32x16x8xf32> 750// CHECK: %[[VAL_29:.*]] = mulf %[[VAL_27]], %[[VAL_28]] : f32 751// CHECK: memref.store %[[VAL_29]], %[[VAL_14]]{{\[}}%[[VAL_18]], %[[VAL_19]], %[[VAL_26]]] : memref<32x16x8xf32> 752// CHECK: } 753// CHECK: } 754// CHECK: } 755// CHECK: %[[VAL_30:.*]] = memref.tensor_load %[[VAL_14]] : memref<32x16x8xf32> 756// CHECK: return %[[VAL_30]] : tensor<32x16x8xf32> 757// CHECK: } 758func @mul_sds(%arga: tensor<32x16x8xf32, #Tsds>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 759 %0 = linalg.generic #trait3 760 ins(%arga, %argb: tensor<32x16x8xf32, #Tsds>, tensor<32x16x8xf32>) 761 outs(%argx: tensor<32x16x8xf32>) { 762 ^bb(%a: f32, %b: f32, %x: f32): 763 %0 = mulf %a, %b : f32 764 linalg.yield %0 : f32 765 } -> tensor<32x16x8xf32> 766 return %0 : tensor<32x16x8xf32> 767} 768 769// CHECK-LABEL: func @add_ssd( 770// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 771// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 772// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 773// CHECK: %[[VAL_3:.*]] = constant 32 : index 774// CHECK: %[[VAL_4:.*]] = constant 16 : index 775// CHECK: %[[VAL_5:.*]] = constant 8 : index 776// CHECK: %[[VAL_6:.*]] = constant true 777// CHECK: %[[VAL_7:.*]] = constant 0 : index 778// CHECK: %[[VAL_8:.*]] = constant 1 : index 779// CHECK: %[[VAL_9:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_7]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 780// CHECK: %[[VAL_10:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_7]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 781// CHECK: %[[VAL_11:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 782// CHECK: %[[VAL_12:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 783// CHECK: %[[VAL_13:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 784// CHECK: %[[VAL_14:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 785// CHECK: %[[VAL_15:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 786// CHECK: %[[VAL_16:.*]] = memref.alloc() : memref<32x16x8xf32> 787// CHECK: linalg.copy(%[[VAL_15]], %[[VAL_16]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 788// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<?xindex> 789// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_8]]] : memref<?xindex> 790// CHECK: %[[VAL_19:.*]]:2 = scf.while (%[[VAL_20:.*]] = %[[VAL_17]], %[[VAL_21:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) { 791// CHECK: %[[VAL_22:.*]] = cmpi ult, %[[VAL_20]], %[[VAL_18]] : index 792// CHECK: scf.condition(%[[VAL_22]]) %[[VAL_20]], %[[VAL_21]] : index, index 793// CHECK: } do { 794// CHECK: ^bb0(%[[VAL_23:.*]]: index, %[[VAL_24:.*]]: index): 795// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_23]]] : memref<?xindex> 796// CHECK: %[[VAL_26:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_24]] : index 797// CHECK: scf.if %[[VAL_26]] { 798// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_23]]] : memref<?xindex> 799// CHECK: %[[VAL_28:.*]] = addi %[[VAL_23]], %[[VAL_8]] : index 800// CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_28]]] : memref<?xindex> 801// CHECK: %[[VAL_30:.*]]:2 = scf.while (%[[VAL_31:.*]] = %[[VAL_27]], %[[VAL_32:.*]] = %[[VAL_7]]) : (index, index) -> (index, index) { 802// CHECK: %[[VAL_33:.*]] = cmpi ult, %[[VAL_31]], %[[VAL_29]] : index 803// CHECK: scf.condition(%[[VAL_33]]) %[[VAL_31]], %[[VAL_32]] : index, index 804// CHECK: } do { 805// CHECK: ^bb0(%[[VAL_34:.*]]: index, %[[VAL_35:.*]]: index): 806// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_34]]] : memref<?xindex> 807// CHECK: %[[VAL_37:.*]] = cmpi eq, %[[VAL_36]], %[[VAL_35]] : index 808// CHECK: scf.if %[[VAL_37]] { 809// CHECK: scf.for %[[VAL_38:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 810// CHECK: %[[VAL_39:.*]] = muli %[[VAL_34]], %[[VAL_5]] : index 811// CHECK: %[[VAL_40:.*]] = addi %[[VAL_39]], %[[VAL_38]] : index 812// CHECK: %[[VAL_41:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_40]]] : memref<?xf32> 813// CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_24]], %[[VAL_35]], %[[VAL_38]]] : memref<32x16x8xf32> 814// CHECK: %[[VAL_43:.*]] = addf %[[VAL_41]], %[[VAL_42]] : f32 815// CHECK: memref.store %[[VAL_43]], %[[VAL_16]]{{\[}}%[[VAL_24]], %[[VAL_35]], %[[VAL_38]]] : memref<32x16x8xf32> 816// CHECK: } 817// CHECK: } else { 818// CHECK: scf.if %[[VAL_6]] { 819// CHECK: scf.for %[[VAL_44:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 820// CHECK: %[[VAL_45:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_24]], %[[VAL_35]], %[[VAL_44]]] : memref<32x16x8xf32> 821// CHECK: memref.store %[[VAL_45]], %[[VAL_16]]{{\[}}%[[VAL_24]], %[[VAL_35]], %[[VAL_44]]] : memref<32x16x8xf32> 822// CHECK: } 823// CHECK: } else { 824// CHECK: } 825// CHECK: } 826// CHECK: %[[VAL_46:.*]] = cmpi eq, %[[VAL_36]], %[[VAL_35]] : index 827// CHECK: %[[VAL_47:.*]] = addi %[[VAL_34]], %[[VAL_8]] : index 828// CHECK: %[[VAL_48:.*]] = select %[[VAL_46]], %[[VAL_47]], %[[VAL_34]] : index 829// CHECK: %[[VAL_49:.*]] = addi %[[VAL_35]], %[[VAL_8]] : index 830// CHECK: scf.yield %[[VAL_48]], %[[VAL_49]] : index, index 831// CHECK: } 832// CHECK: scf.for %[[VAL_50:.*]] = %[[VAL_51:.*]]#1 to %[[VAL_4]] step %[[VAL_8]] { 833// CHECK: scf.for %[[VAL_52:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 834// CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_24]], %[[VAL_50]], %[[VAL_52]]] : memref<32x16x8xf32> 835// CHECK: memref.store %[[VAL_53]], %[[VAL_16]]{{\[}}%[[VAL_24]], %[[VAL_50]], %[[VAL_52]]] : memref<32x16x8xf32> 836// CHECK: } 837// CHECK: } 838// CHECK: } else { 839// CHECK: scf.if %[[VAL_6]] { 840// CHECK: scf.for %[[VAL_54:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_8]] { 841// CHECK: scf.for %[[VAL_55:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 842// CHECK: %[[VAL_56:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_24]], %[[VAL_54]], %[[VAL_55]]] : memref<32x16x8xf32> 843// CHECK: memref.store %[[VAL_56]], %[[VAL_16]]{{\[}}%[[VAL_24]], %[[VAL_54]], %[[VAL_55]]] : memref<32x16x8xf32> 844// CHECK: } 845// CHECK: } 846// CHECK: } else { 847// CHECK: } 848// CHECK: } 849// CHECK: %[[VAL_57:.*]] = cmpi eq, %[[VAL_25]], %[[VAL_24]] : index 850// CHECK: %[[VAL_58:.*]] = addi %[[VAL_23]], %[[VAL_8]] : index 851// CHECK: %[[VAL_59:.*]] = select %[[VAL_57]], %[[VAL_58]], %[[VAL_23]] : index 852// CHECK: %[[VAL_60:.*]] = addi %[[VAL_24]], %[[VAL_8]] : index 853// CHECK: scf.yield %[[VAL_59]], %[[VAL_60]] : index, index 854// CHECK: } 855// CHECK: scf.for %[[VAL_61:.*]] = %[[VAL_62:.*]]#1 to %[[VAL_3]] step %[[VAL_8]] { 856// CHECK: scf.for %[[VAL_63:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_8]] { 857// CHECK: scf.for %[[VAL_64:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 858// CHECK: %[[VAL_65:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_61]], %[[VAL_63]], %[[VAL_64]]] : memref<32x16x8xf32> 859// CHECK: memref.store %[[VAL_65]], %[[VAL_16]]{{\[}}%[[VAL_61]], %[[VAL_63]], %[[VAL_64]]] : memref<32x16x8xf32> 860// CHECK: } 861// CHECK: } 862// CHECK: } 863// CHECK: %[[VAL_66:.*]] = memref.tensor_load %[[VAL_16]] : memref<32x16x8xf32> 864// CHECK: return %[[VAL_66]] : tensor<32x16x8xf32> 865// CHECK: } 866func @add_ssd(%arga: tensor<32x16x8xf32, #Tssd>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 867 %0 = linalg.generic #trait3 868 ins(%arga, %argb: tensor<32x16x8xf32, #Tssd>, tensor<32x16x8xf32>) 869 outs(%argx: tensor<32x16x8xf32>) { 870 ^bb(%a: f32, %b: f32, %x: f32): 871 %0 = addf %a, %b : f32 872 linalg.yield %0 : f32 873 } -> tensor<32x16x8xf32> 874 return %0 : tensor<32x16x8xf32> 875} 876 877// CHECK-LABEL: func @mul_ssd( 878// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 879// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 880// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 881// CHECK: %[[VAL_3:.*]] = constant 8 : index 882// CHECK: %[[VAL_4:.*]] = constant 0 : index 883// CHECK: %[[VAL_5:.*]] = constant 1 : index 884// CHECK: %[[VAL_6:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_4]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 885// CHECK: %[[VAL_7:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 886// CHECK: %[[VAL_8:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 887// CHECK: %[[VAL_9:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 888// CHECK: %[[VAL_10:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "dense" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 889// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 890// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 891// CHECK: %[[VAL_13:.*]] = memref.alloc() : memref<32x16x8xf32> 892// CHECK: linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 893// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> 894// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> 895// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_14]] to %[[VAL_15]] step %[[VAL_5]] { 896// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_16]]] : memref<?xindex> 897// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_16]]] : memref<?xindex> 898// CHECK: %[[VAL_19:.*]] = addi %[[VAL_16]], %[[VAL_5]] : index 899// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_19]]] : memref<?xindex> 900// CHECK: scf.for %[[VAL_21:.*]] = %[[VAL_18]] to %[[VAL_20]] step %[[VAL_5]] { 901// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_21]]] : memref<?xindex> 902// CHECK: scf.for %[[VAL_23:.*]] = %[[VAL_4]] to %[[VAL_3]] step %[[VAL_5]] { 903// CHECK: %[[VAL_24:.*]] = muli %[[VAL_21]], %[[VAL_3]] : index 904// CHECK: %[[VAL_25:.*]] = addi %[[VAL_24]], %[[VAL_23]] : index 905// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_25]]] : memref<?xf32> 906// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_17]], %[[VAL_22]], %[[VAL_23]]] : memref<32x16x8xf32> 907// CHECK: %[[VAL_28:.*]] = mulf %[[VAL_26]], %[[VAL_27]] : f32 908// CHECK: memref.store %[[VAL_28]], %[[VAL_13]]{{\[}}%[[VAL_17]], %[[VAL_22]], %[[VAL_23]]] : memref<32x16x8xf32> 909// CHECK: } 910// CHECK: } 911// CHECK: } 912// CHECK: %[[VAL_29:.*]] = memref.tensor_load %[[VAL_13]] : memref<32x16x8xf32> 913// CHECK: return %[[VAL_29]] : tensor<32x16x8xf32> 914// CHECK: } 915func @mul_ssd(%arga: tensor<32x16x8xf32, #Tssd>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 916 %0 = linalg.generic #trait3 917 ins(%arga, %argb: tensor<32x16x8xf32, #Tssd>, tensor<32x16x8xf32>) 918 outs(%argx: tensor<32x16x8xf32>) { 919 ^bb(%a: f32, %b: f32, %x: f32): 920 %0 = mulf %a, %b : f32 921 linalg.yield %0 : f32 922 } -> tensor<32x16x8xf32> 923 return %0 : tensor<32x16x8xf32> 924} 925 926// CHECK-LABEL: func @add_sss( 927// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 928// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 929// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 930// CHECK: %[[VAL_3:.*]] = constant 2 : index 931// CHECK: %[[VAL_4:.*]] = constant 32 : index 932// CHECK: %[[VAL_5:.*]] = constant 16 : index 933// CHECK: %[[VAL_6:.*]] = constant 8 : index 934// CHECK: %[[VAL_7:.*]] = constant true 935// CHECK: %[[VAL_8:.*]] = constant 0 : index 936// CHECK: %[[VAL_9:.*]] = constant 1 : index 937// CHECK: %[[VAL_10:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 938// CHECK: %[[VAL_11:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_8]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 939// CHECK: %[[VAL_12:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_9]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 940// CHECK: %[[VAL_13:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_9]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 941// CHECK: %[[VAL_14:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 942// CHECK: %[[VAL_15:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 943// CHECK: %[[VAL_16:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 944// CHECK: %[[VAL_17:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 945// CHECK: %[[VAL_18:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 946// CHECK: %[[VAL_19:.*]] = memref.alloc() : memref<32x16x8xf32> 947// CHECK: linalg.copy(%[[VAL_18]], %[[VAL_19]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 948// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<?xindex> 949// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_9]]] : memref<?xindex> 950// CHECK: %[[VAL_22:.*]]:2 = scf.while (%[[VAL_23:.*]] = %[[VAL_20]], %[[VAL_24:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { 951// CHECK: %[[VAL_25:.*]] = cmpi ult, %[[VAL_23]], %[[VAL_21]] : index 952// CHECK: scf.condition(%[[VAL_25]]) %[[VAL_23]], %[[VAL_24]] : index, index 953// CHECK: } do { 954// CHECK: ^bb0(%[[VAL_26:.*]]: index, %[[VAL_27:.*]]: index): 955// CHECK: %[[VAL_28:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_26]]] : memref<?xindex> 956// CHECK: %[[VAL_29:.*]] = cmpi eq, %[[VAL_28]], %[[VAL_27]] : index 957// CHECK: scf.if %[[VAL_29]] { 958// CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_26]]] : memref<?xindex> 959// CHECK: %[[VAL_31:.*]] = addi %[[VAL_26]], %[[VAL_9]] : index 960// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_31]]] : memref<?xindex> 961// CHECK: %[[VAL_33:.*]]:2 = scf.while (%[[VAL_34:.*]] = %[[VAL_30]], %[[VAL_35:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { 962// CHECK: %[[VAL_36:.*]] = cmpi ult, %[[VAL_34]], %[[VAL_32]] : index 963// CHECK: scf.condition(%[[VAL_36]]) %[[VAL_34]], %[[VAL_35]] : index, index 964// CHECK: } do { 965// CHECK: ^bb0(%[[VAL_37:.*]]: index, %[[VAL_38:.*]]: index): 966// CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_37]]] : memref<?xindex> 967// CHECK: %[[VAL_40:.*]] = cmpi eq, %[[VAL_39]], %[[VAL_38]] : index 968// CHECK: scf.if %[[VAL_40]] { 969// CHECK: %[[VAL_41:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_37]]] : memref<?xindex> 970// CHECK: %[[VAL_42:.*]] = addi %[[VAL_37]], %[[VAL_9]] : index 971// CHECK: %[[VAL_43:.*]] = memref.load %[[VAL_14]]{{\[}}%[[VAL_42]]] : memref<?xindex> 972// CHECK: %[[VAL_44:.*]]:2 = scf.while (%[[VAL_45:.*]] = %[[VAL_41]], %[[VAL_46:.*]] = %[[VAL_8]]) : (index, index) -> (index, index) { 973// CHECK: %[[VAL_47:.*]] = cmpi ult, %[[VAL_45]], %[[VAL_43]] : index 974// CHECK: scf.condition(%[[VAL_47]]) %[[VAL_45]], %[[VAL_46]] : index, index 975// CHECK: } do { 976// CHECK: ^bb0(%[[VAL_48:.*]]: index, %[[VAL_49:.*]]: index): 977// CHECK: %[[VAL_50:.*]] = memref.load %[[VAL_15]]{{\[}}%[[VAL_48]]] : memref<?xindex> 978// CHECK: %[[VAL_51:.*]] = cmpi eq, %[[VAL_50]], %[[VAL_49]] : index 979// CHECK: scf.if %[[VAL_51]] { 980// CHECK: %[[VAL_52:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_48]]] : memref<?xf32> 981// CHECK: %[[VAL_53:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_27]], %[[VAL_38]], %[[VAL_49]]] : memref<32x16x8xf32> 982// CHECK: %[[VAL_54:.*]] = addf %[[VAL_52]], %[[VAL_53]] : f32 983// CHECK: memref.store %[[VAL_54]], %[[VAL_19]]{{\[}}%[[VAL_27]], %[[VAL_38]], %[[VAL_49]]] : memref<32x16x8xf32> 984// CHECK: } else { 985// CHECK: scf.if %[[VAL_7]] { 986// CHECK: %[[VAL_55:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_27]], %[[VAL_38]], %[[VAL_49]]] : memref<32x16x8xf32> 987// CHECK: memref.store %[[VAL_55]], %[[VAL_19]]{{\[}}%[[VAL_27]], %[[VAL_38]], %[[VAL_49]]] : memref<32x16x8xf32> 988// CHECK: } else { 989// CHECK: } 990// CHECK: } 991// CHECK: %[[VAL_56:.*]] = cmpi eq, %[[VAL_50]], %[[VAL_49]] : index 992// CHECK: %[[VAL_57:.*]] = addi %[[VAL_48]], %[[VAL_9]] : index 993// CHECK: %[[VAL_58:.*]] = select %[[VAL_56]], %[[VAL_57]], %[[VAL_48]] : index 994// CHECK: %[[VAL_59:.*]] = addi %[[VAL_49]], %[[VAL_9]] : index 995// CHECK: scf.yield %[[VAL_58]], %[[VAL_59]] : index, index 996// CHECK: } 997// CHECK: scf.for %[[VAL_60:.*]] = %[[VAL_61:.*]]#1 to %[[VAL_6]] step %[[VAL_9]] { 998// CHECK: %[[VAL_62:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_27]], %[[VAL_38]], %[[VAL_60]]] : memref<32x16x8xf32> 999// CHECK: memref.store %[[VAL_62]], %[[VAL_19]]{{\[}}%[[VAL_27]], %[[VAL_38]], %[[VAL_60]]] : memref<32x16x8xf32> 1000// CHECK: } 1001// CHECK: } else { 1002// CHECK: scf.if %[[VAL_7]] { 1003// CHECK: scf.for %[[VAL_63:.*]] = %[[VAL_8]] to %[[VAL_6]] step %[[VAL_9]] { 1004// CHECK: %[[VAL_64:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_27]], %[[VAL_38]], %[[VAL_63]]] : memref<32x16x8xf32> 1005// CHECK: memref.store %[[VAL_64]], %[[VAL_19]]{{\[}}%[[VAL_27]], %[[VAL_38]], %[[VAL_63]]] : memref<32x16x8xf32> 1006// CHECK: } 1007// CHECK: } else { 1008// CHECK: } 1009// CHECK: } 1010// CHECK: %[[VAL_65:.*]] = cmpi eq, %[[VAL_39]], %[[VAL_38]] : index 1011// CHECK: %[[VAL_66:.*]] = addi %[[VAL_37]], %[[VAL_9]] : index 1012// CHECK: %[[VAL_67:.*]] = select %[[VAL_65]], %[[VAL_66]], %[[VAL_37]] : index 1013// CHECK: %[[VAL_68:.*]] = addi %[[VAL_38]], %[[VAL_9]] : index 1014// CHECK: scf.yield %[[VAL_67]], %[[VAL_68]] : index, index 1015// CHECK: } 1016// CHECK: scf.for %[[VAL_69:.*]] = %[[VAL_70:.*]]#1 to %[[VAL_5]] step %[[VAL_9]] { 1017// CHECK: scf.for %[[VAL_71:.*]] = %[[VAL_8]] to %[[VAL_6]] step %[[VAL_9]] { 1018// CHECK: %[[VAL_72:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_27]], %[[VAL_69]], %[[VAL_71]]] : memref<32x16x8xf32> 1019// CHECK: memref.store %[[VAL_72]], %[[VAL_19]]{{\[}}%[[VAL_27]], %[[VAL_69]], %[[VAL_71]]] : memref<32x16x8xf32> 1020// CHECK: } 1021// CHECK: } 1022// CHECK: } else { 1023// CHECK: scf.if %[[VAL_7]] { 1024// CHECK: scf.for %[[VAL_73:.*]] = %[[VAL_8]] to %[[VAL_5]] step %[[VAL_9]] { 1025// CHECK: scf.for %[[VAL_74:.*]] = %[[VAL_8]] to %[[VAL_6]] step %[[VAL_9]] { 1026// CHECK: %[[VAL_75:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_27]], %[[VAL_73]], %[[VAL_74]]] : memref<32x16x8xf32> 1027// CHECK: memref.store %[[VAL_75]], %[[VAL_19]]{{\[}}%[[VAL_27]], %[[VAL_73]], %[[VAL_74]]] : memref<32x16x8xf32> 1028// CHECK: } 1029// CHECK: } 1030// CHECK: } else { 1031// CHECK: } 1032// CHECK: } 1033// CHECK: %[[VAL_76:.*]] = cmpi eq, %[[VAL_28]], %[[VAL_27]] : index 1034// CHECK: %[[VAL_77:.*]] = addi %[[VAL_26]], %[[VAL_9]] : index 1035// CHECK: %[[VAL_78:.*]] = select %[[VAL_76]], %[[VAL_77]], %[[VAL_26]] : index 1036// CHECK: %[[VAL_79:.*]] = addi %[[VAL_27]], %[[VAL_9]] : index 1037// CHECK: scf.yield %[[VAL_78]], %[[VAL_79]] : index, index 1038// CHECK: } 1039// CHECK: scf.for %[[VAL_80:.*]] = %[[VAL_81:.*]]#1 to %[[VAL_4]] step %[[VAL_9]] { 1040// CHECK: scf.for %[[VAL_82:.*]] = %[[VAL_8]] to %[[VAL_5]] step %[[VAL_9]] { 1041// CHECK: scf.for %[[VAL_83:.*]] = %[[VAL_8]] to %[[VAL_6]] step %[[VAL_9]] { 1042// CHECK: %[[VAL_84:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_80]], %[[VAL_82]], %[[VAL_83]]] : memref<32x16x8xf32> 1043// CHECK: memref.store %[[VAL_84]], %[[VAL_19]]{{\[}}%[[VAL_80]], %[[VAL_82]], %[[VAL_83]]] : memref<32x16x8xf32> 1044// CHECK: } 1045// CHECK: } 1046// CHECK: } 1047// CHECK: %[[VAL_85:.*]] = memref.tensor_load %[[VAL_19]] : memref<32x16x8xf32> 1048// CHECK: return %[[VAL_85]] : tensor<32x16x8xf32> 1049// CHECK: } 1050func @add_sss(%arga: tensor<32x16x8xf32, #Tsss>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 1051 %0 = linalg.generic #trait3 1052 ins(%arga, %argb: tensor<32x16x8xf32, #Tsss>, tensor<32x16x8xf32>) 1053 outs(%argx: tensor<32x16x8xf32>) { 1054 ^bb(%a: f32, %b: f32, %x: f32): 1055 %0 = addf %a, %b : f32 1056 linalg.yield %0 : f32 1057 } -> tensor<32x16x8xf32> 1058 return %0 : tensor<32x16x8xf32> 1059} 1060 1061// CHECK-LABEL: func @mul_sss( 1062// CHECK-SAME: %[[VAL_0:.*]]: tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 1063// CHECK-SAME: %[[VAL_1:.*]]: tensor<32x16x8xf32>, 1064// CHECK-SAME: %[[VAL_2:.*]]: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 1065// CHECK: %[[VAL_3:.*]] = constant 2 : index 1066// CHECK: %[[VAL_4:.*]] = constant 0 : index 1067// CHECK: %[[VAL_5:.*]] = constant 1 : index 1068// CHECK: %[[VAL_6:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_4]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1069// CHECK: %[[VAL_7:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_4]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1070// CHECK: %[[VAL_8:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1071// CHECK: %[[VAL_9:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_5]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1072// CHECK: %[[VAL_10:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1073// CHECK: %[[VAL_11:.*]] = sparse_tensor.indices %[[VAL_0]], %[[VAL_3]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1074// CHECK: %[[VAL_12:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<32x16x8xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 1075// CHECK: %[[VAL_13:.*]] = memref.buffer_cast %[[VAL_1]] : memref<32x16x8xf32> 1076// CHECK: %[[VAL_14:.*]] = memref.buffer_cast %[[VAL_2]] : memref<32x16x8xf32> 1077// CHECK: %[[VAL_15:.*]] = memref.alloc() : memref<32x16x8xf32> 1078// CHECK: linalg.copy(%[[VAL_14]], %[[VAL_15]]) : memref<32x16x8xf32>, memref<32x16x8xf32> 1079// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<?xindex> 1080// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_5]]] : memref<?xindex> 1081// CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_16]] to %[[VAL_17]] step %[[VAL_5]] { 1082// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_18]]] : memref<?xindex> 1083// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_18]]] : memref<?xindex> 1084// CHECK: %[[VAL_21:.*]] = addi %[[VAL_18]], %[[VAL_5]] : index 1085// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_21]]] : memref<?xindex> 1086// CHECK: scf.for %[[VAL_23:.*]] = %[[VAL_20]] to %[[VAL_22]] step %[[VAL_5]] { 1087// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_23]]] : memref<?xindex> 1088// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_23]]] : memref<?xindex> 1089// CHECK: %[[VAL_26:.*]] = addi %[[VAL_23]], %[[VAL_5]] : index 1090// CHECK: %[[VAL_27:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_26]]] : memref<?xindex> 1091// CHECK: scf.for %[[VAL_28:.*]] = %[[VAL_25]] to %[[VAL_27]] step %[[VAL_5]] { 1092// CHECK: %[[VAL_29:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_28]]] : memref<?xindex> 1093// CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_28]]] : memref<?xf32> 1094// CHECK: %[[VAL_31:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_19]], %[[VAL_24]], %[[VAL_29]]] : memref<32x16x8xf32> 1095// CHECK: %[[VAL_32:.*]] = mulf %[[VAL_30]], %[[VAL_31]] : f32 1096// CHECK: memref.store %[[VAL_32]], %[[VAL_15]]{{\[}}%[[VAL_19]], %[[VAL_24]], %[[VAL_29]]] : memref<32x16x8xf32> 1097// CHECK: } 1098// CHECK: } 1099// CHECK: } 1100// CHECK: %[[VAL_33:.*]] = memref.tensor_load %[[VAL_15]] : memref<32x16x8xf32> 1101// CHECK: return %[[VAL_33]] : tensor<32x16x8xf32> 1102// CHECK: } 1103func @mul_sss(%arga: tensor<32x16x8xf32, #Tsss>, %argb: tensor<32x16x8xf32>, %argx: tensor<32x16x8xf32>) -> tensor<32x16x8xf32> { 1104 %0 = linalg.generic #trait3 1105 ins(%arga, %argb: tensor<32x16x8xf32, #Tsss>, tensor<32x16x8xf32>) 1106 outs(%argx: tensor<32x16x8xf32>) { 1107 ^bb(%a: f32, %b: f32, %x: f32): 1108 %0 = mulf %a, %b : f32 1109 linalg.yield %0 : f32 1110 } -> tensor<32x16x8xf32> 1111 return %0 : tensor<32x16x8xf32> 1112} 1113 1114#trait_kernel_3d = { 1115 indexing_maps = [ 1116 affine_map<(i,j,k,l) -> (i,k,l)>, // B 1117 affine_map<(i,j,k,l) -> (k,j)>, // C 1118 affine_map<(i,j,k,l) -> (l,j)>, // D 1119 affine_map<(i,j,k,l) -> (i,j)> // A (out) 1120 ], 1121 iterator_types = ["parallel", "parallel", "reduction", "reduction"], 1122 doc = "A(i,j) += SUM_k,l B(i,k,l) * C(k,j) * D(l,j)" 1123} 1124 1125// CHECK-LABEL: func @kernel_3d( 1126// CHECK-SAME: %[[VAL_0:.*0]]: tensor<?x?xf32>, 1127// CHECK-SAME: %[[VAL_1:.*1]]: tensor<?x?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 1128// CHECK-SAME: %[[VAL_2:.*2]]: tensor<?x?xf32>, 1129// CHECK-SAME: %[[VAL_3:.*3]]: tensor<?x?xf32>) -> tensor<?x?xf32> { 1130// CHECK: %[[VAL_4:.*]] = constant 2 : index 1131// CHECK: %[[VAL_5:.*]] = constant 0 : index 1132// CHECK: %[[VAL_6:.*]] = constant 1 : index 1133// CHECK: %[[VAL_7:.*]] = sparse_tensor.pointers %[[VAL_1]], %[[VAL_4]] : tensor<?x?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1134// CHECK: %[[VAL_8:.*]] = sparse_tensor.indices %[[VAL_1]], %[[VAL_4]] : tensor<?x?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1135// CHECK: %[[VAL_9:.*]] = sparse_tensor.values %[[VAL_1]] : tensor<?x?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "dense", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 1136// CHECK: %[[VAL_10:.*]] = memref.dim %[[VAL_2]], %[[VAL_5]] : tensor<?x?xf32> 1137// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<?x?xf32> 1138// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_3]] : memref<?x?xf32> 1139// CHECK: %[[VAL_13:.*]] = memref.dim %[[VAL_0]], %[[VAL_5]] : tensor<?x?xf32> 1140// CHECK: %[[VAL_14:.*]] = memref.dim %[[VAL_0]], %[[VAL_6]] : tensor<?x?xf32> 1141// CHECK: %[[VAL_15:.*]] = memref.buffer_cast %[[VAL_0]] : memref<?x?xf32> 1142// CHECK: %[[VAL_16:.*]] = memref.alloc(%[[VAL_13]], %[[VAL_14]]) : memref<?x?xf32> 1143// CHECK: linalg.copy(%[[VAL_15]], %[[VAL_16]]) : memref<?x?xf32>, memref<?x?xf32> 1144// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_5]] to %[[VAL_13]] step %[[VAL_6]] { 1145// CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_5]] to %[[VAL_10]] step %[[VAL_6]] { 1146// CHECK: %[[VAL_19:.*]] = muli %[[VAL_10]], %[[VAL_17]] : index 1147// CHECK: %[[VAL_20:.*]] = addi %[[VAL_19]], %[[VAL_18]] : index 1148// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_20]]] : memref<?xindex> 1149// CHECK: %[[VAL_22:.*]] = addi %[[VAL_20]], %[[VAL_6]] : index 1150// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_22]]] : memref<?xindex> 1151// CHECK: scf.for %[[VAL_24:.*]] = %[[VAL_21]] to %[[VAL_23]] step %[[VAL_6]] { 1152// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_24]]] : memref<?xindex> 1153// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_24]]] : memref<?xf32> 1154// CHECK: scf.for %[[VAL_27:.*]] = %[[VAL_5]] to %[[VAL_14]] step %[[VAL_6]] { 1155// CHECK: %[[VAL_28:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_18]], %[[VAL_27]]] : memref<?x?xf32> 1156// CHECK: %[[VAL_29:.*]] = mulf %[[VAL_26]], %[[VAL_28]] : f32 1157// CHECK: %[[VAL_30:.*]] = memref.load %[[VAL_12]]{{\[}}%[[VAL_25]], %[[VAL_27]]] : memref<?x?xf32> 1158// CHECK: %[[VAL_31:.*]] = mulf %[[VAL_29]], %[[VAL_30]] : f32 1159// CHECK: %[[VAL_32:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_17]], %[[VAL_27]]] : memref<?x?xf32> 1160// CHECK: %[[VAL_33:.*]] = addf %[[VAL_31]], %[[VAL_32]] : f32 1161// CHECK: memref.store %[[VAL_33]], %[[VAL_16]]{{\[}}%[[VAL_17]], %[[VAL_27]]] : memref<?x?xf32> 1162// CHECK: } 1163// CHECK: } 1164// CHECK: } 1165// CHECK: } 1166// CHECK: %[[VAL_34:.*]] = memref.tensor_load %[[VAL_16]] : memref<?x?xf32> 1167// CHECK: return %[[VAL_34]] : tensor<?x?xf32> 1168// CHECK: } 1169func @kernel_3d(%arga: tensor<?x?xf32>, 1170 %argb: tensor<?x?x?xf32, #Tdds>, 1171 %argc: tensor<?x?xf32>, 1172 %argd: tensor<?x?xf32>) -> tensor<?x?xf32> { 1173 %0 = linalg.generic #trait_kernel_3d 1174 ins(%argb, %argc, %argd: tensor<?x?x?xf32, #Tdds>, tensor<?x?xf32>, tensor<?x?xf32>) 1175 outs(%arga: tensor<?x?xf32>) { 1176 ^bb(%b: f32, %c: f32, %d: f32, %a: f32): 1177 %0 = mulf %b, %c : f32 1178 %1 = mulf %0, %d : f32 1179 %2 = addf %1, %a : f32 1180 linalg.yield %2 : f32 1181 } -> tensor<?x?xf32> 1182 return %0 : tensor<?x?xf32> 1183} 1184 1185#trait_sum_reduction = { 1186 indexing_maps = [ 1187 affine_map<(i,j,k) -> (i,j,k)>, // A 1188 affine_map<(i,j,k) -> ()> // x (scalar out) 1189 ], 1190 iterator_types = ["reduction", "reduction", "reduction"], 1191 doc = "x += SUM_ijk A(i,j,k)" 1192} 1193 1194// CHECK-LABEL: func @sum_reduction( 1195// CHECK-SAME: %[[VAL_0:.*]]: tensor<10x20x30xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>>, 1196// CHECK-SAME: %[[VAL_1:.*]]: tensor<f32>) -> tensor<f32> { 1197// CHECK: %[[VAL_2:.*]] = constant 2 : index 1198// CHECK: %[[VAL_3:.*]] = constant 0 : index 1199// CHECK: %[[VAL_4:.*]] = constant 1 : index 1200// CHECK: %[[VAL_5:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_3]] : tensor<10x20x30xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1201// CHECK: %[[VAL_6:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_4]] : tensor<10x20x30xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1202// CHECK: %[[VAL_7:.*]] = sparse_tensor.pointers %[[VAL_0]], %[[VAL_2]] : tensor<10x20x30xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xindex> 1203// CHECK: %[[VAL_8:.*]] = sparse_tensor.values %[[VAL_0]] : tensor<10x20x30xf32, #sparse_tensor.encoding<{ dimLevelType = [ "compressed", "compressed", "compressed" ], pointerBitWidth = 0, indexBitWidth = 0 }>> to memref<?xf32> 1204// CHECK: %[[VAL_9:.*]] = memref.buffer_cast %[[VAL_1]] : memref<f32> 1205// CHECK: %[[VAL_10:.*]] = memref.alloc() : memref<f32> 1206// CHECK: linalg.copy(%[[VAL_9]], %[[VAL_10]]) : memref<f32>, memref<f32> 1207// CHECK: %[[VAL_11:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_3]]] : memref<?xindex> 1208// CHECK: %[[VAL_12:.*]] = memref.load %[[VAL_5]]{{\[}}%[[VAL_4]]] : memref<?xindex> 1209// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_11]] to %[[VAL_12]] step %[[VAL_4]] { 1210// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_13]]] : memref<?xindex> 1211// CHECK: %[[VAL_15:.*]] = addi %[[VAL_13]], %[[VAL_4]] : index 1212// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_6]]{{\[}}%[[VAL_15]]] : memref<?xindex> 1213// CHECK: scf.for %[[VAL_17:.*]] = %[[VAL_14]] to %[[VAL_16]] step %[[VAL_4]] { 1214// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_17]]] : memref<?xindex> 1215// CHECK: %[[VAL_19:.*]] = addi %[[VAL_17]], %[[VAL_4]] : index 1216// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_7]]{{\[}}%[[VAL_19]]] : memref<?xindex> 1217// CHECK: %[[VAL_21:.*]] = memref.load %[[VAL_10]][] : memref<f32> 1218// CHECK: %[[VAL_22:.*]] = scf.for %[[VAL_23:.*]] = %[[VAL_18]] to %[[VAL_20]] step %[[VAL_4]] iter_args(%[[VAL_24:.*]] = %[[VAL_21]]) -> (f32) { 1219// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_23]]] : memref<?xf32> 1220// CHECK: %[[VAL_26:.*]] = addf %[[VAL_24]], %[[VAL_25]] : f32 1221// CHECK: scf.yield %[[VAL_26]] : f32 1222// CHECK: } 1223// CHECK: memref.store %[[VAL_27:.*]], %[[VAL_10]][] : memref<f32> 1224// CHECK: } 1225// CHECK: } 1226// CHECK: %[[VAL_28:.*]] = memref.tensor_load %[[VAL_10]] : memref<f32> 1227// CHECK: return %[[VAL_28]] : tensor<f32> 1228// CHECK: } 1229func @sum_reduction(%arga: tensor<10x20x30xf32, #Tsss>, %argx: tensor<f32>) -> tensor<f32> { 1230 %0 = linalg.generic #trait_sum_reduction 1231 ins(%arga: tensor<10x20x30xf32, #Tsss>) 1232 outs(%argx: tensor<f32>) { 1233 ^bb(%a: f32, %x: f32): 1234 %0 = addf %x, %a : f32 1235 linalg.yield %0 : f32 1236 } -> tensor<f32> 1237 return %0 : tensor<f32> 1238} 1239 1240#trait_sum_reduction_inv = { 1241 indexing_maps = [ 1242 affine_map<(i,j,k) -> (i,j,k)>, // A 1243 affine_map<(i,j,k) -> (i)>, // b 1244 affine_map<(i,j,k) -> ()> // x (scalar out) 1245 ], 1246 iterator_types = ["reduction", "reduction", "reduction"], 1247 doc = "x += SUM_i A(i,j,k) * b(i)" 1248} 1249 1250// CHECK-LABEL: func @sum_reduction_inv( 1251// CHECK-SAME: %[[VAL_0:.*]]: tensor<?x?x?xf32>, 1252// CHECK-SAME: %[[VAL_1:.*]]: tensor<?xf32>, 1253// CHECK-SAME: %[[VAL_2:.*]]: tensor<f32>) -> tensor<f32> { 1254// CHECK: %[[VAL_3:.*]] = constant 2 : index 1255// CHECK: %[[VAL_4:.*]] = constant 0 : index 1256// CHECK: %[[VAL_5:.*]] = constant 1 : index 1257// CHECK: %[[VAL_6:.*]] = memref.dim %[[VAL_0]], %[[VAL_5]] : tensor<?x?x?xf32> 1258// CHECK: %[[VAL_7:.*]] = memref.dim %[[VAL_0]], %[[VAL_3]] : tensor<?x?x?xf32> 1259// CHECK: %[[VAL_8:.*]] = memref.buffer_cast %[[VAL_0]] : memref<?x?x?xf32> 1260// CHECK: %[[VAL_9:.*]] = memref.dim %[[VAL_1]], %[[VAL_4]] : tensor<?xf32> 1261// CHECK: %[[VAL_10:.*]] = memref.buffer_cast %[[VAL_1]] : memref<?xf32> 1262// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<f32> 1263// CHECK: %[[VAL_12:.*]] = memref.alloc() : memref<f32> 1264// CHECK: linalg.copy(%[[VAL_11]], %[[VAL_12]]) : memref<f32>, memref<f32> 1265// CHECK: scf.for %[[VAL_13:.*]] = %[[VAL_4]] to %[[VAL_9]] step %[[VAL_5]] { 1266// CHECK: %[[VAL_14:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_13]]] : memref<?xf32> 1267// CHECK: scf.for %[[VAL_15:.*]] = %[[VAL_4]] to %[[VAL_6]] step %[[VAL_5]] { 1268// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_12]][] : memref<f32> 1269// CHECK: %[[VAL_17:.*]] = scf.for %[[VAL_18:.*]] = %[[VAL_4]] to %[[VAL_7]] step %[[VAL_5]] iter_args(%[[VAL_19:.*]] = %[[VAL_16]]) -> (f32) { 1270// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_8]]{{\[}}%[[VAL_13]], %[[VAL_15]], %[[VAL_18]]] : memref<?x?x?xf32> 1271// CHECK: %[[VAL_21:.*]] = mulf %[[VAL_20]], %[[VAL_14]] : f32 1272// CHECK: %[[VAL_22:.*]] = addf %[[VAL_19]], %[[VAL_21]] : f32 1273// CHECK: scf.yield %[[VAL_22]] : f32 1274// CHECK: } 1275// CHECK: memref.store %[[VAL_23:.*]], %[[VAL_12]][] : memref<f32> 1276// CHECK: } 1277// CHECK: } 1278// CHECK: %[[VAL_24:.*]] = memref.tensor_load %[[VAL_12]] : memref<f32> 1279// CHECK: return %[[VAL_24]] : tensor<f32> 1280// CHECK: } 1281func @sum_reduction_inv(%arga: tensor<?x?x?xf32>, 1282 %argb: tensor<?xf32>, 1283 %argx: tensor<f32>) -> tensor<f32> { 1284 %0 = linalg.generic #trait_sum_reduction_inv 1285 ins(%arga, %argb: tensor<?x?x?xf32>, tensor<?xf32>) 1286 outs(%argx: tensor<f32>) { 1287 ^bb(%a: f32, %b: f32, %x: f32): 1288 %0 = mulf %a, %b : f32 1289 %1 = addf %x, %0 : f32 1290 linalg.yield %1 : f32 1291 } -> tensor<f32> 1292 return %0 : tensor<f32> 1293} 1294 1295#trait_invariants = { 1296 indexing_maps = [ 1297 affine_map<(i,j,k) -> (i)>, // a 1298 affine_map<(i,j,k) -> (j)>, // b 1299 affine_map<(i,j,k) -> (k)>, // c 1300 affine_map<(i,j,k) -> (i,j,k)> // X (out) 1301 ], 1302 iterator_types = ["parallel", "parallel", "parallel"], 1303 doc = "X(i,j,k) = a(i) * b(j) * c(k)" 1304} 1305 1306// CHECK-LABEL: func @invariants( 1307// CHECK-SAME: %[[VAL_0:.*]]: tensor<10xf32>, 1308// CHECK-SAME: %[[VAL_1:.*]]: tensor<20xf32>, 1309// CHECK-SAME: %[[VAL_2:.*]]: tensor<30xf32>, 1310// CHECK-SAME: %[[VAL_3:.*]]: tensor<10x20x30xf32>) -> tensor<10x20x30xf32> { 1311// CHECK: %[[VAL_4:.*]] = constant 10 : index 1312// CHECK: %[[VAL_5:.*]] = constant 20 : index 1313// CHECK: %[[VAL_6:.*]] = constant 30 : index 1314// CHECK: %[[VAL_7:.*]] = constant 0 : index 1315// CHECK: %[[VAL_8:.*]] = constant 1 : index 1316// CHECK: %[[VAL_9:.*]] = memref.buffer_cast %[[VAL_0]] : memref<10xf32> 1317// CHECK: %[[VAL_10:.*]] = memref.buffer_cast %[[VAL_1]] : memref<20xf32> 1318// CHECK: %[[VAL_11:.*]] = memref.buffer_cast %[[VAL_2]] : memref<30xf32> 1319// CHECK: %[[VAL_12:.*]] = memref.buffer_cast %[[VAL_3]] : memref<10x20x30xf32> 1320// CHECK: %[[VAL_13:.*]] = memref.alloc() : memref<10x20x30xf32> 1321// CHECK: linalg.copy(%[[VAL_12]], %[[VAL_13]]) : memref<10x20x30xf32>, memref<10x20x30xf32> 1322// CHECK: scf.for %[[VAL_14:.*]] = %[[VAL_7]] to %[[VAL_4]] step %[[VAL_8]] { 1323// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_9]]{{\[}}%[[VAL_14]]] : memref<10xf32> 1324// CHECK: scf.for %[[VAL_16:.*]] = %[[VAL_7]] to %[[VAL_5]] step %[[VAL_8]] { 1325// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_10]]{{\[}}%[[VAL_16]]] : memref<20xf32> 1326// CHECK: scf.for %[[VAL_18:.*]] = %[[VAL_7]] to %[[VAL_6]] step %[[VAL_8]] { 1327// CHECK: %[[VAL_19:.*]] = mulf %[[VAL_15]], %[[VAL_17]] : f32 1328// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_11]]{{\[}}%[[VAL_18]]] : memref<30xf32> 1329// CHECK: %[[VAL_21:.*]] = mulf %[[VAL_19]], %[[VAL_20]] : f32 1330// CHECK: memref.store %[[VAL_21]], %[[VAL_13]]{{\[}}%[[VAL_14]], %[[VAL_16]], %[[VAL_18]]] : memref<10x20x30xf32> 1331// CHECK: } 1332// CHECK: } 1333// CHECK: } 1334// CHECK: %[[VAL_22:.*]] = memref.tensor_load %[[VAL_13]] : memref<10x20x30xf32> 1335// CHECK: return %[[VAL_22]] : tensor<10x20x30xf32> 1336// CHECK: } 1337func @invariants(%arga: tensor<10xf32>, 1338 %argb: tensor<20xf32>, 1339 %argc: tensor<30xf32>, 1340 %argx: tensor<10x20x30xf32>) -> tensor<10x20x30xf32> { 1341 %0 = linalg.generic #trait_invariants 1342 ins(%arga, %argb, %argc : tensor<10xf32>, tensor<20xf32>, tensor<30xf32>) 1343 outs(%argx: tensor<10x20x30xf32>) { 1344 ^bb(%a: f32, %b: f32, %c: f32, %x: f32): 1345 %0 = mulf %a, %b : f32 1346 %1 = mulf %0, %c : f32 1347 linalg.yield %1 : f32 1348 } -> tensor<10x20x30xf32> 1349 return %0 : tensor<10x20x30xf32> 1350} 1351