LLVM  3.7.0
ScheduleHazardRecognizer.h
Go to the documentation of this file.
1 //=- llvm/CodeGen/ScheduleHazardRecognizer.h - Scheduling Support -*- 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 implements the ScheduleHazardRecognizer class, which implements
11 // hazard-avoidance heuristics for scheduling.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
16 #define LLVM_CODEGEN_SCHEDULEHAZARDRECOGNIZER_H
17 
18 namespace llvm {
19 
20 class SUnit;
21 
22 /// HazardRecognizer - This determines whether or not an instruction can be
23 /// issued this cycle, and whether or not a noop needs to be inserted to handle
24 /// the hazard.
26 protected:
27  /// MaxLookAhead - Indicate the number of cycles in the scoreboard
28  /// state. Important to restore the state after backtracking. Additionally,
29  /// MaxLookAhead=0 identifies a fake recognizer, allowing the client to
30  /// bypass virtual calls. Currently the PostRA scheduler ignores it.
31  unsigned MaxLookAhead;
32 
33 public:
35  virtual ~ScheduleHazardRecognizer();
36 
37  enum HazardType {
38  NoHazard, // This instruction can be emitted at this cycle.
39  Hazard, // This instruction can't be emitted at this cycle.
40  NoopHazard // This instruction can't be emitted, and needs noops.
41  };
42 
43  unsigned getMaxLookAhead() const { return MaxLookAhead; }
44 
45  bool isEnabled() const { return MaxLookAhead != 0; }
46 
47  /// atIssueLimit - Return true if no more instructions may be issued in this
48  /// cycle.
49  ///
50  /// FIXME: remove this once MachineScheduler is the only client.
51  virtual bool atIssueLimit() const { return false; }
52 
53  /// getHazardType - Return the hazard type of emitting this node. There are
54  /// three possible results. Either:
55  /// * NoHazard: it is legal to issue this instruction on this cycle.
56  /// * Hazard: issuing this instruction would stall the machine. If some
57  /// other instruction is available, issue it first.
58  /// * NoopHazard: issuing this instruction would break the program. If
59  /// some other instruction can be issued, do so, otherwise issue a noop.
60  virtual HazardType getHazardType(SUnit *m, int Stalls = 0) {
61  return NoHazard;
62  }
63 
64  /// Reset - This callback is invoked when a new block of
65  /// instructions is about to be schedule. The hazard state should be
66  /// set to an initialized state.
67  virtual void Reset() {}
68 
69  /// EmitInstruction - This callback is invoked when an instruction is
70  /// emitted, to advance the hazard state.
71  virtual void EmitInstruction(SUnit *) {}
72 
73  /// PreEmitNoops - This callback is invoked prior to emitting an instruction.
74  /// It should return the number of noops to emit prior to the provided
75  /// instruction.
76  /// Note: This is only used during PostRA scheduling. EmitNoop is not called
77  /// for these noops.
78  virtual unsigned PreEmitNoops(SUnit *) {
79  return 0;
80  }
81 
82  /// ShouldPreferAnother - This callback may be invoked if getHazardType
83  /// returns NoHazard. If, even though there is no hazard, it would be better to
84  /// schedule another available instruction, this callback should return true.
85  virtual bool ShouldPreferAnother(SUnit *) {
86  return false;
87  }
88 
89  /// AdvanceCycle - This callback is invoked whenever the next top-down
90  /// instruction to be scheduled cannot issue in the current cycle, either
91  /// because of latency or resource conflicts. This should increment the
92  /// internal state of the hazard recognizer so that previously "Hazard"
93  /// instructions will now not be hazards.
94  virtual void AdvanceCycle() {}
95 
96  /// RecedeCycle - This callback is invoked whenever the next bottom-up
97  /// instruction to be scheduled cannot issue in the current cycle, either
98  /// because of latency or resource conflicts.
99  virtual void RecedeCycle() {}
100 
101  /// EmitNoop - This callback is invoked when a noop was added to the
102  /// instruction stream.
103  virtual void EmitNoop() {
104  // Default implementation: count it as a cycle.
105  AdvanceCycle();
106  }
107 };
108 
109 }
110 
111 #endif
virtual void AdvanceCycle()
AdvanceCycle - This callback is invoked whenever the next top-down instruction to be scheduled cannot...
virtual void RecedeCycle()
RecedeCycle - This callback is invoked whenever the next bottom-up instruction to be scheduled cannot...
unsigned MaxLookAhead
MaxLookAhead - Indicate the number of cycles in the scoreboard state.
HazardRecognizer - This determines whether or not an instruction can be issued this cycle...
virtual bool ShouldPreferAnother(SUnit *)
ShouldPreferAnother - This callback may be invoked if getHazardType returns NoHazard.
virtual void EmitNoop()
EmitNoop - This callback is invoked when a noop was added to the instruction stream.
virtual void EmitInstruction(SUnit *)
EmitInstruction - This callback is invoked when an instruction is emitted, to advance the hazard stat...
virtual void Reset()
Reset - This callback is invoked when a new block of instructions is about to be schedule.
virtual unsigned PreEmitNoops(SUnit *)
PreEmitNoops - This callback is invoked prior to emitting an instruction.
virtual bool atIssueLimit() const
atIssueLimit - Return true if no more instructions may be issued in this cycle.
virtual HazardType getHazardType(SUnit *m, int Stalls=0)
getHazardType - Return the hazard type of emitting this node.
SUnit - Scheduling unit. This is a node in the scheduling DAG.
Definition: ScheduleDAG.h:261