MLIR  20.0.0git
BufferUtils.cpp
Go to the documentation of this file.
1 //===- BufferUtils.cpp - buffer transformation utilities ------------------===//
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 //
9 // This file implements utilities for buffer optimization passes.
10 //
11 //===----------------------------------------------------------------------===//
12 
17 #include "mlir/IR/Operation.h"
20 #include "mlir/Pass/Pass.h"
21 #include "llvm/ADT/SetOperations.h"
22 #include "llvm/ADT/SmallString.h"
23 #include <optional>
24 
25 using namespace mlir;
26 using namespace mlir::bufferization;
27 
28 //===----------------------------------------------------------------------===//
29 // BufferPlacementAllocs
30 //===----------------------------------------------------------------------===//
31 
32 /// Get the start operation to place the given alloc value withing the
33 // specified placement block.
35  Block *placementBlock,
36  const Liveness &liveness) {
37  // We have to ensure that we place the alloc before its first use in this
38  // block.
39  const LivenessBlockInfo &livenessInfo = *liveness.getLiveness(placementBlock);
40  Operation *startOperation = livenessInfo.getStartOperation(allocValue);
41  // Check whether the start operation lies in the desired placement block.
42  // If not, we will use the terminator as this is the last operation in
43  // this block.
44  if (startOperation->getBlock() != placementBlock) {
45  Operation *opInPlacementBlock =
46  placementBlock->findAncestorOpInBlock(*startOperation);
47  startOperation = opInPlacementBlock ? opInPlacementBlock
48  : placementBlock->getTerminator();
49  }
50 
51  return startOperation;
52 }
53 
54 /// Initializes the internal list by discovering all supported allocation
55 /// nodes.
57 
58 /// Searches for and registers all supported allocation entries.
59 void BufferPlacementAllocs::build(Operation *op) {
60  op->walk([&](MemoryEffectOpInterface opInterface) {
61  // Try to find a single allocation result.
63  opInterface.getEffects(effects);
64 
66  llvm::copy_if(
67  effects, std::back_inserter(allocateResultEffects),
69  Value value = it.getValue();
70  return isa<MemoryEffects::Allocate>(it.getEffect()) && value &&
71  isa<OpResult>(value) &&
72  it.getResource() !=
74  });
75  // If there is one result only, we will be able to move the allocation and
76  // (possibly existing) deallocation ops.
77  if (allocateResultEffects.size() != 1)
78  return;
79  // Get allocation result.
80  Value allocValue = allocateResultEffects[0].getValue();
81  // Find the associated dealloc value and register the allocation entry.
82  std::optional<Operation *> dealloc = memref::findDealloc(allocValue);
83  // If the allocation has > 1 dealloc associated with it, skip handling it.
84  if (!dealloc)
85  return;
86  allocs.push_back(std::make_tuple(allocValue, *dealloc));
87  });
88 }
89 
90 //===----------------------------------------------------------------------===//
91 // BufferPlacementTransformationBase
92 //===----------------------------------------------------------------------===//
93 
94 /// Constructs a new transformation base using the given root operation.
96  Operation *op)
97  : aliases(op), allocs(op), liveness(op) {}
98 
99 //===----------------------------------------------------------------------===//
100 // BufferPlacementTransformationBase
101 //===----------------------------------------------------------------------===//
102 
103 FailureOr<memref::GlobalOp>
104 bufferization::getGlobalFor(arith::ConstantOp constantOp, uint64_t alignment,
105  Attribute memorySpace) {
106  auto type = cast<RankedTensorType>(constantOp.getType());
107  auto moduleOp = constantOp->getParentOfType<ModuleOp>();
108  if (!moduleOp)
109  return failure();
110 
111  // If we already have a global for this constant value, no need to do
112  // anything else.
113  for (Operation &op : moduleOp.getRegion().getOps()) {
114  auto globalOp = dyn_cast<memref::GlobalOp>(&op);
115  if (!globalOp)
116  continue;
117  if (!globalOp.getInitialValue().has_value())
118  continue;
119  uint64_t opAlignment = globalOp.getAlignment().value_or(0);
120  Attribute initialValue = globalOp.getInitialValue().value();
121  if (opAlignment == alignment && initialValue == constantOp.getValue())
122  return globalOp;
123  }
124 
125  // Create a builder without an insertion point. We will insert using the
126  // symbol table to guarantee unique names.
127  OpBuilder globalBuilder(moduleOp.getContext());
128  SymbolTable symbolTable(moduleOp);
129 
130  // Create a pretty name.
131  SmallString<64> buf;
132  llvm::raw_svector_ostream os(buf);
133  interleave(type.getShape(), os, "x");
134  os << "x" << type.getElementType();
135 
136  // Add an optional alignment to the global memref.
137  IntegerAttr memrefAlignment =
138  alignment > 0 ? IntegerAttr::get(globalBuilder.getI64Type(), alignment)
139  : IntegerAttr();
140 
141  BufferizeTypeConverter typeConverter;
142  auto memrefType = cast<MemRefType>(typeConverter.convertType(type));
143  if (memorySpace)
144  memrefType = MemRefType::Builder(memrefType).setMemorySpace(memorySpace);
145  auto global = globalBuilder.create<memref::GlobalOp>(
146  constantOp.getLoc(), (Twine("__constant_") + os.str()).str(),
147  /*sym_visibility=*/globalBuilder.getStringAttr("private"),
148  /*type=*/memrefType,
149  /*initial_value=*/cast<ElementsAttr>(constantOp.getValue()),
150  /*constant=*/true,
151  /*alignment=*/memrefAlignment);
152  symbolTable.insert(global);
153  // The symbol table inserts at the end of the module, but globals are a bit
154  // nicer if they are at the beginning.
155  global->moveBefore(&moduleOp.front());
156  return global;
157 }
Attributes are known-constant values of operations.
Definition: Attributes.h:25
Block represents an ordered list of Operations.
Definition: Block.h:31
Operation * findAncestorOpInBlock(Operation &op)
Returns 'op' if 'op' lies in this block, or otherwise finds the ancestor operation of 'op' that lies ...
Definition: Block.cpp:73
Operation * getTerminator()
Get the terminator operation of this block.
Definition: Block.cpp:243
IntegerType getI64Type()
Definition: Builders.cpp:109
StringAttr getStringAttr(const Twine &bytes)
Definition: Builders.cpp:302
This class represents liveness information on block level.
Definition: Liveness.h:99
Operation * getStartOperation(Value value) const
Gets the start operation for the given value.
Definition: Liveness.cpp:368
Represents an analysis for computing liveness information from a given top-level operation.
Definition: Liveness.h:47
const LivenessBlockInfo * getLiveness(Block *block) const
Gets liveness info (if any) for the block.
Definition: Liveness.cpp:229
This is a builder type that keeps local references to arguments.
Definition: BuiltinTypes.h:213
Builder & setMemorySpace(Attribute newMemorySpace)
Definition: BuiltinTypes.h:239
This class helps build Operations.
Definition: Builders.h:215
Operation * create(const OperationState &state)
Creates an operation given the fields represented as an OperationState.
Definition: Builders.cpp:497
Operation is the basic unit of execution within MLIR.
Definition: Operation.h:88
std::enable_if_t< llvm::function_traits< std::decay_t< FnT > >::num_args==1, RetT > walk(FnT &&callback)
Walk the operation by calling the callback for each nested operation (including this one),...
Definition: Operation.h:793
Block * getBlock()
Returns the operation block that contains this operation.
Definition: Operation.h:213
Region & getRegion(unsigned index)
Returns the region held by this operation at position 'index'.
Definition: Operation.h:682
iterator_range< OpIterator > getOps()
Definition: Region.h:172
This class represents a specific instance of an effect.
Resource * getResource() const
Return the resource that the effect applies to.
EffectT * getEffect() const
Return the effect being applied.
Value getValue() const
Return the value the effect is applied on, or nullptr if there isn't a known value being affected.
static AutomaticAllocationScopeResource * get()
Returns a unique instance for the given effect class.
This class allows for representing and managing the symbol table used by operations with the 'SymbolT...
Definition: SymbolTable.h:24
StringAttr insert(Operation *symbol, Block::iterator insertPt={})
Insert a new symbol into the table, and rename it as necessary to avoid collisions.
LogicalResult convertType(Type t, SmallVectorImpl< Type > &results) const
Convert the given type.
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:96
static Operation * getStartOperation(Value allocValue, Block *placementBlock, const Liveness &liveness)
Get the start operation to place the given alloc value within the specified placement block.
Definition: BufferUtils.cpp:34
BufferPlacementAllocs(Operation *op)
Initializes the internal list by discovering all supported allocation nodes.
Definition: BufferUtils.cpp:56
BufferPlacementTransformationBase(Operation *op)
Constructs a new operation base using the given root operation.
Definition: BufferUtils.cpp:95
A helper type converter class that automatically populates the relevant materializations and type con...
Definition: Bufferize.h:43
FailureOr< memref::GlobalOp > getGlobalFor(arith::ConstantOp constantOp, uint64_t alignment, Attribute memorySpace={})
std::optional< Operation * > findDealloc(Value allocValue)
Finds a single dealloc operation for the given allocated value.
Include the generated interface declarations.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...