[llvm-mca] Introduce a pipeline Stage class and FetchStage.

[mattd]

Summary

 This is just an idea, really two ideas.  I expect some push-back,
 but I realize that posting a diff is the most comprehensive way to express
 these concepts.

 This patch introduces a Stage class which represents the
 various stages of an instruction pipeline.  As a start, I have created a simple
 FetchStage that is based on existing logic for how MCA produces
 instructions, but now encapsulated in a Stage.  The idea should become more concrete
 once we introduce additional stages.  The idea being, that when a stage completes,
 the next stage in the pipeline will be executed.  Stages are chained together
 as a singly linked list to closely model a real pipeline. For now there is only one stage,
 so the stage-to-stage flow of instructions isn't immediately obvious.

 Eventually, Stage will also handle event notifications, but that functionality
 is not complete, and not destined for this patch.  Ideally, an interested party 
 can register for notifications from a particular stage.  Callbacks will be issued to
 these listeners at various points in the execution of the stage.  
 For now, eventing functionality remains similar to what it has been in mca::Backend. 
 We will be building-up the Stage class as we move on, such as adding debug output.

 This patch also removes the unique_ptr<Instruction> return value from
 InstrBuilder::createInstruction.  An Instruction pointer is still produced,
 but now it's up to the caller to decide how that item should be managed post-allocation
 (e.g., smart pointer).  This allows the Fetch stage to create instructions and
 manage the lifetime of those instructions as it wishes, and not have to be bound to any
 specific managed pointer type.  Other callers of createInstruction might have different 
 requirements, and thus can manage the pointer to fit their needs.  Another idea would be to push the
ownership to the RCU. 

 Currently, the FetchStage will wrap the Instruction
 pointer in a shared_ptr.  This allows us to remove the Instruction container in
 Backend, which was probably going to disappear, or move, at some point anyways.
 Note that I did run these changes through valgrind, to make sure we are not leaking
 memory.  While the shared_ptr comes with some additional overhead it relieves us
 from having to manage a list of generated instructions, and/or make lookup calls
 to remove the instructions. 

 I realize that both the Stage class and the Instruction pointer management
 (mentioned directly above) are separate but related ideas, and probably should
 land as separate patches; I am happy to do that if either idea is decent.
 The main reason these two ideas are together is that
 Stage::execute() can mutate an InstRef. For the fetch stage, the InstRef is populated
 as the primary action of that stage (execute()).  I didn't want to change the Stage interface
 to support the idea of generating an instruction.  Ideally, instructions are to
 be pushed through the pipeline.  I didn't want to draw too much of a
 specialization just for the fetch stage.  Excuse the word-salad.

[mattd]

Store each stage in the pipeline as a unique_ptr. There should only be a single owner of a stage. The initial stage is owned by the backend, and all subsequent stages are owned by their predecessor stage.

[andreadb]

Hi Matt,

Thanks for the patch! See my comments below.

-Andrea

tools/llvm-mca/Backend.cpp

42 ↗

