[Analysis] RemoveTotalMemInst counting in InstCount to avoid reading back other Statistic variables

[craig.topper]

Summary

Previously, we counted TotalMemInst by reading certain instruction counters before and after calling visit and then finding the difference. But that wouldn't be thread safe if this same pass was being ran on multiple threads.

This list of "memory instructions" doesn't make sense to me as it includes call/invoke and is missing atomics.

This patch removes the counter all together.

[chandlerc]

lib/Analysis/InstCount.cpp

44–56

This seems... a little crazy.

First off, we don't need to increment TotalInsts here. You can just override visitInstruction and teach this to delegate to the base class after incrementing the opcode specific counter. But maybe that doesn't really matter...

But the whole point of InstVisitor is to avoid these long || chains. =[

And what even is a "memory instruction"? Why is a call a memory instruction even if it is calling an LLVM intrinsic? I know you didn't add any of this, but it seems somewhat crazy to bend over backwards to keep it.

How about just deleting the TotalMemInst statistic entirely until someone comes back with a specific use case?

[craig.topper]

Just remove the TotalMemInst counter

[craig.topper]

Ping

[craig.topper]

Ping * 2

[craig.topper]

Ping * 4

[davide]

I'm with Chandler on this one.

lib/Analysis/InstCount.cpp

 
 namespace {
   class InstCount : public FunctionPass, public InstVisitor<InstCount> {
     friend class InstVisitor<InstCount>;
 
     void visitFunction  (Function &F) { ++TotalFuncs; }
     void visitBasicBlock(BasicBlock &BB) { ++TotalBlocks; }
 
 #define HANDLE_INST(N, OPCODE, CLASS) \
-    void visit##OPCODE(CLASS &) { ++Num##OPCODE##Inst; ++TotalInsts; }
+    void visit##OPCODE(CLASS &) { \
+      ++Num##OPCODE##Inst; ++TotalInsts; \
+      if (N == Instruction::GetElementPtr || \
+          N == Instruction::Load || \
+          N == Instruction::Store || \
+          N == Instruction::Call || \
+          N == Instruction::Invoke || \
+          N == Instruction::Alloca) \
+        ++TotalMemInst; \
+    }
 
 #include "llvm/IR/Instruction.def"
 
     void visitInstruction(Instruction &I) {
       errs() << "Instruction Count does not know about " << I;
       llvm_unreachable(nullptr);
     }
   public:
     static char ID; // Pass identification, replacement for typeid
     InstCount() : FunctionPass(ID) {
INITIALIZE_PASS(InstCount, "instcount",
                 "Counts the various types of Instructions", false, true)
 
 FunctionPass *llvm::createInstCountPass() { return new InstCount(); }
 
 // InstCount::run - This is the main Analysis entry point for a
 // function.
 //
 bool InstCount::runOnFunction(Function &F) {
-  unsigned StartMemInsts =
-    NumGetElementPtrInst + NumLoadInst + NumStoreInst + NumCallInst +
-    NumInvokeInst + NumAllocaInst;
   visit(F);
-  unsigned EndMemInsts =
-    NumGetElementPtrInst + NumLoadInst + NumStoreInst + NumCallInst +
-    NumInvokeInst + NumAllocaInst;
-  TotalMemInst += EndMemInsts-StartMemInsts;
   return false;
 }