1// RUN: mlir-opt %s -linalg-tile="tile-sizes=2" -mlir-disable-threading=true | FileCheck %s -check-prefix=TILE-2 2// RUN: mlir-opt %s -linalg-tile="tile-sizes=0,2" -mlir-disable-threading=true | FileCheck %s -check-prefix=TILE-02 3// RUN: mlir-opt %s -linalg-tile="tile-sizes=0,0,2" -mlir-disable-threading=true | FileCheck %s -check-prefix=TILE-002 4// RUN: mlir-opt %s -linalg-tile="tile-sizes=2,3,4" -mlir-disable-threading=true | FileCheck %s -check-prefix=TILE-234 5 6// TILE-2-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> 7// TILE-02-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> 8// TILE-002-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> 9// TILE-234-DAG: #[[$strided1D:.*]] = affine_map<(d0)[s0] -> (d0 + s0)> 10 11// TILE-2-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> 12// TILE-02-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> 13// TILE-002-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> 14// TILE-234-DAG: #[[$strided2D:.*]] = affine_map<(d0, d1)[s0, s1] -> (d0 * s1 + s0 + d1)> 15 16// TILE-2-DAG: #[[$bound_map:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> 17// TILE-02-DAG: #[[$bound_map:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> 18// TILE-002-DAG: #[[$bound_map:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> 19// TILE-234-DAG: #[[$bound_map_2:.*]] = affine_map<(d0)[s0] -> (2, -d0 + s0)> 20// TILE-234-DAG: #[[$bound_map_3:.*]] = affine_map<(d0)[s0] -> (3, -d0 + s0)> 21// TILE-234-DAG: #[[$bound_map_4:.*]] = affine_map<(d0)[s0] -> (4, -d0 + s0)> 22 23// TILE-2-DAG: #[[$stride_99_1_layout_map:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 99 + s0 + d1)> 24// TILE-02-DAG: #[[$stride_99_1_layout_map:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 99 + s0 + d1)> 25// TILE-234-DAG: #[[$stride_99_1_layout_map:.*]] = affine_map<(d0, d1)[s0] -> (d0 * 99 + s0 + d1)> 26 27func @matmul(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>, 28 %arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>, 29 %arg2: memref<?x?xf32, offset: ?, strides: [?, 1]>) { 30 linalg.matmul 31 ins(%arg0, %arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>, 32 memref<?x?xf32, offset: ?, strides: [?, 1]>) 33 outs(%arg2: memref<?x?xf32, offset: ?, strides: [?, 1]>) 34 return 35} 36// TILE-2-LABEL: func @matmul( 37// TILE-2-DAG: %[[C0:.*]] = constant 0 : index 38// TILE-2-DAG: %[[C2:.*]] = constant 2 : index 39// TILE-2: %[[M:.*]] = memref.dim %{{.*}}, %c0 : memref<?x?xf32, #[[$strided2D]]> 40// TILE-2: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[M]] step %{{.*}} { 41// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[M]]] 42// TILE-2: %[[K:.*]] = memref.dim %{{.*}}, %c1 : memref<?x?xf32, #[[$strided2D]]> 43// TILE-2: %[[sAi:.*]] = memref.subview %{{.*}}[%[[I]], 0] [%[[szM]], %[[K]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 44// TILE-2: %[[szK:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[M]]] 45// TILE-2: %[[N:.*]] = memref.dim %{{.*}}, %c1 : memref<?x?xf32, #[[$strided2D]]> 46// TILE-2: %[[sCi:.*]] = memref.subview %{{.*}}[%[[I]], 0] [%[[szK]], %[[N]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 47// TILE-2: linalg.matmul ins(%[[sAi]]{{.*}} outs(%[[sCi]] 48 49// TILE-02-LABEL: func @matmul( 50// TILE-02-DAG: %[[C0:.*]] = constant 0 : index 51// TILE-02-DAG: %[[C2:.*]] = constant 2 : index 52// TILE-02: %[[N:.*]] = memref.dim %arg1, %c1 : memref<?x?xf32, #[[$strided2D]]> 53// TILE-02: scf.for %[[J:.*]] = %{{.*}} to %[[N]] step %{{.*}} { 54// TILE-02: %[[K:.*]] = memref.dim %{{.*}}, %c0 : memref<?x?xf32, #[[$strided2D]]> 55// TILE-02: %[[szN:.*]] = affine.min #[[$bound_map]](%[[J]])[%[[N]]] 56// TILE-02: %[[sBj:.*]] = memref.subview %{{.*}}[0, %[[J]]] [%[[K]], %[[szN]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 57// TILE-02: %[[M:.*]] = memref.dim %{{.*}}, %c0 : memref<?x?xf32, #[[$strided2D]]> 58// TILE-02: %[[szK:.*]] = affine.min #[[$bound_map]](%[[J]])[%[[N]]] 59// TILE-02: %[[sCj:.*]] = memref.subview %{{.*}}[0, %[[J]]] [%[[M]], %[[szK]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 60// TILE-02: linalg.matmul ins(%{{.*}}, %[[sBj]]{{.*}} outs(%[[sCj]] 61 62// TILE-002-LABEL: func @matmul( 63// TILE-002-DAG: %[[C0:.*]] = constant 0 : index 64// TILE-002-DAG: %[[C2:.*]] = constant 2 : index 65// TILE-002: %[[ubK:.*]] = memref.dim %{{.*}}, %c1 : memref<?x?xf32, #[[$strided2D]]> 66// TILE-002: scf.for %[[K:.*]] = %{{.*}}{{.*}} to %[[ubK]] step %{{.*}} { 67// TILE-002: %[[M:.*]] = memref.dim %{{.*}}, %c0 : memref<?x?xf32, #[[$strided2D]]> 68// TILE-002: %[[szK:.*]] = affine.min #[[$bound_map]](%[[K]])[%[[ubK]]] 69// TILE-002: %[[sAj:.*]] = memref.subview %{{.*}}[0, %[[K]]] [%[[M]], %[[szK]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 70// TILE-002: %[[szK:.*]] = affine.min #[[$bound_map]](%[[K]])[%[[ubK]]] 71// TILE-002: %[[N:.*]] = memref.dim %{{.*}}, %c1 : memref<?x?xf32, #[[$strided2D]]> 72// TILE-002: %[[sBj:.*]] = memref.subview %{{.*}}[%[[K]], 0] [%[[szK]], %[[N]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 73// TILE-002: linalg.matmul ins(%[[sAj]], %[[sBj]]{{.*}} outs(%{{.*}} 74 75// TILE-234-LABEL: func @matmul( 76// TILE-234-DAG: %[[C0:.*]] = constant 0 : index 77// TILE-234-DAG: %[[C2:.*]] = constant 2 : index 78// TILE-234-DAG: %[[C3:.*]] = constant 3 : index 79// TILE-234-DAG: %[[C4:.*]] = constant 4 : index 80// TILE-234: %[[ubM:.*]] = memref.dim %{{.*}}, %c0 : memref<?x?xf32, #[[$strided2D]]> 81// TILE-234: %[[ubK:.*]] = memref.dim %{{.*}}, %c1 : memref<?x?xf32, #[[$strided2D]]> 82// TILE-234: %[[ubN:.*]] = memref.dim %{{.*}}, %c1 : memref<?x?xf32, #[[$strided2D]]> 83// TILE-234: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[ubM]] step %{{.*}} { 84// TILE-234: scf.for %[[J:.*]] = %{{.*}}{{.*}} to %[[ubN]] step %{{.*}} { 85// TILE-234: scf.for %[[K:.*]] = %{{.*}}{{.*}} to %[[ubK]] step %{{.*}} { 86// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[ubM]]] 87// TILE-234: %[[szK:.*]] = affine.min #[[$bound_map_4]](%[[K]])[%[[ubK]]] 88// TILE-234: %[[sAik:.*]] = memref.subview %{{.*}}[%[[I]], %[[K]]] [%[[szM]], %[[szK]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 89// TILE-234: %[[szK:.*]] = affine.min #[[$bound_map_4]](%[[K]])[%[[ubK]]] 90// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]])[%[[ubN]]] 91// TILE-234: %[[sBkj:.*]] = memref.subview %{{.*}}[%[[K]], %[[J]]] [%[[szK]], %[[szN]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 92// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[ubM]]] 93// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]])[%[[ubN]]] 94// TILE-234: %[[sCij:.*]] = memref.subview %{{.*}}[%[[I]], %[[J]]] [%[[szM]], %[[szN]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 95// 96// TILE-234: linalg.matmul ins(%[[sAik]], %[[sBkj]]{{.*}} outs(%[[sCij]] 97 98// When the buffer shapes are known at compile time, it is possible to avoid 99// the "min" in subview size computation. This test uses buffer sizes divisible 100// by respective tile sizes (M=10 divisble by 2, N=12 divisible by 2 and 3, 101// K=16 divisble by 2 and 4). 102func @matmul_static(%arg0: memref<10x16xf32, offset: ?, strides: [?, 1]>, 103 %arg1: memref<16x12xf32, offset: ?, strides: [?, 1]>, 104 %arg2: memref<10x12xf32, offset: ?, strides: [?, 1]>) { 105 linalg.matmul 106 ins(%arg0, %arg1: memref<10x16xf32, offset: ?, strides: [?, 1]>, 107 memref<16x12xf32, offset: ?, strides: [?, 1]>) 108 outs(%arg2: memref<10x12xf32, offset: ?, strides: [?, 1]>) 109 return 110} 111// TILE-2-LABEL: func @matmul_static( 112// TILE-2-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref 113// TILE-2-SAME: %[[ARG1:[0-9a-zA-Z]*]]: memref 114// TILE-2-SAME: %[[ARG2:[0-9a-zA-Z]*]]: memref 115// TILE-2-DAG: %[[C0:.*]] = constant 0 : index 116// TILE-2-DAG: %[[C2:.*]] = constant 2 : index 117// TILE-2-DAG: %[[M:.*]] = constant 10 : index 118// TILE-2: scf.for %[[I:.*]] = %{{.*}} to %[[M]] step %{{.*}} { 119// TILE-2: %[[sAi:.*]] = memref.subview %{{.*}}[%[[I]], 0] [2, 16] [1, 1] : memref<10x16xf32, #[[$strided2D]]> to memref<2x16xf32, #[[$strided2D]]> 120// TILE-2: %[[sCi:.*]] = memref.subview %{{.*}}[%[[I]], 0] [2, 12] [1, 1] : memref<10x12xf32, #[[$strided2D]]> to memref<2x12xf32, #[[$strided2D]]> 121// TILE-2: linalg.matmul ins(%[[sAi]], %{{.*}}{{.*}} outs(%[[sCi]] 122 123// TILE-02-LABEL: func @matmul_static( 124// TILE-02-DAG: %[[C0:.*]] = constant 0 : index 125// TILE-02-DAG: %[[C2:.*]] = constant 2 : index 126// TILE-02-DAG: %[[N:.*]] = constant 12 : index 127// TILE-02: scf.for %[[J:.*]] = %{{.*}} to %[[N]] step %{{.*}} { 128// TILE-02: %[[sBj:.*]] = memref.subview %{{.*}}[0, %[[J]]] [16, 2] [1, 1] : memref<16x12xf32, #[[$strided2D]]> to memref<16x2xf32, #[[$strided2D]]> 129// TILE-02: %[[sCj:.*]] = memref.subview %{{.*}}[0, %[[J]]] [10, 2] [1, 1] : memref<10x12xf32, #[[$strided2D]]> to memref<10x2xf32, #[[$strided2D]]> 130// TILE-02: linalg.matmul ins(%{{.*}}, %[[sBj]]{{.*}} outs(%[[sCj]] 131 132// TILE-002-LABEL: func @matmul_static( 133// TILE-002-DAG: %[[C0:.*]] = constant 0 : index 134// TILE-002-DAG: %[[C2:.*]] = constant 2 : index 135// TILE-002-DAG: %[[C16:.*]] = constant 16 : index 136// TILE-002: scf.for %[[K:.*]] = %{{.*}}{{.*}} to %[[C16]] step %{{.*}} { 137// TILE-002: %[[sAj:.*]] = memref.subview %{{.*}}[0, %[[K]]] [10, 2] [1, 1] : memref<10x16xf32, #[[$strided2D]]> to memref<10x2xf32, #[[$strided2D]]> 138// TILE-002: %[[sBj:.*]] = memref.subview %{{.*}}[%[[K]], 0] [2, 12] [1, 1] : memref<16x12xf32, #[[$strided2D]]> to memref<2x12xf32, #[[$strided2D]]> 139// TILE-002: linalg.matmul ins(%[[sAj]], %[[sBj]]{{.*}} outs(%{{.*}} 140 141// TILE-234-LABEL: func @matmul_static( 142// TILE-234-DAG: %[[C0:.*]] = constant 0 : index 143// TILE-234-DAG: %[[C2:.*]] = constant 2 : index 144// TILE-234-DAG: %[[C3:.*]] = constant 3 : index 145// TILE-234-DAG: %[[C4:.*]] = constant 4 : index 146// TILE-234-DAG: %[[C10:.*]] = constant 10 : index 147// TILE-234-DAG: %[[C16:.*]] = constant 16 : index 148// TILE-234-DAG: %[[C12:.*]] = constant 12 : index 149// TILE-234: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[C10]] step %{{.*}} { 150// TILE-234: scf.for %[[J:.*]] = %{{.*}}{{.*}} to %[[C12]] step %{{.*}} { 151// TILE-234: scf.for %[[K:.*]] = %{{.*}}{{.*}} to %[[C16]] step %{{.*}} { 152// TILE-234: %[[sAik:.*]] = memref.subview %{{.*}}[%[[I]], %[[K]]] [2, 4] [1, 1] : memref<10x16xf32, #[[$strided2D]]> to memref<2x4xf32, #[[$strided2D]]> 153// TILE-234: %[[sBkj:.*]] = memref.subview %{{.*}}[%[[K]], %[[J]]] [4, 3] [1, 1] : memref<16x12xf32, #[[$strided2D]]> to memref<4x3xf32, #[[$strided2D]]> 154// TILE-234: %[[sCij:.*]] = memref.subview %{{.*}}[%[[I]], %[[J]]] [2, 3] [1, 1] : memref<10x12xf32, #[[$strided2D]]> to memref<2x3xf32, #[[$strided2D]]> 155// 156// TILE-234: linalg.matmul ins(%[[sAik]], %[[sBkj]]{{.*}} outs(%[[sCij]] 157 158func @matvec(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>, %arg1: memref<?xf32, offset: ?, strides: [1]>, %arg2: memref<?xf32, offset: ?, strides: [1]>) { 159 linalg.matvec 160 ins(%arg0, %arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>, 161 memref<?xf32, offset: ?, strides: [1]>) 162 outs(%arg2: memref<?xf32, offset: ?, strides: [1]>) 163 return 164} 165// TILE-2-LABEL: func @matvec( 166// TILE-2-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref 167// TILE-2-SAME: %[[ARG1:[0-9a-zA-Z]*]]: memref 168// TILE-2-SAME: %[[ARG2:[0-9a-zA-Z]*]]: memref 169// TILE-2-DAG: %[[C0:.*]] = constant 0 : index 170// TILE-2-DAG: %[[C2:.*]] = constant 2 : index 171// TILE-2: %[[M:.*]] = memref.dim %{{.*}}, %c0 : memref<?x?xf32, #[[$strided2D]]> 172// TILE-2: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[M]] step %{{.*}} { 173// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[M]]] 174// TILE-2: %[[N:.*]] = memref.dim %{{.*}}, %c1 : memref<?x?xf32, #[[$strided2D]]> 175// TILE-2: %[[sAi:.*]] = memref.subview %{{.*}}[%[[I]], 0] [%[[szM]], %[[N]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 176// TILE-2: %[[szN:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[M]]] 177// TILE-2: %[[sCi:.*]] = memref.subview %{{.*}}[%[[I]]] [%[[szN]]] [1] : memref<?xf32, #[[$strided1D]]> to memref<?xf32, #[[$strided1D]]> 178// TILE-2: linalg.matvec ins(%[[sAi]], %{{.*}} outs(%[[sCi]] 179 180// TILE-02-LABEL: func @matvec( 181// TILE-02-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref 182// TILE-02-SAME: %[[ARG1:[0-9a-zA-Z]*]]: memref 183// TILE-02-SAME: %[[ARG2:[0-9a-zA-Z]*]]: memref 184// TILE-02-DAG: %[[C0:.*]] = constant 0 : index 185// TILE-02-DAG: %[[C2:.*]] = constant 2 : index 186// TILE-02: %[[K:.*]] = memref.dim %{{.*}}, %c1 : memref<?x?xf32, #[[$strided2D]]> 187// TILE-02: scf.for %[[J:.*]] = %{{.*}}{{.*}} to %[[K]] step %{{.*}} { 188// TILE-02: %[[M:.*]] = memref.dim %{{.*}}, %c0 : memref<?x?xf32, #[[$strided2D]]> 189// TILE-02: %[[szN:.*]] = affine.min #[[$bound_map]](%[[J]])[%[[K]]] 190// TILE-02: %[[sAj:.*]] = memref.subview %{{.*}}[0, %[[J]]] [%[[M]], %[[szN]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 191// TILE-02: %[[szN:.*]] = affine.min #[[$bound_map]](%[[J]])[%[[K]]] 192// TILE-02: %[[sBj:.*]] = memref.subview %{{.*}}[%[[J]]] [%[[szN]]] [1] : memref<?xf32, #[[$strided1D]]> to memref<?xf32, #[[$strided1D]]> 193// TILE-02: linalg.matvec ins(%[[sAj]], %[[sBj]]{{.*}} outs(%{{.*}} 194 195// TILE-002-LABEL: func @matvec( 196// TILE-002-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref 197// TILE-002-SAME: %[[ARG1:[0-9a-zA-Z]*]]: memref 198// TILE-002-SAME: %[[ARG2:[0-9a-zA-Z]*]]: memref 199// TILE-002-NOT: scf.for 200 201// TILE-234-LABEL: func @matvec( 202// TILE-234-SAME: %[[ARG0:[0-9a-zA-Z]*]]: memref 203// TILE-234-SAME: %[[ARG1:[0-9a-zA-Z]*]]: memref 204// TILE-234-SAME: %[[ARG2:[0-9a-zA-Z]*]]: memref 205// TILE-234-DAG: %[[C0:.*]] = constant 0 : index 206// TILE-234-DAG: %[[C2:.*]] = constant 2 : index 207// TILE-234-DAG: %[[C3:.*]] = constant 3 : index 208// TILE-234: %[[M:.*]] = memref.dim %{{.*}}, %c0 : memref<?x?xf32, #[[$strided2D]]> 209// TILE-234: %[[K:.*]] = memref.dim %{{.*}}, %c1 : memref<?x?xf32, #[[$strided2D]]> 210// TILE-234: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[M]] step %{{.*}} { 211// TILE-234: scf.for %[[J:.*]] = %{{.*}}{{.*}} to %[[K]] step %{{.*}} { 212// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[M]]] 213// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]])[%[[K]]] 214// TILE-234: %[[sAij:.*]] = memref.subview %{{.*}}[%[[I]], %[[J]]] [%[[szM]], %[[szN]]] [1, 1] : memref<?x?xf32, #[[$strided2D]]> to memref<?x?xf32, #[[$strided2D]]> 215// TILE-234: %[[szN:.*]] = affine.min #[[$bound_map_3]](%[[J]])[%[[K]]] 216// TILE-234: %[[sBj:.*]] = memref.subview %{{.*}}[%[[J]]] [%[[szN]]] [1] : memref<?xf32, #[[$strided1D]]> to memref<?xf32, #[[$strided1D]]> 217// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[M]]] 218// TILE-234: %[[sCi:.*]] = memref.subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref<?xf32, #[[$strided1D]]> to memref<?xf32, #[[$strided1D]]> 219// 220// TILE-234: linalg.matvec ins(%[[sAij]], %[[sBj]]{{.*}} outs(%[[sCi]] 221 222func @dot(%arg0: memref<?xf32, offset: ?, strides: [1]>, %arg1: memref<?xf32, offset: ?, strides: [1]>, %arg2: memref<f32>) { 223 linalg.dot 224 ins(%arg0, %arg1: memref<?xf32, offset: ?, strides: [1]>, memref<?xf32, offset: ?, strides: [1]>) 225 outs(%arg2: memref<f32>) 226 return 227} 228// TILE-2-LABEL: func @dot( 229// TILE-2-DAG: %[[C0:.*]] = constant 0 : index 230// TILE-2-DAG: %[[C2:.*]] = constant 2 : index 231// TILE-2: %[[M:.*]] = memref.dim %{{.*}}, %c0 : memref<?xf32, #[[$strided1D]]> 232// TILE-2: scf.for %[[I:.*]] = %{{.*}}{{.*}} to %[[M]] step %{{.*}} { 233// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[M]]] 234// TILE-2: %[[sAi:.*]] = memref.subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref<?xf32, #[[$strided1D]]> to memref<?xf32, #[[$strided1D]]> 235// TILE-2: %[[szM:.*]] = affine.min #[[$bound_map]](%[[I]])[%[[M]]] 236// TILE-2: %[[sBi:.*]] = memref.subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref<?xf32, #[[$strided1D]]> to memref<?xf32, #[[$strided1D]]> 237// TILE-2: linalg.dot ins(%[[sAi]], %[[sBi]]{{.*}} outs( 238 239// TILE-02-LABEL: func @dot( 240// TILE-02-NOT: scf.for 241 242// TILE-002-LABEL: func @dot( 243// TILE-002-NOT: scf.for 244 245// TILE-234-LABEL: func @dot( 246// TILE-234-DAG: %[[C0:.*]] = constant 0 : index 247// TILE-234-DAG: %[[C2:.*]] = constant 2 : index 248// TILE-234: %[[ubK:.*]] = memref.dim %{{.*}}, %c0 : memref<?xf32, #[[$strided1D]]> 249// TILE-234: scf.for %[[I:.*]] = %{{.*}} to %[[ubK]] step %{{.*}} { 250// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[ubK]]] 251// TILE-234: %[[sAi:.*]] = memref.subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref<?xf32, #[[$strided1D]]> to memref<?xf32, #[[$strided1D]]> 252// TILE-234: %[[szM:.*]] = affine.min #[[$bound_map_2]](%[[I]])[%[[ubK]]] 253// TILE-234: %[[sBi:.*]] = memref.subview %{{.*}}[%[[I]]] [%[[szM]]] [1] : memref<?xf32, #[[$strided1D]]> to memref<?xf32, #[[$strided1D]]> 254// TILE-234: linalg.dot ins(%[[sAi]], %[[sBi]]{{.*}} outs( 255 256func @fill_static(%arg0: memref<127x99xf32>, %arg1: f32) { 257 linalg.fill(%arg1, %arg0) : f32, memref<127x99xf32> 258 return 259} 260// TILE-2-LABEL: func @fill_static 261// TILE-2: for 262// TILE-2-NOT: for 263// TILE-2: memref.subview{{.*}} : memref<127x99xf32> 264// TILE-2: linalg.fill{{.*}} : f32, memref<?x99xf32, #[[$stride_99_1_layout_map]]> 265 266// TILE-02-LABEL: func @fill_static 267// TILE-02: for 268// TILE-02-NOT: for 269// TILE-02: memref.subview{{.*}} : memref<127x99xf32> 270// TILE-02: linalg.fill{{.*}} : f32, memref<127x?xf32, #[[$stride_99_1_layout_map]]> 271 272// TILE-002-LABEL: func @fill_static 273// TILE-002-NOT: for 274// TILE-002: linalg.fill{{.*}} f32, memref<127x99xf32> 275 276// TILE-234-LABEL: func @fill_static 277// TILE-234: for 278// TILE-234: for 279// TILE-234-NOT: for 280// TILE-234: memref.subview{{.*}} : memref<127x99xf32> 281// TILE-234: linalg.fill{{.*}} : f32, memref<?x3xf32, #[[$stride_99_1_layout_map]]> 282 283 284func @fill(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>, %arg1: f32) { 285 linalg.fill(%arg1, %arg0) : f32, memref<?x?xf32, offset: ?, strides: [?, 1]> 286 return 287} 288// TILE-2-LABEL: func @fill 289// TILE-2: for 290// TILE-2-NOT: for 291// TILE-2: fill{{.*}} f32 292 293// TILE-02-LABEL: func @fill 294// TILE-02: for 295// TILE-02-NOT: for 296// TILE-02: fill{{.*}} f32 297 298// TILE-002-LABEL: func @fill 299// TILE-002-NOT: for 300// TILE-002: fill{{.*}} f32 301 302// TILE-234-LABEL: func @fill 303// TILE-234: for 304// TILE-234: for 305// TILE-234-NOT: for 306// TILE-234: fill{{.*}} f32 307 308#id_2d = affine_map<(i, j) -> (i, j)> 309#pointwise_2d_trait = { 310 args_in = 2, 311 args_out = 1, 312 indexing_maps = [#id_2d, #id_2d, #id_2d], 313 iterator_types = ["parallel", "parallel"] 314} 315 316func @pointwise(%arg0: memref<?x?xf32, offset: ?, strides: [?, 1]>, %arg1: memref<?x?xf32, offset: ?, strides: [?, 1]>, 317 %arg2: memref<?x?xf32, offset: ?, strides: [?, 1]>) { 318 linalg.generic #pointwise_2d_trait 319 ins(%arg0, %arg1 : memref<?x?xf32, offset: ?, strides: [?, 1]>, memref<?x?xf32, offset: ?, strides: [?, 1]>) 320 outs(%arg2 : memref<?x?xf32, offset: ?, strides: [?, 1]>) { 321 ^bb0(%arg4: f32, %arg5: f32, %arg6: f32): // no predecessors 322 %4 = addf %arg4, %arg5 : f32 323 linalg.yield %4 : f32 324 } 325 return 326} 327// TILE-2-LABEL: func @pointwise 328// TILE-2: for 329// TILE-2-NOT: for 330// TILE-2: linalg.generic 331 332// TILE-02-LABEL: func @pointwise 333// TILE-02: for 334// TILE-02-NOT: for 335// TILE-02: linalg.generic 336 337// TILE-002-LABEL: func @pointwise 338// TILE-002-NOT: for 339// TILE-002: linalg.generic 340 341// TILE-234-LABEL: func @pointwise 342// TILE-234: for 343// TILE-234: for 344// TILE-234-NOT: for 345// TILE-234: linalg.generic 346