contrib/llvm/include/llvm/CodeGen/ScoreboardHazardRecognizer.h

   1 //=- llvm/CodeGen/ScoreboardHazardRecognizer.h - Schedule Support -*- C++ -*-=//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the ScoreboardHazardRecognizer class, which
  11 // encapsulates hazard-avoidance heuristics for scheduling, based on the
  12 // scheduling itineraries specified for the target.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
  17 #define LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
  18
  19 #include "llvm/CodeGen/ScheduleHazardRecognizer.h"
  20 #include <cassert>
  21 #include <cstddef>
  22 #include <cstring>
  23
  24 namespace llvm {
  25
  26 class InstrItineraryData;
  27 class ScheduleDAG;
  28 class SUnit;
  29
  30 class ScoreboardHazardRecognizer : public ScheduleHazardRecognizer {
  31   // Scoreboard to track function unit usage. Scoreboard[0] is a
  32   // mask of the FUs in use in the cycle currently being
  33   // schedule. Scoreboard[1] is a mask for the next cycle. The
  34   // Scoreboard is used as a circular buffer with the current cycle
  35   // indicated by Head.
  36   //
  37   // Scoreboard always counts cycles in forward execution order. If used by a
  38   // bottom-up scheduler, then the scoreboard cycles are the inverse of the
  39   // scheduler's cycles.
  40   class Scoreboard {
  41     unsigned *Data = nullptr;
  42
  43     // The maximum number of cycles monitored by the Scoreboard. This
  44     // value is determined based on the target itineraries to ensure
  45     // that all hazards can be tracked.
  46     size_t Depth = 0;
  47
  48     // Indices into the Scoreboard that represent the current cycle.
  49     size_t Head = 0;
  50
  51   public:
  52     Scoreboard() = default;
  53
  54     ~Scoreboard() {
  55       delete[] Data;
  56     }
  57
  58     size_t getDepth() const { return Depth; }
  59
  60     unsigned& operator[](size_t idx) const {
  61       // Depth is expected to be a power-of-2.
  62       assert(Depth && !(Depth & (Depth - 1)) &&
  63              "Scoreboard was not initialized properly!");
  64
  65       return Data[(Head + idx) & (Depth-1)];
  66     }
  67
  68     void reset(size_t d = 1) {
  69       if (!Data) {
  70         Depth = d;
  71         Data = new unsigned[Depth];
  72       }
  73
  74       memset(Data, 0, Depth * sizeof(Data[0]));
  75       Head = 0;
  76     }
  77
  78     void advance() {
  79       Head = (Head + 1) & (Depth-1);
  80     }
  81
  82     void recede() {
  83       Head = (Head - 1) & (Depth-1);
  84     }
  85
  86     // Print the scoreboard.
  87     void dump() const;
  88   };
  89
  90   // Support for tracing ScoreboardHazardRecognizer as a component within
  91   // another module.
  92   const char *DebugType;
  93
  94   // Itinerary data for the target.
  95   const InstrItineraryData *ItinData;
  96
  97   const ScheduleDAG *DAG;
  98
  99   /// IssueWidth - Max issue per cycle. 0=Unknown.
 100   unsigned IssueWidth = 0;
 101
 102   /// IssueCount - Count instructions issued in this cycle.
 103   unsigned IssueCount = 0;
 104
 105   Scoreboard ReservedScoreboard;
 106   Scoreboard RequiredScoreboard;
 107
 108 public:
 109   ScoreboardHazardRecognizer(const InstrItineraryData *ItinData,
 110                              const ScheduleDAG *DAG,
 111                              const char *ParentDebugType = "");
 112
 113   /// atIssueLimit - Return true if no more instructions may be issued in this
 114   /// cycle.
 115   bool atIssueLimit() const override;
 116
 117   // Stalls provides an cycle offset at which SU will be scheduled. It will be
 118   // negative for bottom-up scheduling.
 119   HazardType getHazardType(SUnit *SU, int Stalls) override;
 120   void Reset() override;
 121   void EmitInstruction(SUnit *SU) override;
 122   void AdvanceCycle() override;
 123   void RecedeCycle() override;
 124 };
 125
 126 } // end namespace llvm
 127
 128 #endif // LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H