[MCA] Moving View.h and View.cpp from /tools/llvm-mca/Views/ to /lib/MCA/ and /include/llvm/MCA/.

[holland11]

Summary

The motivation for this change is to allow for target specific View classes that require backend (/lib/Target/) functionality. I have a downstream target that requires this so hopefully my explanation will do a good enough job motivating the change since I don't have an upstream example to include with this patch.

Most of this patch is just moving View.h and View.cpp, and changing the #include lines from files that need to include them. I also added the CustomBehaviour::getCBViews() method which returns a std::vector<std::unique_ptr<View>>. This lets a target's CustomBehaviour class return a list of these custom Views within llvm-mca.cpp so that they can be passed to the PipelinePrinter.

Currently, View.cpp and View.h reside within the /tools/llvm-mca/Views/ directory. This makes sense as Views are exclusive to mca so there's no reason why they should be part of the lib. As part of my downstream target's usage of mca, we created a new View to help visualize important information that occurs during mca's simulation. This View needs to be able to use backend symbols or interact with our target's CustomBehaviour class.

Since the target specific CustomBehaviour classes were moved to /lib/Target/<TargetName>/MCA/ in a recent patch, a custom View class cannot be placed within /tools/llvm-mca/Views/ and still interact with (#include) a target's CustomBehaviour class*. This means that the custom View needs to be defined within the target lib. And since the custom View needs to inherit from View.h, View.h needs to be part of the lib.

*A View could actually #include a target's CustomBehaviour class, but this would result in an error when trying to build with shared libs on linux. This is the same issue that originally motivated moving the target specific CustomBehaviour classes out of /tools/llvm-mca/lib/<TargetName>/ and into the target's lib.

There are other ways to get around this problem on our downstream target such as taking all of the classes and functions that our custom View needs to access from our CustomBehaviour class and then exposing the functions as virtual functions (and completely defining the classes) within the base CustomBehaviour class. This would work, but would be poor design, would be prone to merge conflicts when our downstream repo merges the upstream repo, and I also believe that this change could prove to be beneficial for an upstream target in the future. I don't think it's out of the question to think that other targets may want to define their own custom Views in the future.

When discussing this potential change with Andrea, one of his main concerns was that authors of future Views may abuse the new location of View.h and View.cpp by defining the new View classes within the lib or target lib even when they don't actually need any backend functionality. To try to make this less likely to occur, I added a section to the llvm-mca docs and also added a comment explaining that you should place the custom Views within /tools/llvm-mca/Views/ and only move it to the target lib if necessary.

[holland11]

Fixed a typo in one of the comments.

[andreadb]

llvm/docs/CommandGuide/llvm-mca.rst

1000

Nice catch!

1023–1029

Maybe we should better clarify what you mean by "backend functionality" in this context.

Most views know how to query information which is available at MC layer.
For example, most views in /tools/llvm-mca/View/ know about MCSubtargetInfo, MCSchedModel and MCInstrInfo.
My point is that, views that require backend functionalities may still be defined in a target-independent way within /tools/llvm-mca/View/, because they only need to use abstractions that are common to all targets.

1031–1038

You should also explain that:

• Default views are still normally executed,
• CustomBehaviour views (if any) are always appended at the end of the pipeline.

Essentially, these views are not used to override the existing pipeline. These views are something "extra" always added at the end.

Ideally, we should make the pipeline a bit more customisable, and let targets customise the ordering of views in the pipeline. Some targets might prefer if custom views are added before the TimelineView, while other targets might prefer to see those printed immediately after the Summary and InstructionInfo views.
Potentially, we could have three of those methods:

• A method that returns a vector of views to be added at the end of the pipeline.
• A method that returns a vector of views to be added directly after the InstructionInfoView
• A method that returns a vector of views to be added before the TimelineView.

llvm/include/llvm/MCA/CustomBehaviour.h

97

Why not just GetViews ?

It is already a method of CustomBehaviour. I am not sure that there is an advantage in adding the extra 'CB' in the name.

llvm/lib/MCA/CustomBehaviour.cpp

27–31

Se my previous comment and the suggestion about adding multiple get*** methods (if that makes sense).

[holland11]

Implemented Andrea's suggestions.

[holland11]

Thanks for the feedback. All your suggestions make a lot of sense and I went ahead and implemented them. I went with a getStartViews(), getPostInstrInfoViews(), and getEndViews() since the TimelineView comes at the end anyways. Updated the docs snippet to be more accurate to those 3 variants and also to clarify what you mentioned. Let me know if there's any other feedback that you have. Happy to continue making any modifications.

[andreadb]

LGTM

Thanks Patrick!

llvm/docs/CommandGuide/llvm-mca.rst

 """"""""""""""""""""""""""""""""""""
 Due to certain instructions not being expressed perfectly within their
 scheduling model, :program:`llvm-mca` isn't always able to simulate them
 perfectly. Modifying the scheduling model isn't always a viable
 option though (maybe because the instruction is modeled incorrectly on
 purpose or the instruction's behaviour is quite complex). The
 CustomBehaviour class can be used in these cases to enforce proper
 instruction modeling (often by customizing data dependencies and detecting
-hazards that :program:`llvm-ma` has no way of knowing about).
+hazards that :program:`llvm-mca` has no way of knowing about).
 
 :program:`llvm-mca` comes with one generic and multiple target specific
 CustomBehaviour classes. The generic class will be used if the ``-disable-cb``
 flag is used or if a target specific CustomBehaviour class doesn't exist for
 that target. (The generic class does nothing.) Currently, the CustomBehaviour
 class is only a part of the in-order pipeline, but there are plans to add it
 to the out-of-order pipeline in the future.
 
 CustomBehaviour's main method is `checkCustomHazard()` which uses the
 current instruction and a list of all instructions still executing within
 the pipeline to determine if the current instruction should be dispatched.
 As output, the method returns an integer representing the number of cycles
 that the current instruction must stall for (this can be an underestimate
 if you don't know the exact number and a value of 0 represents no stall).
 
 If you'd like to add a CustomBehaviour class for a target that doesn't
 already have one, refer to an existing implementation to see how to set it
 up. The classes are implemented within the target specific backend (for
 example `/llvm/lib/Target/AMDGPU/MCA/`) so that they can access backend symbols.
+
+Custom Views
+""""""""""""""""""""""""""""""""""""
+:program:`llvm-mca` comes with several Views such as the Timeline View and
+Summary View. These Views are generic and can work with most (if not all)
+targets. If you wish to add a new View to :program:`llvm-mca` and it does not
+require any backend functionality that is not already exposed through MC layer
+classes (MCSubtargetInfo, MCInstrInfo, etc.), please add it to the
+`/tools/llvm-mca/View/` directory. However, if your new View is target specific
+AND requires unexposed backend symbols or functionality, you can define it in
+the `/lib/Target/<TargetName>/MCA/` directory.
+
+To enable this target specific View, you will have to use this target's
+CustomBehaviour class to override the `CustomBehaviour::getViews()` methods.
+There are 3 variations of these methods based on where you want your View to
+appear in the output: `getStartViews()`, `getPostInstrInfoViews()`, and
+`getEndViews()`. These methods returns a vector of Views so you will want to
+return a vector containing all of the target specific Views for the target in
+question.
+
+Because these target specific (and backend dependent) Views require the
+`CustomBehaviour::getViews()` variants, these Views will not be enabled if
+the `-disable-cb` flag is used.
+
+Enabling these custom Views does not affect the non-custom (generic) Views.
+Continue to use the usual command line arguments to enable / disable those
+Views.

llvm/include/llvm/MCA/CustomBehaviour.h

 
 #ifndef LLVM_MCA_CUSTOMBEHAVIOUR_H
 #define LLVM_MCA_CUSTOMBEHAVIOUR_H
 
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MCA/SourceMgr.h"
+#include "llvm/MCA/View.h"
 
 namespace llvm {
 namespace mca {
 
 /// Class which can be overriden by targets to modify the
 /// mca::Instruction objects before the pipeline starts.
 /// A common usage of this class is to add immediate operands to certain
 /// instructions or to remove Defs/Uses from an instruction where the

 
 public:
   CustomBehaviour(const MCSubtargetInfo &STI, const mca::SourceMgr &SrcMgr,
                   const MCInstrInfo &MCII)
       : STI(STI), SrcMgr(SrcMgr), MCII(MCII) {}
 
   virtual ~CustomBehaviour();
 
-  // Before the llvm-mca pipeline dispatches an instruction, it first checks
-  // for any register or resource dependencies / hazards. If it doesn't find
-  // any, this method will be invoked to determine if there are any custom
-  // hazards that the instruction needs to wait for.
-  // The return value of this method is the number of cycles that the
-  // instruction needs to wait for.
-  // It's safe to underestimate the number of cycles to wait for since these
-  // checks will be invoked again before the intruction gets dispatched.
-  // However, it's not safe (accurate) to overestimate the number of cycles
-  // to wait for since the instruction will wait for AT LEAST that number of
-  // cycles before attempting to be dispatched again.
+  /// Before the llvm-mca pipeline dispatches an instruction, it first checks
+  /// for any register or resource dependencies / hazards. If it doesn't find
+  /// any, this method will be invoked to determine if there are any custom
+  /// hazards that the instruction needs to wait for.
+  /// The return value of this method is the number of cycles that the
+  /// instruction needs to wait for.
+  /// It's safe to underestimate the number of cycles to wait for since these
+  /// checks will be invoked again before the intruction gets dispatched.
+  /// However, it's not safe (accurate) to overestimate the number of cycles
+  /// to wait for since the instruction will wait for AT LEAST that number of
+  /// cycles before attempting to be dispatched again.
   virtual unsigned checkCustomHazard(ArrayRef<InstRef> IssuedInst,
                                      const InstRef &IR);
+
+  // Functions that target CBs can override to return a list of
+  // target specific Views that need to live within /lib/Target/ so that
+  // they can benefit from the target CB or from backend functionality that is
+  // not already exposed through MC-layer classes. Keep in mind that how this
+  // function is used is that the function is called within llvm-mca.cpp and
+  // then each unique_ptr<View> is passed into the PipelinePrinter::addView()
+  // function. This function will then std::move the View into its own vector of
+  // Views. So any CB that overrides this function needs to make sure that they
+  // are not relying on the current address or reference of the View
+  // unique_ptrs. If you do need the CB and View to be able to communicate with
+  // each other, consider giving the View a reference or pointer to the CB when
+  // the View is constructed. Then the View can query the CB for information
+  // when it needs it.
+  /// Return a vector of Views that will be added before all other Views.
+  virtual std::vector<std::unique_ptr<View>>
+  getStartViews(llvm::MCInstPrinter &IP, llvm::ArrayRef<llvm::MCInst> Insts);
+  /// Return a vector of Views that will be added after the InstructionInfoView.
+  virtual std::vector<std::unique_ptr<View>>
+  getPostInstrInfoViews(llvm::MCInstPrinter &IP,
+                        llvm::ArrayRef<llvm::MCInst> Insts);
+  /// Return a vector of Views that will be added after all other Views.
+  virtual std::vector<std::unique_ptr<View>>
+  getEndViews(llvm::MCInstPrinter &IP, llvm::ArrayRef<llvm::MCInst> Insts);
 };
 
 } // namespace mca
 } // namespace llvm
 
 #endif /* LLVM_MCA_CUSTOMBEHAVIOUR_H */

llvm/include/llvm/MCA/View.h

 //===----------------------- View.h -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file defines the main interface for Views. Each view contributes a
 /// portion of the final report generated by the tool.
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TOOLS_LLVM_MCA_VIEW_H
-#define LLVM_TOOLS_LLVM_MCA_VIEW_H
+#ifndef LLVM_MCA_VIEW_H
+#define LLVM_MCA_VIEW_H
 
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MCA/HWEventListener.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace mca {

llvm/lib/MCA/CMakeLists.txt

add_llvm_component_library(LLVMMCA
   Stages/EntryStage.cpp
   Stages/ExecuteStage.cpp
   Stages/InOrderIssueStage.cpp
   Stages/InstructionTables.cpp
   Stages/MicroOpQueueStage.cpp
   Stages/RetireStage.cpp
   Stages/Stage.cpp
   Support.cpp
+  View.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/MCA
 
   LINK_COMPONENTS
   MC
   Support
   )

llvm/lib/MCA/CustomBehaviour.cpp

 CustomBehaviour::~CustomBehaviour() {}
 
 unsigned CustomBehaviour::checkCustomHazard(ArrayRef<InstRef> IssuedInst,
                                             const InstRef &IR) {
   // 0 signifies that there are no hazards that need to be waited on
   return 0;
 }
 
+std::vector<std::unique_ptr<View>>
+CustomBehaviour::getStartViews(llvm::MCInstPrinter &IP,
+                               llvm::ArrayRef<llvm::MCInst> Insts) {
+  return std::vector<std::unique_ptr<View>>();
+}
+
+std::vector<std::unique_ptr<View>>
+CustomBehaviour::getPostInstrInfoViews(llvm::MCInstPrinter &IP,
+                                       llvm::ArrayRef<llvm::MCInst> Insts) {
+  return std::vector<std::unique_ptr<View>>();
+}
+
+std::vector<std::unique_ptr<View>>
+CustomBehaviour::getEndViews(llvm::MCInstPrinter &IP,
+                             llvm::ArrayRef<llvm::MCInst> Insts) {
+  return std::vector<std::unique_ptr<View>>();
+}
+
 } // namespace mca
 } // namespace llvm

