[polly] r258808 - Unique value read accesses
Michael Kruse via llvm-commits
llvm-commits at lists.llvm.org
Tue Jan 26 05:33:15 PST 2016
Author: meinersbur
Date: Tue Jan 26 07:33:15 2016
New Revision: 258808
URL: http://llvm.org/viewvc/llvm-project?rev=258808&view=rev
Log:
Unique value read accesses
Keep at most one value read MemoryAccess per value and statement;
multiple generated loads do not have any additional effect. As one such
MemoryAccess can cater multiple uses within the statement, the
AccessInstruction property is not unique any more and set to nullptr.
Differential Revision: http://reviews.llvm.org/D15510
Modified:
polly/trunk/include/polly/ScopInfo.h
polly/trunk/lib/Analysis/ScopInfo.cpp
Modified: polly/trunk/include/polly/ScopInfo.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/ScopInfo.h?rev=258808&r1=258807&r2=258808&view=diff
==============================================================================
--- polly/trunk/include/polly/ScopInfo.h (original)
+++ polly/trunk/include/polly/ScopInfo.h Tue Jan 26 07:33:15 2016
@@ -494,8 +494,9 @@ private:
/// intruction.
///
/// For memory accesses of kind MK_Value the access instruction of a load
- /// access is the instruction that uses the load. The access instruction of
- /// a write access is the instruction that defines the llvm::Value.
+ /// access is nullptr because generally there can be multiple instructions in
+ /// the statement using the same llvm::Value. The access instruction of a
+ /// write access is the instruction that defines the llvm::Value.
Instruction *AccessInstruction;
/// @brief The value associated with this memory access.
@@ -830,6 +831,10 @@ private:
/// @brief Mapping from instructions to (scalar) memory accesses.
DenseMap<const Instruction *, MemoryAccessList> InstructionToAccess;
+ /// @brief The set of values defined elsewhere required in this ScopStmt and
+ /// their MK_Value READ MemoryAccesses.
+ DenseMap<Value *, MemoryAccess *> ValueReads;
+
/// @brief The set of values defined in this ScopStmt that are required
/// elsewhere, mapped to their MK_Value WRITE MemoryAccesses.
DenseMap<Instruction *, MemoryAccess *> ValueWrites;
@@ -1006,6 +1011,12 @@ public:
return ValueWrites.lookup(Inst);
}
+ /// @brief Return the MemoryAccess that reloads a value, or nullptr if not
+ /// existing, respectively not yet added.
+ MemoryAccess *lookupValueReadOf(Value *Inst) const {
+ return ValueReads.lookup(Inst);
+ }
+
void setBasicBlock(BasicBlock *Block) {
// TODO: Handle the case where the statement is a region statement, thus
// the entry block was split and needs to be changed in the region R.
@@ -1928,33 +1939,18 @@ class ScopInfo : public RegionPass {
/// The access will be created at the @p Value's definition.
///
/// @param Value The value to be written.
- /// @see addValueReadAccess()
+ /// @see ensureValueRead()
/// @see ScopArrayInfo::MemoryKind
void ensureValueWrite(Instruction *Value);
- /// @brief Create a MemoryAccess for reloading an llvm::Value.
- ///
- /// Use this overload only for non-PHI instructions.
- ///
- /// @param Value The scalar expected to be loaded.
- /// @param User User of the scalar; this is where the access is added.
- /// @see ensureValueWrite()
- /// @see ScopArrayInfo::MemoryKind
- void addValueReadAccess(Value *Value, Instruction *User);
-
- /// @brief Create a MemoryAccess for reloading an llvm::Value.
+ /// @brief Ensure an llvm::Value is available in the BB's statement, creating
+ /// a MemoryAccess for reloading it if necessary.
///
- /// This is for PHINodes using the scalar. As we model it, the used value must
- /// be available at the incoming block instead of when hitting the
- /// instruction.
- ///
- /// @param Value The scalar expected to be loaded.
- /// @param User The PHI node referencing @p Value.
- /// @param UserBB Incoming block for the incoming @p Value.
- /// @see addPHIWriteAccess()
- /// @see ensureValueWrite()
+ /// @param Value The value expected to be loaded.
+ /// @param UserBB Where to reload the value.
+ /// @see ensureValueStore()
/// @see ScopArrayInfo::MemoryKind
- void addValueReadAccess(Value *Value, PHINode *User, BasicBlock *UserBB);
+ void ensureValueRead(Value *Value, BasicBlock *UserBB);
/// @brief Create a write MemoryAccess for the incoming block of a phi node.
///
Modified: polly/trunk/lib/Analysis/ScopInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Analysis/ScopInfo.cpp?rev=258808&r1=258807&r2=258808&view=diff
==============================================================================
--- polly/trunk/lib/Analysis/ScopInfo.cpp (original)
+++ polly/trunk/lib/Analysis/ScopInfo.cpp Tue Jan 26 07:33:15 2016
@@ -524,8 +524,9 @@ void MemoryAccess::assumeNoOutOfBound()
// bail out more often than strictly necessary.
Outside = isl_set_remove_divs(Outside);
Outside = isl_set_complement(Outside);
- Statement->getParent()->addAssumption(INBOUNDS, Outside,
- getAccessInstruction()->getDebugLoc());
+ Statement->getParent()->addAssumption(
+ INBOUNDS, Outside,
+ getAccessInstruction() ? getAccessInstruction()->getDebugLoc() : nullptr);
isl_space_free(Space);
}
@@ -911,6 +912,11 @@ void ScopStmt::addAccess(MemoryAccess *A
assert(!ValueWrites.lookup(AccessVal));
ValueWrites[AccessVal] = Access;
+ } else if (Access->isValueKind() && Access->isRead()) {
+ Value *AccessVal = Access->getAccessValue();
+ assert(!ValueReads.lookup(AccessVal));
+
+ ValueReads[AccessVal] = Access;
}
MemAccs.push_back(Access);
@@ -1473,6 +1479,10 @@ void ScopStmt::dump() const { print(dbgs
void ScopStmt::removeMemoryAccesses(MemoryAccessList &InvMAs) {
// Remove all memory accesses in @p InvMAs from this statement
// together with all scalar accesses that were caused by them.
+ // MK_Value READs have no access instruction, hence would not be removed by
+ // this function. However, it is only used for invariant LoadInst accesses,
+ // its arguments are always affine, hence synthesizable, and therefore there
+ // are no MK_Value READ accesses to be removed.
for (MemoryAccess *MA : InvMAs) {
auto Predicate = [&](MemoryAccess *Acc) {
return Acc->getAccessInstruction() == MA->getAccessInstruction();
@@ -3559,11 +3569,11 @@ void ScopInfo::buildPHIAccesses(PHINode
// OpBB if the definition is not in OpBB.
if (scop->getStmtForBasicBlock(OpIBB) !=
scop->getStmtForBasicBlock(OpBB)) {
- addValueReadAccess(OpI, PHI, OpBB);
+ ensureValueRead(OpI, OpBB);
ensureValueWrite(OpI);
}
} else if (ModelReadOnlyScalars && !isa<Constant>(Op)) {
- addValueReadAccess(Op, PHI, OpBB);
+ ensureValueRead(Op, OpBB);
}
addPHIWriteAccess(PHI, OpBB, Op, IsExitBlock);
@@ -3663,7 +3673,7 @@ bool ScopInfo::buildScalarDependences(In
// Do not build a read access that is not in the current SCoP
// Use the def instruction as base address of the MemoryAccess, so that it
// will become the name of the scalar access in the polyhedral form.
- addValueReadAccess(Inst, UI);
+ ensureValueRead(Inst, UI->getParent());
}
if (ModelReadOnlyScalars && !isa<PHINode>(Inst)) {
@@ -3678,7 +3688,7 @@ bool ScopInfo::buildScalarDependences(In
if (isa<Constant>(Op))
continue;
- addValueReadAccess(Op, Inst);
+ ensureValueRead(Op, Inst->getParent());
}
}
@@ -3952,15 +3962,19 @@ void ScopInfo::ensureValueWrite(Instruct
true, Value, ArrayRef<const SCEV *>(),
ArrayRef<const SCEV *>(), ScopArrayInfo::MK_Value);
}
-void ScopInfo::addValueReadAccess(Value *Value, Instruction *User) {
- assert(!isa<PHINode>(User));
- addMemoryAccess(User->getParent(), User, MemoryAccess::READ, Value, 1, true,
- Value, ArrayRef<const SCEV *>(), ArrayRef<const SCEV *>(),
- ScopArrayInfo::MK_Value);
-}
-void ScopInfo::addValueReadAccess(Value *Value, PHINode *User,
- BasicBlock *UserBB) {
- addMemoryAccess(UserBB, User, MemoryAccess::READ, Value, 1, true, Value,
+void ScopInfo::ensureValueRead(Value *Value, BasicBlock *UserBB) {
+ ScopStmt *UserStmt = scop->getStmtForBasicBlock(UserBB);
+
+ // We do not model uses outside the scop.
+ if (!UserStmt)
+ return;
+
+ // Do not create another MemoryAccess for reloading the value if one already
+ // exists.
+ if (UserStmt->lookupValueReadOf(Value))
+ return;
+
+ addMemoryAccess(UserBB, nullptr, MemoryAccess::READ, Value, 1, true, Value,
ArrayRef<const SCEV *>(), ArrayRef<const SCEV *>(),
ScopArrayInfo::MK_Value);
}
More information about the llvm-commits
mailing list