1 //=- llvm/CodeGen/ScoreboardHazardRecognizer.h - Schedule Support -*- C++ -*-=// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines the ScoreboardHazardRecognizer class, which 10 // encapsulates hazard-avoidance heuristics for scheduling, based on the 11 // scheduling itineraries specified for the target. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H 16 #define LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H 17 18 #include "llvm/CodeGen/ScheduleHazardRecognizer.h" 19 #include "llvm/MC/MCInstrItineraries.h" 20 #include <cassert> 21 #include <cstddef> 22 #include <cstring> 23 24 namespace llvm { 25 26 class ScheduleDAG; 27 class SUnit; 28 29 class ScoreboardHazardRecognizer : public ScheduleHazardRecognizer { 30 // Scoreboard to track function unit usage. Scoreboard[0] is a 31 // mask of the FUs in use in the cycle currently being 32 // schedule. Scoreboard[1] is a mask for the next cycle. The 33 // Scoreboard is used as a circular buffer with the current cycle 34 // indicated by Head. 35 // 36 // Scoreboard always counts cycles in forward execution order. If used by a 37 // bottom-up scheduler, then the scoreboard cycles are the inverse of the 38 // scheduler's cycles. 39 class Scoreboard { 40 InstrStage::FuncUnits *Data = nullptr; 41 42 // The maximum number of cycles monitored by the Scoreboard. This 43 // value is determined based on the target itineraries to ensure 44 // that all hazards can be tracked. 45 size_t Depth = 0; 46 47 // Indices into the Scoreboard that represent the current cycle. 48 size_t Head = 0; 49 50 public: 51 Scoreboard() = default; 52 Scoreboard &operator=(const Scoreboard &other) = delete; 53 Scoreboard(const Scoreboard &other) = delete; ~Scoreboard()54 ~Scoreboard() { 55 delete[] Data; 56 } 57 getDepth()58 size_t getDepth() const { return Depth; } 59 60 InstrStage::FuncUnits& 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 InstrStage::FuncUnits[Depth]; 72 } 73 74 memset(Data, 0, Depth * sizeof(Data[0])); 75 Head = 0; 76 } 77 advance()78 void advance() { 79 Head = (Head + 1) & (Depth-1); 80 } 81 recede()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 *II, 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 129