[Mlir-commits] [mlir] 1617557 - [mlir][linalg][bufferize] Move BufferizationAliasInfo to op interface
Matthias Springer
llvmlistbot at llvm.org
Wed Nov 10 17:46:29 PST 2021
Author: Matthias Springer
Date: 2021-11-11T10:45:45+09:00
New Revision: 161755770a44faaedc1a5e74a22b91f4d6ef9669
URL: https://github.com/llvm/llvm-project/commit/161755770a44faaedc1a5e74a22b91f4d6ef9669
DIFF: https://github.com/llvm/llvm-project/commit/161755770a44faaedc1a5e74a22b91f4d6ef9669.diff
LOG: [mlir][linalg][bufferize] Move BufferizationAliasInfo to op interface
BufferizationAliasInfo is used in BufferizationOpInterface::bufferize implementations, so it should be part of the same build target as BufferizableOpInterface.
This commit is in preparation of decoupling the ComprehensiveBufferize from the various dialects.
Differential Revision: https://reviews.llvm.org/D113378
Added:
Modified:
mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h
mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.h
mlir/lib/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.cpp
mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.cpp
Removed:
################################################################################
diff --git a/mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h b/mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h
index ce3fd97cbc81..2889040f7593 100644
--- a/mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h
+++ b/mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h
@@ -13,6 +13,7 @@
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Operation.h"
#include "mlir/Support/LLVM.h"
+#include "llvm/ADT/EquivalenceClasses.h"
namespace mlir {
class BlockAndValueMapping;
@@ -31,6 +32,105 @@ enum class BufferRelation {
Equivalent
};
+/// The BufferizationAliasInfo class maintains a list of buffer aliases and
+/// equivalence classes to support bufferization.
+class BufferizationAliasInfo {
+public:
+ explicit BufferizationAliasInfo(Operation *rootOp);
+
+ /// Add a new entry for `v` in the `aliasInfo` and `equivalentInfo`. In the
+ /// beginning the alias and equivalence sets only contain `v` itself.
+ void createAliasInfoEntry(Value v);
+
+ /// Insert an info entry for `newValue` and merge its alias set with that of
+ /// `alias`.
+ void insertNewBufferAlias(Value newValue, Value alias);
+
+ /// Insert an info entry for `newValue` and merge its alias set with that of
+ /// `alias`. Additionally, merge their equivalence classes.
+ void insertNewBufferEquivalence(Value newValue, Value alias);
+
+ /// Set the inPlace bufferization spec to true.
+ /// Merge result's and operand's aliasing sets and iterate to a fixed point.
+ void bufferizeInPlace(OpResult result, OpOperand &operand);
+
+ /// Set the inPlace bufferization spec to false.
+ void bufferizeOutOfPlace(OpResult result);
+
+ /// Return true if `v1` and `v2` bufferize to equivalent buffers.
+ bool areEquivalentBufferizedValues(Value v1, Value v2) const {
+ return equivalentInfo.isEquivalent(v1, v2);
+ }
+
+ /// Return true if `v1` and `v2` bufferize to aliasing buffers.
+ bool areAliasingBufferizedValues(Value v1, Value v2) const {
+ return aliasInfo.isEquivalent(v1, v2);
+ }
+
+ /// Union the alias sets of `v1` and `v2`.
+ void unionAliasSets(Value v1, Value v2) { aliasInfo.unionSets(v1, v2); }
+
+ /// Union the equivalence classes of `v1` and `v2`.
+ void unionEquivalenceClasses(Value v1, Value v2) {
+ equivalentInfo.unionSets(v1, v2);
+ }
+
+ /// Apply `fun` to all the members of the equivalence class of `v`.
+ void applyOnEquivalenceClass(Value v, function_ref<void(Value)> fun) const;
+
+ /// Apply `fun` to all aliases of `v`.
+ void applyOnAliases(Value v, function_ref<void(Value)> fun) const;
+
+ // TODO: Move these out of BufferizationAliasInfo.
+ /// Return true if the value is known to bufferize to writable memory.
+ bool bufferizesToWritableMemory(Value v) const;
+
+ /// Specify that the value is known to bufferize to writable memory.
+ void setBufferizesToWritableMemory(Value v);
+
+ /// Mark a value as in-place bufferized.
+ void markInPlace(OpResult v) { inplaceBufferized.insert(v); }
+
+ /// Return `true` if a value was marked as in-place bufferized.
+ bool isInPlace(OpResult opResult) const;
+
+private:
+ /// llvm::EquivalenceClasses wants comparable elements. This comparator uses
+ /// uses pointer comparison on the defining op. This is a poor man's
+ /// comparison but it's not like UnionFind needs ordering anyway.
+ struct ValueComparator {
+ bool operator()(const Value &lhs, const Value &rhs) const {
+ return lhs.getImpl() < rhs.getImpl();
+ }
+ };
+
+ using EquivalenceClassRangeType = llvm::iterator_range<
+ llvm::EquivalenceClasses<Value, ValueComparator>::member_iterator>;
+ /// Check that aliasInfo for `v` exists and return a reference to it.
+ EquivalenceClassRangeType getAliases(Value v) const;
+
+ /// Set of tensors that are known to bufferize to writable memory.
+ llvm::DenseSet<Value> bufferizeToWritableMemory;
+
+ /// Set of all OpResults that were decided to bufferize in-place.
+ llvm::DenseSet<OpResult> inplaceBufferized;
+
+ /// Auxiliary structure to store all the values a given value may alias with.
+ /// Alias information is "may be" conservative: In the presence of branches, a
+ /// value may alias with one of multiple other values. The concrete aliasing
+ /// value may not even be known at compile time. All such values are
+ /// considered to be aliases.
+ llvm::EquivalenceClasses<Value, ValueComparator> aliasInfo;
+
+ /// Auxiliary structure to store all the equivalent buffer classes. Equivalent
+ /// buffer information is "must be" conservative: Only if two values are
+ /// guaranteed to be equivalent at runtime, they said to be equivalent. It is
+ /// possible that, in the presence of branches, it cannot be determined
+ /// statically if two values are equivalent. In that case, the values are
+ /// considered to be not equivalent.
+ llvm::EquivalenceClasses<Value, ValueComparator> equivalentInfo;
+};
+
/// Determine which OpOperand* will alias with `result` if the op is bufferized
/// in place. Return an empty vector if the op is not bufferizable.
SmallVector<OpOperand *> getAliasingOpOperand(OpResult result);
diff --git a/mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.h b/mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.h
index 75406883612d..83ce9cc026a4 100644
--- a/mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.h
+++ b/mlir/include/mlir/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.h
@@ -11,7 +11,6 @@
#include "mlir/Dialect/Tensor/IR/Tensor.h"
#include "mlir/IR/Value.h"
-#include "llvm/ADT/EquivalenceClasses.h"
#include "llvm/ADT/SetOperations.h"
namespace mlir {
@@ -24,124 +23,11 @@ class ModuleOp;
namespace linalg {
namespace comprehensive_bufferize {
+class BufferizationAliasInfo;
+
// TODO: from some HW description.
static constexpr int64_t kBufferAlignments = 128;
-/// The BufferizationAliasInfo class maintains a list of buffer aliases and
-/// equivalence classes to support bufferization.
-/// ExtractSliceOps have special behavior, they act as a level of indirection
-/// for bufferization. They don't create reads or writes themselves and analysis
-/// needs to look through their uses.
-/// ExtractSliceOp + InsertSliceOp have special joint behavior: they may
-/// bufferize to the same buffer (i.e. subview), which is what introduces the
-/// need for bufferization classes.
-/// Some of these functionalities could be refactored in a Bufferizer class that
-/// uses BufferizationAliasInfo.
-class BufferizationAliasInfo {
-public:
- explicit BufferizationAliasInfo(Operation *rootOp);
-
- /// Add a new entry for `v` in the `aliasInfo` and `equivalentInfo`. In the
- /// beginning the alias and equivalence sets only contain `v` itself.
- void createAliasInfoEntry(Value v);
-
- /// Insert an info entry for `newValue` and merge its alias set with that of
- /// `alias`.
- void insertNewBufferAlias(Value newValue, Value alias);
-
- /// Insert an info entry for `newValue` and merge its alias set with that of
- /// `alias`. Additionally, merge their equivalence classes.
- void insertNewBufferEquivalence(Value newValue, Value alias);
-
- /// Set the inPlace bufferization spec to true.
- /// Merge result's and operand's aliasing sets and iterate to a fixed point.
- void bufferizeInPlace(OpResult result, OpOperand &operand);
-
- /// Set the inPlace bufferization spec to false.
- void bufferizeOutOfPlace(OpResult result);
-
- /// Return true if `v1` and `v2` bufferize to equivalent buffers.
- bool areEquivalentBufferizedValues(Value v1, Value v2) const {
- return equivalentInfo.isEquivalent(v1, v2);
- }
-
- /// Return true if `v1` and `v2` bufferize to aliasing buffers.
- bool areAliasingBufferizedValues(Value v1, Value v2) const {
- return aliasInfo.isEquivalent(v1, v2);
- }
-
- /// Union the alias sets of `v1` and `v2`.
- void unionAliasSets(Value v1, Value v2) { aliasInfo.unionSets(v1, v2); }
-
- /// Union the equivalence classes of `v1` and `v2`.
- void unionEquivalenceClasses(Value v1, Value v2) {
- equivalentInfo.unionSets(v1, v2);
- }
-
- /// Apply `fun` to all the members of the equivalence class of `v`.
- void applyOnEquivalenceClass(Value v, function_ref<void(Value)> fun) const;
-
- /// Apply `fun` to all aliases of `v`.
- void applyOnAliases(Value v, function_ref<void(Value)> fun) const;
-
- // TODO: Move these out of BufferizationAliasInfo.
- /// Return true if the value is known to bufferize to writable memory.
- bool bufferizesToWritableMemory(Value v) const;
-
- /// Specify that the value is known to bufferize to writable memory.
- void setBufferizesToWritableMemory(Value v);
-
- /// Mark a value as in-place bufferized.
- void markInPlace(OpResult v) { inplaceBufferized.insert(v); }
-
- /// Return `true` if a value was marked as in-place bufferized.
- bool isInPlace(OpResult opResult) const;
-
- /// Print to `os`.
- void printAliases(raw_ostream &os) const;
- void printEquivalences(raw_ostream &os) const;
-
- /// Print to `errs()`.
- void dumpAliases() const;
- void dumpEquivalences() const;
-
-private:
- /// llvm::EquivalenceClasses wants comparable elements. This comparator uses
- /// uses pointer comparison on the defining op. This is a poor man's
- /// comparison but it's not like UnionFind needs ordering anyway.
- struct ValueComparator {
- bool operator()(const Value &lhs, const Value &rhs) const {
- return lhs.getImpl() < rhs.getImpl();
- }
- };
-
- using EquivalenceClassRangeType = llvm::iterator_range<
- llvm::EquivalenceClasses<Value, ValueComparator>::member_iterator>;
- /// Check that aliasInfo for `v` exists and return a reference to it.
- EquivalenceClassRangeType getAliases(Value v) const;
-
- /// Set of tensors that are known to bufferize to writable memory.
- llvm::DenseSet<Value> bufferizeToWritableMemory;
-
- /// Set of all OpResults that were decided to bufferize in-place.
- llvm::DenseSet<OpResult> inplaceBufferized;
-
- /// Auxiliary structure to store all the values a given value may alias with.
- /// Alias information is "may be" conservative: In the presence of branches, a
- /// value may alias with one of multiple other values. The concrete aliasing
- /// value may not even be known at compile time. All such values are
- /// considered to be aliases.
- llvm::EquivalenceClasses<Value, ValueComparator> aliasInfo;
-
- /// Auxiliary structure to store all the equivalent buffer classes. Equivalent
- /// buffer information is "must be" conservative: Only if two values are
- /// guaranteed to be equivalent at runtime, they said to be equivalent. It is
- /// possible that, in the presence of branches, it cannot be determined
- /// statically if two values are equivalent. In that case, the values are
- /// considered to be not equivalent.
- llvm::EquivalenceClasses<Value, ValueComparator> equivalentInfo;
-};
-
/// Analyze the `ops` to determine which OpResults are inplaceable.
LogicalResult inPlaceAnalysis(SmallVector<Operation *> &ops,
BufferizationAliasInfo &aliasInfo,
diff --git a/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.cpp b/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.cpp
index 435f712cec04..3efc6e8c3303 100644
--- a/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.cpp
+++ b/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.cpp
@@ -8,6 +8,7 @@
#include "mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h"
#include "mlir/IR/Operation.h"
+#include "llvm/Support/Debug.h"
namespace mlir {
namespace linalg {
@@ -19,9 +20,150 @@ namespace comprehensive_bufferize {
} // namespace linalg
} // namespace mlir
+#define DEBUG_TYPE "bufferizable-op-interface"
+#define DBGS() (llvm::dbgs() << '[' << DEBUG_TYPE << "] ")
+#define LDBG(X) LLVM_DEBUG(DBGS() << X)
+
using namespace mlir;
using namespace linalg::comprehensive_bufferize;
+//===----------------------------------------------------------------------===//
+// BufferizationAliasInfo
+//===----------------------------------------------------------------------===//
+
+BufferizationAliasInfo::BufferizationAliasInfo(Operation *rootOp) {
+ rootOp->walk([&](Operation *op) {
+ for (Value v : op->getResults())
+ if (v.getType().isa<TensorType>())
+ createAliasInfoEntry(v);
+ for (Region &r : op->getRegions())
+ for (Block &b : r.getBlocks())
+ for (auto bbArg : b.getArguments())
+ if (bbArg.getType().isa<TensorType>())
+ createAliasInfoEntry(bbArg);
+ });
+
+ // Set up alias sets for OpResults that must bufferize in-place. This should
+ // be done before making any other bufferization decisions.
+ rootOp->walk([&](BufferizableOpInterface bufferizableOp) {
+ for (OpResult opResult : bufferizableOp->getOpResults()) {
+ if (opResult.getType().isa<TensorType>())
+ if (bufferizableOp.mustBufferizeInPlace(opResult)) {
+ SmallVector<OpOperand *> operands =
+ bufferizableOp.getAliasingOpOperand(opResult);
+ assert(!operands.empty() &&
+ "expected that OpResult has aliasing OpOperand");
+ for (OpOperand *operand : operands)
+ aliasInfo.unionSets(operand->get(), opResult);
+ markInPlace(opResult);
+ }
+ }
+ });
+}
+
+/// Add a new entry for `v` in the `aliasInfo` and `equivalentInfo`. In the
+/// beginning the alias and equivalence sets only contain `v` itself.
+void BufferizationAliasInfo::createAliasInfoEntry(Value v) {
+ aliasInfo.insert(v);
+ equivalentInfo.insert(v);
+}
+
+/// Insert an info entry for `newValue` and merge its alias set with that of
+/// `alias`.
+void BufferizationAliasInfo::insertNewBufferAlias(Value newValue, Value alias) {
+ createAliasInfoEntry(newValue);
+ aliasInfo.unionSets(newValue, alias);
+}
+
+/// Insert an info entry for `newValue` and merge its alias set with that of
+/// `alias`. Additionally, merge their equivalence classes.
+void BufferizationAliasInfo::insertNewBufferEquivalence(Value newValue,
+ Value alias) {
+ insertNewBufferAlias(newValue, alias);
+ equivalentInfo.unionSets(newValue, alias);
+}
+
+bool BufferizationAliasInfo::bufferizesToWritableMemory(Value v) const {
+ return bufferizeToWritableMemory.count(v) > 0;
+}
+
+/// Specify that the value is known to bufferize to writable memory.
+void BufferizationAliasInfo::setBufferizesToWritableMemory(Value v) {
+ bufferizeToWritableMemory.insert(v);
+}
+
+/// Return `true` if a value was marked as in-place bufferized.
+bool BufferizationAliasInfo::isInPlace(OpResult opResult) const {
+ bool inplace = inplaceBufferized.contains(opResult);
+#ifndef NDEBUG
+ if (inplace) {
+ auto bufferizableOp =
+ dyn_cast<BufferizableOpInterface>(opResult.getDefiningOp());
+ assert(bufferizableOp &&
+ "expected that in-place bufferized op is bufferizable");
+ SmallVector<OpOperand *> operands =
+ bufferizableOp.getAliasingOpOperand(opResult);
+ for (OpOperand *operand : operands)
+ assert(areAliasingBufferizedValues(operand->get(), opResult) &&
+ "expected that in-place bufferized OpResult aliases with "
+ "aliasing OpOperand");
+ }
+#endif // NDEBUG
+ return inplace;
+}
+
+/// Set the inPlace bufferization spec to true.
+void BufferizationAliasInfo::bufferizeInPlace(OpResult result,
+ OpOperand &operand) {
+ LLVM_DEBUG(llvm::dbgs() << "bufferizeInPlace: ");
+ LLVM_DEBUG(result.print(llvm::dbgs()));
+
+ markInPlace(result);
+ aliasInfo.unionSets(result, operand.get());
+ if (bufferRelation(operand) == BufferRelation::Equivalent)
+ equivalentInfo.unionSets(result, operand.get());
+}
+
+/// Set the inPlace bufferization spec to false.
+void BufferizationAliasInfo::bufferizeOutOfPlace(OpResult result) {
+ LLVM_DEBUG(llvm::dbgs() << "bufferizeOutOfPlace: ");
+ LLVM_DEBUG(result.print(llvm::dbgs()));
+
+ if (inplaceBufferized.contains(result))
+ inplaceBufferized.erase(result);
+}
+
+/// Apply `fun` to all the members of the equivalence class of `v`.
+void BufferizationAliasInfo::applyOnEquivalenceClass(
+ Value v, function_ref<void(Value)> fun) const {
+ auto leaderIt = equivalentInfo.findLeader(v);
+ for (auto mit = leaderIt, meit = equivalentInfo.member_end(); mit != meit;
+ ++mit) {
+ fun(*mit);
+ }
+}
+
+/// Apply `fun` to all aliases of `v`.
+void BufferizationAliasInfo::applyOnAliases(
+ Value v, function_ref<void(Value)> fun) const {
+ auto leaderIt = aliasInfo.findLeader(v);
+ for (auto mit = leaderIt, meit = aliasInfo.member_end(); mit != meit; ++mit) {
+ fun(*mit);
+ }
+}
+
+BufferizationAliasInfo::EquivalenceClassRangeType
+BufferizationAliasInfo::getAliases(Value v) const {
+ DenseSet<Value> res;
+ auto it = aliasInfo.findValue(aliasInfo.getLeaderValue(v));
+ for (auto mit = aliasInfo.member_begin(it), meit = aliasInfo.member_end();
+ mit != meit; ++mit) {
+ res.insert(static_cast<Value>(*mit));
+ }
+ return BufferizationAliasInfo::EquivalenceClassRangeType(
+ aliasInfo.member_begin(it), aliasInfo.member_end());
+}
+
//===----------------------------------------------------------------------===//
// Helper functions for BufferizableOpInterface
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.cpp b/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.cpp
index 76126693b228..433edf1b94f1 100644
--- a/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.cpp
+++ b/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ComprehensiveBufferize.cpp
@@ -351,58 +351,6 @@ static bool isInplaceMemoryWrite(OpOperand &opOperand,
return opResult && aliasInfo.isInPlace(opResult);
}
-BufferizationAliasInfo::BufferizationAliasInfo(Operation *rootOp) {
- rootOp->walk([&](Operation *op) {
- for (Value v : op->getResults())
- if (v.getType().isa<TensorType>())
- createAliasInfoEntry(v);
- for (Region &r : op->getRegions())
- for (Block &b : r.getBlocks())
- for (auto bbArg : b.getArguments())
- if (bbArg.getType().isa<TensorType>())
- createAliasInfoEntry(bbArg);
- });
-
- // Set up alias sets for OpResults that must bufferize in-place. This should
- // be done before making any other bufferization decisions.
- rootOp->walk([&](BufferizableOpInterface bufferizableOp) {
- for (OpResult opResult : bufferizableOp->getOpResults()) {
- if (opResult.getType().isa<TensorType>())
- if (bufferizableOp.mustBufferizeInPlace(opResult)) {
- SmallVector<OpOperand *> operands =
- bufferizableOp.getAliasingOpOperand(opResult);
- assert(!operands.empty() &&
- "expected that OpResult has aliasing OpOperand");
- for (OpOperand *operand : operands)
- aliasInfo.unionSets(operand->get(), opResult);
- markInPlace(opResult);
- }
- }
- });
-}
-
-/// Add a new entry for `v` in the `aliasInfo` and `equivalentInfo`. In the
-/// beginning the alias and equivalence sets only contain `v` itself.
-void BufferizationAliasInfo::createAliasInfoEntry(Value v) {
- aliasInfo.insert(v);
- equivalentInfo.insert(v);
-}
-
-/// Insert an info entry for `newValue` and merge its alias set with that of
-/// `alias`.
-void BufferizationAliasInfo::insertNewBufferAlias(Value newValue, Value alias) {
- createAliasInfoEntry(newValue);
- aliasInfo.unionSets(newValue, alias);
-}
-
-/// Insert an info entry for `newValue` and merge its alias set with that of
-/// `alias`. Additionally, merge their equivalence classes.
-void BufferizationAliasInfo::insertNewBufferEquivalence(Value newValue,
- Value alias) {
- insertNewBufferAlias(newValue, alias);
- equivalentInfo.unionSets(newValue, alias);
-}
-
/// Return true if, under current bufferization decisions, the buffer of `value`
/// is not writable.
static bool aliasesNonWritableBuffer(Value value,
@@ -438,15 +386,6 @@ static bool aliasesNonWritableBuffer(Value value,
return foundNonWritableBuffer;
}
-bool BufferizationAliasInfo::bufferizesToWritableMemory(Value v) const {
- return bufferizeToWritableMemory.count(v) > 0;
-}
-
-/// Specify that the value is known to bufferize to writable memory.
-void BufferizationAliasInfo::setBufferizesToWritableMemory(Value v) {
- bufferizeToWritableMemory.insert(v);
-}
-
/// Return true if the buffer to which `operand` would bufferize is equivalent
/// to some buffer write.
static bool aliasesInPlaceWrite(Value value,
@@ -471,45 +410,6 @@ static bool aliasesInPlaceWrite(Value value,
return foundInplaceWrite;
}
-/// Return `true` if a value was marked as in-place bufferized.
-bool BufferizationAliasInfo::isInPlace(OpResult opResult) const {
- bool inplace = inplaceBufferized.contains(opResult);
-#ifndef NDEBUG
- if (inplace) {
- auto bufferizableOp =
- dyn_cast<BufferizableOpInterface>(opResult.getDefiningOp());
- assert(bufferizableOp &&
- "expected that in-place bufferized op is bufferizable");
- SmallVector<OpOperand *> operands =
- bufferizableOp.getAliasingOpOperand(opResult);
- for (OpOperand *operand : operands)
- assert(areAliasingBufferizedValues(operand->get(), opResult) &&
- "expected that in-place bufferized OpResult aliases with "
- "aliasing OpOperand");
- }
-#endif // NDEBUG
- return inplace;
-}
-
-/// Set the inPlace bufferization spec to true.
-void BufferizationAliasInfo::bufferizeInPlace(OpResult result,
- OpOperand &operand) {
- markInPlace(result);
- aliasInfo.unionSets(result, operand.get());
- // Dump the updated alias analysis.
- LLVM_DEBUG(dumpAliases());
- if (bufferRelation(operand) == BufferRelation::Equivalent)
- equivalentInfo.unionSets(result, operand.get());
- // Dump the updated equivalence analysis.
- LLVM_DEBUG(dumpEquivalences());
-}
-
-/// Set the inPlace bufferization spec to false.
-void BufferizationAliasInfo::bufferizeOutOfPlace(OpResult result) {
- if (inplaceBufferized.contains(result))
- inplaceBufferized.erase(result);
-}
-
/// Starting from `value`, follow the use-def chain in reverse, always selecting
/// the aliasing OpOperands. Find and return Values for which `condition`
/// evaluates to true. OpOperands of such matching Values are not traversed any
@@ -870,81 +770,6 @@ wouldCreateWriteToNonWritableBuffer(OpOperand &opOperand, OpResult opResult,
return true;
}
-/// Apply `fun` to all the members of the equivalence class of `v`.
-void BufferizationAliasInfo::applyOnEquivalenceClass(
- Value v, function_ref<void(Value)> fun) const {
- auto leaderIt = equivalentInfo.findLeader(v);
- for (auto mit = leaderIt, meit = equivalentInfo.member_end(); mit != meit;
- ++mit) {
- fun(*mit);
- }
-}
-
-/// Apply `fun` to all aliases of `v`.
-void BufferizationAliasInfo::applyOnAliases(
- Value v, function_ref<void(Value)> fun) const {
- auto leaderIt = aliasInfo.findLeader(v);
- for (auto mit = leaderIt, meit = aliasInfo.member_end(); mit != meit; ++mit) {
- fun(*mit);
- }
-}
-
-void BufferizationAliasInfo::printAliases(raw_ostream &os) const {
- os << "\n/===================== AliasInfo =====================\n";
- for (auto it = aliasInfo.begin(), eit = aliasInfo.end(); it != eit; ++it) {
- if (!it->isLeader())
- continue;
- Value leader = it->getData();
- os << "|\n| -- leader: " << printValueInfo(leader, /*prefix=*/false)
- << '\n';
- for (auto mit = aliasInfo.member_begin(it), meit = aliasInfo.member_end();
- mit != meit; ++mit) {
- Value v = static_cast<Value>(*mit);
- os << "| ---- aliasing member: " << printValueInfo(v, /*prefix=*/false)
- << '\n';
- }
- }
- os << "\n/===================== End AliasInfo =====================\n\n";
-}
-
-void BufferizationAliasInfo::printEquivalences(raw_ostream &os) const {
- os << "\n/********************* Equivalent Buffers *********************\n";
- for (auto it = equivalentInfo.begin(), eit = equivalentInfo.end(); it != eit;
- ++it) {
- if (!it->isLeader())
- continue;
- Value leader = it->getData();
- os << "|\n| -- leader: " << printValueInfo(leader, /*prefix=*/false)
- << '\n';
- for (auto mit = equivalentInfo.member_begin(it),
- meit = equivalentInfo.member_end();
- mit != meit; ++mit) {
- Value v = static_cast<Value>(*mit);
- os << "| ---- equivalent member: " << printValueInfo(v, /*prefix=*/false)
- << '\n';
- }
- }
- os << "|\n\\***************** End Equivalent Buffers *****************\n\n";
-}
-
-BufferizationAliasInfo::EquivalenceClassRangeType
-BufferizationAliasInfo::getAliases(Value v) const {
- DenseSet<Value> res;
- auto it = aliasInfo.findValue(aliasInfo.getLeaderValue(v));
- for (auto mit = aliasInfo.member_begin(it), meit = aliasInfo.member_end();
- mit != meit; ++mit) {
- res.insert(static_cast<Value>(*mit));
- }
- return BufferizationAliasInfo::EquivalenceClassRangeType(
- aliasInfo.member_begin(it), aliasInfo.member_end());
-}
-
-void BufferizationAliasInfo::dumpAliases() const { printAliases(llvm::errs()); }
-
-void BufferizationAliasInfo::dumpEquivalences() const {
- printEquivalences(llvm::errs());
-}
-
//===----------------------------------------------------------------------===//
// Forward declarations.
//===----------------------------------------------------------------------===//
More information about the Mlir-commits
mailing list