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 "llvm/Support/DataTypes.h" 21 #include <cassert> 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; 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; 47 // Indices into the Scoreboard that represent the current cycle. 48 size_t Head; 49 public: 50 Scoreboard():Data(NULL), Depth(0), Head(0) { } 51 ~Scoreboard() { 52 delete[] Data; 53 } 54 55 size_t getDepth() const { return Depth; } 56 unsigned& operator[](size_t idx) const { 57 // Depth is expected to be a power-of-2. 58 assert(Depth && !(Depth & (Depth - 1)) && 59 "Scoreboard was not initialized properly!"); 60 61 return Data[(Head + idx) & (Depth-1)]; 62 } 63 64 void reset(size_t d = 1) { 65 if (Data == NULL) { 66 Depth = d; 67 Data = new unsigned[Depth]; 68 } 69 70 memset(Data, 0, Depth * sizeof(Data[0])); 71 Head = 0; 72 } 73 74 void advance() { 75 Head = (Head + 1) & (Depth-1); 76 } 77 78 void recede() { 79 Head = (Head - 1) & (Depth-1); 80 } 81 82 // Print the scoreboard. 83 void dump() const; 84 }; 85 86 #ifndef NDEBUG 87 // Support for tracing ScoreboardHazardRecognizer as a component within 88 // another module. Follows the current thread-unsafe model of tracing. 89 static const char *DebugType; 90 #endif 91 92 // Itinerary data for the target. 93 const InstrItineraryData *ItinData; 94 95 const ScheduleDAG *DAG; 96 97 /// IssueWidth - Max issue per cycle. 0=Unknown. 98 unsigned IssueWidth; 99 100 /// IssueCount - Count instructions issued in this cycle. 101 unsigned IssueCount; 102 103 Scoreboard ReservedScoreboard; 104 Scoreboard RequiredScoreboard; 105 106 public: 107 ScoreboardHazardRecognizer(const InstrItineraryData *ItinData, 108 const ScheduleDAG *DAG, 109 const char *ParentDebugType = ""); 110 111 /// atIssueLimit - Return true if no more instructions may be issued in this 112 /// cycle. 113 virtual bool atIssueLimit() const; 114 115 // Stalls provides an cycle offset at which SU will be scheduled. It will be 116 // negative for bottom-up scheduling. 117 virtual HazardType getHazardType(SUnit *SU, int Stalls); 118 virtual void Reset(); 119 virtual void EmitInstruction(SUnit *SU); 120 virtual void AdvanceCycle(); 121 virtual void RecedeCycle(); 122 }; 123 124 } 125 126 #endif //!LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H 127
