From cde404af39110f3b1da9e0777c4ac17c01e3ba34 Mon Sep 17 00:00:00 2001 From: Ashutosh Nema Date: Tue, 23 Jan 2018 09:47:28 +0000 Subject: [PATCH] This change add's optimization remark in LoopVersioning LICM pass. Summary: This patch is adding remark messages to the LoopVersioning LICM pass, which will be useful for optimization remark emitter (ORE) infrastructure. Patch by: Deepak Porwal Reviewers: anemet, ashutosh.nema, eastig Subscribers: eastig, vivekvpandya, fhahn, llvm-commits git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@323183 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/DiagnosticInfo.h | 1 + lib/IR/DiagnosticInfo.cpp | 4 ++ lib/Transforms/Scalar/LoopVersioningLICM.cpp | 57 +++++++++++++++++++++++++++- 3 files changed, 60 insertions(+), 2 deletions(-) diff --git a/include/llvm/IR/DiagnosticInfo.h b/include/llvm/IR/DiagnosticInfo.h index 020b67d6b71..bfec2be36c3 100644 --- a/include/llvm/IR/DiagnosticInfo.h +++ b/include/llvm/IR/DiagnosticInfo.h @@ -415,6 +415,7 @@ public: Argument(StringRef Key, const Type *T); Argument(StringRef Key, StringRef S); Argument(StringRef Key, int N); + Argument(StringRef Key, float N); Argument(StringRef Key, long N); Argument(StringRef Key, long long N); Argument(StringRef Key, unsigned N); diff --git a/lib/IR/DiagnosticInfo.cpp b/lib/IR/DiagnosticInfo.cpp index b81d205306b..5ddb1196b07 100644 --- a/lib/IR/DiagnosticInfo.cpp +++ b/lib/IR/DiagnosticInfo.cpp @@ -35,6 +35,7 @@ #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/Regex.h" #include "llvm/Support/raw_ostream.h" +#include "llvm/Support/ScopedPrinter.h" #include #include #include @@ -167,6 +168,9 @@ DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, StringRef S) DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, int N) : Key(Key), Val(itostr(N)) {} +DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, float N) + : Key(Key), Val(llvm::to_string(N)) {} + DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, long N) : Key(Key), Val(itostr(N)) {} diff --git a/lib/Transforms/Scalar/LoopVersioningLICM.cpp b/lib/Transforms/Scalar/LoopVersioningLICM.cpp index 53b25e688e8..aad82a442ae 100644 --- a/lib/Transforms/Scalar/LoopVersioningLICM.cpp +++ b/lib/Transforms/Scalar/LoopVersioningLICM.cpp @@ -68,6 +68,7 @@ #include "llvm/Analysis/LoopAccessAnalysis.h" #include "llvm/Analysis/LoopInfo.h" #include "llvm/Analysis/LoopPass.h" +#include "llvm/Analysis/OptimizationRemarkEmitter.h" #include "llvm/Analysis/ScalarEvolution.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/Constants.h" @@ -166,6 +167,7 @@ struct LoopVersioningLICM : public LoopPass { AU.addRequired(); AU.addPreserved(); AU.addPreserved(); + AU.addRequired(); } StringRef getPassName() const override { return "Loop Versioning for LICM"; } @@ -178,6 +180,7 @@ struct LoopVersioningLICM : public LoopPass { LoadAndStoreCounter = 0; InvariantCounter = 0; IsReadOnlyLoop = true; + ORE = nullptr; CurAST.reset(); } @@ -207,7 +210,7 @@ private: Loop *CurLoop = nullptr; // AliasSet information for the current loop. - std::unique_ptr CurAST; + std::unique_ptr CurAST; // Maximum loop nest threshold unsigned LoopDepthThreshold; @@ -224,6 +227,9 @@ private: // Read only loop marker. bool IsReadOnlyLoop = true; + // OptimizationRemarkEmitter + OptimizationRemarkEmitter *ORE; + bool isLegalForVersioning(); bool legalLoopStructure(); bool legalLoopInstructions(); @@ -403,13 +409,19 @@ bool LoopVersioningLICM::legalLoopInstructions() { LoadAndStoreCounter = 0; InvariantCounter = 0; IsReadOnlyLoop = true; + using namespace ore; // Iterate over loop blocks and instructions of each block and check // instruction safety. for (auto *Block : CurLoop->getBlocks()) for (auto &Inst : *Block) { // If instruction is unsafe just return false. - if (!instructionSafeForVersioning(&Inst)) + if (!instructionSafeForVersioning(&Inst)) { + ORE->emit([&]() { + return OptimizationRemarkMissed(DEBUG_TYPE, "IllegalLoopInst", &Inst) + << " Unsafe Loop Instruction"; + }); return false; + } } // Get LoopAccessInfo from current loop. LAI = &LAA->getInfo(CurLoop); @@ -422,6 +434,15 @@ bool LoopVersioningLICM::legalLoopInstructions() { if (LAI->getNumRuntimePointerChecks() > VectorizerParams::RuntimeMemoryCheckThreshold) { DEBUG(dbgs() << " LAA: Runtime checks are more than threshold !!\n"); + ORE->emit([&]() { + return OptimizationRemarkMissed(DEBUG_TYPE, "RuntimeCheck", + CurLoop->getStartLoc(), + CurLoop->getHeader()) + << "Number of runtime checks " + << NV("RuntimeChecks", LAI->getNumRuntimePointerChecks()) + << " exceeds threshold " + << NV("Threshold", VectorizerParams::RuntimeMemoryCheckThreshold); + }); return false; } // Loop should have at least one invariant load or store instruction. @@ -443,6 +464,16 @@ bool LoopVersioningLICM::legalLoopInstructions() { << ((InvariantCounter * 100) / LoadAndStoreCounter) << "%\n"); DEBUG(dbgs() << " Invariant loads & store threshold: " << InvariantThreshold << "%\n"); + ORE->emit([&]() { + return OptimizationRemarkMissed(DEBUG_TYPE, "InvariantThreshold", + CurLoop->getStartLoc(), + CurLoop->getHeader()) + << "Invariant load & store " + << NV("LoadAndStoreCounter", + ((InvariantCounter * 100) / LoadAndStoreCounter)) + << " are less then defined threshold " + << NV("Threshold", InvariantThreshold); + }); return false; } return true; @@ -464,6 +495,7 @@ bool LoopVersioningLICM::isLoopAlreadyVisited() { /// c) loop memory access legality. /// Return true if legal else returns false. bool LoopVersioningLICM::isLegalForVersioning() { + using namespace ore; DEBUG(dbgs() << "Loop: " << *CurLoop); // Make sure not re-visiting same loop again. if (isLoopAlreadyVisited()) { @@ -475,6 +507,12 @@ bool LoopVersioningLICM::isLegalForVersioning() { if (!legalLoopStructure()) { DEBUG( dbgs() << " Loop structure not suitable for LoopVersioningLICM\n\n"); + ORE->emit([&]() { + return OptimizationRemarkMissed(DEBUG_TYPE, "IllegalLoopStruct", + CurLoop->getStartLoc(), + CurLoop->getHeader()) + << " Unsafe Loop structure"; + }); return false; } // Check loop instruction leagality. @@ -487,10 +525,23 @@ bool LoopVersioningLICM::isLegalForVersioning() { if (!legalLoopMemoryAccesses()) { DEBUG(dbgs() << " Loop memory access not suitable for LoopVersioningLICM\n\n"); + ORE->emit([&]() { + return OptimizationRemarkMissed(DEBUG_TYPE, "IllegalLoopMemoryAccess", + CurLoop->getStartLoc(), + CurLoop->getHeader()) + << " Unsafe Loop memory access"; + }); return false; } // Loop versioning is feasible, return true. DEBUG(dbgs() << " Loop Versioning found to be beneficial\n\n"); + ORE->emit([&]() { + return OptimizationRemark(DEBUG_TYPE, "IsLegalForVersioning", + CurLoop->getStartLoc(), CurLoop->getHeader()) + << " Versioned loop for LICM." + << " Number of runtime checks we had to insert " + << NV("RuntimeChecks", LAI->getNumRuntimePointerChecks()); + }); return true; } @@ -542,6 +593,7 @@ bool LoopVersioningLICM::runOnLoop(Loop *L, LPPassManager &LPM) { AA = &getAnalysis().getAAResults(); SE = &getAnalysis().getSE(); LAA = &getAnalysis(); + ORE = &getAnalysis().getORE(); LAI = nullptr; // Set Current Loop CurLoop = L; @@ -592,6 +644,7 @@ INITIALIZE_PASS_DEPENDENCY(LoopAccessLegacyAnalysis) INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass) INITIALIZE_PASS_DEPENDENCY(LoopSimplify) INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass) +INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass) INITIALIZE_PASS_END(LoopVersioningLICM, "loop-versioning-licm", "Loop Versioning For LICM", false, false) -- 2.11.0