[llvm-mca] Simplify eventing by adding an onEvent templated method.

[mattd]

Summary

This patch eliminates some redundancy in iterating across Listeners for the
Instruction and Stall HWEvents, by introducing a template onEvent routine.
This change was suggested by @courbet in https://reviews.llvm.org/D48576. I
hope that this patch addresses that suggestion appropriately. I do like this
change better than what we had previously.

[courbet]

Thanks !

tools/llvm-mca/Stage.h

59 ↗

(On Diff #153174)

This can now be const.

[andreadb]

Sorry. I completely forgot about this patch.

I like this approach (thanks @courbet for suggesting it!).

LGTM too.

llvm/trunk/tools/llvm-mca/DispatchStage.h

class DispatchStage : public Stage {
   Scheduler ≻
 
   bool checkRCU(const InstRef &IR);
   bool checkPRF(const InstRef &IR);
   bool checkScheduler(const InstRef &IR);
   void dispatch(InstRef IR);
   void updateRAWDependencies(ReadState &RS, const llvm::MCSubtargetInfo &STI);
 
-  void notifyStallEvent(const HWStallEvent &Event);
   void notifyInstructionDispatched(const InstRef &IR,
                                    llvm::ArrayRef<unsigned> UsedPhysRegs);
 
   bool isAvailable(unsigned NumEntries) const {
     return NumEntries <= AvailableEntries || AvailableEntries == DispatchWidth;
   }
 
   bool canDispatch(const InstRef &IR) {

llvm/trunk/tools/llvm-mca/DispatchStage.cpp

 
 #define DEBUG_TYPE "llvm-mca"
 
 namespace mca {
 
 void DispatchStage::notifyInstructionDispatched(const InstRef &IR,
                                                 ArrayRef<unsigned> UsedRegs) {
   LLVM_DEBUG(dbgs() << "[E] Instruction Dispatched: " << IR << '\n');
-  notifyInstructionEvent(HWInstructionDispatchedEvent(IR, UsedRegs));
-}
-
-void DispatchStage::notifyStallEvent(const HWStallEvent &Event) {
-  for (HWEventListener *Listener : getListeners())
-    Listener->onStallEvent(Event);
+  notifyEvent<HWInstructionEvent>(HWInstructionDispatchedEvent(IR, UsedRegs));
 }
 
 bool DispatchStage::checkPRF(const InstRef &IR) {
   SmallVector<unsigned, 4> RegDefs;
   for (const std::unique_ptr<WriteState> &RegDef :
        IR.getInstruction()->getDefs())
     RegDefs.emplace_back(RegDef->getRegisterID());
 
   const unsigned RegisterMask = PRF.isAvailable(RegDefs);
   // A mask with all zeroes means: register files are available.
   if (RegisterMask) {
-    notifyStallEvent(HWStallEvent(HWStallEvent::RegisterFileStall, IR));
+    notifyEvent<HWStallEvent>(
+        HWStallEvent(HWStallEvent::RegisterFileStall, IR));
     return false;
   }
 
   return true;
 }
 
 bool DispatchStage::checkRCU(const InstRef &IR) {
   const unsigned NumMicroOps = IR.getInstruction()->getDesc().NumMicroOps;
   if (RCU.isAvailable(NumMicroOps))
     return true;
-  notifyStallEvent(HWStallEvent(HWStallEvent::RetireControlUnitStall, IR));
+  notifyEvent<HWStallEvent>(
+      HWStallEvent(HWStallEvent::RetireControlUnitStall, IR));
   return false;
 }
 
 bool DispatchStage::checkScheduler(const InstRef &IR) {
   HWStallEvent::GenericEventType Event;
   const bool Ready = SC.canBeDispatched(IR, Event);
   if (!Ready)
-    notifyStallEvent(HWStallEvent(Event, IR));
+    notifyEvent<HWStallEvent>(HWStallEvent(Event, IR));
   return Ready;
 }
 
 void DispatchStage::updateRAWDependencies(ReadState &RS,
                                           const MCSubtargetInfo &STI) {
   SmallVector<WriteRef, 4> DependentWrites;
 
   collectWrites(DependentWrites, RS.getRegisterID());

llvm/trunk/tools/llvm-mca/DispatchStatistics.h

class DispatchStatistics : public View {
 
   void printDispatchStalls(llvm::raw_ostream &OS) const;
 
 public:
   DispatchStatistics()
       : NumDispatched(0), NumCycles(0),
         HWStalls(HWStallEvent::LastGenericEvent) {}
 
-  void onInstructionEvent(const HWInstructionEvent &Event) override;
+  void onEvent(const HWStallEvent &Event) override;
+
+  void onEvent(const HWInstructionEvent &Event) override;
 
   void onCycleBegin() override { NumCycles++; }
 
   void onCycleEnd() override { updateHistograms(); }
 
-  void onStallEvent(const HWStallEvent &Event) override;
-
   void printView(llvm::raw_ostream &OS) const override {
     printDispatchStalls(OS);
     printDispatchHistogram(OS);
   }
 };
 } // namespace mca
 
 #endif

llvm/trunk/tools/llvm-mca/DispatchStatistics.cpp

 
 #include "DispatchStatistics.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 
 namespace mca {
 
-void DispatchStatistics::onStallEvent(const HWStallEvent &Event) {
+void DispatchStatistics::onEvent(const HWStallEvent &Event) {
   if (Event.Type < HWStallEvent::LastGenericEvent)
     HWStalls[Event.Type]++;
 }
 
-void DispatchStatistics::onInstructionEvent(const HWInstructionEvent &Event) {
+void DispatchStatistics::onEvent(const HWInstructionEvent &Event) {
   if (Event.Type == HWInstructionEvent::Dispatched)
     ++NumDispatched;
 }
 
 void DispatchStatistics::printDispatchHistogram(llvm::raw_ostream &OS) const {
   std::string Buffer;
   raw_string_ostream TempStream(Buffer);
   TempStream << "\n\nDispatch Logic - "

llvm/trunk/tools/llvm-mca/ExecuteStage.cpp

if (IR.getInstruction()->isExecuted())
     notifyInstructionExecuted(IR);
 
   return true;
 }
 
 void ExecuteStage::notifyInstructionExecuted(const InstRef &IR) {
   HWS.onInstructionExecuted(IR);
   LLVM_DEBUG(dbgs() << "[E] Instruction Executed: " << IR << '\n');
-  notifyInstructionEvent(HWInstructionEvent(HWInstructionEvent::Executed, IR));
+  notifyEvent<HWInstructionEvent>(
+      HWInstructionEvent(HWInstructionEvent::Executed, IR));
   RCU.onInstructionExecuted(IR.getInstruction()->getRCUTokenID());
 }
 
 void ExecuteStage::notifyInstructionReady(const InstRef &IR) {
   LLVM_DEBUG(dbgs() << "[E] Instruction Ready: " << IR << '\n');
-  notifyInstructionEvent(HWInstructionEvent(HWInstructionEvent::Ready, IR));
+  notifyEvent<HWInstructionEvent>(
+      HWInstructionEvent(HWInstructionEvent::Ready, IR));
 }
 
 void ExecuteStage::notifyResourceAvailable(const ResourceRef &RR) {
   LLVM_DEBUG(dbgs() << "[E] Resource Available: [" << RR.first << '.'
                     << RR.second << "]\n");
   for (HWEventListener *Listener : getListeners())
     Listener->onResourceAvailable(RR);
 }
 
 void ExecuteStage::notifyInstructionIssued(
     const InstRef &IR, ArrayRef<std::pair<ResourceRef, double>> Used) {
   LLVM_DEBUG({
     dbgs() << "[E] Instruction Issued: " << IR << '\n';
     for (const std::pair<ResourceRef, unsigned> &Resource : Used) {
       dbgs() << "[E] Resource Used: [" << Resource.first.first << '.'
              << Resource.first.second << "]\n";
       dbgs() << "           cycles: " << Resource.second << '\n';
     }
   });
-  notifyInstructionEvent(HWInstructionIssuedEvent(IR, Used));
+  notifyEvent<HWInstructionEvent>(HWInstructionIssuedEvent(IR, Used));
 }
 
 void ExecuteStage::notifyReservedBuffers(ArrayRef<uint64_t> Buffers) {
   if (Buffers.empty())
     return;
 
   SmallVector<unsigned, 4> BufferIDs(Buffers.begin(), Buffers.end());
   std::transform(Buffers.begin(), Buffers.end(), BufferIDs.begin(),

llvm/trunk/tools/llvm-mca/HWEventListener.h

 };
 
 class HWEventListener {
 public:
   // Generic events generated by the pipeline.
   virtual void onCycleBegin() {}
   virtual void onCycleEnd() {}
 
-  virtual void onInstructionEvent(const HWInstructionEvent &Event) {}
-  virtual void onStallEvent(const HWStallEvent &Event) {}
+  virtual void onEvent(const HWInstructionEvent &Event) {}
+  virtual void onEvent(const HWStallEvent &Event) {}
 
   using ResourceRef = std::pair<uint64_t, uint64_t>;
   virtual void onResourceAvailable(const ResourceRef &RRef) {}
 
   // Events generated by the Scheduler when buffered resources are
   // consumed/freed.
   virtual void onReservedBuffers(llvm::ArrayRef<unsigned> Buffers) {}
   virtual void onReleasedBuffers(llvm::ArrayRef<unsigned> Buffers) {}

llvm/trunk/tools/llvm-mca/InstructionTables.cpp

while (S.hasNext()) {
     std::unique_ptr<Instruction> Inst = IB.createInstruction(*SR.second);
     const InstrDesc &Desc = Inst->getDesc();
     // Now identify the resources consumed by this instruction.
     for (const std::pair<uint64_t, ResourceUsage> Resource : Desc.Resources) {
       // Skip zero-cycle resources (i.e. unused resources).
       if (!Resource.second.size())
         continue;
       double Cycles = static_cast<double>(Resource.second.size());
-      unsigned Index =
-          std::distance(Masks.begin(), std::find(Masks.begin(), Masks.end(),
-                                                 Resource.first));
+      unsigned Index = std::distance(
+          Masks.begin(), std::find(Masks.begin(), Masks.end(), Resource.first));
       const MCProcResourceDesc &ProcResource = *SM.getProcResource(Index);
       unsigned NumUnits = ProcResource.NumUnits;
       if (!ProcResource.SubUnitsIdxBegin) {
         // The number of cycles consumed by each unit.
         Cycles /= NumUnits;
         for (unsigned I = 0, E = NumUnits; I < E; ++I) {
           ResourceRef ResourceUnit = std::make_pair(Index, 1U << I);
           UsedResources.emplace_back(std::make_pair(ResourceUnit, Cycles));
for (const std::pair<uint64_t, ResourceUsage> Resource : Desc.Resources) {
         }
       }
     }
 
     // Now send a fake instruction issued event to all the views.
     InstRef IR(SR.first, Inst.get());
     HWInstructionIssuedEvent Event(IR, UsedResources);
     for (std::unique_ptr<View> &Listener : Views)
-      Listener->onInstructionEvent(Event);
+      Listener->onEvent(Event);
     S.updateNext();
   }
 }
 
 void InstructionTables::printReport(llvm::raw_ostream &OS) const {
   for (const std::unique_ptr<View> &V : Views)
     V->printView(OS);
 }
 
 } // namespace mca

llvm/trunk/tools/llvm-mca/RegisterFileStatistics.h

class RegisterFileStatistics : public View {
 
   void initializeRegisterFileInfo();
 
 public:
   RegisterFileStatistics(const llvm::MCSubtargetInfo &sti) : STI(sti) {
     initializeRegisterFileInfo();
   }
 
-  void onInstructionEvent(const HWInstructionEvent &Event) override;
+  void onEvent(const HWInstructionEvent &Event) override;
 
   void printView(llvm::raw_ostream &OS) const override;
 };
 } // namespace mca
 
 #endif

llvm/trunk/tools/llvm-mca/RegisterFileStatistics.cpp

void RegisterFileStatistics::initializeRegisterFileInfo() {
   // There is always an "InvalidRegisterFile" entry in tablegen. That entry can
   // be skipped. If there are no user defined register files, then reserve a
   // single entry for the default register file at index #0.
   unsigned NumRegFiles = std::max(PI.NumRegisterFiles, 1U);
   RegisterFiles.resize(NumRegFiles);
   std::fill(RegisterFiles.begin(), RegisterFiles.end(), Empty);
 }
 
-void RegisterFileStatistics::onInstructionEvent(
-    const HWInstructionEvent &Event) {
+void RegisterFileStatistics::onEvent(const HWInstructionEvent &Event) {
   switch (Event.Type) {
   default:
     break;
   case HWInstructionEvent::Retired: {
     const auto &RE = static_cast<const HWInstructionRetiredEvent &>(Event);
     for (unsigned I = 0, E = RegisterFiles.size(); I < E; ++I)
       RegisterFiles[I].CurrentlyUsedMappings -= RE.FreedPhysRegs[I];
     break;

llvm/trunk/tools/llvm-mca/ResourcePressureView.h

 
 public:
   ResourcePressureView(const llvm::MCSubtargetInfo &sti,
                        llvm::MCInstPrinter &Printer, const SourceMgr &SM)
       : STI(sti), MCIP(Printer), Source(SM) {
     initialize();
   }
 
-  void onInstructionEvent(const HWInstructionEvent &Event) override;
+  void onEvent(const HWInstructionEvent &Event) override;
 
   void printView(llvm::raw_ostream &OS) const override {
     unsigned Executions = Source.getNumIterations();
     printResourcePressurePerIteration(OS, Executions);
     printResourcePressurePerInstruction(OS, Executions);
   }
 };
 } // namespace mca
 
 #endif

llvm/trunk/tools/llvm-mca/ResourcePressureView.cpp

for (unsigned I = 0, E = SM.getNumProcResourceKinds(); I < E; ++I) {
     R2VIndex += ProcResource.NumUnits;
   }
 
   NumResourceUnits = R2VIndex;
   ResourceUsage.resize(NumResourceUnits * (Source.size() + 1));
   std::fill(ResourceUsage.begin(), ResourceUsage.end(), 0.0);
 }
 
-void ResourcePressureView::onInstructionEvent(const HWInstructionEvent &Event) {
+void ResourcePressureView::onEvent(const HWInstructionEvent &Event) {
   // We're only interested in Issue events.
   if (Event.Type != HWInstructionEvent::Issued)
     return;
   const auto &IssueEvent = static_cast<const HWInstructionIssuedEvent &>(Event);
   const unsigned SourceIdx = Event.IR.getSourceIndex() % Source.size();
   for (const std::pair<ResourceRef, double> &Use : IssueEvent.UsedResources) {
     const ResourceRef &RR = Use.first;
     assert(Resource2VecIndex.find(RR.first) != Resource2VecIndex.end());

llvm/trunk/tools/llvm-mca/RetireControlUnitStatistics.h

class RetireControlUnitStatistics : public View {
   void updateHistograms() {
     RetiredPerCycle[NumRetired]++;
     NumRetired = 0;
   }
 
 public:
   RetireControlUnitStatistics() : NumRetired(0), NumCycles(0) {}
 
-  void onInstructionEvent(const HWInstructionEvent &Event) override;
+  void onEvent(const HWInstructionEvent &Event) override;
 
   void onCycleBegin() override { NumCycles++; }
 
   void onCycleEnd() override { updateHistograms(); }
 
   void printView(llvm::raw_ostream &OS) const override;
 };
 } // namespace mca
 
 #endif

llvm/trunk/tools/llvm-mca/RetireControlUnitStatistics.cpp

 
 #include "RetireControlUnitStatistics.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 
 namespace mca {
 
-void RetireControlUnitStatistics::onInstructionEvent(
-    const HWInstructionEvent &Event) {
+void RetireControlUnitStatistics::onEvent(const HWInstructionEvent &Event) {
   if (Event.Type == HWInstructionEvent::Retired)
     ++NumRetired;
 }
 
 void RetireControlUnitStatistics::printView(llvm::raw_ostream &OS) const {
   std::string Buffer;
   raw_string_ostream TempStream(Buffer);
   TempStream << "\n\nRetire Control Unit - "

llvm/trunk/tools/llvm-mca/RetireStage.cpp

 
 void RetireStage::notifyInstructionRetired(const InstRef &IR) {
   LLVM_DEBUG(dbgs() << "[E] Instruction Retired: " << IR << '\n');
   SmallVector<unsigned, 4> FreedRegs(PRF.getNumRegisterFiles());
   const InstrDesc &Desc = IR.getInstruction()->getDesc();
 
   for (const std::unique_ptr<WriteState> &WS : IR.getInstruction()->getDefs())
     PRF.removeRegisterWrite(*WS.get(), FreedRegs, !Desc.isZeroLatency());
-  notifyInstructionEvent(HWInstructionRetiredEvent(IR, FreedRegs));
+  notifyEvent<HWInstructionEvent>(HWInstructionRetiredEvent(IR, FreedRegs));
 }
 
 } // namespace mca

llvm/trunk/tools/llvm-mca/SchedulerStatistics.h

void updateHistograms() {
     NumIssued = 0;
   }
 
   void printSchedulerStatistics(llvm::raw_ostream &OS) const;
   void printSchedulerUsage(llvm::raw_ostream &OS) const;
 
 public:
   SchedulerStatistics(const llvm::MCSubtargetInfo &STI)
-      : SM(STI.getSchedModel()), NumIssued(0), NumCycles(0) { }
+      : SM(STI.getSchedModel()), NumIssued(0), NumCycles(0) {}
 
-  void onInstructionEvent(const HWInstructionEvent &Event) override;
+  void onEvent(const HWInstructionEvent &Event) override;
 
   void onCycleBegin() override { NumCycles++; }
 
   void onCycleEnd() override { updateHistograms(); }
 
   // Increases the number of used scheduler queue slots of every buffered
   // resource in the Buffers set.
   void onReservedBuffers(llvm::ArrayRef<unsigned> Buffers) override;

llvm/trunk/tools/llvm-mca/SchedulerStatistics.cpp

 
 #include "SchedulerStatistics.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 
 namespace mca {
 
-void SchedulerStatistics::onInstructionEvent(const HWInstructionEvent &Event) {
+void SchedulerStatistics::onEvent(const HWInstructionEvent &Event) {
   if (Event.Type == HWInstructionEvent::Issued)
     ++NumIssued;
 }
 
 void SchedulerStatistics::onReservedBuffers(ArrayRef<unsigned> Buffers) {
   for (const unsigned Buffer : Buffers) {
     if (BufferedResources.find(Buffer) != BufferedResources.end()) {
       BufferUsage &BU = BufferedResources[Buffer];

llvm/trunk/tools/llvm-mca/Stage.h

public:
   /// The primary action that this stage performs.
   /// Returning false prevents successor stages from having their 'execute'
   /// routine called.
   virtual bool execute(InstRef &IR) = 0;
 
   /// Add a listener to receive callbacks during the execution of this stage.
   void addListener(HWEventListener *Listener);
 
-  virtual void notifyInstructionEvent(const HWInstructionEvent &Event);
+  /// Notify listeners of a particular hardware event.
+  template <typename EventT> void notifyEvent(const EventT &Event) {
+    for (HWEventListener *Listener : Listeners)
+      Listener->onEvent(Event);
+  }
 };
 
 } // namespace mca
 #endif // LLVM_TOOLS_LLVM_MCA_STAGE_H

llvm/trunk/tools/llvm-mca/Stage.cpp

 
 // Pin the vtable here in the implementation file.
 Stage::Stage() {}
 
 void Stage::addListener(HWEventListener *Listener) {
   Listeners.insert(Listener);
 }
 
-void Stage::notifyInstructionEvent(const HWInstructionEvent &Event) {
-  for (HWEventListener *Listener : Listeners)
-    Listener->onInstructionEvent(Event);
-}
-
 } // namespace mca

llvm/trunk/tools/llvm-mca/SummaryView.h

class SummaryView : public View {
   double getBlockRThroughput() const;
 
 public:
   SummaryView(const llvm::MCSchedModel &Model, const SourceMgr &S,
               unsigned Width);
 
   void onCycleEnd() override { ++TotalCycles; }
 
-  void onInstructionEvent(const HWInstructionEvent &Event) override;
+  void onEvent(const HWInstructionEvent &Event) override;
 
   void printView(llvm::raw_ostream &OS) const override;
 };
 } // namespace mca
 
 #endif

llvm/trunk/tools/llvm-mca/SummaryView.cpp

 SummaryView::SummaryView(const llvm::MCSchedModel &Model, const SourceMgr &S,
                          unsigned Width)
     : SM(Model), Source(S), DispatchWidth(Width), TotalCycles(0),
       NumMicroOps(0), ProcResourceUsage(Model.getNumProcResourceKinds(), 0),
       ProcResourceMasks(Model.getNumProcResourceKinds(), 0) {
   computeProcResourceMasks(SM, ProcResourceMasks);
 }
 
-void SummaryView::onInstructionEvent(const HWInstructionEvent &Event) {
+void SummaryView::onEvent(const HWInstructionEvent &Event) {
   // We are only interested in the "instruction dispatched" events generated by
   // the dispatch stage for instructions that are part of iteration #0.
   if (Event.Type != HWInstructionEvent::Dispatched)
     return;
 
   if (Event.IR.getSourceIndex() >= Source.size())
     return;
 

llvm/trunk/tools/llvm-mca/TimelineView.h

TimelineView(const llvm::MCSubtargetInfo &sti, llvm::MCInstPrinter &Printer,
                unsigned Cycles)
       : STI(sti), MCIP(Printer), AsmSequence(Sequence), CurrentCycle(0),
         MaxCycle(Cycles == 0 ? 80 : Cycles), LastCycle(0) {
     initialize(MaxIterations);
   }
 
   // Event handlers.
   void onCycleEnd() override { ++CurrentCycle; }
-  void onInstructionEvent(const HWInstructionEvent &Event) override;
+  void onEvent(const HWInstructionEvent &Event) override;
 
   // print functionalities.
   void printTimeline(llvm::raw_ostream &OS) const;
   void printAverageWaitTimes(llvm::raw_ostream &OS) const;
   void printView(llvm::raw_ostream &OS) const override {
     printTimeline(OS);
     printAverageWaitTimes(OS);
   }
 };
 } // namespace mca
 
 #endif

llvm/trunk/tools/llvm-mca/TimelineView.cpp

void TimelineView::initialize(unsigned MaxIterations) {
   TimelineViewEntry NullTVEntry = {0, 0, 0, 0, 0};
   std::fill(Timeline.begin(), Timeline.end(), NullTVEntry);
 
   WaitTime.resize(AsmSequence.size());
   WaitTimeEntry NullWTEntry = {0, 0, 0, 0};
   std::fill(WaitTime.begin(), WaitTime.end(), NullWTEntry);
 }
 
-void TimelineView::onInstructionEvent(const HWInstructionEvent &Event) {
+void TimelineView::onEvent(const HWInstructionEvent &Event) {
   const unsigned Index = Event.IR.getSourceIndex();
   if (CurrentCycle >= MaxCycle || Index >= Timeline.size())
     return;
   switch (Event.Type) {
   case HWInstructionEvent::Retired: {
     TimelineViewEntry &TVEntry = Timeline[Index];
     TVEntry.CycleRetired = CurrentCycle;