[llvm-mca] Turn InstructionTables into a Stage.

[mattd]

Summary

This patch converts the InstructionTables class into a subclass of mca::Stage. This change allows us to use the Stage's inherited Listeners for event notifications. This also allows us to create a simple pipeline for viewing the InstructionTables report.

I have been working on a follow on patch that should cleanup addView in InstructionTables. Right now, addView adds the view to both the Listener list and Views list. The follow-on patch addresses the fact that we don't really need two lists in this case. That change is not specific to just InstructionTables, so it will be a separate patch.

[mattd]

tools/llvm-mca/InstructionTables.h

40 ↗

(On Diff #155529)

I'm working on a follow on patch to clean this addListener call up.

tools/llvm-mca/llvm-mca.cpp

507 ↗

(On Diff #155529)

A follow on patch will clean this printReport up.

[mattd]

tools/llvm-mca/llvm-mca.cpp

507 ↗

(On Diff #155529)

It doesn't look like the follow-on patch will clean this line up.

[andreadb]

Hi Matt,

Thanks for working on this.
There are a couple of changes that I don't quite understand. Unless I am missing something, I think the patch could have been a lot simpler. See my comments below.

Thanks,
-Andrea

tools/llvm-mca/InstructionTables.cpp

35–58 ↗

(On Diff #155529)

We don't tend to add const to local variables with primitive types. Although, technically it is not wrong, it needlessly increases the level of verbosity for no good reason (no value in return).
In several parts of LLVM, const is mainly associated with reference/pointer types, mainly to avoid that non-const methods are called on them, and to emphasize that data is not changed through those pointers.

In this particular case, adding const doesn't make things better imho. I also don't want that we end up doing similar changes to other files of this project. Since this change is not really needed to fix the issue with the patch, I suggest to remove it if you don't mind.

tools/llvm-mca/InstructionTables.h

32 ↗

(On Diff #155529)

This is not needed.

40 ↗

(On Diff #155529)

Hang on.
You shouldn't have this method at all! Just use a PipelinePrinter to generate the report.

tools/llvm-mca/llvm-mca.cpp

493–507 ↗

(On Diff #155529)

Unless I am missing something, I think you should simply use a PipelinePrinter. I don't think that any follow-on patch is actually needed here. If you use a PipelinePrinter, then it becomes the owner of all the views.

494–499 ↗

(On Diff #155529)

Why this? You should be able to use a PipelinePrinter, and add View objects directly to the printer.
The printer would then subscribe views to each stage of the pipeline.

[mattd]

• Removed some constified locals (my style/habit)
• Yanked out the original Printer functionality from InstructionTables, and use the PipelinePrinter instead.

[mattd]

tools/llvm-mca/InstructionTables.cpp

35–58 ↗

(On Diff #155529)

Fair point. I tend to do this as part of my personal style, indicating that a value will not change, implying that there's no need to hunt down any writes to the variable later on. But your point is clear, I'll undo it.

tools/llvm-mca/InstructionTables.h

40 ↗

(On Diff #155529)

I didn't consider a PipelinePrinter, I kept the InstructionTables close to its original structure with its original Printer-like representation (addView/printReport/Views). PipelinePrinter will remove the need for those bits, sorry for that.

Note that InstructionTables is now a Stage, with listeners. We will still need to associate the events generated by the stage to the views. This means we will need to make a call to addListener to IT. If we don't do this, then the resource pressure view will not get any data.

[mattd]

• Move the adding of stages to the pipeline earlier, so that they automatically register view-listeners when views are added to the printer.

[mattd]

tools/llvm-mca/InstructionTables.h

40 ↗

(On Diff #155529)

The code now relies on the addView in Pipeline to register the views to the pipeline's stages. PipelinePrinter is definitely the way to go here, thanks for the suggestion.

[andreadb]

Nice!

LGTM.

Thanks for working on this!

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

 //===--------------------- InstructionTables.h ------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
-/// This file implements a custom driver to generate instruction tables.
+/// This file implements a custom stage to generate instruction tables.
 /// See the description of command-line flag -instruction-tables in
 /// docs/CommandGuide/lvm-mca.rst
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_INSTRUCTIONTABLES_H
 #define LLVM_TOOLS_LLVM_MCA_INSTRUCTIONTABLES_H
 
-#include "View.h"
 #include "InstrBuilder.h"
-#include "SourceMgr.h"
+#include "Scheduler.h"
+#include "Stage.h"
+#include "View.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSchedule.h"
 
 namespace mca {
 
-class InstructionTables {
+class InstructionTables : public Stage {
   const llvm::MCSchedModel &SM;
   InstrBuilder &IB;
-  SourceMgr &S;
-  llvm::SmallVector<std::unique_ptr<View>, 8> Views;
+  llvm::SmallVector<std::pair<ResourceRef, double>, 4> UsedResources;
 
 public:
-  InstructionTables(const llvm::MCSchedModel &Model, InstrBuilder &Builder,
-                    SourceMgr &Source)
-      : SM(Model), IB(Builder), S(Source) {}
-
-  void addView(std::unique_ptr<View> V) {
-    Views.emplace_back(std::move(V));
-  }
-
-  void run();
-  
-  void printReport(llvm::raw_ostream &OS) const;
+  InstructionTables(const llvm::MCSchedModel &Model, InstrBuilder &Builder)
+      : Stage(), SM(Model), IB(Builder) {}
+  bool hasWorkToComplete() const override final { return false; }
+  bool execute(InstRef &IR) override final;
 };
 } // namespace mca
 
 #endif

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

 //===--------------------- InstructionTables.cpp ----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
-/// This file implements method InstructionTables::run().
-/// Method run() prints a theoretical resource pressure distribution based on
-/// the information available in the scheduling model, and without running
+/// This file implements the method InstructionTables::execute().
+/// Method execute() prints a theoretical resource pressure distribution based
+/// on the information available in the scheduling model, and without running
 /// the pipeline.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "InstructionTables.h"
 
 namespace mca {
 
 using namespace llvm;
 
-using ResourceRef = std::pair<uint64_t, uint64_t>;
-
-void InstructionTables::run() {
+bool InstructionTables::execute(InstRef &IR) {
   ArrayRef<uint64_t> Masks = IB.getProcResourceMasks();
-  SmallVector<std::pair<ResourceRef, double>, 4> UsedResources;
-
-  // Create an instruction descriptor for every instruction in the sequence.
-  while (S.hasNext()) {
-    UsedResources.clear();
-    SourceRef SR = S.peekNext();
-    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));
-      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));
-        }
-        continue;
-      }
+  const InstrDesc &Desc = IR.getInstruction()->getDesc();
+
+  // Identify the resources consumed by this instruction.
+    // Skip zero-cycle resources (i.e., unused resources).
 
-      // This is a group. Obtain the set of resources contained in this
-      // group. Some of these resources may implement multiple units.
-      // Uniformly distribute Cycles across all of the units.
-      for (unsigned I1 = 0; I1 < NumUnits; ++I1) {
-        unsigned SubUnitIdx = ProcResource.SubUnitsIdxBegin[I1];
-        const MCProcResourceDesc &SubUnit = *SM.getProcResource(SubUnitIdx);
-        // Compute the number of cycles consumed by each resource unit.
-        double RUCycles = Cycles / (NumUnits * SubUnit.NumUnits);
-        for (unsigned I2 = 0, E2 = SubUnit.NumUnits; I2 < E2; ++I2) {
-          ResourceRef ResourceUnit = std::make_pair(SubUnitIdx, 1U << I2);
-          UsedResources.emplace_back(std::make_pair(ResourceUnit, RUCycles));
-        }
-      }
-    }
 
-    // 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->onEvent(Event);
-    S.updateNext();
-  }
-}
-
-void InstructionTables::printReport(llvm::raw_ostream &OS) const {
-  for (const std::unique_ptr<View> &V : Views)
-    V->printView(OS);
+  // Send a fake instruction issued event to all the views.
+  notifyEvent<HWInstructionIssuedEvent>(Event);
+  return true;
 }
 
 } // namespace mca

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

 //===--------------------- PipelinePrinter.cpp ------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file implements the PipelinePrinter interface.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "PipelinePrinter.h"
 #include "View.h"
-#include "llvm/CodeGen/TargetSchedule.h"
 
 namespace mca {
 
 using namespace llvm;
 
 void PipelinePrinter::printReport(llvm::raw_ostream &OS) const {
   for (const auto &V : Views)
     V->printView(OS);
 }
 } // namespace mca.

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

 // The cpu defaults to the 'native' host cpu.
 // The output defaults to standard output.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeRegion.h"
 #include "Context.h"
 #include "DispatchStatistics.h"
+#include "FetchStage.h"
 #include "InstructionInfoView.h"
 #include "InstructionTables.h"
 #include "Pipeline.h"
 #include "PipelinePrinter.h"
 #include "RegisterFileStatistics.h"
 #include "ResourcePressureView.h"
 #include "RetireControlUnitStatistics.h"
 #include "SchedulerStatistics.h"
if (Region->startLoc().isValid() || Region->endLoc().isValid()) {
         TOF->os() << " - " << Desc;
       TOF->os() << "\n\n";
     }
 
     mca::SourceMgr S(Region->getInstructions(),
                      PrintInstructionTables ? 1 : Iterations);
 
     if (PrintInstructionTables) {
-      mca::InstructionTables IT(SM, IB, S);
+      //  Create a pipeline, stages, and a printer.
+      auto P = llvm::make_unique<mca::Pipeline>();
+      P->appendStage(llvm::make_unique<mca::FetchStage>(IB, S));
+      P->appendStage(llvm::make_unique<mca::InstructionTables>(SM, IB));
+      mca::PipelinePrinter Printer(*P);
 
+      // Create the views for this pipeline, execute, and emit a report.
       if (PrintInstructionInfoView) {
-        IT.addView(
+        Printer.addView(
             llvm::make_unique<mca::InstructionInfoView>(*STI, *MCII, S, *IP));
       }
-
-      IT.addView(llvm::make_unique<mca::ResourcePressureView>(*STI, *IP, S));
-      IT.run();
-      IT.printReport(TOF->os());
+      Printer.addView(
+          llvm::make_unique<mca::ResourcePressureView>(*STI, *IP, S));
+      P->run();
+      Printer.printReport(TOF->os());
       continue;
     }
 
     // Create a basic pipeline simulating an out-of-order backend.
     auto P = MCA.createDefaultPipeline(PO, IB, S);
     mca::PipelinePrinter Printer(*P);
 
     if (PrintSummaryView)