(On Diff #146353)

Remove this assert. By construction, you cannot have a null pointer from the SourceMgr.

tools/llvm-mca/Backend.h

58 ↗

(On Diff #146353)

I would just call it FetchStage for now.

86 ↗

(On Diff #146353)

I would remove this for now.
It is clear that this is never going to be null.

tools/llvm-mca/FetchStage.cpp

1 ↗

(On Diff #146353)

It should be FetchStage.cpp.

tools/llvm-mca/InstrBuilder.cpp

430–433 ↗

(On Diff #146353)

It should return a unique_ptr.

tools/llvm-mca/InstrBuilder.h

65 ↗

(On Diff #146353)

I don't like the changes to InstrBuilder.h and InstrBuilder.cpp.

I don't think that there is a good reason why createInstruction should return a normal pointer instead of a unique_ptr.

tools/llvm-mca/Instruction.h

39 ↗

(On Diff #146353)

I've been thinking about the instruction ownership problem.

My opinion is that there is no real advantage in passing the ownership of an instruction from stage to stage.
It complicates the logic for very little (if no) gain. It forces the instruction to be manipulated as a shared_ptr in the Scheduler.

I'd like to keep the code simple. I prefer a simpler (and more intuitive) approach where instructions are created and destroyed in the same place.

Any particular reason why the FetchStage cannot be the owner of all Instructions? At the end of each cycle, it looks for instructions that have reached the retired stage, and remove them. That approach would be much cleaner, and - more importantly - it would not require using shared_ptr everywhere.

tools/llvm-mca/Stage.h

28 ↗

(On Diff #146353)

Create a Stage.cpp, and pin the vtable there.
Move the definition of registerNextStage and addListener to Stage.cpp.

29 ↗

(On Diff #146353)

Please remove this field.

31 ↗

(On Diff #146353)

A stage should not "own" the next stage. I think the Backend (i.e. our pipeline) should be the owner of all the stages. Please remove this unique_ptr.

36–37 ↗

(On Diff #146353)

Make these two to private.

[mattd]

Thanks a ton for your comments. I'll simplify per our offline discussion, and what was grazed upon in your comments above. Thanks.

tools/llvm-mca/InstrBuilder.h

65 ↗

(On Diff #146353)

My reason was to allow the caller decide how to manage the pointer. The benefit was that we can treat the pointer as a shared, or unique, else where. But given comments below, I'm convinced we can leave it as is.

tools/llvm-mca/Instruction.h

39 ↗

(On Diff #146353)

Those are all valid points. My goal was to remove the Instructions list and any callbacks, such as eraseInstruction, to that list. I was trying to remove the need for any Stage to have to callback-out to another stage or backend. However, after discussing off-line, I am convinced to keep this Stage introduction simple. While Instruction ownership did influence this patch, and I built Stage around that idea, I am convinced that we can just move the ownership to the FetchStage, at least for now.

tools/llvm-mca/Stage.h

31 ↗

(On Diff #146353)

The idea was that once a stage finishes with an instruction, it would then push that instruction to the next stage in the pipeline, very reactive. However, for now, we can just manage the stages as a list in Backend.

[mattd]

• Cleaned up the code per items mentioned in the comments.
• I added a single stage to Backend.h, in the future this will be a list of stages that represent the instruction pipeline. This patch is about introducing the Stage and FetchStage idea.
• As suggested, the Instruction list is now owned by the Fetch stage, since that stage produces the instructions.
  • I wonder if it would be cleaner to have an InstructionManager class, that manages the list of Instructions?
    • When the Backend instantiates the stages of the pipeline, it would also pass a reference to the InstructionManager instance to the stages.
• The callback to Backend::eraseInstruction is still there, however, that routine now invokes the Fetch stage to remove the specified Instruction instance. I don't like that indirection, but that would be a different patch. Specifically, once we add eventing to the Stages, then that functionality would be completely removed from the Backend.
  • If we take the InstructionManager idea, then that would eliminate the eraseInstruction definition from Backend and any Stage.

[andreadb]

Thanks Matt,

the patch looks much better now. I like how you designed the Stage interface.
See my comments below.

In D46741#1098416, @mattd wrote:

• The callback to Backend::eraseInstruction is still there, however, that routine now invokes the Fetch stage to remove the specified Instruction instance. I don't like that indirection, but that would be a different patch. Specifically, once we add eventing to the Stages, then that functionality would be completely removed from the Backend.
  • If we take the InstructionManager idea, then that would eliminate the eraseInstruction definition from Backend and any Stage.

There is no reason why you shouldn't be able to get rid of it now.
In FetchStage::postExecute(), you should be able to iterate over the set of instructions, and remove instructions that have reached the retire stage.

tools/llvm-mca/Backend.h

89–93 ↗

(On Diff #146671)

I think that you can get rid of this, if you modify the FetchStage::postExecute() method.

tools/llvm-mca/Stage.cpp

27 ↗

(On Diff #146671)

You can simply call llvm::llvm_unreachable("...").

[mattd]

• Removed eraseInstruction. Since we place ownership of all instructions in FetchStage, we can scan the list at the end of each Fetch cycle (postExecute) and clean up retired instructions at that time (thanks Andrea for that suggestion).
• Added isRetired predicate to Instruction.h

[andreadb]

LGTM. Thanks!

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

 /// This file implements an OoO backend for the llvm-mca tool.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_BACKEND_H
 #define LLVM_TOOLS_LLVM_MCA_BACKEND_H
 
 #include "Dispatch.h"
+#include "FetchStage.h"
 #include "InstrBuilder.h"
 #include "Scheduler.h"
-#include "SourceMgr.h"
 
 namespace mca {
 
 class HWEventListener;
 class HWInstructionEvent;
 class HWStallEvent;
 
 /// An out of order backend for a specific subtarget.
 ///
 /// It emulates an out-of-order execution of instructions. Instructions are
-/// fetched from a MCInst sequence managed by an object of class SourceMgr.
-/// Instructions are firstly dispatched to the schedulers and then executed.
+/// fetched from a MCInst sequence managed by an initial 'Fetch' stage.
+/// Instructions are firstly fetched, then dispatched to the schedulers, and
+/// then executed.
+///
 /// This class tracks the lifetime of an instruction from the moment where
 /// it gets dispatched to the schedulers, to the moment where it finishes
 /// executing and register writes are architecturally committed.
 /// In particular, it monitors changes in the state of every instruction
 /// in flight.
+///
 /// Instructions are executed in a loop of iterations. The number of iterations
-/// is defined by the SourceMgr object.
-/// The Backend entrypoint is method 'Run()' which execute cycles in a loop
+/// is defined by the SourceMgr object, which is managed by the initial stage
+/// of the instruction pipeline.
+///
+/// The Backend entry point is method 'run()' which executes cycles in a loop
 /// until there are new instructions to dispatch, and not every instruction
 /// has been retired.
+///
 /// Internally, the Backend collects statistical information in the form of
 /// histograms. For example, it tracks how the dispatch group size changes
 /// over time.
 class Backend {
   const llvm::MCSubtargetInfo &STI;
 
-  InstrBuilder &IB;
+  /// This is the initial stage of the pipeline.
+  /// TODO: Eventually this will become a list of unique Stage* that this
+  /// backend pipeline executes.
+  std::unique_ptr<FetchStage> Fetch;
+
   std::unique_ptr<Scheduler> HWS;
   std::unique_ptr<DispatchUnit> DU;
-  SourceMgr &SM;
-  unsigned Cycles;
-
-  llvm::DenseMap<unsigned, std::unique_ptr<Instruction>> Instructions;
   std::set<HWEventListener *> Listeners;
+  unsigned Cycles;
 
   void runCycle(unsigned Cycle);
 
 public:
   Backend(const llvm::MCSubtargetInfo &Subtarget,
-          const llvm::MCRegisterInfo &MRI, InstrBuilder &B, SourceMgr &Source,
-          unsigned DispatchWidth = 0, unsigned RegisterFileSize = 0,
-          unsigned LoadQueueSize = 0, unsigned StoreQueueSize = 0,
-          bool AssumeNoAlias = false)
-      : STI(Subtarget), IB(B),
+          const llvm::MCRegisterInfo &MRI,
+          std::unique_ptr<FetchStage> InitialStage, unsigned DispatchWidth = 0,
+          unsigned RegisterFileSize = 0, unsigned LoadQueueSize = 0,
+          unsigned StoreQueueSize = 0, bool AssumeNoAlias = false)
+      : STI(Subtarget), Fetch(std::move(InitialStage)),
         HWS(llvm::make_unique<Scheduler>(this, Subtarget.getSchedModel(),
                                          LoadQueueSize, StoreQueueSize,
                                          AssumeNoAlias)),
         DU(llvm::make_unique<DispatchUnit>(this, Subtarget.getSchedModel(), MRI,
                                            RegisterFileSize, DispatchWidth,
                                            HWS.get())),
-        SM(Source), Cycles(0) {
+        Cycles(0) {
     HWS->setDispatchUnit(DU.get());
   }
 
-  void run() {
-    while (SM.hasNext() || !DU->isRCUEmpty())
-      runCycle(Cycles++);
-  }
-
-  void eraseInstruction(const InstRef &IR) {
-    Instructions.erase(IR.getSourceIndex());
-  }
-
+  void run();
   void addEventListener(HWEventListener *Listener);
   void notifyCycleBegin(unsigned Cycle);
   void notifyInstructionEvent(const HWInstructionEvent &Event);
   void notifyStallEvent(const HWStallEvent &Event);
   void notifyResourceAvailable(const ResourceRef &RR);
   void notifyReservedBuffers(llvm::ArrayRef<unsigned> Buffers);
   void notifyReleasedBuffers(llvm::ArrayRef<unsigned> Buffers);
   void notifyCycleEnd(unsigned Cycle);
 };
 } // namespace mca
 
 #endif

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

 //===--------------------- Backend.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// Implementation of class Backend which emulates an hardware OoO backend.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "Backend.h"
+#include "FetchStage.h"
 #include "HWEventListener.h"
 #include "llvm/CodeGen/TargetSchedule.h"
 #include "llvm/Support/Debug.h"
 
 namespace mca {
 
 #define DEBUG_TYPE "llvm-mca"
 
 using namespace llvm;
 
 void Backend::addEventListener(HWEventListener *Listener) {
   if (Listener)
     Listeners.insert(Listener);
 }
 
+void Backend::run() {
+  while (Fetch->isReady() || !DU->isRCUEmpty())
+    runCycle(Cycles++);
+}
+
 void Backend::runCycle(unsigned Cycle) {
   notifyCycleBegin(Cycle);
 
-  while (SM.hasNext()) {
-    SourceRef SR = SM.peekNext();
-    std::unique_ptr<Instruction> NewIS = IB.createInstruction(*SR.second);
-    const InstrDesc &Desc = NewIS->getDesc();
-    Instruction *IS = NewIS.get();
-    InstRef IR(SR.first, IS);
+  InstRef IR;
+  while (Fetch->execute(IR)) {
+    const InstrDesc &Desc = IR.getInstruction()->getDesc();
     if (!DU->isAvailable(Desc.NumMicroOps) || !DU->canDispatch(IR))
       break;
-    Instructions[SR.first] = std::move(NewIS);
     DU->dispatch(IR, STI);
-    SM.updateNext();
+    Fetch->postExecute(IR);
   }
 
   notifyCycleEnd(Cycle);
 }
 
 void Backend::notifyCycleBegin(unsigned Cycle) {
   LLVM_DEBUG(dbgs() << "[E] Cycle begin: " << Cycle << '\n');
   for (HWEventListener *Listener : Listeners)

llvm/trunk/tools/llvm-mca/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   )
 
 add_llvm_tool(llvm-mca
   Backend.cpp
   BackendPrinter.cpp
   CodeRegion.cpp
   Dispatch.cpp
   DispatchStatistics.cpp
+  FetchStage.cpp
   HWEventListener.cpp
   InstrBuilder.cpp
   Instruction.cpp
   InstructionInfoView.cpp
   InstructionTables.cpp
   LSUnit.cpp
   llvm-mca.cpp
   RegisterFileStatistics.cpp
   ResourcePressureView.cpp
   RetireControlUnit.cpp
   RetireControlUnitStatistics.cpp
   Scheduler.cpp
   SchedulerStatistics.cpp
+  Stage.cpp
   Support.cpp
   SummaryView.cpp
   TimelineView.cpp
   View.cpp
   )

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

void RegisterFile::addRegisterWrite(WriteState &WS,
   // If this is a partial update, then we are done.
   if (!WS.fullyUpdatesSuperRegs())
     return;
 
   for (MCSuperRegIterator I(RegID, &MRI); I.isValid(); ++I)
     RegisterMappings[*I].first = &WS;
 }
 
-void RegisterFile::removeRegisterWrite(
-    const WriteState &WS, MutableArrayRef<unsigned> FreedPhysRegs,
+void RegisterFile::removeRegisterWrite(const WriteState &WS,
+                                       MutableArrayRef<unsigned> FreedPhysRegs,
                                        bool ShouldFreePhysRegs) {
   unsigned RegID = WS.getRegisterID();
   bool ShouldInvalidateSuperRegs = WS.fullyUpdatesSuperRegs();
 
   assert(RegID != 0 && "Invalidating an already invalid register?");
   assert(WS.getCyclesLeft() != -512 &&
          "Invalidating a write of unknown cycles!");
   assert(WS.getCyclesLeft() <= 0 && "Invalid cycles left for this write!");
   RegisterMapping &Mapping = RegisterMappings[RegID];

 void DispatchUnit::notifyInstructionRetired(const InstRef &IR) {
   LLVM_DEBUG(dbgs() << "[E] Instruction Retired: " << IR << '\n');
   SmallVector<unsigned, 4> FreedRegs(RAT->getNumRegisterFiles());
   const InstrDesc &Desc = IR.getInstruction()->getDesc();
 
   for (const std::unique_ptr<WriteState> &WS : IR.getInstruction()->getDefs())
     RAT->removeRegisterWrite(*WS.get(), FreedRegs, !Desc.isZeroLatency());
   Owner->notifyInstructionEvent(HWInstructionRetiredEvent(IR, FreedRegs));
-  Owner->eraseInstruction(IR);
 }
 
 bool DispatchUnit::checkRAT(const InstRef &IR) {
   SmallVector<unsigned, 4> RegDefs;
   for (const std::unique_ptr<WriteState> &RegDef :
        IR.getInstruction()->getDefs())
     RegDefs.emplace_back(RegDef->getRegisterID());
 

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

+//===---------------------- FetchStage.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 defines the Fetch stage of an instruction pipeline.  Its sole
+/// purpose in life is to produce instructions for the rest of the pipeline.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_MCA_FETCH_STAGE_H
+#define LLVM_TOOLS_LLVM_MCA_FETCH_STAGE_H
+
+#include "InstrBuilder.h"
+#include "Instruction.h"
+#include "SourceMgr.h"
+#include "Stage.h"
+#include "llvm/ADT/DenseMap.h"
+
+namespace mca {
+
+class FetchStage : public Stage {
+  using InstMap = llvm::DenseMap<unsigned, std::unique_ptr<Instruction>>;
+  using InstMapPr =
+      llvm::detail::DenseMapPair<unsigned, std::unique_ptr<Instruction>>;
+  InstMap Instructions;
+  InstrBuilder &IB;
+  SourceMgr &SM;
+
+public:
+  FetchStage(InstrBuilder &IB, SourceMgr &SM) : IB(IB), SM(SM) {}
+  FetchStage(const FetchStage &Other) = delete;
+  FetchStage &operator=(const FetchStage &Other) = delete;
+
+  bool isReady() override final;
+  bool execute(InstRef &IR) override final;
+  void postExecute(const InstRef &IR) override final;
+};
+
+} // namespace mca
+
+#endif // LLVM_TOOLS_LLVM_MCA_FETCH_STAGE_H

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

+//===---------------------- FetchStage.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 defines the Fetch stage of an instruction pipeline.  Its sole
+/// purpose in life is to produce instructions for the rest of the pipeline.
+///
+//===----------------------------------------------------------------------===//
+
+#include "FetchStage.h"
+#include "Instruction.h"
+
+using namespace mca;
+
+bool FetchStage::isReady() { return SM.hasNext(); }
+
+bool FetchStage::execute(InstRef &IR) {
+  if (!SM.hasNext())
+    return false;
+  const SourceRef SR = SM.peekNext();
+  std::unique_ptr<Instruction> I = IB.createInstruction(*SR.second);
+  IR = InstRef(SR.first, I.get());
+  Instructions[IR.getSourceIndex()] = std::move(I);
+  return true;
+}
+
+void FetchStage::postExecute(const InstRef &IR) {
+  // Reclaim instructions that have been retired.
+  llvm::remove_if(Instructions,
+                  [](InstMapPr &Pr) { return Pr.getSecond()->isRetired(); });
+  SM.updateNext();
+}

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

public:
   // as the result of another issue event.  This method is called every time the
   // instruction might have changed in state.
   void update();
 
   bool isDispatched() const { return Stage == IS_AVAILABLE; }
   bool isReady() const { return Stage == IS_READY; }
   bool isExecuting() const { return Stage == IS_EXECUTING; }
   bool isExecuted() const { return Stage == IS_EXECUTED; }
+  bool isRetired() const { return Stage == IS_RETIRED; }
 
   void retire() {
     assert(isExecuted() && "Instruction is in an invalid state!");
     Stage = IS_RETIRED;
   }
 
   void cycleEvent();
 };
 } // namespace mca
 
 #endif

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

+//===---------------------- Stage.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 defines a stage.
+/// A chain of stages compose an instruction pipeline.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_MCA_STAGE_H
+#define LLVM_TOOLS_LLVM_MCA_STAGE_H
+
+#include "HWEventListener.h"
+#include "Instruction.h"
+#include "SourceMgr.h"
+#include <memory>
+#include <string>
+
+namespace mca {
+
+class Stage {
+  std::set<HWEventListener *> Listeners;
+  Stage(const Stage &Other) = delete;
+  Stage &operator=(const Stage &Other) = delete;
+
+public:
+  Stage();
+  virtual ~Stage() = default;
+
+  /// Called prior to preExecute to ensure that the stage can operate.
+  /// TODO: Remove this logic once backend::run and backend::runCycle become
+  /// one routine.
+  virtual bool isReady() { return true; }
+
+  /// Called as a setup phase to prepare for the main stage execution.
+  virtual void preExecute(const InstRef &IR) {}
+
+  /// Called as a cleanup and finalization phase after main stage execution.
+  virtual void postExecute(const InstRef &IR) {}
+
+  /// The primary action that this stage performs.
+  virtual bool execute(InstRef &IR) = 0;
+
+  /// Add a listener to receive callbaks during the execution of this stage.
+  void addListener(HWEventListener *Listener);
+};
+
+} // namespace mca
+#endif // LLVM_TOOLS_LLVM_MCA_STAGE_H

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

+//===---------------------- Stage.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 defines a stage.
+/// A chain of stages compose an instruction pipeline.
+///
+//===----------------------------------------------------------------------===//
+
+#include "Stage.h"
+#include "llvm/Support/ErrorHandling.h"
+
+namespace mca {
+
+// Pin the vtable here in the implementation file.
+Stage::Stage() {}
+
+void Stage::addListener(HWEventListener *Listener) {
+  llvm::llvm_unreachable_internal("Stage-based eventing is not implemented.");
+}
+
+} // 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 "BackendPrinter.h"
 #include "CodeRegion.h"
 #include "DispatchStatistics.h"
+#include "FetchStage.h"
 #include "InstructionInfoView.h"
 #include "InstructionTables.h"
 #include "RegisterFileStatistics.h"
 #include "ResourcePressureView.h"
 #include "RetireControlUnitStatistics.h"
 #include "SchedulerStatistics.h"
 #include "SummaryView.h"
 #include "TimelineView.h"
if (PrintInstructionTables) {
       }
 
       IT.addView(llvm::make_unique<mca::ResourcePressureView>(*STI, *IP, S));
       IT.run();
       IT.printReport(TOF->os());
       continue;
     }
 
-    mca::Backend B(*STI, *MRI, IB, S, Width, RegisterFileSize, LoadQueueSize,
-                   StoreQueueSize, AssumeNoAlias);
+    // Ideally, I'd like to expose the pipeline building here,
+    // by registering all of the Stage instances.
+    // But for now, it's just this single puppy.
+    std::unique_ptr<mca::FetchStage> Fetch =
+        llvm::make_unique<mca::FetchStage>(IB, S);
+    mca::Backend B(*STI, *MRI, std::move(Fetch), Width, RegisterFileSize,
+                   LoadQueueSize, StoreQueueSize, AssumeNoAlias);
     mca::BackendPrinter Printer(B);
 
     Printer.addView(llvm::make_unique<mca::SummaryView>(S, Width));
     if (PrintInstructionInfoView)
       Printer.addView(
           llvm::make_unique<mca::InstructionInfoView>(*STI, *MCII, S, *IP));
 
     if (PrintDispatchStats)