1 //===--------------------- RegisterFileStatistics.cpp -----------*- 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 /// \file
9 ///
10 /// This file implements the RegisterFileStatistics interface.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "Views/RegisterFileStatistics.h"
15 #include "llvm/Support/Format.h"
16 
17 namespace llvm {
18 namespace mca {
19 
RegisterFileStatistics(const MCSubtargetInfo & sti)20 RegisterFileStatistics::RegisterFileStatistics(const MCSubtargetInfo &sti)
21     : STI(sti) {
22   const MCSchedModel &SM = STI.getSchedModel();
23   RegisterFileUsage RFUEmpty = {0, 0, 0};
24   MoveEliminationInfo MEIEmpty = {0, 0, 0, 0, 0};
25   if (!SM.hasExtraProcessorInfo()) {
26     // Assume a single register file.
27     PRFUsage.emplace_back(RFUEmpty);
28     MoveElimInfo.emplace_back(MEIEmpty);
29     return;
30   }
31 
32   // Initialize a RegisterFileUsage for every user defined register file, plus
33   // the default register file which is always at index #0.
34   const MCExtraProcessorInfo &PI = SM.getExtraProcessorInfo();
35   // There is always an "InvalidRegisterFile" entry in tablegen. That entry can
36   // be skipped. If there are no user defined register files, then reserve a
37   // single entry for the default register file at index #0.
38   unsigned NumRegFiles = std::max(PI.NumRegisterFiles, 1U);
39 
40   PRFUsage.resize(NumRegFiles);
41   std::fill(PRFUsage.begin(), PRFUsage.end(), RFUEmpty);
42 
43   MoveElimInfo.resize(NumRegFiles);
44   std::fill(MoveElimInfo.begin(), MoveElimInfo.end(), MEIEmpty);
45 }
46 
updateRegisterFileUsage(ArrayRef<unsigned> UsedPhysRegs)47 void RegisterFileStatistics::updateRegisterFileUsage(
48     ArrayRef<unsigned> UsedPhysRegs) {
49   for (unsigned I = 0, E = PRFUsage.size(); I < E; ++I) {
50     RegisterFileUsage &RFU = PRFUsage[I];
51     unsigned NumUsedPhysRegs = UsedPhysRegs[I];
52     RFU.CurrentlyUsedMappings += NumUsedPhysRegs;
53     RFU.TotalMappings += NumUsedPhysRegs;
54     RFU.MaxUsedMappings =
55         std::max(RFU.MaxUsedMappings, RFU.CurrentlyUsedMappings);
56   }
57 }
58 
updateMoveElimInfo(const Instruction & Inst)59 void RegisterFileStatistics::updateMoveElimInfo(const Instruction &Inst) {
60   if (!Inst.isOptimizableMove())
61     return;
62 
63   if (Inst.getDefs().size() != Inst.getUses().size())
64     return;
65 
66   for (size_t I = 0, E = Inst.getDefs().size(); I < E; ++I) {
67     const WriteState &WS = Inst.getDefs()[I];
68     const ReadState &RS = Inst.getUses()[E - (I + 1)];
69 
70     MoveEliminationInfo &Info =
71         MoveElimInfo[Inst.getDefs()[0].getRegisterFileID()];
72     Info.TotalMoveEliminationCandidates++;
73     if (WS.isEliminated())
74       Info.CurrentMovesEliminated++;
75     if (WS.isWriteZero() && RS.isReadZero())
76       Info.TotalMovesThatPropagateZero++;
77   }
78 }
79 
onEvent(const HWInstructionEvent & Event)80 void RegisterFileStatistics::onEvent(const HWInstructionEvent &Event) {
81   switch (Event.Type) {
82   default:
83     break;
84   case HWInstructionEvent::Retired: {
85     const auto &RE = static_cast<const HWInstructionRetiredEvent &>(Event);
86     for (unsigned I = 0, E = PRFUsage.size(); I < E; ++I)
87       PRFUsage[I].CurrentlyUsedMappings -= RE.FreedPhysRegs[I];
88     break;
89   }
90   case HWInstructionEvent::Dispatched: {
91     const auto &DE = static_cast<const HWInstructionDispatchedEvent &>(Event);
92     updateRegisterFileUsage(DE.UsedPhysRegs);
93     updateMoveElimInfo(*DE.IR.getInstruction());
94   }
95   }
96 }
97 
onCycleEnd()98 void RegisterFileStatistics::onCycleEnd() {
99   for (MoveEliminationInfo &MEI : MoveElimInfo) {
100     unsigned &CurrentMax = MEI.MaxMovesEliminatedPerCycle;
101     CurrentMax = std::max(CurrentMax, MEI.CurrentMovesEliminated);
102     MEI.TotalMovesEliminated += MEI.CurrentMovesEliminated;
103     MEI.CurrentMovesEliminated = 0;
104   }
105 }
106 
printView(raw_ostream & OS) const107 void RegisterFileStatistics::printView(raw_ostream &OS) const {
108   std::string Buffer;
109   raw_string_ostream TempStream(Buffer);
110 
111   TempStream << "\n\nRegister File statistics:";
112   const RegisterFileUsage &GlobalUsage = PRFUsage[0];
113   TempStream << "\nTotal number of mappings created:    "
114              << GlobalUsage.TotalMappings;
115   TempStream << "\nMax number of mappings used:         "
116              << GlobalUsage.MaxUsedMappings << '\n';
117 
118   for (unsigned I = 1, E = PRFUsage.size(); I < E; ++I) {
119     const RegisterFileUsage &RFU = PRFUsage[I];
120     // Obtain the register file descriptor from the scheduling model.
121     assert(STI.getSchedModel().hasExtraProcessorInfo() &&
122            "Unable to find register file info!");
123     const MCExtraProcessorInfo &PI =
124         STI.getSchedModel().getExtraProcessorInfo();
125     assert(I <= PI.NumRegisterFiles && "Unexpected register file index!");
126     const MCRegisterFileDesc &RFDesc = PI.RegisterFiles[I];
127     // Skip invalid register files.
128     if (!RFDesc.NumPhysRegs)
129       continue;
130 
131     TempStream << "\n*  Register File #" << I;
132     TempStream << " -- " << StringRef(RFDesc.Name) << ':';
133     TempStream << "\n   Number of physical registers:     ";
134     if (!RFDesc.NumPhysRegs)
135       TempStream << "unbounded";
136     else
137       TempStream << RFDesc.NumPhysRegs;
138     TempStream << "\n   Total number of mappings created: "
139                << RFU.TotalMappings;
140     TempStream << "\n   Max number of mappings used:      "
141                << RFU.MaxUsedMappings << '\n';
142     const MoveEliminationInfo &MEI = MoveElimInfo[I];
143 
144     if (MEI.TotalMoveEliminationCandidates) {
145       TempStream << "   Number of optimizable moves:      "
146                  << MEI.TotalMoveEliminationCandidates;
147       double EliminatedMovProportion = (double)MEI.TotalMovesEliminated /
148                                        MEI.TotalMoveEliminationCandidates *
149                                        100.0;
150       double ZeroMovProportion = (double)MEI.TotalMovesThatPropagateZero /
151                                  MEI.TotalMoveEliminationCandidates * 100.0;
152       TempStream << "\n   Number of moves eliminated:       "
153                  << MEI.TotalMovesEliminated << "  "
154                  << format("(%.1f%%)",
155                            floor((EliminatedMovProportion * 10) + 0.5) / 10);
156       TempStream << "\n   Number of zero moves:             "
157                  << MEI.TotalMovesThatPropagateZero << "  "
158                  << format("(%.1f%%)",
159                            floor((ZeroMovProportion * 10) + 0.5) / 10);
160       TempStream << "\n   Max moves eliminated per cycle:   "
161                  << MEI.MaxMovesEliminatedPerCycle << '\n';
162     }
163   }
164 
165   TempStream.flush();
166   OS << Buffer;
167 }
168 
169 } // namespace mca
170 } // namespace llvm
171