From 2b63446e67f71dd54fd798541ab2c01f7728f106 Mon Sep 17 00:00:00 2001 From: Alina Sbirlea Date: Fri, 15 Feb 2019 22:47:54 +0000 Subject: [PATCH] [EarlyCSE & MSSA] Cap the clobbering calls in EarlyCSE. Summary: Unlimitted number of calls to getClobberingAccess can lead to high compile times in pathological cases. Limitting getClobberingAccess to a fairly high number. Can be adjusted based on users/need. Note: this is the only user of MemorySSA currently enabled by default. The same handling exists in LICM (disabled atm). As MemorySSA gains more users, this logic of capping will need to move inside MemorySSA. Reviewers: george.burgess.iv Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D58248 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@354182 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Transforms/Scalar/EarlyCSE.cpp | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/lib/Transforms/Scalar/EarlyCSE.cpp b/lib/Transforms/Scalar/EarlyCSE.cpp index bec84ae1057..bc6c60cf314 100644 --- a/lib/Transforms/Scalar/EarlyCSE.cpp +++ b/lib/Transforms/Scalar/EarlyCSE.cpp @@ -75,6 +75,11 @@ STATISTIC(NumDSE, "Number of trivial dead stores removed"); DEBUG_COUNTER(CSECounter, "early-cse", "Controls which instructions are removed"); +static cl::opt EarlyCSEMssaOptCap( + "earlycse-mssa-optimization-cap", cl::init(500), cl::Hidden, + cl::desc("Enable imprecision in EarlyCSE in pathological cases, in exchange " + "for faster compile. Caps the MemorySSA clobbering calls.")); + //===----------------------------------------------------------------------===// // SimpleValue //===----------------------------------------------------------------------===// @@ -418,6 +423,7 @@ public: bool run(); private: + unsigned ClobberCounter = 0; // Almost a POD, but needs to call the constructors for the scoped hash // tables so that a new scope gets pushed on. These are RAII so that the // scope gets popped when the NodeScope is destroyed. @@ -662,8 +668,13 @@ bool EarlyCSE::isSameMemGeneration(unsigned EarlierGeneration, // LaterInst, if LaterDef dominates EarlierInst then it can't occur between // EarlierInst and LaterInst and neither can any other write that potentially // clobbers LaterInst. - MemoryAccess *LaterDef = - MSSA->getWalker()->getClobberingMemoryAccess(LaterInst); + MemoryAccess *LaterDef; + if (ClobberCounter < EarlyCSEMssaOptCap) { + LaterDef = MSSA->getWalker()->getClobberingMemoryAccess(LaterInst); + ClobberCounter++; + } else + LaterDef = LaterMA->getDefiningAccess(); + return MSSA->dominates(LaterDef, EarlierMA); } -- 2.11.0