mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-08 18:30:04 +00:00
2da8bc8a5f
DAG scheduling during isel. Most new functionality is currently guarded by -enable-sched-cycles and -enable-sched-hazard. Added InstrItineraryData::IssueWidth field, currently derived from ARM itineraries, but could be initialized differently on other targets. Added ScheduleHazardRecognizer::MaxLookAhead to indicate whether it is active, and if so how many cycles of state it holds. Added SchedulingPriorityQueue::HasReadyFilter to allowing gating entry into the scheduler's available queue. ScoreboardHazardRecognizer now accesses the ScheduleDAG in order to get information about it's SUnits, provides RecedeCycle for bottom-up scheduling, correctly computes scoreboard depth, tracks IssueCount, and considers potential stall cycles when checking for hazards. ScheduleDAGRRList now models machine cycles and hazards (under flags). It tracks MinAvailableCycle, drives the hazard recognizer and priority queue's ready filter, manages a new PendingQueue, properly accounts for stall cycles, etc. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@122541 91177308-0d34-0410-b5e6-96231b3b80d8
92 lines
3.4 KiB
C++
92 lines
3.4 KiB
C++
//=- llvm/CodeGen/ScheduleHazardRecognizer.h - Scheduling 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 implements the ScheduleHazardRecognizer class, which implements
|
|
// hazard-avoidance heuristics for scheduling.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
|
|
#define LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
|
|
|
|
namespace llvm {
|
|
|
|
class SUnit;
|
|
|
|
/// HazardRecognizer - This determines whether or not an instruction can be
|
|
/// issued this cycle, and whether or not a noop needs to be inserted to handle
|
|
/// the hazard.
|
|
class ScheduleHazardRecognizer {
|
|
protected:
|
|
/// MaxLookAhead - Indicate the number of cycles in the scoreboard
|
|
/// state. Important to restore the state after backtracking. Additionally,
|
|
/// MaxLookAhead=0 identifies a fake recognizer, allowing the client to
|
|
/// bypass virtual calls. Currently the PostRA scheduler ignores it.
|
|
unsigned MaxLookAhead;
|
|
|
|
public:
|
|
ScheduleHazardRecognizer(): MaxLookAhead(0) {}
|
|
virtual ~ScheduleHazardRecognizer();
|
|
|
|
enum HazardType {
|
|
NoHazard, // This instruction can be emitted at this cycle.
|
|
Hazard, // This instruction can't be emitted at this cycle.
|
|
NoopHazard // This instruction can't be emitted, and needs noops.
|
|
};
|
|
|
|
unsigned getMaxLookAhead() const { return MaxLookAhead; }
|
|
|
|
/// atIssueLimit - Return true if no more instructions may be issued in this
|
|
/// cycle.
|
|
virtual bool atIssueLimit() const { return false; }
|
|
|
|
/// getHazardType - Return the hazard type of emitting this node. There are
|
|
/// three possible results. Either:
|
|
/// * NoHazard: it is legal to issue this instruction on this cycle.
|
|
/// * Hazard: issuing this instruction would stall the machine. If some
|
|
/// other instruction is available, issue it first.
|
|
/// * NoopHazard: issuing this instruction would break the program. If
|
|
/// some other instruction can be issued, do so, otherwise issue a noop.
|
|
virtual HazardType getHazardType(SUnit *m, int Stalls) {
|
|
return NoHazard;
|
|
}
|
|
|
|
/// Reset - This callback is invoked when a new block of
|
|
/// instructions is about to be schedule. The hazard state should be
|
|
/// set to an initialized state.
|
|
virtual void Reset() {}
|
|
|
|
/// EmitInstruction - This callback is invoked when an instruction is
|
|
/// emitted, to advance the hazard state.
|
|
virtual void EmitInstruction(SUnit *) {}
|
|
|
|
/// AdvanceCycle - This callback is invoked whenever the next top-down
|
|
/// instruction to be scheduled cannot issue in the current cycle, either
|
|
/// because of latency or resource conflicts. This should increment the
|
|
/// internal state of the hazard recognizer so that previously "Hazard"
|
|
/// instructions will now not be hazards.
|
|
virtual void AdvanceCycle() {}
|
|
|
|
/// RecedeCycle - This callback is invoked whenever the next bottom-up
|
|
/// instruction to be scheduled cannot issue in the current cycle, either
|
|
/// because of latency or resource conflicts.
|
|
virtual void RecedeCycle() {}
|
|
|
|
/// EmitNoop - This callback is invoked when a noop was added to the
|
|
/// instruction stream.
|
|
virtual void EmitNoop() {
|
|
// Default implementation: count it as a cycle.
|
|
AdvanceCycle();
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|