59 #include "llvm/ADT/DenseSet.h"
60 #include "llvm/ADT/SetVector.h"
66 #define DEBUG_TYPE "one-shot-analysis"
85 "__opresult_alias_set_attr__";
95 cast<ArrayAttr>(attr).getAsValueRange<StringAttr>()));
99 if (isa<TensorType>(opOperand.
get().
getType()))
104 OpBuilder(op).getStrArrayAttr(inPlaceVector));
117 if (isa<TensorType>(v.getType()))
120 for (
Block &b : r.getBlocks())
121 for (
auto bbArg : b.getArguments())
122 if (isa<TensorType>(bbArg.getType()))
127 op->
walk([&](BufferizableOpInterface bufferizableOp) {
130 for (
OpOperand &opOperand : bufferizableOp->getOpOperands())
131 if (isa<TensorType>(opOperand.get().getType()))
132 if (bufferizableOp.mustBufferizeInPlace(opOperand, *
this))
140 auto leaderIt = equivalentInfo.findLeader(v);
141 for (
auto mit = leaderIt, meit = equivalentInfo.member_end(); mit != meit;
149 auto leaderIt = aliasInfo.findLeader(v);
150 for (
auto mit = leaderIt, meit = aliasInfo.member_end(); mit != meit; ++mit) {
157 return equivalentInfo.isEquivalent(v1, v2);
162 return aliasInfo.isEquivalent(v1, v2);
166 if (inplaceBufferized.contains(&operand))
168 inplaceBufferized.insert(&operand);
170 aliasInfo.unionSets(alias.value, operand.
get());
171 ++statNumTensorInPlace;
175 assert(!inplaceBufferized.contains(&operand) &&
176 "OpOperand was already decided to bufferize inplace");
177 ++statNumTensorOutOfPlace;
182 equivalentInfo.insert(v);
194 if (!isa<TensorType>(opResult.getType()))
199 if (opResult.getUses().empty())
203 OpOperand *opOperand = &(*opResult.getUses().begin());
205 for (
OpOperand &use : opResult.getUses())
206 undefinedTensorUses.insert(&use);
214 return undefinedTensorUses.contains(opOperand);
218 return inplaceBufferized.contains(&opOperand);
222 bool isWritten =
false;
234 if (
auto bufferizableOp =
236 return bufferizableOp.isWritable(value, *
this);
243 aliasInfo.unionSets(v1, v2);
247 equivalentInfo.unionSets(v1, v2);
260 if (!state.bufferizesToMemoryWrite(opOperand))
263 return state.isInPlace(opOperand);
360 for (
Value def : definitions) {
363 Region *rDef = state.getEnclosingRepetitiveRegion(def,
options);
374 if (nextRegion == rDef)
376 assert(nextRegion &&
"expected to find another repetitive region");
414 for (
Value def : definitions) {
415 Block *defBlock = def.getParentBlock();
416 if (readBlock->
isReachable(writeBlock, {defBlock}) &&
434 static uint64_t counter = 0;
439 std::string
id =
"C_" + std::to_string(counter++);
441 std::string conflictingWriteAttr =
447 std::string readAttr =
451 if (
auto opResult = dyn_cast<OpResult>(definition)) {
452 std::string defAttr =
453 id +
"[DEF: result " + std::to_string(opResult.getResultNumber()) +
"]";
454 opResult.getDefiningOp()->setAttr(defAttr, b.
getUnitAttr());
456 auto bbArg = cast<BlockArgument>(definition);
457 std::string defAttr =
458 id +
"[DEF: bbArg " + std::to_string(bbArg.getArgNumber()) +
"]";
459 bbArg.getOwner()->getParentOp()->setAttr(defAttr, b.
getUnitAttr());
475 config.followEquivalentOnly =
true;
476 config.alwaysIncludeLeaves =
false;
477 config.followSameTypeOrCastsOnly =
true;
479 .findValueInReverseUseDefChain(
480 start, [&](
Value v) {
return v == other; },
config)
488 SubsetInsertionOpInterface subsetOp) {
489 auto matchingSubset = [&](
Value val) {
490 if (
auto opResult = dyn_cast<OpResult>(val))
491 if (subsetOp.isEquivalentSubset(opResult, [&](
Value v1,
Value v2) {
492 return state.areEquivalentBufferizedValues(v1, v2);
500 state.findValueInReverseUseDefChain(opOperand, matchingSubset);
501 return static_cast<bool>(llvm::all_of(backwardSlice, matchingSubset));
517 if (
auto subsetOp = dyn_cast<SubsetInsertionOpInterface>(readingOp)) {
525 if (uRead == &subsetOp.getDestinationOperand() &&
541 if (uRead == &subsetOp.getSourceOperand() &&
542 uConflictingWrite == &subsetOp.getDestinationOperand() &&
557 dyn_cast<SubsetInsertionOpInterface>(conflictingWritingOp))
574 if (uConflictingWrite == &subsetOp.getDestinationOperand() &&
575 state.areEquivalentBufferizedValues(
576 uRead->
get(), subsetOp.getSourceOperand().get()) &&
600 if (
options.checkParallelRegions && !usesRead.empty()) {
601 for (
OpOperand *uConflictingWrite : usesWrite) {
609 state.findValueInReverseUseDefChain(uConflictingWrite, [&](
Value v) {
610 return state.bufferizesToMemoryWrite(v);
612 assert(!definitionsOrLeaves.empty() &&
613 "expected at least one definition or leaf");
617 for (
Value def : definitionsOrLeaves) {
623 <<
"\n- bufferizes out-of-place due to parallel region:\n");
624 LLVM_DEBUG(llvm::dbgs()
625 <<
" unConflictingWrite = operand "
626 << uConflictingWrite->getOperandNumber() <<
" of "
627 << *uConflictingWrite->getOwner() <<
"\n");
635 Operation *readingOp = uRead->getOwner();
636 LLVM_DEBUG(llvm::dbgs() <<
"\n- check conflict:\n");
637 LLVM_DEBUG(llvm::dbgs() <<
" uRead = operand " << uRead->getOperandNumber()
638 <<
" of " << *readingOp <<
"\n");
651 if (definitions.empty()) {
653 LLVM_DEBUG(llvm::dbgs()
654 <<
" no conflict: read value has no definitions\n");
660 for (
OpOperand *uConflictingWrite : usesWrite) {
661 LLVM_DEBUG(llvm::dbgs() <<
" unConflictingWrite = operand "
662 << uConflictingWrite->getOperandNumber() <<
" of "
663 << *uConflictingWrite->getOwner() <<
"\n");
669 LLVM_DEBUG(llvm::dbgs() <<
"\n- useDominance = " << useDominance <<
"\n");
673 Operation *conflictingWritingOp = uConflictingWrite->getOwner();
684 if (
happensBefore(readingOp, conflictingWritingOp, domInfo)) {
685 LLVM_DEBUG(llvm::dbgs()
686 <<
" no conflict: read happens before write\n");
697 if (uConflictingWrite == uRead) {
698 LLVM_DEBUG(llvm::dbgs()
699 <<
" no conflict: read and write are same use\n");
709 LLVM_DEBUG(llvm::dbgs() <<
" no conflict: read and write are in "
710 "mutually exclusive regions\n");
717 if (conflictingWritingOp == readingOp) {
718 if (
auto bufferizableOp =
options.dynCastBufferizableOp(readingOp)) {
719 if (bufferizableOp.bufferizesToElementwiseAccess(
720 state, {uRead, uConflictingWrite})) {
722 state, uRead, uConflictingWrite->get()) ||
724 state, uConflictingWrite, uRead->get())) {
727 <<
" no conflict: op bufferizes to element-wise access\n");
737 LLVM_DEBUG(llvm::dbgs() <<
" no conflict: non-conflicting subsets\n");
742 if (
auto bufferizableOp =
options.dynCastBufferizableOp(readingOp)) {
743 if (bufferizableOp.isNotConflicting(uRead, uConflictingWrite, state)) {
744 LLVM_DEBUG(llvm::dbgs()
745 <<
" no conflict: op interace of reading op says 'no'\n");
750 if (conflictingWritingOp != readingOp) {
751 if (
auto bufferizableOp =
752 options.dynCastBufferizableOp(conflictingWritingOp)) {
753 if (bufferizableOp.isNotConflicting(uRead, uConflictingWrite,
757 <<
" no conflict: op interace of writing op says 'no'\n");
764 for (
Value definition : definitions) {
765 LLVM_DEBUG(llvm::dbgs() <<
" * definition = " << definition <<
"\n");
768 if (
Operation *defOp = definition.getDefiningOp()) {
771 LLVM_DEBUG(llvm::dbgs()
772 <<
" no conflict: write happens before definition\n");
776 if (defOp->isProperAncestor(conflictingWritingOp)) {
779 <<
" no conflict: write is contained in definition\n");
783 auto bbArg = cast<BlockArgument>(definition);
784 Block *block = bbArg.getOwner();
786 LLVM_DEBUG(llvm::dbgs() <<
" no conflict: definition is bbArg "
787 "and write happens outside of block\n");
798 aliases.
getAliases()[0].value == definition) {
799 LLVM_DEBUG(llvm::dbgs()
800 <<
" no conflict: definition and write are same\n");
808 LLVM_DEBUG(llvm::dbgs() <<
" => RaW CONFLICT FOUND\n");
820 state.applyOnAliases(root, [&](
Value alias) {
821 for (
auto &use : alias.
getUses())
831 state.applyOnAliases(root, [&](
Value alias) {
832 for (
auto &use : alias.
getUses()) {
834 if (state.bufferizesToMemoryRead(use)) {
854 if (!state.bufferizesToMemoryWrite(use)) {
855 AliasingValueList aliases = state.getAliasingValues(use);
856 if (llvm::any_of(aliases, [&](AliasingValue a) {
857 return state.isValueRead(a.value);
901 for (
AliasingValue alias : state.getAliasingValues(operand)) {
905 if (!checkConsistencyOnly && state.bufferizesToMemoryWrite(operand))
906 usesWrite.insert(&operand);
913 static int64_t counter = 0;
915 std::string
id =
"W_" + std::to_string(counter++);
916 if (
auto opResult = dyn_cast<OpResult>(value)) {
917 std::string attr =
id +
"[NOT-WRITABLE: result " +
918 std::to_string(opResult.getResultNumber()) +
"]";
919 opResult.getDefiningOp()->setAttr(attr, b.
getUnitAttr());
921 auto bbArg = cast<BlockArgument>(value);
922 std::string attr =
id +
"[NOT-WRITABLE: bbArg " +
923 std::to_string(bbArg.getArgNumber()) +
"]";
924 bbArg.getOwner()->getParentOp()->setAttr(attr, b.
getUnitAttr());
933 bool checkConsistencyOnly =
false) {
935 !checkConsistencyOnly && state.bufferizesToMemoryWrite(operand);
943 foundWrite = !usesWrite.empty();
950 bool foundReadOnly =
false;
951 auto checkReadOnly = [&](
Value v) {
952 if (!state.isWritable(v)) {
953 foundReadOnly =
true;
954 if (state.getOptions().printConflicts)
958 state.applyOnAliases(operand.
get(), checkReadOnly);
960 state.applyOnAliases(alias.value, checkReadOnly);
962 LLVM_DEBUG(llvm::dbgs() <<
"=> NOT WRITABLE\n");
975 OneShotAnalysisState::findDefinitionsCached(
OpOperand *opOperand) {
977 if (!cachedDefinitions.count(value))
979 return cachedDefinitions[value];
984 cachedDefinitions.clear();
992 llvm::dbgs() <<
"//===-------------------------------------------===//\n"
994 <<
" of " << *operand.
getOwner() <<
"\n");
996 bool foundInterference =
1000 if (foundInterference)
1001 state.bufferizeOutOfPlace(operand);
1003 state.bufferizeInPlace(operand);
1005 LLVM_DEBUG(llvm::dbgs()
1006 <<
"//===-------------------------------------------===//\n");
1014 if (isa<TensorType>(opOperand.get().getType()))
1024 if (
auto bufferizableOp = state.getOptions().dynCastBufferizableOp(op)) {
1025 for (
OpResult opResult : op->getOpResults()) {
1026 if (!isa<TensorType>(opResult.getType()))
1033 Value firstOperand = aliases.
begin()->opOperand->get();
1034 bool allEquivalent =
true;
1037 bool isInPlace = state.isInPlace(*alias.opOperand);
1038 Value operand = alias.opOperand->get();
1039 if (isEquiv && isInPlace && alias.isDefinite) {
1042 state.unionEquivalenceClasses(opResult, operand);
1043 allEquivalent =
false;
1046 if (!isEquiv || !isInPlace)
1047 allEquivalent =
false;
1048 if (!state.areEquivalentBufferizedValues(operand, firstOperand))
1049 allEquivalent =
false;
1062 if (allEquivalent && !bufferizableOp.bufferizesToAllocation(opResult))
1063 state.unionEquivalenceClasses(opResult, firstOperand);
1092 if (!traversedOps.insert(term))
1097 for (
Value v : term->getOperands()) {
1098 if (!isa<TensorType>(v.getType()))
1100 auto opResult = dyn_cast<OpResult>(v);
1103 worklist.push_back(opResult);
1105 while (!worklist.empty()) {
1106 OpResult opResult = worklist.pop_back_val();
1108 if (!traversedOps.insert(defOp))
1110 if (!term->getParentRegion()->findAncestorOpInRegion(*defOp))
1113 for (
auto alias : aliases) {
1114 Value v = alias.opOperand->get();
1115 if (!isa<TensorType>(v.
getType()))
1117 auto opResult = dyn_cast<OpResult>(v);
1120 worklist.push_back(opResult);
1129 result.push_back(op);
1148 orderedOps.push_back(op);
1150 switch (heuristic) {
1153 std::reverse(orderedOps.begin(), orderedOps.end());
1162 "expected that fuzzer seed it set");
1167 std::mt19937 g(
getOptions().analysisFuzzerSeed);
1168 llvm::shuffle(orderedOps.begin(), orderedOps.end(), g);
1172 llvm_unreachable(
"unsupported heuristic");
1188 static LogicalResult
1196 WalkResult walkResult = op->
walk([&](BufferizableOpInterface op) {
1198 if (!
options.isOpAllowed(op.getOperation()))
1202 if (!op.supportsUnstructuredControlFlow()) {
1203 for (Region &r : op->getRegions()) {
1204 if (r.getBlocks().size() > 1) {
1205 op->emitOpError(
"op or BufferizableOpInterface implementation does "
1206 "not support unstructured control flow, but at least "
1207 "one region has multiple blocks");
1208 return WalkResult::interrupt();
1215 if (walkResult.wasInterrupted())
1218 walkResult = op->walk([&](BufferizableOpInterface op) {
1220 if (!
options.isOpAllowed(op.getOperation()))
1226 if (
auto toTensorOp = dyn_cast<ToTensorOp>(op.getOperation())) {
1227 if (!toTensorOp.getRestrict() && !toTensorOp->getUses().empty()) {
1228 op->emitOpError(
"to_tensor ops without `restrict` are not supported by "
1229 "One-Shot Analysis");
1234 for (
OpOperand &opOperand : op->getOpOperands()) {
1235 if (isa<TensorType>(opOperand.get().getType())) {
1237 opOperand, domInfo, state,
1244 op->emitOpError(
"not bufferizable under the given constraints: "
1245 "cannot avoid RaW conflict");
1249 if (state.isInPlace(opOperand) &&
1251 opOperand, state,
true)) {
1252 op->emitOpError(
"not bufferizable under the given constraints: would "
1253 "write to read-only buffer");
1262 return success(!walkResult.wasInterrupted());
1272 if (isa<TensorType>(opOperand.get().getType()))
1282 auto buildAliasesArray = [&](
Value v) {
1284 state.applyOnAliases(v, [&](
Value alias) {
1286 llvm::raw_string_ostream stream(buffer);
1297 if (llvm::isa<TensorType>(opResult.getType())) {
1298 opResultAliasSets.push_back(buildAliasesArray(opResult));
1301 if (!opResultAliasSets.empty())
1306 bool hasTensorBbArg =
false;
1309 for (
Block &block : r.getBlocks()) {
1312 if (llvm::isa<TensorType>(bbArg.getType())) {
1313 bbArgAliasSets.push_back(buildAliasesArray(bbArg));
1314 hasTensorBbArg =
true;
1317 blockAliasSets.push_back(b.
getArrayAttr(bbArgAliasSets));
1319 regionAliasSets.push_back(b.
getArrayAttr(blockAliasSets));
1336 if (failed(state.analyzeOp(op, domInfo)))
1344 bool failedAnalysis =
false;
1347 state.gatherUndefinedTensorUses(op);
1353 if (BufferizableOpInterface bufferizableOp =
1354 options.dynCastBufferizableOp(op))
1355 failedAnalysis |= failed(bufferizableOp.verifyAnalysis(state));
1364 return success(!failedAnalysis);
1374 "invalid combination of bufferization flags");
1376 if (
options.copyBeforeWrite) {
static bool hasReadAfterWriteInterference(const DenseSet< OpOperand * > &usesRead, const DenseSet< OpOperand * > &usesWrite, const DominanceInfo &domInfo, OneShotAnalysisState &state)
Given sets of uses and writes, return true if there is a RaW conflict under the assumption that all g...
static void getAliasingReads(DenseSet< OpOperand * > &res, Value root, const OneShotAnalysisState &state)
static void equivalenceAnalysis(SmallVector< Operation * > &ops, OneShotAnalysisState &state)
Analyze equivalence of tied OpResult/OpOperand pairs of the given ops.
static void setInPlaceOpOperand(OpOperand &opOperand, bool inPlace)
Mark whether OpOperand will be bufferized inplace.
static SmallVector< Operation * > bottomUpFromTerminatorsHeuristic(Operation *op, const OneShotAnalysisState &state)
"Bottom-up from terminators" heuristic.
constexpr StringLiteral kInPlaceOperandsAttrName
Attribute marker to specify op operands that bufferize in-place.
static bool isaTensor(Type t)
static void annotateNonWritableTensor(Value value)
Annotate IR with details about the detected non-writability conflict.
static bool canUseOpDominanceDueToRegions(OpOperand *uRead, OpOperand *uWrite, const SetVector< Value > &definitions, AnalysisState &state)
Return true if op dominance can be used to rule out a read-after-write conflicts based on the orderin...
static LogicalResult bufferizableInPlaceAnalysisImpl(OpOperand &operand, OneShotAnalysisState &state, const DominanceInfo &domInfo)
Determine if operand can be bufferized in-place.
constexpr StringLiteral kOpResultAliasSetAttrName
static bool happensBefore(Operation *a, Operation *b, const DominanceInfo &domInfo)
Return true if a happens before b, i.e., a or one of its ancestors properly dominates b and b is not ...
static bool canUseOpDominance(OpOperand *uRead, OpOperand *uWrite, const SetVector< Value > &definitions, AnalysisState &state)
static bool matchesInsertDestination(const AnalysisState &state, OpOperand *opOperand, SubsetInsertionOpInterface subsetOp)
Return "true" if the given operand's value is originating from a subset that is equivalent to the sub...
static bool wouldCreateWriteToNonWritableBuffer(OpOperand &operand, OneShotAnalysisState &state, bool checkConsistencyOnly=false)
Return true if bufferizing operand inplace would create a write to a non-writable buffer.
static void annotateOpsWithAliasSets(Operation *op, const OneShotAnalysisState &state)
static LogicalResult checkPreBufferizationAssumptions(Operation *op, const DominanceInfo &domInfo, OneShotAnalysisState &state)
Perform various checks on the input IR to see if it contains IR constructs that are unsupported by On...
static void annotateOpsWithBufferizationMarkers(Operation *op, const OneShotAnalysisState &state)
Annotate the IR with the result of the analysis. For testing/debugging only.
static bool wouldCreateReadAfterWriteInterference(OpOperand &operand, const DominanceInfo &domInfo, OneShotAnalysisState &state, bool checkConsistencyOnly=false)
Return true if bufferizing operand inplace would create a conflict.
constexpr StringLiteral kBbArgAliasSetAttrName
static bool canUseOpDominanceDueToBlocks(OpOperand *uRead, OpOperand *uWrite, const SetVector< Value > &definitions, AnalysisState &state)
Return true if op dominance can be used to rule out a read-after-write conflicts based on the orderin...
static void getAliasingInplaceWrites(DenseSet< OpOperand * > &res, Value root, const OneShotAnalysisState &state)
static bool areNonConflictingSubsets(OpOperand *uRead, OpOperand *uConflictingWrite, const AnalysisState &state)
Return "true" if the given "read" and potentially conflicting "write" are not conflicting due to thei...
static void annotateConflict(OpOperand *uRead, OpOperand *uConflictingWrite, Value definition)
Annotate IR with details about the detected RaW conflict.
static bool hasEquivalentValueInReverseUseDefChain(AnalysisState &state, OpOperand *start, Value other)
Return 'true' if a tensor that is equivalent to other can be found in the reverse use-def chain of st...
static bool isInplaceMemoryWrite(OpOperand &opOperand, const OneShotAnalysisState &state)
Return true if opOperand has been decided to bufferize in-place.
static llvm::ManagedStatic< PassManagerOptions > options
#define MLIR_DEFINE_EXPLICIT_TYPE_ID(CLASS_NAME)
Base class for generic analysis states.
This class provides management for the lifetime of the state used when printing the IR.
This class represents an argument of a Block.
Block represents an ordered list of Operations.
Operation * findAncestorOpInBlock(Operation &op)
Returns 'op' if 'op' lies in this block, or otherwise finds the ancestor operation of 'op' that lies ...
bool isReachable(Block *other, SmallPtrSet< Block *, 16 > &&except={})
Return "true" if there is a path from this block to the given block (according to the successors rela...
This class is a general helper class for creating context-global objects like types,...
StringAttr getStringAttr(const Twine &bytes)
ArrayAttr getArrayAttr(ArrayRef< Attribute > value)
A class for computing basic dominance information.
bool properlyDominates(Operation *a, Operation *b, bool enclosingOpOk=true) const
Return true if operation A properly dominates operation B, i.e.
IRValueT get() const
Return the current value being used by this operand.
This class helps build Operations.
This class represents an operand of an operation.
unsigned getOperandNumber()
Return which operand this is in the OpOperand list of the Operation.
This is a value defined by a result of an operation.
Operation is the basic unit of execution within MLIR.
Attribute getAttr(StringAttr name)
Return the specified attribute if present, null otherwise.
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),...
MLIRContext * getContext()
Return the context this operation is associated with.
unsigned getNumOperands()
Operation * getParentOp()
Returns the closest surrounding operation that contains this operation or nullptr if this is a top-le...
Block * getBlock()
Returns the operation block that contains this operation.
void setAttr(StringAttr name, Attribute value)
If the an attribute exists with the specified name, change it to the new value.
MutableArrayRef< Region > getRegions()
Returns the regions held by this operation.
MutableArrayRef< OpOperand > getOpOperands()
result_type_range getResultTypes()
bool isAncestor(Operation *other)
Return true if this operation is an ancestor of the other operation.
result_range getOpResults()
Region * getParentRegion()
Returns the region to which the instruction belongs.
result_range getResults()
bool isProperAncestor(Operation *other)
Return true if this operation is a proper ancestor of the other operation.
This class contains a list of basic blocks and a link to the parent operation it is attached to.
Operation * getParentOp()
Return the parent operation this region is attached to.
This class provides an efficient unique identifier for a specific C++ type.
Instances of the Type class are uniqued, have an immutable identifier and an optional mutable compone...
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
MLIRContext * getContext() const
Utility to get the associated MLIRContext that this value is defined in.
Type getType() const
Return the type of this value.
use_range getUses() const
Returns a range of all uses, which is useful for iterating over all uses.
void printAsOperand(raw_ostream &os, AsmState &state) const
Print this value as if it were an operand.
Operation * getDefiningOp() const
If this value is the result of an operation, return the operation that defines it.
A utility result that is used to signal how to proceed with an ongoing walk:
static WalkResult advance()
static WalkResult interrupt()
size_t getNumAliases() const
ArrayRef< T > getAliases() const
AnalysisState provides a variety of helper functions for dealing with tensor values.
AliasingValueList getAliasingValues(OpOperand &opOperand) const
Determine which Value will alias with opOperand if the op is bufferized in place.
bool bufferizesToMemoryWrite(OpOperand &opOperand) const
Return true if opOperand bufferizes to a memory write.
SetVector< Value > findDefinitions(OpOperand *opOperand) const
Find the values that may define the contents of the given value at runtime.
virtual void resetCache()
virtual ~Extension()
Base virtual destructor.
State for analysis-enabled bufferization.
void bufferizeOutOfPlace(OpOperand &operand)
Mark the given OpOperand as out-of-place.
bool isWritable(Value value) const
Return true if the buffer of the given tensor value is writable.
const SetVector< Value > & findDefinitionsCached(OpOperand *opOperand)
Find the definitions of the given operand's value or retrieve them from the cache.
bool isInPlace(OpOperand &opOperand) const override
Return true if the given OpResult has been decided to bufferize inplace.
LogicalResult analyzeOp(Operation *op, const DominanceInfo &domInfo)
Analyze the given op and its nested ops.
bool isValueWritten(Value value) const
Return true if the buffer of the given tensor value is written to.
const OneShotBufferizationOptions & getOptions() const
Return a reference to the BufferizationOptions.
void unionEquivalenceClasses(Value v1, Value v2)
Union the equivalence classes of v1 and v2.
void gatherUndefinedTensorUses(Operation *op)
Find all tensor values in the given operation that have undefined contents and store them in undefine...
void resetCache() override
Reset cached data structures.
LogicalResult analyzeSingleOp(Operation *op, const DominanceInfo &domInfo)
Analyze a single op (without nested ops).
void applyOnEquivalenceClass(Value v, function_ref< void(Value)> fun) const
Apply fun to all the members of the equivalence class of v.
bool hasUndefinedContents(OpOperand *opOperand) const override
Return true if the given tensor has undefined contents.
void bufferizeInPlace(OpOperand &operand)
Mark the given OpOperand as in-place and merge the results' and operand's aliasing sets.
void applyOnAliases(Value v, function_ref< void(Value)> fun) const
Apply fun to all aliases of v.
bool areEquivalentBufferizedValues(Value v1, Value v2) const override
Return true if v1 and v2 bufferize to equivalent buffers.
OneShotAnalysisState(Operation *op, const OneShotBufferizationOptions &options)
bool areAliasingBufferizedValues(Value v1, Value v2) const override
Return true if v1 and v2 may bufferize to aliasing buffers.
void unionAliasSets(Value v1, Value v2)
Union the alias sets of v1 and v2.
void createAliasInfoEntry(Value v)
Add a new entry for v in the aliasInfo and equivalentInfo.
Operation * getOwner() const
Return the owner of this operand.
LogicalResult runOneShotBufferize(Operation *op, const OneShotBufferizationOptions &options, BufferizationStatistics *statistics=nullptr)
Run One-Shot Bufferize on the given op: Analysis + Bufferization.
LogicalResult analyzeOp(Operation *op, OneShotAnalysisState &state, BufferizationStatistics *statistics=nullptr)
Analyze op and its nested ops.
Operation * getOwnerOfValue(Value value)
Return the owner of the given value.
LogicalResult bufferizeOp(Operation *op, const BufferizationOptions &options, BufferizationStatistics *statistics=nullptr)
Bufferize op and its nested ops that implement BufferizableOpInterface.
LogicalResult insertTensorCopies(Operation *op, const OneShotBufferizationOptions &options, BufferizationStatistics *statistics=nullptr)
Resolve RaW and other conflicts by inserting bufferization.alloc_tensor ops.
Region * getParallelRegion(Region *region, const BufferizationOptions &options)
If region is a parallel region, return region.
Region * getNextEnclosingRepetitiveRegion(Region *region, const BufferizationOptions &options)
Assuming that the given region is repetitive, find the next enclosing repetitive region.
bool hasTensorSemantics(Operation *op)
Return "true" if the given op has tensor semantics and should be bufferized.
Include the generated interface declarations.
const FrozenRewritePatternSet GreedyRewriteConfig config
bool insideMutuallyExclusiveRegions(Operation *a, Operation *b)
Return true if a and b are in mutually exclusive regions as per RegionBranchOpInterface.
auto get(MLIRContext *context, Ts &&...params)
Helper method that injects context only if needed, this helps unify some of the attribute constructio...
This iterator enumerates elements in "reverse" order.
A maybe aliasing OpOperand.
Options for BufferizableOpInterface-based bufferization.
BufferizableOpInterface dynCastBufferizableOp(Operation *op) const
Try to cast the given op to BufferizableOpInterface if the op is allow listed.
bool isOpAllowed(Operation *op) const
Return true if the given op should be bufferized.
Bufferization statistics for debugging.
int64_t numTensorOutOfPlace
Options for analysis-enabled bufferization.
AnalysisHeuristic analysisHeuristic
The heuristic controls the order in which ops are traversed during the analysis.
@ BottomUpFromTerminators
Traversal parameters for findValueInReverseUseDefChain.