From: Matt Davis Date: Mon, 25 Jun 2018 16:53:00 +0000 (+0000) Subject: [llvm-mca] Rename Backend to Pipeline. NFC. X-Git-Tag: android-x86-8.1-r1~1666 X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=d8c387b1dd34fa8043624d479a62d673dc632226;p=android-x86%2Fexternal-llvm.git [llvm-mca] Rename Backend to Pipeline. NFC. Summary: This change renames the Backend and BackendPrinter to Pipeline and PipelinePrinter respectively. Variables and comments have also been updated to reflect this change. The reason for this rename, is to be slightly more correct about what MCA is modeling. MCA models a Pipeline, which implies some logical sequence of stages. Reviewers: andreadb, courbet, RKSimon Reviewed By: andreadb, courbet Subscribers: mgorny, javed.absar, tschuett, gbedwell, llvm-commits Differential Revision: https://reviews.llvm.org/D48496 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@335496 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/tools/llvm-mca/CMakeLists.txt b/tools/llvm-mca/CMakeLists.txt index 6692adcdcdb..f98d6313f0e 100644 --- a/tools/llvm-mca/CMakeLists.txt +++ b/tools/llvm-mca/CMakeLists.txt @@ -10,8 +10,6 @@ set(LLVM_LINK_COMPONENTS ) add_llvm_tool(llvm-mca - Backend.cpp - BackendPrinter.cpp CodeRegion.cpp DispatchStage.cpp DispatchStatistics.cpp @@ -24,6 +22,8 @@ add_llvm_tool(llvm-mca InstructionTables.cpp LSUnit.cpp llvm-mca.cpp + Pipeline.cpp + PipelinePrinter.cpp RegisterFile.cpp RegisterFileStatistics.cpp ResourcePressureView.cpp diff --git a/tools/llvm-mca/DispatchStage.cpp b/tools/llvm-mca/DispatchStage.cpp index 07666edf359..80909188767 100644 --- a/tools/llvm-mca/DispatchStage.cpp +++ b/tools/llvm-mca/DispatchStage.cpp @@ -17,8 +17,8 @@ //===----------------------------------------------------------------------===// #include "DispatchStage.h" -#include "Backend.h" #include "HWEventListener.h" +#include "Pipeline.h" #include "Scheduler.h" #include "llvm/Support/Debug.h" diff --git a/tools/llvm-mca/DispatchStage.h b/tools/llvm-mca/DispatchStage.h index 60b33324ba0..47e4864a459 100644 --- a/tools/llvm-mca/DispatchStage.h +++ b/tools/llvm-mca/DispatchStage.h @@ -30,7 +30,7 @@ namespace mca { class WriteState; class Scheduler; -class Backend; +class Pipeline; // Implements the hardware dispatch logic. // @@ -54,7 +54,7 @@ class DispatchStage : public Stage { unsigned DispatchWidth; unsigned AvailableEntries; unsigned CarryOver; - Backend *Owner; + Pipeline *Owner; const llvm::MCSubtargetInfo &STI; RetireControlUnit &RCU; RegisterFile &PRF; @@ -84,12 +84,12 @@ class DispatchStage : public Stage { } public: - DispatchStage(Backend *B, const llvm::MCSubtargetInfo &Subtarget, + DispatchStage(Pipeline *P, const llvm::MCSubtargetInfo &Subtarget, const llvm::MCRegisterInfo &MRI, unsigned RegisterFileSize, unsigned MaxDispatchWidth, RetireControlUnit &R, RegisterFile &F, Scheduler &Sched) : DispatchWidth(MaxDispatchWidth), AvailableEntries(MaxDispatchWidth), - CarryOver(0U), Owner(B), STI(Subtarget), RCU(R), PRF(F), SC(Sched) {} + CarryOver(0U), Owner(P), STI(Subtarget), RCU(R), PRF(F), SC(Sched) {} // We can always try to dispatch, so returning false is okay in this case. // The retire stage, which controls the RCU, might have items to complete but diff --git a/tools/llvm-mca/ExecuteStage.cpp b/tools/llvm-mca/ExecuteStage.cpp index 6a0fefdadcc..ebd87150f0a 100644 --- a/tools/llvm-mca/ExecuteStage.cpp +++ b/tools/llvm-mca/ExecuteStage.cpp @@ -16,7 +16,7 @@ //===----------------------------------------------------------------------===// #include "ExecuteStage.h" -#include "Backend.h" +#include "Pipeline.h" #include "Scheduler.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Debug.h" diff --git a/tools/llvm-mca/ExecuteStage.h b/tools/llvm-mca/ExecuteStage.h index a71aa45b3fd..82b9369352d 100644 --- a/tools/llvm-mca/ExecuteStage.h +++ b/tools/llvm-mca/ExecuteStage.h @@ -26,11 +26,11 @@ namespace mca { -class Backend; +class Pipeline; class ExecuteStage : public Stage { // Owner will go away when we move listeners/eventing to the stages. - Backend *Owner; + Pipeline *Owner; RetireControlUnit &RCU; Scheduler &HWS; @@ -40,8 +40,8 @@ class ExecuteStage : public Stage { void issueReadyInstructions(); public: - ExecuteStage(Backend *B, RetireControlUnit &R, Scheduler &S) - : Stage(), Owner(B), RCU(R), HWS(S) {} + ExecuteStage(Pipeline *P, RetireControlUnit &R, Scheduler &S) + : Stage(), Owner(P), RCU(R), HWS(S) {} ExecuteStage(const ExecuteStage &Other) = delete; ExecuteStage &operator=(const ExecuteStage &Other) = delete; diff --git a/tools/llvm-mca/HWEventListener.h b/tools/llvm-mca/HWEventListener.h index fe379c981d9..c7384d51b13 100644 --- a/tools/llvm-mca/HWEventListener.h +++ b/tools/llvm-mca/HWEventListener.h @@ -27,11 +27,11 @@ namespace mca { class HWInstructionEvent { public: // This is the list of event types that are shared by all targets, that - // generic subtarget-agnostic classes (e.g. Backend, HWInstructionEvent, ...) - // and generic Views can manipulate. + // generic subtarget-agnostic classes (e.g., Pipeline, HWInstructionEvent, + // ...) and generic Views can manipulate. // Subtargets are free to define additional event types, that are goin to be // handled by generic components as opaque values, but can still be - // emitted by subtarget-specific pipeline components (e.g. Scheduler, + // emitted by subtarget-specific pipeline stages (e.g., ExecuteStage, // DispatchStage, ...) and interpreted by subtarget-specific EventListener // implementations. enum GenericEventType { @@ -116,7 +116,7 @@ public: class HWEventListener { public: - // Generic events generated by the backend pipeline. + // Generic events generated by the pipeline. virtual void onCycleBegin() {} virtual void onCycleEnd() {} diff --git a/tools/llvm-mca/Instruction.cpp b/tools/llvm-mca/Instruction.cpp index f0f4de5a5fe..3abf30c5055 100644 --- a/tools/llvm-mca/Instruction.cpp +++ b/tools/llvm-mca/Instruction.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file defines abstractions used by the Backend to model register reads, +// This file defines abstractions used by the Pipeline to model register reads, // register writes and instructions. // //===----------------------------------------------------------------------===// diff --git a/tools/llvm-mca/Instruction.h b/tools/llvm-mca/Instruction.h index 0837c50506c..558ef42c266 100644 --- a/tools/llvm-mca/Instruction.h +++ b/tools/llvm-mca/Instruction.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// \file /// -/// This file defines abstractions used by the Backend to model register reads, +/// This file defines abstractions used by the Pipeline to model register reads, /// register writes and instructions. /// //===----------------------------------------------------------------------===// @@ -264,10 +264,10 @@ struct InstrDesc { bool isZeroLatency() const { return !MaxLatency && Resources.empty(); } }; -/// An instruction dispatched to the out-of-order backend. +/// An instruction propagated through the simulated instruction pipeline. /// -/// This class is used to monitor changes in the internal state of instructions -/// that are dispatched by the DispatchUnit to the hardware schedulers. +/// This class is used to monitor changes to the internal state of instructions +/// that are sent to the various components of the simulated hardware pipeline. class Instruction { const InstrDesc &Desc; diff --git a/tools/llvm-mca/InstructionTables.cpp b/tools/llvm-mca/InstructionTables.cpp index 79ca87048af..652ef201388 100644 --- a/tools/llvm-mca/InstructionTables.cpp +++ b/tools/llvm-mca/InstructionTables.cpp @@ -11,7 +11,7 @@ /// 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 -/// the backend pipeline. +/// the pipeline. /// //===----------------------------------------------------------------------===// diff --git a/tools/llvm-mca/Backend.cpp b/tools/llvm-mca/Pipeline.cpp similarity index 72% rename from tools/llvm-mca/Backend.cpp rename to tools/llvm-mca/Pipeline.cpp index c3e8d2f44c3..49cf71e60e3 100644 --- a/tools/llvm-mca/Backend.cpp +++ b/tools/llvm-mca/Pipeline.cpp @@ -1,4 +1,4 @@ -//===--------------------- Backend.cpp --------------------------*- C++ -*-===// +//===--------------------- Pipeline.cpp -------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -8,11 +8,12 @@ //===----------------------------------------------------------------------===// /// \file /// -/// Implementation of class Backend which emulates an hardware OoO backend. +/// This file implements an ordered container of stages that simulate the +/// pipeline of a hardware backend. /// //===----------------------------------------------------------------------===// -#include "Backend.h" +#include "Pipeline.h" #include "HWEventListener.h" #include "llvm/CodeGen/TargetSchedule.h" #include "llvm/Support/Debug.h" @@ -23,12 +24,12 @@ namespace mca { using namespace llvm; -void Backend::addEventListener(HWEventListener *Listener) { +void Pipeline::addEventListener(HWEventListener *Listener) { if (Listener) Listeners.insert(Listener); } -bool Backend::hasWorkToProcess() { +bool Pipeline::hasWorkToProcess() { const auto It = llvm::find_if(Stages, [](const std::unique_ptr &S) { return S->hasWorkToComplete(); }); @@ -37,24 +38,24 @@ bool Backend::hasWorkToProcess() { // This routine returns early if any stage returns 'false' after execute() is // called on it. -bool Backend::executeStages(InstRef &IR) { +bool Pipeline::executeStages(InstRef &IR) { for (const std::unique_ptr &S : Stages) if (!S->execute(IR)) return false; return true; } -void Backend::postExecuteStages(const InstRef &IR) { +void Pipeline::postExecuteStages(const InstRef &IR) { for (const std::unique_ptr &S : Stages) S->postExecute(IR); } -void Backend::run() { +void Pipeline::run() { while (hasWorkToProcess()) runCycle(Cycles++); } -void Backend::runCycle(unsigned Cycle) { +void Pipeline::runCycle(unsigned Cycle) { notifyCycleBegin(Cycle); // Update the stages before we do any processing for this cycle. @@ -70,40 +71,40 @@ void Backend::runCycle(unsigned Cycle) { notifyCycleEnd(Cycle); } -void Backend::notifyCycleBegin(unsigned Cycle) { +void Pipeline::notifyCycleBegin(unsigned Cycle) { LLVM_DEBUG(dbgs() << "[E] Cycle begin: " << Cycle << '\n'); for (HWEventListener *Listener : Listeners) Listener->onCycleBegin(); } -void Backend::notifyInstructionEvent(const HWInstructionEvent &Event) { +void Pipeline::notifyInstructionEvent(const HWInstructionEvent &Event) { for (HWEventListener *Listener : Listeners) Listener->onInstructionEvent(Event); } -void Backend::notifyStallEvent(const HWStallEvent &Event) { +void Pipeline::notifyStallEvent(const HWStallEvent &Event) { for (HWEventListener *Listener : Listeners) Listener->onStallEvent(Event); } -void Backend::notifyResourceAvailable(const ResourceRef &RR) { +void Pipeline::notifyResourceAvailable(const ResourceRef &RR) { LLVM_DEBUG(dbgs() << "[E] Resource Available: [" << RR.first << '.' << RR.second << "]\n"); for (HWEventListener *Listener : Listeners) Listener->onResourceAvailable(RR); } -void Backend::notifyReservedBuffers(ArrayRef Buffers) { +void Pipeline::notifyReservedBuffers(ArrayRef Buffers) { for (HWEventListener *Listener : Listeners) Listener->onReservedBuffers(Buffers); } -void Backend::notifyReleasedBuffers(ArrayRef Buffers) { +void Pipeline::notifyReleasedBuffers(ArrayRef Buffers) { for (HWEventListener *Listener : Listeners) Listener->onReleasedBuffers(Buffers); } -void Backend::notifyCycleEnd(unsigned Cycle) { +void Pipeline::notifyCycleEnd(unsigned Cycle) { LLVM_DEBUG(dbgs() << "[E] Cycle end: " << Cycle << "\n\n"); for (HWEventListener *Listener : Listeners) Listener->onCycleEnd(); diff --git a/tools/llvm-mca/Backend.h b/tools/llvm-mca/Pipeline.h similarity index 75% rename from tools/llvm-mca/Backend.h rename to tools/llvm-mca/Pipeline.h index 87969ae61c5..3ff4f152624 100644 --- a/tools/llvm-mca/Backend.h +++ b/tools/llvm-mca/Pipeline.h @@ -1,4 +1,4 @@ -//===--------------------- Backend.h ----------------------------*- C++ -*-===// +//===--------------------- Pipeline.h ---------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -8,12 +8,13 @@ //===----------------------------------------------------------------------===// /// \file /// -/// This file implements an OoO backend for the llvm-mca tool. +/// This file implements an ordered container of stages that simulate the +/// pipeline of a hardware backend. /// //===----------------------------------------------------------------------===// -#ifndef LLVM_TOOLS_LLVM_MCA_BACKEND_H -#define LLVM_TOOLS_LLVM_MCA_BACKEND_H +#ifndef LLVM_TOOLS_LLVM_MCA_PIPELINE_H +#define LLVM_TOOLS_LLVM_MCA_PIPELINE_H #include "Scheduler.h" #include "Stage.h" @@ -25,7 +26,7 @@ class HWEventListener; class HWInstructionEvent; class HWStallEvent; -/// An out of order backend for a specific subtarget. +/// A pipeline for a specific subtarget. /// /// It emulates an out-of-order execution of instructions. Instructions are /// fetched from a MCInst sequence managed by an initial 'Fetch' stage. @@ -42,15 +43,15 @@ class HWStallEvent; /// 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 +/// The Pipeline 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 +/// Internally, the Pipeline collects statistical information in the form of /// histograms. For example, it tracks how the dispatch group size changes /// over time. -class Backend { - /// An ordered list of stages that define this backend's instruction pipeline. +class Pipeline { + /// An ordered list of stages that define this instruction pipeline. llvm::SmallVector, 8> Stages; std::set Listeners; unsigned Cycles; @@ -61,9 +62,9 @@ class Backend { void runCycle(unsigned Cycle); public: - Backend(unsigned DispatchWidth = 0, unsigned RegisterFileSize = 0, - unsigned LoadQueueSize = 0, unsigned StoreQueueSize = 0, - bool AssumeNoAlias = false) + Pipeline(unsigned DispatchWidth = 0, unsigned RegisterFileSize = 0, + unsigned LoadQueueSize = 0, unsigned StoreQueueSize = 0, + bool AssumeNoAlias = false) : Cycles(0) {} void appendStage(std::unique_ptr S) { Stages.push_back(std::move(S)); } void run(); @@ -78,4 +79,4 @@ public: }; } // namespace mca -#endif +#endif // LLVM_TOOLS_LLVM_MCA_PIPELINE_H diff --git a/tools/llvm-mca/BackendPrinter.cpp b/tools/llvm-mca/PipelinePrinter.cpp similarity index 72% rename from tools/llvm-mca/BackendPrinter.cpp rename to tools/llvm-mca/PipelinePrinter.cpp index 6fc78a5112b..6e85b92db2f 100644 --- a/tools/llvm-mca/BackendPrinter.cpp +++ b/tools/llvm-mca/PipelinePrinter.cpp @@ -1,4 +1,4 @@ -//===--------------------- BackendPrinter.cpp -------------------*- C++ -*-===// +//===--------------------- PipelinePrinter.cpp ------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -8,11 +8,11 @@ //===----------------------------------------------------------------------===// /// \file /// -/// This file implements the BackendPrinter interface. +/// This file implements the PipelinePrinter interface. /// //===----------------------------------------------------------------------===// -#include "BackendPrinter.h" +#include "PipelinePrinter.h" #include "View.h" #include "llvm/CodeGen/TargetSchedule.h" @@ -20,7 +20,7 @@ namespace mca { using namespace llvm; -void BackendPrinter::printReport(llvm::raw_ostream &OS) const { +void PipelinePrinter::printReport(llvm::raw_ostream &OS) const { for (const auto &V : Views) V->printView(OS); } diff --git a/tools/llvm-mca/BackendPrinter.h b/tools/llvm-mca/PipelinePrinter.h similarity index 69% rename from tools/llvm-mca/BackendPrinter.h rename to tools/llvm-mca/PipelinePrinter.h index e367554d06a..fe871414418 100644 --- a/tools/llvm-mca/BackendPrinter.h +++ b/tools/llvm-mca/PipelinePrinter.h @@ -1,4 +1,4 @@ -//===--------------------- BackendPrinter.h ---------------------*- C++ -*-===// +//===--------------------- PipelinePrinter.h --------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -8,16 +8,16 @@ //===----------------------------------------------------------------------===// /// \file /// -/// This file implements class BackendPrinter. +/// This file implements class PipelinePrinter. /// -/// BackendPrinter allows the customization of the performance report. +/// PipelinePrinter allows the customization of the performance report. /// //===----------------------------------------------------------------------===// -#ifndef LLVM_TOOLS_LLVM_MCA_BACKENDPRINTER_H -#define LLVM_TOOLS_LLVM_MCA_BACKENDPRINTER_H +#ifndef LLVM_TOOLS_LLVM_MCA_PIPELINEPRINTER_H +#define LLVM_TOOLS_LLVM_MCA_PIPELINEPRINTER_H -#include "Backend.h" +#include "Pipeline.h" #include "View.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/raw_ostream.h" @@ -33,15 +33,15 @@ namespace mca { /// during the execution of the code. Internally, it delegates to other /// classes the task of printing out timeline information as well as /// resource pressure. -class BackendPrinter { - Backend &B; +class PipelinePrinter { + Pipeline &P; llvm::SmallVector, 8> Views; public: - BackendPrinter(Backend &backend) : B(backend) {} + PipelinePrinter(Pipeline &pipeline) : P(pipeline) {} void addView(std::unique_ptr V) { - B.addEventListener(V.get()); + P.addEventListener(V.get()); Views.emplace_back(std::move(V)); } @@ -49,4 +49,4 @@ public: }; } // namespace mca -#endif +#endif // LLVM_TOOLS_LLVM_MCA_PIPELINEPRINTER_H diff --git a/tools/llvm-mca/README.txt b/tools/llvm-mca/README.txt index 7fa12f3604b..8b1670db0fc 100644 --- a/tools/llvm-mca/README.txt +++ b/tools/llvm-mca/README.txt @@ -18,7 +18,7 @@ cycle), as well as hardware resources pressure. The analysis and reporting style were inspired by the IACA tool from Intel. The presence of long data dependency chains, as well as poor usage of hardware -resources may lead to bottlenecks in the back-end. The tool is able to generate +resources may lead to bottlenecks in the backend. The tool is able to generate a detailed report which should help with identifying and analyzing sources of bottlenecks. @@ -54,12 +54,12 @@ How the tool works The tool takes assembly code as input. Assembly code is parsed into a sequence of MCInst with the help of the existing LLVM target assembly parsers. The parsed -sequence of MCInst is then analyzed by a 'Backend' module to generate a +sequence of MCInst is then analyzed by a 'Pipeline' module to generate a performance report. -The Backend module internally emulates the execution of the machine code +The Pipeline module internally emulates the execution of the machine code sequence in a loop of iterations (which by default is 100). At the end of this -process, the backend collects a number of statistics which are then printed out +process, the pipeline collects a number of statistics which are then printed out in the form of a report. Here is an example of performance report generated by the tool for a dot-product @@ -311,7 +311,7 @@ JFPU01, 18/18 JLSAGU, 0/12 /////////////////// -Based on the verbose report, the backend was only able to dispatch two +Based on the verbose report, the pipeline was only able to dispatch two instructions 51.5% of the time. The dispatch group was limited to one instruction 44.6% of the cycles, which corresponds to 272 cycles. @@ -344,8 +344,8 @@ dependencies, and not by resource pressure. LLVM-MCA instruction flow ------------------------- -This section describes the instruction flow through the out-of-order backend, as -well as the functional units involved in the process. +This section describes the instruction flow through the out-of-order backend, +as well as the functional units involved in the process. An instruction goes through a default sequence of stages: - Dispatch (Instruction is dispatched to the schedulers). diff --git a/tools/llvm-mca/ResourcePressureView.h b/tools/llvm-mca/ResourcePressureView.h index 570cdc63f1e..c15cf1832ad 100644 --- a/tools/llvm-mca/ResourcePressureView.h +++ b/tools/llvm-mca/ResourcePressureView.h @@ -10,7 +10,7 @@ /// /// This file define class ResourcePressureView. /// Class ResourcePressureView observes hardware events generated by -/// the Backend object and collects statistics related to resource usage at +/// the Pipeline object and collects statistics related to resource usage at /// instruction granularity. /// Resource pressure information is then printed out to a stream in the /// form of a table like the one from the example below: @@ -67,8 +67,6 @@ namespace mca { -class Backend; - /// This class collects resource pressure statistics and it is able to print /// out all the collected information as a table to an output stream. class ResourcePressureView : public View { diff --git a/tools/llvm-mca/RetireStage.cpp b/tools/llvm-mca/RetireStage.cpp index a38c7582878..cdd0a22fb35 100644 --- a/tools/llvm-mca/RetireStage.cpp +++ b/tools/llvm-mca/RetireStage.cpp @@ -15,8 +15,8 @@ //===----------------------------------------------------------------------===// #include "RetireStage.h" -#include "Backend.h" #include "HWEventListener.h" +#include "Pipeline.h" #include "llvm/Support/Debug.h" using namespace llvm; diff --git a/tools/llvm-mca/RetireStage.h b/tools/llvm-mca/RetireStage.h index 3041f26fd6e..4466890e790 100644 --- a/tools/llvm-mca/RetireStage.h +++ b/tools/llvm-mca/RetireStage.h @@ -23,17 +23,17 @@ namespace mca { -class Backend; +class Pipeline; class RetireStage : public Stage { // Owner will go away when we move listeners/eventing to the stages. - Backend *Owner; + Pipeline *Owner; RetireControlUnit &RCU; RegisterFile &PRF; public: - RetireStage(Backend *B, RetireControlUnit &R, RegisterFile &F) - : Stage(), Owner(B), RCU(R), PRF(F) {} + RetireStage(Pipeline *P, RetireControlUnit &R, RegisterFile &F) + : Stage(), Owner(P), RCU(R), PRF(F) {} RetireStage(const RetireStage &Other) = delete; RetireStage &operator=(const RetireStage &Other) = delete; diff --git a/tools/llvm-mca/Scheduler.cpp b/tools/llvm-mca/Scheduler.cpp index ebf67bcb441..0e4bd77b7fd 100644 --- a/tools/llvm-mca/Scheduler.cpp +++ b/tools/llvm-mca/Scheduler.cpp @@ -12,8 +12,8 @@ //===----------------------------------------------------------------------===// #include "Scheduler.h" -#include "Backend.h" #include "HWEventListener.h" +#include "Pipeline.h" #include "Support.h" #include "llvm/Support/raw_ostream.h" diff --git a/tools/llvm-mca/Support.cpp b/tools/llvm-mca/Support.cpp index fac237f740d..8f6b8a91f38 100644 --- a/tools/llvm-mca/Support.cpp +++ b/tools/llvm-mca/Support.cpp @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// \file /// -/// This file implements a few helper functions used by various backend +/// This file implements a few helper functions used by various pipeline /// components. /// //===----------------------------------------------------------------------===// diff --git a/tools/llvm-mca/Support.h b/tools/llvm-mca/Support.h index 98302e7e15c..fd8d8b5a23b 100644 --- a/tools/llvm-mca/Support.h +++ b/tools/llvm-mca/Support.h @@ -8,7 +8,7 @@ //===----------------------------------------------------------------------===// /// \file /// -/// Helper functions used by various backend components. +/// Helper functions used by various pipeline components. /// //===----------------------------------------------------------------------===// diff --git a/tools/llvm-mca/TimelineView.h b/tools/llvm-mca/TimelineView.h index 9b9c4e3d26b..1a85ca1de64 100644 --- a/tools/llvm-mca/TimelineView.h +++ b/tools/llvm-mca/TimelineView.h @@ -10,8 +10,8 @@ /// /// This file implements a timeline view for the llvm-mca tool. /// -/// Class TimelineView observes events generated by the backend. For every -/// instruction executed by the backend, it stores information related to +/// Class TimelineView observes events generated by the pipeline. For every +/// instruction executed by the pipeline, it stores information related to /// state transition. It then plots that information in the form of a table /// as reported by the example below: /// @@ -113,7 +113,7 @@ namespace mca { /// This class listens to instruction state transition events /// in order to construct a timeline information. /// -/// For every instruction executed by the Backend, this class constructs +/// For every instruction executed by the Pipeline, this class constructs /// a TimelineViewEntry object. TimelineViewEntry objects are then used /// to print the timeline information, as well as the "average wait times" /// for every instruction in the input assembly sequence. diff --git a/tools/llvm-mca/llvm-mca.cpp b/tools/llvm-mca/llvm-mca.cpp index fb019f12580..380cd3f6adc 100644 --- a/tools/llvm-mca/llvm-mca.cpp +++ b/tools/llvm-mca/llvm-mca.cpp @@ -21,7 +21,6 @@ // //===----------------------------------------------------------------------===// -#include "BackendPrinter.h" #include "CodeRegion.h" #include "DispatchStage.h" #include "DispatchStatistics.h" @@ -29,6 +28,8 @@ #include "FetchStage.h" #include "InstructionInfoView.h" #include "InstructionTables.h" +#include "Pipeline.h" +#include "PipelinePrinter.h" #include "RegisterFile.h" #include "RegisterFileStatistics.h" #include "ResourcePressureView.h" @@ -506,14 +507,14 @@ int main(int argc, char **argv) { mca::Scheduler HWS(SM, LoadQueueSize, StoreQueueSize, AssumeNoAlias); // Create the pipeline and add stages to it. - auto B = llvm::make_unique( + auto P = llvm::make_unique( Width, RegisterFileSize, LoadQueueSize, StoreQueueSize, AssumeNoAlias); - B->appendStage(llvm::make_unique(IB, S)); - B->appendStage(llvm::make_unique( - B.get(), *STI, *MRI, RegisterFileSize, Width, RCU, PRF, HWS)); - B->appendStage(llvm::make_unique(B.get(), RCU, PRF)); - B->appendStage(llvm::make_unique(B.get(), RCU, HWS)); - mca::BackendPrinter Printer(*B); + P->appendStage(llvm::make_unique(IB, S)); + P->appendStage(llvm::make_unique( + P.get(), *STI, *MRI, RegisterFileSize, Width, RCU, PRF, HWS)); + P->appendStage(llvm::make_unique(P.get(), RCU, PRF)); + P->appendStage(llvm::make_unique(P.get(), RCU, HWS)); + mca::PipelinePrinter Printer(*P); if (PrintSummaryView) Printer.addView(llvm::make_unique(SM, S, Width)); @@ -543,7 +544,7 @@ int main(int argc, char **argv) { *STI, *IP, S, TimelineMaxIterations, TimelineMaxCycles)); } - B->run(); + P->run(); Printer.printReport(TOF->os()); }