xref: /freebsd/contrib/llvm-project/llvm/lib/Target/SystemZ/SystemZHazardRecognizer.h (revision 0d8fe2373503aeac48492f28073049a8bfa4feb5)
1 //=-- SystemZHazardRecognizer.h - SystemZ Hazard Recognizer -----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file declares a hazard recognizer for the SystemZ scheduler.
10 //
11 // This class is used by the SystemZ scheduling strategy to maintain
12 // the state during scheduling, and provide cost functions for
13 // scheduling candidates. This includes:
14 //
15 // * Decoder grouping. A decoder group can maximally hold 3 uops, and
16 // instructions that always begin a new group should be scheduled when
17 // the current decoder group is empty.
18 // * Processor resources usage. It is beneficial to balance the use of
19 // resources.
20 //
21 // A goal is to consider all instructions, also those outside of any
22 // scheduling region. Such instructions are "advanced" past and include
23 // single instructions before a scheduling region, branches etc.
24 //
25 // A block that has only one predecessor continues scheduling with the state
26 // of it (which may be updated by emitting branches).
27 //
28 // ===---------------------------------------------------------------------===//
29 
30 #ifndef LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZHAZARDRECOGNIZER_H
31 #define LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZHAZARDRECOGNIZER_H
32 
33 #include "SystemZSubtarget.h"
34 #include "llvm/ADT/SmallVector.h"
35 #include "llvm/CodeGen/MachineFunction.h"
36 #include "llvm/CodeGen/MachineScheduler.h"
37 #include "llvm/CodeGen/ScheduleHazardRecognizer.h"
38 #include "llvm/MC/MCInstrDesc.h"
39 #include "llvm/Support/raw_ostream.h"
40 #include <string>
41 
42 namespace llvm {
43 
44 /// SystemZHazardRecognizer maintains the state for one MBB during scheduling.
45 class SystemZHazardRecognizer : public ScheduleHazardRecognizer {
46 
47   const SystemZInstrInfo *TII;
48   const TargetSchedModel *SchedModel;
49 
50   /// Keep track of the number of decoder slots used in the current
51   /// decoder group.
52   unsigned CurrGroupSize;
53 
54   /// True if an instruction with four reg operands have been scheduled into
55   /// the current decoder group.
56   bool CurrGroupHas4RegOps;
57 
58   /// The tracking of resources here are quite similar to the common
59   /// code use of a critical resource. However, z13 differs in the way
60   /// that it has two processor sides which may be interesting to
61   /// model in the future (a work in progress).
62 
63   /// Counters for the number of uops scheduled per processor
64   /// resource.
65   SmallVector<int, 0> ProcResourceCounters;
66 
67   /// This is the resource with the greatest queue, which the
68   /// scheduler tries to avoid.
69   unsigned CriticalResourceIdx;
70 
71   /// Return the number of decoder slots MI requires.
72   inline unsigned getNumDecoderSlots(SUnit *SU) const;
73 
74   /// Return true if MI fits into current decoder group.
75   bool fitsIntoCurrentGroup(SUnit *SU) const;
76 
77   /// Return true if this instruction has four register operands.
78   bool has4RegOps(const MachineInstr *MI) const;
79 
80   /// Two decoder groups per cycle are formed (for z13), meaning 2x3
81   /// instructions. This function returns a number between 0 and 5,
82   /// representing the current decoder slot of the current cycle.  If an SU
83   /// is passed which will begin a new decoder group, the returned value is
84   /// the cycle index of the next group.
85   unsigned getCurrCycleIdx(SUnit *SU = nullptr) const;
86 
87   /// LastFPdOpCycleIdx stores the numbeer returned by getCurrCycleIdx()
88   /// when a stalling operation is scheduled (which uses the FPd resource).
89   unsigned LastFPdOpCycleIdx;
90 
91   /// A counter of decoder groups scheduled.
92   unsigned GrpCount;
93 
94   unsigned getCurrGroupSize() {return CurrGroupSize;};
95 
96   /// Start next decoder group.
97   void nextGroup();
98 
99   /// Clear all counters for processor resources.
100   void clearProcResCounters();
101 
102   /// With the goal of alternating processor sides for stalling (FPd)
103   /// ops, return true if it seems good to schedule an FPd op next.
104   bool isFPdOpPreferred_distance(SUnit *SU) const;
105 
106   /// Last emitted instruction or nullptr.
107   MachineInstr *LastEmittedMI;
108 
109 public:
110   SystemZHazardRecognizer(const SystemZInstrInfo *tii,
111                           const TargetSchedModel *SM)
112       : TII(tii), SchedModel(SM) {
113     Reset();
114   }
115 
116   HazardType getHazardType(SUnit *SU, int Stalls = 0) override;
117   void Reset() override;
118   void EmitInstruction(SUnit *SU) override;
119 
120   /// Resolves and cache a resolved scheduling class for an SUnit.
121   const MCSchedClassDesc *getSchedClass(SUnit *SU) const {
122     if (!SU->SchedClass && SchedModel->hasInstrSchedModel())
123       SU->SchedClass = SchedModel->resolveSchedClass(SU->getInstr());
124     return SU->SchedClass;
125   }
126 
127   /// Wrap a non-scheduled instruction in an SU and emit it.
128   void emitInstruction(MachineInstr *MI, bool TakenBranch = false);
129 
130   // Cost functions used by SystemZPostRASchedStrategy while
131   // evaluating candidates.
132 
133   /// Return the cost of decoder grouping for SU. If SU must start a
134   /// new decoder group, this is negative if this fits the schedule or
135   /// positive if it would mean ending a group prematurely. For normal
136   /// instructions this returns 0.
137   int groupingCost(SUnit *SU) const;
138 
139   /// Return the cost of SU in regards to processor resources usage.
140   /// A positive value means it would be better to wait with SU, while
141   /// a negative value means it would be good to schedule SU next.
142   int resourcesCost(SUnit *SU);
143 
144 #ifndef NDEBUG
145   // Debug dumping.
146   std::string CurGroupDbg; // current group as text
147   void dumpSU(SUnit *SU, raw_ostream &OS) const;
148   void dumpCurrGroup(std::string Msg = "") const;
149   void dumpProcResourceCounters() const;
150   void dumpState() const;
151 #endif
152 
153   MachineBasicBlock::iterator getLastEmittedMI() { return LastEmittedMI; }
154 
155   /// Copy counters from end of single predecessor.
156   void copyState(SystemZHazardRecognizer *Incoming);
157 };
158 
159 } // namespace llvm
160 
161 #endif /* LLVM_LIB_TARGET_SYSTEMZ_SYSTEMZHAZARDRECOGNIZER_H */
162