mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-29 11:29:39 +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
101 lines
2.9 KiB
C++
101 lines
2.9 KiB
C++
//===---- LatencyPriorityQueue.h - A latency-oriented priority queue ------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file declares the LatencyPriorityQueue class, which is a
|
|
// SchedulingPriorityQueue that schedules using latency information to
|
|
// reduce the length of the critical path through the basic block.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LATENCY_PRIORITY_QUEUE_H
|
|
#define LATENCY_PRIORITY_QUEUE_H
|
|
|
|
#include "llvm/CodeGen/ScheduleDAG.h"
|
|
|
|
namespace llvm {
|
|
class LatencyPriorityQueue;
|
|
|
|
/// Sorting functions for the Available queue.
|
|
struct latency_sort : public std::binary_function<SUnit*, SUnit*, bool> {
|
|
LatencyPriorityQueue *PQ;
|
|
explicit latency_sort(LatencyPriorityQueue *pq) : PQ(pq) {}
|
|
|
|
bool operator()(const SUnit* left, const SUnit* right) const;
|
|
};
|
|
|
|
class LatencyPriorityQueue : public SchedulingPriorityQueue {
|
|
// SUnits - The SUnits for the current graph.
|
|
std::vector<SUnit> *SUnits;
|
|
|
|
/// NumNodesSolelyBlocking - This vector contains, for every node in the
|
|
/// Queue, the number of nodes that the node is the sole unscheduled
|
|
/// predecessor for. This is used as a tie-breaker heuristic for better
|
|
/// mobility.
|
|
std::vector<unsigned> NumNodesSolelyBlocking;
|
|
|
|
/// Queue - The queue.
|
|
std::vector<SUnit*> Queue;
|
|
latency_sort Picker;
|
|
|
|
public:
|
|
LatencyPriorityQueue() : Picker(this) {
|
|
}
|
|
|
|
bool isBottomUp() const { return false; }
|
|
|
|
void initNodes(std::vector<SUnit> &sunits) {
|
|
SUnits = &sunits;
|
|
NumNodesSolelyBlocking.resize(SUnits->size(), 0);
|
|
}
|
|
|
|
void addNode(const SUnit *SU) {
|
|
NumNodesSolelyBlocking.resize(SUnits->size(), 0);
|
|
}
|
|
|
|
void updateNode(const SUnit *SU) {
|
|
}
|
|
|
|
void releaseState() {
|
|
SUnits = 0;
|
|
}
|
|
|
|
unsigned getLatency(unsigned NodeNum) const {
|
|
assert(NodeNum < (*SUnits).size());
|
|
return (*SUnits)[NodeNum].getHeight();
|
|
}
|
|
|
|
unsigned getNumSolelyBlockNodes(unsigned NodeNum) const {
|
|
assert(NodeNum < NumNodesSolelyBlocking.size());
|
|
return NumNodesSolelyBlocking[NodeNum];
|
|
}
|
|
|
|
bool empty() const { return Queue.empty(); }
|
|
|
|
virtual void push(SUnit *U);
|
|
|
|
virtual SUnit *pop();
|
|
|
|
virtual void remove(SUnit *SU);
|
|
|
|
virtual void dump(ScheduleDAG* DAG) const;
|
|
|
|
// ScheduledNode - As nodes are scheduled, we look to see if there are any
|
|
// successor nodes that have a single unscheduled predecessor. If so, that
|
|
// single predecessor has a higher priority, since scheduling it will make
|
|
// the node available.
|
|
void ScheduledNode(SUnit *Node);
|
|
|
|
private:
|
|
void AdjustPriorityOfUnscheduledPreds(SUnit *SU);
|
|
SUnit *getSingleUnscheduledPred(SUnit *SU);
|
|
};
|
|
}
|
|
|
|
#endif
|