LLVM  3.7.0
TargetSchedule.h
Go to the documentation of this file.
1 //===-- llvm/CodeGen/TargetSchedule.h - Sched Machine Model -----*- 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 a wrapper around MCSchedModel that allows the interface to
11 // benefit from information currently only available in TargetInstrInfo.
12 // Ideally, the scheduling interface would be fully defined in the MC layer.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_CODEGEN_TARGETSCHEDULE_H
17 #define LLVM_CODEGEN_TARGETSCHEDULE_H
18 
19 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/MC/MCSchedule.h"
23 
24 namespace llvm {
25 
26 class TargetRegisterInfo;
27 class TargetSubtargetInfo;
28 class TargetInstrInfo;
29 class MachineInstr;
30 
31 /// Provide an instruction scheduling machine model to CodeGen passes.
33  // For efficiency, hold a copy of the statically defined MCSchedModel for this
34  // processor.
35  MCSchedModel SchedModel;
36  InstrItineraryData InstrItins;
37  const TargetSubtargetInfo *STI;
38  const TargetInstrInfo *TII;
39 
40  SmallVector<unsigned, 16> ResourceFactors;
41  unsigned MicroOpFactor; // Multiply to normalize microops to resource units.
42  unsigned ResourceLCM; // Resource units per cycle. Latency normalization factor.
43 
44  unsigned computeInstrLatency(const MCSchedClassDesc &SCDesc) const;
45 
46 public:
47  TargetSchedModel(): SchedModel(MCSchedModel::GetDefaultSchedModel()), STI(nullptr), TII(nullptr) {}
48 
49  /// \brief Initialize the machine model for instruction scheduling.
50  ///
51  /// The machine model API keeps a copy of the top-level MCSchedModel table
52  /// indices and may query TargetSubtargetInfo and TargetInstrInfo to resolve
53  /// dynamic properties.
54  void init(const MCSchedModel &sm, const TargetSubtargetInfo *sti,
55  const TargetInstrInfo *tii);
56 
57  /// Return the MCSchedClassDesc for this instruction.
59 
60  /// \brief TargetInstrInfo getter.
61  const TargetInstrInfo *getInstrInfo() const { return TII; }
62 
63  /// \brief Return true if this machine model includes an instruction-level
64  /// scheduling model.
65  ///
66  /// This is more detailed than the course grain IssueWidth and default
67  /// latency properties, but separate from the per-cycle itinerary data.
68  bool hasInstrSchedModel() const;
69 
70  const MCSchedModel *getMCSchedModel() const { return &SchedModel; }
71 
72  /// \brief Return true if this machine model includes cycle-to-cycle itinerary
73  /// data.
74  ///
75  /// This models scheduling at each stage in the processor pipeline.
76  bool hasInstrItineraries() const;
77 
79  if (hasInstrItineraries())
80  return &InstrItins;
81  return nullptr;
82  }
83 
84  /// \brief Identify the processor corresponding to the current subtarget.
85  unsigned getProcessorID() const { return SchedModel.getProcessorID(); }
86 
87  /// \brief Maximum number of micro-ops that may be scheduled per cycle.
88  unsigned getIssueWidth() const { return SchedModel.IssueWidth; }
89 
90  /// \brief Return the number of issue slots required for this MI.
91  unsigned getNumMicroOps(const MachineInstr *MI,
92  const MCSchedClassDesc *SC = nullptr) const;
93 
94  /// \brief Get the number of kinds of resources for this target.
95  unsigned getNumProcResourceKinds() const {
96  return SchedModel.getNumProcResourceKinds();
97  }
98 
99  /// \brief Get a processor resource by ID for convenience.
100  const MCProcResourceDesc *getProcResource(unsigned PIdx) const {
101  return SchedModel.getProcResource(PIdx);
102  }
103 
104 #ifndef NDEBUG
105  const char *getResourceName(unsigned PIdx) const {
106  if (!PIdx)
107  return "MOps";
108  return SchedModel.getProcResource(PIdx)->Name;
109  }
110 #endif
111 
113 
114  // \brief Get an iterator into the processor resources consumed by this
115  // scheduling class.
117  // The subtarget holds a single resource table for all processors.
118  return STI->getWriteProcResBegin(SC);
119  }
121  return STI->getWriteProcResEnd(SC);
122  }
123 
124  /// \brief Multiply the number of units consumed for a resource by this factor
125  /// to normalize it relative to other resources.
126  unsigned getResourceFactor(unsigned ResIdx) const {
127  return ResourceFactors[ResIdx];
128  }
129 
130  /// \brief Multiply number of micro-ops by this factor to normalize it
131  /// relative to other resources.
132  unsigned getMicroOpFactor() const {
133  return MicroOpFactor;
134  }
135 
136  /// \brief Multiply cycle count by this factor to normalize it relative to
137  /// other resources. This is the number of resource units per cycle.
138  unsigned getLatencyFactor() const {
139  return ResourceLCM;
140  }
141 
142  /// \brief Number of micro-ops that may be buffered for OOO execution.
143  unsigned getMicroOpBufferSize() const { return SchedModel.MicroOpBufferSize; }
144 
145  /// \brief Number of resource units that may be buffered for OOO execution.
146  /// \return The buffer size in resource units or -1 for unlimited.
147  int getResourceBufferSize(unsigned PIdx) const {
148  return SchedModel.getProcResource(PIdx)->BufferSize;
149  }
150 
151  /// \brief Compute operand latency based on the available machine model.
152  ///
153  /// Compute and return the latency of the given data dependent def and use
154  /// when the operand indices are already known. UseMI may be NULL for an
155  /// unknown user.
156  unsigned computeOperandLatency(const MachineInstr *DefMI, unsigned DefOperIdx,
157  const MachineInstr *UseMI, unsigned UseOperIdx)
158  const;
159 
160  /// \brief Compute the instruction latency based on the available machine
161  /// model.
162  ///
163  /// Compute and return the expected latency of this instruction independent of
164  /// a particular use. computeOperandLatency is the preferred API, but this is
165  /// occasionally useful to help estimate instruction cost.
166  ///
167  /// If UseDefaultDefLatency is false and no new machine sched model is
168  /// present this method falls back to TII->getInstrLatency with an empty
169  /// instruction itinerary (this is so we preserve the previous behavior of the
170  /// if converter after moving it to TargetSchedModel).
171  unsigned computeInstrLatency(const MachineInstr *MI,
172  bool UseDefaultDefLatency = true) const;
173  unsigned computeInstrLatency(unsigned Opcode) const;
174 
175  /// \brief Output dependency latency of a pair of defs of the same register.
176  ///
177  /// This is typically one cycle.
178  unsigned computeOutputLatency(const MachineInstr *DefMI, unsigned DefIdx,
179  const MachineInstr *DepMI) const;
180 };
181 
182 } // namespace llvm
183 
184 #endif
const MCSchedClassDesc * resolveSchedClass(const MachineInstr *MI) const
Return the MCSchedClassDesc for this instruction.
bool hasInstrItineraries() const
Return true if this machine model includes cycle-to-cycle itinerary data.
unsigned MicroOpBufferSize
Definition: MCSchedule.h:156
const MCWriteProcResEntry * getWriteProcResBegin(const MCSchedClassDesc *SC) const
Return an iterator at the first process resource consumed by the given scheduling class...
unsigned IssueWidth
Definition: MCSchedule.h:139
unsigned computeOutputLatency(const MachineInstr *DefMI, unsigned DefIdx, const MachineInstr *DepMI) const
Output dependency latency of a pair of defs of the same register.
void init(const MCSchedModel &sm, const TargetSubtargetInfo *sti, const TargetInstrInfo *tii)
Initialize the machine model for instruction scheduling.
unsigned getMicroOpBufferSize() const
Number of micro-ops that may be buffered for OOO execution.
const MCProcResourceDesc * getProcResource(unsigned ProcResourceIdx) const
Definition: MCSchedule.h:213
const TargetInstrInfo * getInstrInfo() const
TargetInstrInfo getter.
unsigned getResourceFactor(unsigned ResIdx) const
Multiply the number of units consumed for a resource by this factor to normalize it relative to other...
const MCWriteProcResEntry * getWriteProcResEnd(const MCSchedClassDesc *SC) const
Provide an instruction scheduling machine model to CodeGen passes.
Itinerary data supplied by a subtarget to be used by a target.
TargetInstrInfo - Interface to description of machine instruction set.
unsigned getNumProcResourceKinds() const
Definition: MCSchedule.h:209
const InstrItineraryData * getInstrItineraries() const
Identify one of the processor resource kinds consumed by a particular scheduling class for the specif...
Definition: MCSchedule.h:55
Summarize the scheduling resources required for an instruction of a particular scheduling class...
Definition: MCSchedule.h:101
unsigned getLatencyFactor() const
Multiply cycle count by this factor to normalize it relative to other resources.
unsigned getNumProcResourceKinds() const
Get the number of kinds of resources for this target.
const MCWriteProcResEntry * ProcResIter
ProcResIter getWriteProcResEnd(const MCSchedClassDesc *SC) const
const MCSchedModel * getMCSchedModel() const
bool hasInstrSchedModel() const
Return true if this machine model includes an instruction-level scheduling model. ...
int getResourceBufferSize(unsigned PIdx) const
Number of resource units that may be buffered for OOO execution.
const MCProcResourceDesc * getProcResource(unsigned PIdx) const
Get a processor resource by ID for convenience.
Define a kind of processor resource that will be modeled by the scheduler.
Definition: MCSchedule.h:26
CHAIN = SC CHAIN, Imm128 - System call.
unsigned getProcessorID() const
Identify the processor corresponding to the current subtarget.
TargetSubtargetInfo - Generic base class for all target subtargets.
unsigned getNumMicroOps(const MachineInstr *MI, const MCSchedClassDesc *SC=nullptr) const
Return the number of issue slots required for this MI.
Representation of each machine instruction.
Definition: MachineInstr.h:51
unsigned getProcessorID() const
Definition: MCSchedule.h:200
unsigned computeOperandLatency(const MachineInstr *DefMI, unsigned DefOperIdx, const MachineInstr *UseMI, unsigned UseOperIdx) const
Compute operand latency based on the available machine model.
unsigned getMicroOpFactor() const
Multiply number of micro-ops by this factor to normalize it relative to other resources.
unsigned getIssueWidth() const
Maximum number of micro-ops that may be scheduled per cycle.
ProcResIter getWriteProcResBegin(const MCSchedClassDesc *SC) const
const char * getResourceName(unsigned PIdx) const
Machine model for scheduling, bundling, and heuristics.
Definition: MCSchedule.h:136