text: //=- llvm/CodeGen/ScoreboardHazardRecognizer.h - Schedule Support -*- C++ -*-=//
  //
  //                     The LLVM Compiler Infrastructure
  //
  // This file is distributed under the University of Illinois Open Source
  // License. See LICENSE.TXT for details.
  //
  //===----------------------------------------------------------------------===//
  //
  // This file defines the ScoreboardHazardRecognizer class, which
  // encapsulates hazard-avoidance heuristics for scheduling, based on the
  // scheduling itineraries specified for the target.
  //
  //===----------------------------------------------------------------------===//
  
  #ifndef LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
  #define LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
  
  #include "llvm/CodeGen/ScheduleHazardRecognizer.h"
  #include "llvm/Support/DataTypes.h"
  
  #include <cassert>
  #include <cstring>
  
  namespace llvm {
  
  class InstrItineraryData;
  class ScheduleDAG;
  class SUnit;
  
  class ScoreboardHazardRecognizer : public ScheduleHazardRecognizer {
    // Scoreboard to track function unit usage. Scoreboard[0] is a
    // mask of the FUs in use in the cycle currently being
    // schedule. Scoreboard[1] is a mask for the next cycle. The
    // Scoreboard is used as a circular buffer with the current cycle
    // indicated by Head.
    //
    // Scoreboard always counts cycles in forward execution order. If used by a
    // bottom-up scheduler, then the scoreboard cycles are the inverse of the
    // scheduler's cycles.
    class Scoreboard {
      unsigned *Data;
  
      // The maximum number of cycles monitored by the Scoreboard. This
      // value is determined based on the target itineraries to ensure
      // that all hazards can be tracked.
      size_t Depth;
      // Indices into the Scoreboard that represent the current cycle.
      size_t Head;
    public:
      Scoreboard():Data(NULL), Depth(0), Head(0) { }
      ~Scoreboard() {
        delete[] Data;
      }
  
      size_t getDepth() const { return Depth; }
      unsigned& operator[](size_t idx) const {
        // Depth is expected to be a power-of-2.
        assert(Depth && !(Depth & (Depth - 1)) &&
               "Scoreboard was not initialized properly!");
  
        return Data[(Head + idx) & (Depth-1)];
      }
  
      void reset(size_t d = 1) {
        if (Data == NULL) {
          Depth = d;
          Data = new unsigned[Depth];
        }
  
        memset(Data, 0, Depth * sizeof(Data[0]));
        Head = 0;
      }
  
      void advance() {
        Head = (Head + 1) & (Depth-1);
      }
  
      void recede() {
        Head = (Head - 1) & (Depth-1);
      }
  
      // Print the scoreboard.
      void dump() const;
    };
  
  #ifndef NDEBUG
    // Support for tracing ScoreboardHazardRecognizer as a component within
    // another module. Follows the current thread-unsafe model of tracing.
    static const char *DebugType;
  #endif
  
    // Itinerary data for the target.
    const InstrItineraryData *ItinData;
  
    const ScheduleDAG *DAG;
  
    /// IssueWidth - Max issue per cycle. 0=Unknown.
    unsigned IssueWidth;
  
    /// IssueCount - Count instructions issued in this cycle.
    unsigned IssueCount;
  
    Scoreboard ReservedScoreboard;
    Scoreboard RequiredScoreboard;
  
  public:
    ScoreboardHazardRecognizer(const InstrItineraryData *ItinData,
                               const ScheduleDAG *DAG,
                               const char *ParentDebugType = "");
  
    /// atIssueLimit - Return true if no more instructions may be issued in this
    /// cycle.
    virtual bool atIssueLimit() const;
  
    // Stalls provides an cycle offset at which SU will be scheduled. It will be
    // negative for bottom-up scheduling.
    virtual HazardType getHazardType(SUnit *SU, int Stalls);
    virtual void Reset();
    virtual void EmitInstruction(SUnit *SU);
    virtual void AdvanceCycle();
    virtual void RecedeCycle();
  };
  
  }
  
  #endif //!LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
  