MLIR  21.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 
19 #include "mlir/Pass/PassManager.h"
20 #include "mlir/Transforms/Passes.h"
21 
22 //===----------------------------------------------------------------------===//
23 // Pipeline implementation.
24 //===----------------------------------------------------------------------===//
25 
27  const SparsifierOptions &options) {
28  // Rewrite named linalg ops into generic ops and apply fusion.
29  pm.addNestedPass<func::FuncOp>(createLinalgGeneralizeNamedOpsPass());
30  pm.addNestedPass<func::FuncOp>(createLinalgElementwiseOpFusionPass());
31 
32  // Sparsification and bufferization mini-pipeline.
35  options.testBufferizationAnalysisOnly),
36  options.sparsificationOptions(), options.createSparseDeallocs,
37  options.enableRuntimeLibrary, options.enableBufferInitialization,
38  options.vectorLength,
39  /*enableVLAVectorization=*/options.armSVE,
40  /*enableSIMDIndex32=*/options.force32BitVectorIndices,
41  options.enableGPULibgen,
42  options.sparsificationOptions().sparseEmitStrategy,
43  options.sparsificationOptions().parallelizationStrategy));
44 
45  // Bail-early for test setup.
46  if (options.testBufferizationAnalysisOnly)
47  return;
48 
49  // Storage specifier lowering and bufferization wrap-up.
51  pm.addNestedPass<func::FuncOp>(createCanonicalizerPass());
52 
53  // GPU code generation.
54  const bool gpuCodegen = options.gpuTriple.hasValue();
55  if (gpuCodegen) {
57  pm.addNestedPass<gpu::GPUModuleOp>(createStripDebugInfoPass());
58  pm.addNestedPass<gpu::GPUModuleOp>(createSCFToControlFlowPass());
59  pm.addNestedPass<gpu::GPUModuleOp>(createConvertGpuOpsToNVVMOps());
60  }
61 
62  // Progressively lower to LLVM. Note that the convert-vector-to-llvm
63  // pass is repeated on purpose.
64  // TODO(springerm): Add sparse support to the BufferDeallocation pass and add
65  // it to this pipeline.
66  pm.addNestedPass<func::FuncOp>(createConvertLinalgToLoopsPass());
67  pm.addNestedPass<func::FuncOp>(createConvertVectorToSCFPass());
69  pm.addNestedPass<func::FuncOp>(createSCFToControlFlowPass());
71  pm.addPass(createLowerAffinePass());
72  pm.addPass(
73  createConvertVectorToLLVMPass(options.convertVectorToLLVMOptions()));
74  pm.addPass(createFinalizeMemRefToLLVMConversionPass());
75  pm.addNestedPass<func::FuncOp>(createConvertComplexToStandardPass());
76  pm.addNestedPass<func::FuncOp>(arith::createArithExpandOpsPass());
77  pm.addNestedPass<func::FuncOp>(createConvertMathToLLVMPass());
78  pm.addPass(createConvertMathToLibmPass());
79  pm.addPass(createConvertComplexToLibm());
80  pm.addPass(
81  createConvertVectorToLLVMPass(options.convertVectorToLLVMOptions()));
82  pm.addPass(createConvertComplexToLLVMPass());
83  pm.addPass(
84  createConvertVectorToLLVMPass(options.convertVectorToLLVMOptions()));
85  pm.addPass(createConvertFuncToLLVMPass());
86  pm.addPass(createArithToLLVMConversionPass());
87  pm.addPass(createConvertControlFlowToLLVMPass());
88 
89  // Finalize GPU code generation.
90  if (gpuCodegen) {
91  GpuNVVMAttachTargetOptions nvvmTargetOptions;
92  nvvmTargetOptions.triple = options.gpuTriple;
93  nvvmTargetOptions.chip = options.gpuChip;
94  nvvmTargetOptions.features = options.gpuFeatures;
95  pm.addPass(createGpuNVVMAttachTarget(nvvmTargetOptions));
96  pm.addPass(createGpuToLLVMConversionPass());
97  GpuModuleToBinaryPassOptions gpuModuleToBinaryPassOptions;
98  gpuModuleToBinaryPassOptions.compilationTarget = options.gpuFormat;
99  pm.addPass(createGpuModuleToBinaryPass(gpuModuleToBinaryPassOptions));
100  }
101 
102  // Convert poison values.
103  pm.addPass(createUBToLLVMConversionPass());
104 
105  // Ensure all casts are realized.
106  pm.addPass(createReconcileUnrealizedCastsPass());
107 }
108 
109 //===----------------------------------------------------------------------===//
110 // Pipeline registration.
111 //===----------------------------------------------------------------------===//
112 
115  "sparsifier",
116  "The standard pipeline for taking sparsity-agnostic IR using the"
117  " sparse-tensor type, and lowering it to LLVM IR with concrete"
118  " representations and algorithms for sparse tensors.",
120 }
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< 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< 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 > 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 > createConvertVectorToSCFPass(const VectorTransferToSCFOptions &options=VectorTransferToSCFOptions())
Create a pass to convert a subset of vector ops to SCF.
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