llvm/lib/MCA/View.cpp

 //===----------------------- View.cpp ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file defines the virtual anchor method in View.h to pin the vtable.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "Views/View.h"
+#include "llvm/MCA/View.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 
 namespace llvm {
 namespace mca {
 
 void View::anchor() {}
 
 } // namespace mca
 } // namespace llvm

llvm/tools/llvm-mca/CMakeLists.txt

add_llvm_tool(llvm-mca
   Views/InstructionInfoView.cpp
   Views/InstructionView.cpp
   Views/RegisterFileStatistics.cpp
   Views/ResourcePressureView.cpp
   Views/RetireControlUnitStatistics.cpp
   Views/SchedulerStatistics.cpp
   Views/SummaryView.cpp
   Views/TimelineView.cpp
-  Views/View.cpp
   )
 
 set(LLVM_MCA_SOURCE_DIR ${CURRENT_SOURCE_DIR})

llvm/tools/llvm-mca/PipelinePrinter.h

 ///
 /// PipelinePrinter allows the customization of the performance report.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_PIPELINEPRINTER_H
 #define LLVM_TOOLS_LLVM_MCA_PIPELINEPRINTER_H
 
-#include "Views/View.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MCA/Context.h"
 #include "llvm/MCA/Pipeline.h"
+#include "llvm/MCA/View.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "llvm-mca"
 
 namespace llvm {
 namespace mca {
 
 class CodeRegion;

llvm/tools/llvm-mca/PipelinePrinter.cpp

 //===--------------------- PipelinePrinter.cpp ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file implements the PipelinePrinter interface.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "PipelinePrinter.h"
 #include "CodeRegion.h"
 #include "Views/InstructionView.h"
-#include "Views/View.h"
 
 namespace llvm {
 namespace mca {
 
 void PipelinePrinter::printRegionHeader(llvm::raw_ostream &OS) const {
   StringRef RegionName;
   if (!Region.getDescription().empty())
     RegionName = Region.getDescription();

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

 ///  0,              15  (11.5%)
 ///  2,              4  (3.1%)
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_DISPATCHVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_DISPATCHVIEW_H
 
-#include "Views/View.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MCA/View.h"
 #include <map>
 
 namespace llvm {
 namespace mca {
 
 class DispatchStatistics : public View {
   unsigned NumDispatched;
   unsigned NumCycles;

llvm/tools/llvm-mca/Views/InstructionView.h

 /// This file defines the main interface for Views that examine and reference
 /// a sequence of machine instructions.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_INSTRUCTIONVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_INSTRUCTIONVIEW_H
 
-#include "Views/View.h"
+#include "llvm/MCA/View.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace mca {
 
 // The base class for views that deal with individual machine instructions.
 class InstructionView : public View {

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

 ///    Total number of mappings created: 6
 ///    Max number of mappings used:      3
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_REGISTERFILESTATISTICS_H
 #define LLVM_TOOLS_LLVM_MCA_REGISTERFILESTATISTICS_H
 
-#include "Views/View.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MCA/View.h"
 
 namespace llvm {
 namespace mca {
 
 class RegisterFileStatistics : public View {
   const llvm::MCSubtargetInfo &STI;
 
   // Used to track the number of physical registers used in a register file.

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

 /// Max Used ROB Entries:             35  ( 54.7% )
 /// Average Used ROB Entries per cy:  32  ( 50.0% )
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_RETIRECONTROLUNITSTATISTICS_H
 #define LLVM_TOOLS_LLVM_MCA_RETIRECONTROLUNITSTATISTICS_H
 
-#include "Views/View.h"
 #include "llvm/MC/MCSchedule.h"
+#include "llvm/MCA/View.h"
 #include <map>
 
 namespace llvm {
 namespace mca {
 
 class RetireControlUnitStatistics : public View {
   using Histogram = std::map<unsigned, unsigned>;
   Histogram RetiredPerCycle;

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

 /// JFPU01           15         18         18
 /// JLSAGU           0          0          12
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_SCHEDULERSTATISTICS_H
 #define LLVM_TOOLS_LLVM_MCA_SCHEDULERSTATISTICS_H
 
-#include "Views/View.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MCA/View.h"
 #include <map>
 
 namespace llvm {
 namespace mca {
 
 class SchedulerStatistics final : public View {
   const llvm::MCSchedModel &SM;
   unsigned LQResourceID;

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

 /// The summary view collects a few performance numbers. The two main
 /// performance indicators are 'Total Cycles' and IPC (Instructions Per Cycle).
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_SUMMARYVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_SUMMARYVIEW_H
 
-#include "Views/View.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/MC/MCSchedule.h"
+#include "llvm/MCA/View.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace mca {
 
 /// A view that collects and prints a few performance numbers.
 class SummaryView : public View {
   const llvm::MCSchedModel &SM;

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

if (!CB)
       // flag is set) then we use the base class (which does nothing).
       CB = std::make_unique<mca::CustomBehaviour>(*STI, S, *MCII);
 
     // Create a basic pipeline simulating an out-of-order backend.
     auto P = MCA.createDefaultPipeline(PO, S, *CB);
 
     mca::PipelinePrinter Printer(*P, *Region, RegionIdx, *STI, PO);
 
+    // Targets can define their own custom Views that exist within their
+    // /lib/Target/ directory so that the View can utilize their CustomBehaviour
+    // or other backend symbols / functionality that are not already exposed
+    // through one of the MC-layer classes. These Views will be initialized
+    // using the CustomBehaviour::getViews() variants.
+    // If a target makes a custom View that does not depend on their target
+    // CB or their backend, they should put the View within
+    // /tools/llvm-mca/Views/ instead.
+    if (!DisableCustomBehaviour) {
+      std::vector<std::unique_ptr<mca::View>> CBViews =
+          CB->getStartViews(*IP, Insts);
+      for (auto &CBView : CBViews)
+        Printer.addView(std::move(CBView));
+    }
+
     // When we output JSON, we add a view that contains the instructions
     // and CPU resource information.
     if (PrintJson) {
       auto IV = std::make_unique<mca::InstructionView>(*STI, *IP, Insts);
       Printer.addView(std::move(IV));
     }
 
     if (PrintSummaryView)
if (EnableBottleneckAnalysis) {
       Printer.addView(std::make_unique<mca::BottleneckAnalysis>(
           *STI, *IP, Insts, S.getNumIterations()));
     }
 
     if (PrintInstructionInfoView)
       Printer.addView(std::make_unique<mca::InstructionInfoView>(
           *STI, *MCII, CE, ShowEncoding, Insts, *IP));
 
+    // Fetch custom Views that are to be placed after the InstructionInfoView.
+    // Refer to the comment paired with the CB->getStartViews(*IP, Insts); line
+    // for more info.
+    if (!DisableCustomBehaviour) {
+      std::vector<std::unique_ptr<mca::View>> CBViews =
+          CB->getPostInstrInfoViews(*IP, Insts);
+      for (auto &CBView : CBViews)
+        Printer.addView(std::move(CBView));
+    }
+
     if (PrintDispatchStats)
       Printer.addView(std::make_unique<mca::DispatchStatistics>());
 
     if (PrintSchedulerStats)
       Printer.addView(std::make_unique<mca::SchedulerStatistics>(*STI));
 
     if (PrintRetireStats)
       Printer.addView(std::make_unique<mca::RetireControlUnitStatistics>(SM));
 
     if (PrintRegisterFileStats)
       Printer.addView(std::make_unique<mca::RegisterFileStatistics>(*STI));
 
     if (PrintResourcePressureView)
       Printer.addView(
           std::make_unique<mca::ResourcePressureView>(*STI, *IP, Insts));
 
     if (PrintTimelineView) {
       unsigned TimelineIterations =
           TimelineMaxIterations ? TimelineMaxIterations : 10;
       Printer.addView(std::make_unique<mca::TimelineView>(
           *STI, *IP, Insts, std::min(TimelineIterations, S.getNumIterations()),
           TimelineMaxCycles));
     }
 
+    // Fetch custom Views that are to be placed after all other Views.
+    // Refer to the comment paired with the CB->getStartViews(*IP, Insts); line
+    // for more info.
+    if (!DisableCustomBehaviour) {
+      std::vector<std::unique_ptr<mca::View>> CBViews =
+          CB->getEndViews(*IP, Insts);
+      for (auto &CBView : CBViews)
+        Printer.addView(std::move(CBView));
+    }
+
     if (!runPipeline(*P))
       return 1;
 
     if (PrintJson) {
       Printer.printReport(JSONOutput);
     } else {
       Printer.printReport(TOF->os());
     }