MLIR  20.0.0git
SparseTensorPipelines.cpp
Go to the documentation of this file.
1 //===- SparseTensorPipelines.cpp - Pipelines for sparse tensor code -------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 
12 #include "mlir/Conversion/Passes.h"
25 #include "mlir/Pass/PassManager.h"
26 #include "mlir/Transforms/Passes.h"
27 
28 //===----------------------------------------------------------------------===//
29 // Pipeline implementation.
30 //===----------------------------------------------------------------------===//
31 
33  const SparsifierOptions &options) {
34  // Rewrite named linalg ops into generic ops and apply fusion.
35  pm.addNestedPass<func::FuncOp>(createLinalgGeneralizeNamedOpsPass());
36  pm.addNestedPass<func::FuncOp>(createLinalgElementwiseOpFusionPass());
37 
38  // Sparsification and bufferization mini-pipeline.
41  options.testBufferizationAnalysisOnly),
42  options.sparsificationOptions(), options.createSparseDeallocs,
43  options.enableRuntimeLibrary, options.enableBufferInitialization,
44  options.vectorLength,
45  /*enableVLAVectorization=*/options.armSVE,
46  /*enableSIMDIndex32=*/options.force32BitVectorIndices,
47  options.enableGPULibgen,
48  options.sparsificationOptions().sparseEmitStrategy,
49  options.sparsificationOptions().parallelizationStrategy));
50 
51  // Bail-early for test setup.
52  if (options.testBufferizationAnalysisOnly)
53  return;
54 
55  // Storage specifier lowering and bufferization wrap-up.
57  pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
58  pm.addNestedPass<func::FuncOp>(
60 
61  // GPU code generation.
62  const bool gpuCodegen = options.gpuTriple.hasValue();
63  if (gpuCodegen) {
65  pm.addNestedPass<gpu::GPUModuleOp>(createStripDebugInfoPass());
66  pm.addNestedPass<gpu::GPUModuleOp>(createConvertSCFToCFPass());
67  pm.addNestedPass<gpu::GPUModuleOp>(createConvertGpuOpsToNVVMOps());
68  }
69 
70  // Progressively lower to LLVM. Note that the convert-vector-to-llvm
71  // pass is repeated on purpose.
72  // TODO(springerm): Add sparse support to the BufferDeallocation pass and add
73  // it to this pipeline.
74  pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass());
75  pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass());
77  pm.addNestedPass<func::FuncOp>(createConvertSCFToCFPass());
80  pm.addPass(
81  createConvertVectorToLLVMPass(options.convertVectorToLLVMOptions()));
82  pm.addPass(createFinalizeMemRefToLLVMConversionPass());
84  pm.addNestedPass<func::FuncOp>(arith::createArithExpandOpsPass());
85  pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
88  pm.addPass(
89  createConvertVectorToLLVMPass(options.convertVectorToLLVMOptions()));
90  pm.addPass(createConvertComplexToLLVMPass());
91  pm.addPass(
92  createConvertVectorToLLVMPass(options.convertVectorToLLVMOptions()));
93  pm.addPass(createConvertFuncToLLVMPass());
94 
95  // Finalize GPU code generation.
96  if (gpuCodegen) {
97  GpuNVVMAttachTargetOptions nvvmTargetOptions;
98  nvvmTargetOptions.triple = options.gpuTriple;
99  nvvmTargetOptions.chip = options.gpuChip;
100  nvvmTargetOptions.features = options.gpuFeatures;
101  pm.addPass(createGpuNVVMAttachTarget(nvvmTargetOptions));
102  pm.addPass(createGpuToLLVMConversionPass());
103  GpuModuleToBinaryPassOptions gpuModuleToBinaryPassOptions;
104  gpuModuleToBinaryPassOptions.compilationTarget = options.gpuFormat;
105  pm.addPass(createGpuModuleToBinaryPass(gpuModuleToBinaryPassOptions));
106  }
107 
108  // Ensure all casts are realized.
110 }
111 
112 //===----------------------------------------------------------------------===//
113 // Pipeline registration.
114 //===----------------------------------------------------------------------===//
115 
118  "sparsifier",
119  "The standard pipeline for taking sparsity-agnostic IR using the"
120  " sparse-tensor type, and lowering it to LLVM IR with concrete"
121  " representations and algorithms for sparse tensors.",
123 }
static llvm::ManagedStatic< PassManagerOptions > options
This class represents a pass manager that runs passes on either a specific operation type,...
Definition: PassManager.h:47
void addPass(std::unique_ptr< Pass > pass)
Add the given pass to this pass manager.
Definition: Pass.cpp:363
void addNestedPass(std::unique_ptr< Pass > pass)
Add the given pass to a nested pass manager for the given operation kind OpT.
Definition: PassManager.h:116
std::unique_ptr< OperationPass< func::FuncOp > > createFinalizingBufferizePass()
Creates a pass that finalizes a partial bufferization by removing remaining bufferization....
Definition: Bufferize.cpp:335
std::unique_ptr< Pass > createExpandStridedMetadataPass()
Creates an operation pass to expand some memref operation into easier to reason about operations.
std::unique_ptr< Pass > createExpandReallocPass(bool emitDeallocs=true)
Creates an operation pass to expand memref.realloc operations into their components.
void buildSparsifier(OpPassManager &pm, const SparsifierOptions &options)
Adds the "sparsifier" pipeline to the OpPassManager.
void registerSparseTensorPipelines()
Registers all pipelines for the sparse_tensor dialect.
std::unique_ptr< OperationPass< ModuleOp > > createConvertComplexToLibmPass()
Create a pass to convert Complex operations to libm calls.
std::unique_ptr< Pass > createSparseGPUCodegenPass()
bufferization::OneShotBufferizationOptions getBufferizationOptionsForSparsification(bool analysisOnly)
std::unique_ptr< Pass > createStripDebugInfoPass()
Creates a pass to strip debug information from a function.
std::unique_ptr< Pass > createSparsificationAndBufferizationPass()
std::unique_ptr< Pass > createConvertSCFToCFPass()
Creates a pass to convert SCF operations to CFG branch-based operation in the ControlFlow dialect.
std::unique_ptr< OperationPass< ModuleOp > > createConvertMathToLibmPass()
Create a pass to convert Math operations to libm calls.
Definition: MathToLibm.cpp:221
std::unique_ptr< Pass > createStorageSpecifierToLLVMPass()
std::unique_ptr< Pass > createCanonicalizerPass()
Creates an instance of the Canonicalizer pass, configured with default settings (which can be overrid...
std::unique_ptr< Pass > createReconcileUnrealizedCastsPass()
Creates a pass that eliminates noop unrealized_conversion_cast operation sequences.
std::unique_ptr< Pass > createConvertVectorToSCFPass(const VectorTransferToSCFOptions &options=VectorTransferToSCFOptions())
Create a pass to convert a subset of vector ops to SCF.
std::unique_ptr< Pass > createConvertComplexToStandardPass()
Create a pass to convert Complex operations to the Standard dialect.
std::unique_ptr< Pass > createLowerAffinePass()
Lowers affine control flow operations (ForStmt, IfStmt and AffineApplyOp) to equivalent lower-level c...
PassPipelineRegistration provides a global initializer that registers a Pass pipeline builder routine...
Definition: PassRegistry.h:177
Options for the "sparsifier" pipeline.
Definition: Passes.h:30