TileUsingInterface.h Source File (original) (raw)

9 #ifndef MLIR_DIALECT_SCF_TRANSFORMS_TILEUSINGINTERFACE_H

10 #define MLIR_DIALECT_SCF_TRANSFORMS_TILEUSINGINTERFACE_H

20 #include

22 namespace mlir {

23 class Operation;

24 class RewriterBase;

25 class TilingInterface;

26 }

28 namespace mlir {

29 namespace scf {

46 return *this;

47 }

67 return *this;

68 }

77 return *this;

78 }

85 return *this;

86 }

100

101

103

104

106

107

109 };

115 return *this;

116 }

117

118

119

120

121

125 return *this;

126 }

127 };

128

129

131

132

133

135

137

139

140

142

143

145

146

147

148

150 };

151

152

153

155 TilingInterface op,

157

158

160

164 return *this;

165 }

166

167

168

169

170

171

172

173

174

175

177

178

180 };

181 using ControlFnTy = std::function<std::optional(

182 tensor::ExtractSliceOp candidateSliceOp, OpResult originalProducer,

183 bool isDestinationOperand)>;

184

185

187 bool) -> std::optional {

189 };

192 return *this;

193 }

194

195

196

197

198 std::optional cleanupPatterns = std::nullopt;

199 };

200

201

202

203

204

210 };

211 std::optional

213 tensor::ExtractSliceOp candidateSliceOp,

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

273 RewriterBase &rewriter, tensor::ExtractSliceOp sliceOp,

277

278

280

282

283

284

286

288

290 };

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317 FailureOr

319 TilingInterface consumer,

321

322

323

324

325

331 };

332 FailureOrscf::SCFFuseConsumerOfSliceResult

335

336

337

338 FailureOr<SmallVectorscf::ForOp>

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365 FailureOrscf::SCFTilingResult

368

369 }

370 }

371

372 #endif

static llvm::ManagedStatic< PassManagerOptions > options

This class helps build Operations.

This class represents an operand of an operation.

This is a value defined by a result of an operation.

Operation is the basic unit of execution within MLIR.

This class coordinates the application of a rewrite on a set of IR, providing a way for clients to tr...

This class represents an instance of an SSA value in the MLIR system, representing a computable value...

FailureOr< scf::SCFFuseConsumerOfSliceResult > tileAndFuseConsumerOfSlice(RewriterBase &rewriter, Operation *candidateSliceOp, MutableArrayRef< LoopLikeOpInterface > loops)

Implementation of fusing consumer of a single slice by computing the slice of the consumer in-place f...

FailureOr< scf::SCFTilingResult > tileReductionUsingScf(RewriterBase &b, PartialReductionOpInterface op, ArrayRef< OpFoldResult > tileSizes)

Method to tile a reduction and generate a parallel op within a serial loop.

FailureOr< SCFTilingResult > tileUsingSCF(RewriterBase &rewriter, TilingInterface op, const SCFTilingOptions &options)

Method to tile an op that implements the TilingInterface using scf.for for iterating over the tiles.

FailureOr< SmallVector< scf::ForOp > > lowerToLoopsUsingSCFForOp(RewriterBase &rewriter, TilingInterface op)

Method to lower an op that implements the TilingInterface to loops/scalars.

FailureOr< SmallVector< Operation * > > yieldReplacementForFusedProducer(RewriterBase &rewriter, tensor::ExtractSliceOp sliceOp, scf::SCFFuseProducerOfSliceResult fusedProducerInfo, MutableArrayRef< LoopLikeOpInterface > loops, ArrayRef< unsigned > yieldResultNumber=ArrayRef< unsigned >{})

Reconstruct the fused producer from within the tiled-and-fused code.

FailureOr< SCFTileAndFuseResult > tileConsumerAndFuseProducersUsingSCF(RewriterBase &rewriter, TilingInterface consumer, const SCFTileAndFuseOptions &options)

Method to tile and fuse a sequence of operations, by tiling the consumer and fusing its producers.

std::function< SmallVector< OpFoldResult >(OpBuilder &, Operation *)> SCFTileSizeComputationFunction

