Partial Executer: Early bailout for a basic block if we stop learning

Instead of looping until we hit the max visits per basic block, I
implemented a way to keep track of how many new edges or values we've discovered
while visiting each SCC. We will always get to a point, especially in self-loops
were we stop knowing anything new. If that is the case I keep track of how many
iterations have passed without knowning any new values. When the iterations without
progress reach the check for staleness, we mark this SCC as reachable and move on
with the rests.

If a child of the parent is stale, with this solution, we just exit that child earlier
but the rest of the parent's children will still be visited.

Author: Andres Madrid Ucha

llvm/lib/CheerpWriter/PartialExecuter.cpp

@@ -69,6 +69,7 @@ typedef llvm::DenseSet<std::pair<GlobalVariable*, uint32_t> > NewAlignmentData;
 namespace cheerp {
 
 const uint32_t MAX_NUMBER_OF_VISITS_PER_BB = 100u;
+const uint32_t CHECK_STALE_FREQUENCY = 10u;
 
 class FunctionData;
 class ModuleData;
@@ -882,11 +883,13 @@ class FunctionData
 		{
 		}
 	};
+
 	llvm::Function& F;
 	std::vector<std::pair<llvm::BasicBlock*, llvm::BasicBlock*>> existingEdges;
 	typedef std::vector<Value*> VectorOfArgs;
 
 	llvm::DenseMap<const llvm::BasicBlock*, int> visitCounter;
+	llvm::DenseMap<const llvm::BasicBlock*, int> iterationsWithoutProgress;
 	llvm::DenseSet<std::pair<const llvm::BasicBlock*, const llvm::BasicBlock*> > visitedEdges;
 	llvm::DenseMap<llvm::Instruction*, KnownValue> knownValues;
 	ModuleData& moduleData;
@@ -966,15 +969,30 @@ class FunctionData
 		currentEE->addAlignmentRequirement(moduleData.alignmentToBeBumped);
 
 	}
+	
 public:
 	explicit FunctionData(llvm::Function& F, ModuleData& moduleData)
 		: F(F), moduleData(moduleData), currentEE(nullptr)
 	{
 	}
+	size_t countReplaceableInstructions() const 
+	{
+		size_t count = 0;
+		for (const auto& kv: knownValues) {
+			if (!kv.second.everSkipped)
+				count++;
+		}
+		return count;
+	}
+	size_t countVisitedEdges() const 
+	{
+		return visitedEdges.size();
+	}
 	llvm::Function* getFunction()
 	{
 		return &F;
 	}
+	
 	uint32_t getVisitCounter(const llvm::BasicBlock* BB)
 	{
 		return visitCounter[BB];
@@ -983,6 +1001,18 @@ class FunctionData
 	{
 		visitCounter[BB]++;
 	}
+	uint32_t getIterationsWithoutProgress(const llvm::BasicBlock* BB)
+	{
+		return iterationsWithoutProgress[BB];
+	}
+	void incrementIterationsWithoutProgress(const llvm::BasicBlock* BB)
+	{
+		iterationsWithoutProgress[BB]++;
+	}
+	void resetIterationsWithoutProgress(const llvm::BasicBlock* BB)
+	{
+		iterationsWithoutProgress[BB] = 0;
+	}
 	PartialInterpreter& getInterpreter()
 	{
 		// currentEE will be non-null while visiting a Call Equivalent
@@ -1114,6 +1144,7 @@ class FunctionData
 		for (const FunctionData::VectorOfArgs& toBeVisited : callEquivalentQueue)
 		{
 			visitCounter.clear();
+			iterationsWithoutProgress.clear();
 			visitCallEquivalent(toBeVisited);
 		}
 	}
@@ -1373,6 +1404,8 @@ class BasicBlockGroupNode
 	llvm::BasicBlock* start;
 	llvm::BasicBlock* from;
 	uint32_t currIter;
+	size_t prevValues;
+	size_t prevEdges;
 	llvm::DenseMap<llvm::BasicBlock*, uint32_t> minVisitIndex;
 	// TODO(carlo): an optmization might be having from be a set<BasicBlock>, conserving the phi that are equals
 
@@ -1395,9 +1428,28 @@ class BasicBlockGroupNode
 		return set;
 	}
 	void splitIntoSCCs(std::list<BasicBlockGroupNode>& queueToBePopulated, ReverseMapBBToGroup& blockToGroupMap);
+	
+	bool hasProgressed(size_t currValues, size_t currEdges)
+	{
+		if (currValues > prevValues || currEdges > prevEdges)
+		{
+			prevValues = currValues;
+			prevEdges = currEdges;
+			data.resetIterationsWithoutProgress(start);
+			return true;
+		}
+		data.incrementIterationsWithoutProgress(start);
+		return false;
+	}
+	bool hasStaled() const 
+	{
+		return data.getIterationsWithoutProgress(start) >= CHECK_STALE_FREQUENCY;
+	}
+
 public:
 	BasicBlockGroupNode(FunctionData& data, BasicBlockGroupNode* parentBBGNode, const DeterministicBBSet& OWNEDblocks, llvm::BasicBlock* start = nullptr)
-		: parentNode(parentBBGNode), data(data), ownedBlocks(OWNEDblocks), blocks(ownedBlocks), isMultiHead(false), isReachable(parentNode == nullptr), start(start), from(nullptr), visitingAll(false)
+		: parentNode(parentBBGNode), data(data), ownedBlocks(OWNEDblocks), blocks(ownedBlocks), isMultiHead(false), isReachable(parentNode == nullptr), start(start), from(nullptr), visitingAll(false), 
+		prevValues(data.countReplaceableInstructions()), prevEdges(data.countVisitedEdges())
 	{
 		if (start)
 			assert(start->getParent() == data.getFunction());
@@ -1407,9 +1459,11 @@ class BasicBlockGroupNode
 	{
 	}
 	BasicBlockGroupNode(BasicBlockGroupNode& BBGNode)
-		: parentNode(&BBGNode), data(BBGNode.data), blocks(BBGNode.blocks), isMultiHead(false), isReachable(false), start(nullptr), from(nullptr), visitingAll(false)
+		: parentNode(&BBGNode), data(BBGNode.data), blocks(BBGNode.blocks), isMultiHead(false), isReachable(false), start(nullptr), from(nullptr), visitingAll(false), 
+		prevValues(data.countReplaceableInstructions()), prevEdges(data.countVisitedEdges())
 	{
 	}
+
 	void addIncomingEdge(llvm::BasicBlock* comingFrom, uint32_t currIter, llvm::BasicBlock* target)
 	{
 		isReachable = true;
@@ -1550,15 +1604,31 @@ class BasicBlockGroupNode
 			}
 		}
 		data.incrementVisitCounter(start);
-
+		
 		splitIntoSCCs(childrenNodes, reverseMappingBBToGroup);	//These should be partially ordered with the last one possibly being the replica of the current one
-
+		
 		llvm::SmallVector<llvm::BasicBlock*, 4> visitNext;
-
+		
 		// Do the actual visit for start, while populating visitNext
 		runVisitBasicBlock(data, *start, visitNext);
 		for (llvm::BasicBlock* succ : visitNext)
 			registerEdge(start, succ);
+		
+		
+		if (currIter > 0)
+		{
+			size_t currentGlobalValues = data.countReplaceableInstructions();
+			size_t currentGlobalEdges = data.countVisitedEdges();
+				
+			if (!hasProgressed(currentGlobalValues, currentGlobalEdges))
+			{
+				if (hasStaled())
+				{
+					visitAll();
+					return;
+				}
+			}
+		}
 
 		// First has been already done
 		childrenNodes.pop_back();