std::optional< SCFFuseProducerOfSliceResult > tileAndFuseProducerOfSlice(RewriterBase &rewriter, tensor::ExtractSliceOp candidateSliceOp, MutableArrayRef< LoopLikeOpInterface > loops)

Implementation of fusing producer of a single slice by computing the slice of the producer in-place.

Include the generated interface declarations.

Fuse the consumer of the source of candidateSliceOp by computing the required slice of the consumer i...

OpOperand * origConsumerOperand

SmallVector< Operation * > tiledOps

OpOperand * tiledAndFusedConsumerOperand

Fuse the producer of the source of candidateSliceOp by computing the required slice of the producer i...

Value tiledAndFusedProducer

SmallVector< Operation * > generatedSlices

SmallVector< Operation * > tiledOps

Control function to check if a slice needs to be fused or not, The control function receives 1) the s...

bool yieldProducerReplacement

Set to true if the loop nest has to return a replacement value for the fused producer.

Options used to control tile + fuse.

SCFTilingOptions tilingOptions

The tiling options used to control the tiling of the consumer.

std::optional< FrozenRewritePatternSet > cleanupPatterns

An optional set of rewrite patterns to apply to the results of tiling before fusion.

SCFTileAndFuseOptions & setTilingOptions(SCFTilingOptions options)

ControlFnTy fusionControlFn

The default control function implements greedy fusion without yielding a replacement for any of the f...

std::function< std::optional< ControlFnResult >(tensor::ExtractSliceOp candidateSliceOp, OpResult originalProducer, bool isDestinationOperand)> ControlFnTy

SCFTileAndFuseOptions & setFusionControlFn(ControlFnTy controlFn)

Transformation information returned after tile and fuse.

SmallVector< LoopLikeOpInterface > loops

The scf.for operations that iterate over the tiles.

llvm::SetVector< Operation * > fusedProducers

List of untiled operations that were fused with the tiled consumer.

llvm::DenseMap< Value, Value > replacements

The replacement values to use for the tiled and fused operations.

llvm::SetVector< Operation * > tiledAndFusedOps

List of tiled and fused operations generated.

Options to use to control tiling.

SCFTileSizeComputationFunction tileSizeComputationFunction

Computation function that returns the tile sizes to use for each loop.

SCFTilingOptions & setTileSizeComputationFunction(SCFTileSizeComputationFunction fun)

SCFTilingOptions & setReductionTilingStrategy(ReductionTilingStrategy strategy)

SCFTilingOptions & setNumThreadsComputationFunction(SCFTileSizeComputationFunction fun)

SCFTilingOptions & setNumThreads(ArrayRef< OpFoldResult > numThreads)

Convenience function to set the numThreadsComputationFunction to a function that computes num threads...

SCFTilingOptions & setInterchange(ArrayRef< int64_t > interchange)

SCFTilingOptions & setTileSizes(ArrayRef< OpFoldResult > tileSizes)

Convenience function to set the tileSizeComputationFunction to a function that computes tile sizes at...

SCFTileSizeComputationFunction numThreadsComputationFunction

Computation function that returns the number of threads to use for each loop.

ReductionTilingStrategy

Specify how reduction dimensions should be tiled.

@ PartialReductionOuterReduction

@ PartialReductionOuterParallel

SmallVector< int64_t > interchangeVector

The interchange vector to reorder the tiled loops.

LoopType

Specify which loop construct to use for tile and fuse.

SmallVector< Attribute > mappingVector

Specify mapping of loops to devices.

SCFTilingOptions & setLoopType(LoopType type)

SCFTilingOptions & setMapping(ArrayRef< Attribute > mapping)

ReductionTilingStrategy reductionStrategy

Transformation information returned after tiling.

SmallVector< Operation * > tiledOps

Tiled operations that are generated during tiling.

SmallVector< Value > initialValues

The initial destination values passed to the tiled operations.

SmallVector< LoopLikeOpInterface > loops

The scf.for operations that iterate over the tiles.

SmallVector< Operation * > generatedSlices

Slices generated after tiling that can be used for fusing with the tiled producer.

SmallVector< Value > replacements

Values to use as replacements for the untiled op.

SmallVector< Operation * > mergeOps

In cases where there as an additional merge step after tiling return the merged ops after tiling.