| 1 |
//===--------------------- TimelineView.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 |
/// \brief |
| 9 |
/// |
| 10 |
/// This file implements the TimelineView interface. |
| 11 |
/// |
| 12 |
//===----------------------------------------------------------------------===// |
| 13 |
|
| 14 |
#include "Views/TimelineView.h" |
| 15 |
#include <numeric> |
| 16 |
|
| 17 |
namespace llvm { |
| 18 |
namespace mca { |
| 19 |
|
| 20 |
TimelineView::TimelineView(const MCSubtargetInfo &sti, MCInstPrinter &Printer, |
| 21 |
llvm::ArrayRef<llvm::MCInst> S, unsigned Iterations, |
| 22 |
unsigned Cycles) |
| 23 |
: InstructionView(sti, Printer, S), CurrentCycle(0), |
| 24 |
MaxCycle(Cycles == 0 ? std::numeric_limits<unsigned>::max() : Cycles), |
| 25 |
LastCycle(0), WaitTime(S.size()), UsedBuffer(S.size()) { |
| 26 |
unsigned NumInstructions = getSource().size(); |
| 27 |
assert(Iterations && "Invalid number of iterations specified!"); |
| 28 |
NumInstructions *= Iterations; |
| 29 |
Timeline.resize(NumInstructions); |
| 30 |
TimelineViewEntry InvalidTVEntry = {-1, 0, 0, 0, 0}; |
| 31 |
std::fill(Timeline.begin(), Timeline.end(), InvalidTVEntry); |
| 32 |
|
| 33 |
WaitTimeEntry NullWTEntry = {0, 0, 0}; |
| 34 |
std::fill(WaitTime.begin(), WaitTime.end(), NullWTEntry); |
| 35 |
|
| 36 |
std::pair<unsigned, int> NullUsedBufferEntry = {/* Invalid resource ID*/ 0, |
| 37 |
/* unknown buffer size */ -1}; |
| 38 |
std::fill(UsedBuffer.begin(), UsedBuffer.end(), NullUsedBufferEntry); |
| 39 |
} |
| 40 |
|
| 41 |
void TimelineView::onReservedBuffers(const InstRef &IR, |
| 42 |
ArrayRef<unsigned> Buffers) { |
| 43 |
if (IR.getSourceIndex() >= getSource().size()) |
| 44 |
return; |
| 45 |
|
| 46 |
const MCSchedModel &SM = getSubTargetInfo().getSchedModel(); |
| 47 |
std::pair<unsigned, int> BufferInfo = {0, -1}; |
| 48 |
for (const unsigned Buffer : Buffers) { |
| 49 |
const MCProcResourceDesc &MCDesc = *SM.getProcResource(Buffer); |
| 50 |
if (!BufferInfo.first || BufferInfo.second > MCDesc.BufferSize) { |
| 51 |
BufferInfo.first = Buffer; |
| 52 |
BufferInfo.second = MCDesc.BufferSize; |
| 53 |
} |
| 54 |
} |
| 55 |
|
| 56 |
UsedBuffer[IR.getSourceIndex()] = BufferInfo; |
| 57 |
} |
| 58 |
|
| 59 |
void TimelineView::onEvent(const HWInstructionEvent &Event) { |
| 60 |
const unsigned Index = Event.IR.getSourceIndex(); |
| 61 |
if (Index >= Timeline.size()) |
| 62 |
return; |
| 63 |
|
| 64 |
switch (Event.Type) { |
| 65 |
case HWInstructionEvent::Retired: { |
| 66 |
TimelineViewEntry &TVEntry = Timeline[Index]; |
| 67 |
if (CurrentCycle < MaxCycle) |
| 68 |
TVEntry.CycleRetired = CurrentCycle; |
| 69 |
|
| 70 |
// Update the WaitTime entry which corresponds to this Index. |
| 71 |
assert(TVEntry.CycleDispatched >= 0 && "Invalid TVEntry found!"); |
| 72 |
unsigned CycleDispatched = static_cast<unsigned>(TVEntry.CycleDispatched); |
| 73 |
WaitTimeEntry &WTEntry = WaitTime[Index % getSource().size()]; |
| 74 |
WTEntry.CyclesSpentInSchedulerQueue += |
| 75 |
TVEntry.CycleIssued - CycleDispatched; |
| 76 |
assert(CycleDispatched <= TVEntry.CycleReady && |
| 77 |
"Instruction cannot be ready if it hasn't been dispatched yet!"); |
| 78 |
WTEntry.CyclesSpentInSQWhileReady += |
| 79 |
TVEntry.CycleIssued - TVEntry.CycleReady; |
| 80 |
if (CurrentCycle > TVEntry.CycleExecuted) { |
| 81 |
WTEntry.CyclesSpentAfterWBAndBeforeRetire += |
| 82 |
(CurrentCycle - 1) - TVEntry.CycleExecuted; |
| 83 |
} |
| 84 |
break; |
| 85 |
} |
| 86 |
case HWInstructionEvent::Ready: |
| 87 |
Timeline[Index].CycleReady = CurrentCycle; |
| 88 |
break; |
| 89 |
case HWInstructionEvent::Issued: |
| 90 |
Timeline[Index].CycleIssued = CurrentCycle; |
| 91 |
break; |
| 92 |
case HWInstructionEvent::Executed: |
| 93 |
Timeline[Index].CycleExecuted = CurrentCycle; |
| 94 |
break; |
| 95 |
case HWInstructionEvent::Dispatched: |
| 96 |
// There may be multiple dispatch events. Microcoded instructions that are |
| 97 |
// expanded into multiple uOps may require multiple dispatch cycles. Here, |
| 98 |
// we want to capture the first dispatch cycle. |
| 99 |
if (Timeline[Index].CycleDispatched == -1) |
| 100 |
Timeline[Index].CycleDispatched = static_cast<int>(CurrentCycle); |
| 101 |
break; |
| 102 |
default: |
| 103 |
return; |
| 104 |
} |
| 105 |
if (CurrentCycle < MaxCycle) |
| 106 |
LastCycle = std::max(LastCycle, CurrentCycle); |
| 107 |
} |
| 108 |
|
| 109 |
static raw_ostream::Colors chooseColor(unsigned CumulativeCycles, |
| 110 |
unsigned Executions, int BufferSize) { |
| 111 |
if (CumulativeCycles && BufferSize < 0) |
| 112 |
return raw_ostream::MAGENTA; |
| 113 |
unsigned Size = static_cast<unsigned>(BufferSize); |
| 114 |
if (CumulativeCycles >= Size * Executions) |
| 115 |
return raw_ostream::RED; |
| 116 |
if ((CumulativeCycles * 2) >= Size * Executions) |
| 117 |
return raw_ostream::YELLOW; |
| 118 |
return raw_ostream::SAVEDCOLOR; |
| 119 |
} |
| 120 |
|
| 121 |
static void tryChangeColor(raw_ostream &OS, unsigned Cycles, |
| 122 |
unsigned Executions, int BufferSize) { |
| 123 |
if (!OS.has_colors()) |
| 124 |
return; |
| 125 |
|
| 126 |
raw_ostream::Colors Color = chooseColor(Cycles, Executions, BufferSize); |
| 127 |
if (Color == raw_ostream::SAVEDCOLOR) { |
| 128 |
OS.resetColor(); |
| 129 |
return; |
| 130 |
} |
| 131 |
OS.changeColor(Color, /* bold */ true, /* BG */ false); |
| 132 |
} |
| 133 |
|
| 134 |
void TimelineView::printWaitTimeEntry(formatted_raw_ostream &OS, |
| 135 |
const WaitTimeEntry &Entry, |
| 136 |
unsigned SourceIndex, |
| 137 |
unsigned Executions) const { |
| 138 |
bool PrintingTotals = SourceIndex == getSource().size(); |
| 139 |
unsigned CumulativeExecutions = PrintingTotals ? Timeline.size() : Executions; |
| 140 |
|
| 141 |
if (!PrintingTotals) |
| 142 |
OS << SourceIndex << '.'; |
| 143 |
|
| 144 |
OS.PadToColumn(7); |
| 145 |
|
| 146 |
double AverageTime1, AverageTime2, AverageTime3; |
| 147 |
AverageTime1 = |
| 148 |
(double)(Entry.CyclesSpentInSchedulerQueue * 10) / CumulativeExecutions; |
| 149 |
AverageTime2 = |
| 150 |
(double)(Entry.CyclesSpentInSQWhileReady * 10) / CumulativeExecutions; |
| 151 |
AverageTime3 = (double)(Entry.CyclesSpentAfterWBAndBeforeRetire * 10) / |
| 152 |
CumulativeExecutions; |
| 153 |
|
| 154 |
OS << Executions; |
| 155 |
OS.PadToColumn(13); |
| 156 |
|
| 157 |
int BufferSize = PrintingTotals ? 0 : UsedBuffer[SourceIndex].second; |
| 158 |
if (!PrintingTotals) |
| 159 |
tryChangeColor(OS, Entry.CyclesSpentInSchedulerQueue, CumulativeExecutions, |
| 160 |
BufferSize); |
| 161 |
OS << format("%.1f", floor(AverageTime1 + 0.5) / 10); |
| 162 |
OS.PadToColumn(20); |
| 163 |
if (!PrintingTotals) |
| 164 |
tryChangeColor(OS, Entry.CyclesSpentInSQWhileReady, CumulativeExecutions, |
| 165 |
BufferSize); |
| 166 |
OS << format("%.1f", floor(AverageTime2 + 0.5) / 10); |
| 167 |
OS.PadToColumn(27); |
| 168 |
if (!PrintingTotals) |
| 169 |
tryChangeColor(OS, Entry.CyclesSpentAfterWBAndBeforeRetire, |
| 170 |
CumulativeExecutions, |
| 171 |
getSubTargetInfo().getSchedModel().MicroOpBufferSize); |
| 172 |
OS << format("%.1f", floor(AverageTime3 + 0.5) / 10); |
| 173 |
|
| 174 |
if (OS.has_colors()) |
| 175 |
OS.resetColor(); |
| 176 |
OS.PadToColumn(34); |
| 177 |
} |
| 178 |
|
| 179 |
void TimelineView::printAverageWaitTimes(raw_ostream &OS) const { |
| 180 |
std::string Header = |
| 181 |
"\n\nAverage Wait times (based on the timeline view):\n" |
| 182 |
"[0]: Executions\n" |
| 183 |
"[1]: Average time spent waiting in a scheduler's queue\n" |
| 184 |
"[2]: Average time spent waiting in a scheduler's queue while ready\n" |
| 185 |
"[3]: Average time elapsed from WB until retire stage\n\n" |
| 186 |
" [0] [1] [2] [3]\n"; |
| 187 |
OS << Header; |
| 188 |
formatted_raw_ostream FOS(OS); |
| 189 |
unsigned Executions = Timeline.size() / getSource().size(); |
| 190 |
unsigned IID = 0; |
| 191 |
for (const MCInst &Inst : getSource()) { |
| 192 |
printWaitTimeEntry(FOS, WaitTime[IID], IID, Executions); |
| 193 |
FOS << " " << printInstructionString(Inst) << '\n'; |
| 194 |
FOS.flush(); |
| 195 |
++IID; |
| 196 |
} |
| 197 |
|
| 198 |
// If the timeline contains more than one instruction, |
| 199 |
// let's also print global averages. |
| 200 |
if (getSource().size() != 1) { |
| 201 |
WaitTimeEntry TotalWaitTime = std::accumulate( |
| 202 |
WaitTime.begin(), WaitTime.end(), WaitTimeEntry{0, 0, 0}, |
| 203 |
[](const WaitTimeEntry &A, const WaitTimeEntry &B) { |
| 204 |
return WaitTimeEntry{ |
| 205 |
A.CyclesSpentInSchedulerQueue + B.CyclesSpentInSchedulerQueue, |
| 206 |
A.CyclesSpentInSQWhileReady + B.CyclesSpentInSQWhileReady, |
| 207 |
A.CyclesSpentAfterWBAndBeforeRetire + |
| 208 |
B.CyclesSpentAfterWBAndBeforeRetire}; |
| 209 |
}); |
| 210 |
printWaitTimeEntry(FOS, TotalWaitTime, IID, Executions); |
| 211 |
FOS << " " |
| 212 |
<< "<total>" << '\n'; |
| 213 |
FOS.flush(); |
| 214 |
} |
| 215 |
} |
| 216 |
|
| 217 |
void TimelineView::printTimelineViewEntry(formatted_raw_ostream &OS, |
| 218 |
const TimelineViewEntry &Entry, |
| 219 |
unsigned Iteration, |
| 220 |
unsigned SourceIndex) const { |
| 221 |
if (Iteration == 0 && SourceIndex == 0) |
| 222 |
OS << '\n'; |
| 223 |
OS << '[' << Iteration << ',' << SourceIndex << ']'; |
| 224 |
OS.PadToColumn(10); |
| 225 |
assert(Entry.CycleDispatched >= 0 && "Invalid TimelineViewEntry!"); |
| 226 |
unsigned CycleDispatched = static_cast<unsigned>(Entry.CycleDispatched); |
| 227 |
for (unsigned I = 0, E = CycleDispatched; I < E; ++I) |
| 228 |
OS << ((I % 5 == 0) ? '.' : ' '); |
| 229 |
OS << TimelineView::DisplayChar::Dispatched; |
| 230 |
if (CycleDispatched != Entry.CycleExecuted) { |
| 231 |
// Zero latency instructions have the same value for CycleDispatched, |
| 232 |
// CycleIssued and CycleExecuted. |
| 233 |
for (unsigned I = CycleDispatched + 1, E = Entry.CycleIssued; I < E; ++I) |
| 234 |
OS << TimelineView::DisplayChar::Waiting; |
| 235 |
if (Entry.CycleIssued == Entry.CycleExecuted) |
| 236 |
OS << TimelineView::DisplayChar::DisplayChar::Executed; |
| 237 |
else { |
| 238 |
if (CycleDispatched != Entry.CycleIssued) |
| 239 |
OS << TimelineView::DisplayChar::Executing; |
| 240 |
for (unsigned I = Entry.CycleIssued + 1, E = Entry.CycleExecuted; I < E; |
| 241 |
++I) |
| 242 |
OS << TimelineView::DisplayChar::Executing; |
| 243 |
OS << TimelineView::DisplayChar::Executed; |
| 244 |
} |
| 245 |
} |
| 246 |
|
| 247 |
for (unsigned I = Entry.CycleExecuted + 1, E = Entry.CycleRetired; I < E; ++I) |
| 248 |
OS << TimelineView::DisplayChar::RetireLag; |
| 249 |
if (Entry.CycleExecuted < Entry.CycleRetired) |
| 250 |
OS << TimelineView::DisplayChar::Retired; |
| 251 |
|
| 252 |
// Skip other columns. |
| 253 |
for (unsigned I = Entry.CycleRetired + 1, E = LastCycle; I <= E; ++I) |
| 254 |
OS << ((I % 5 == 0 || I == LastCycle) ? '.' : ' '); |
| 255 |
} |
| 256 |
|
| 257 |
static void printTimelineHeader(formatted_raw_ostream &OS, unsigned Cycles) { |
| 258 |
OS << "\n\nTimeline view:\n"; |
| 259 |
if (Cycles >= 10) { |
| 260 |
OS.PadToColumn(10); |
| 261 |
for (unsigned I = 0; I <= Cycles; ++I) { |
| 262 |
if (((I / 10) & 1) == 0) |
| 263 |
OS << ' '; |
| 264 |
else |
| 265 |
OS << I % 10; |
| 266 |
} |
| 267 |
OS << '\n'; |
| 268 |
} |
| 269 |
|
| 270 |
OS << "Index"; |
| 271 |
OS.PadToColumn(10); |
| 272 |
for (unsigned I = 0; I <= Cycles; ++I) { |
| 273 |
if (((I / 10) & 1) == 0) |
| 274 |
OS << I % 10; |
| 275 |
else |
| 276 |
OS << ' '; |
| 277 |
} |
| 278 |
OS << '\n'; |
| 279 |
} |
| 280 |
|
| 281 |
void TimelineView::printTimeline(raw_ostream &OS) const { |
| 282 |
formatted_raw_ostream FOS(OS); |
| 283 |
printTimelineHeader(FOS, LastCycle); |
| 284 |
FOS.flush(); |
| 285 |
|
| 286 |
unsigned IID = 0; |
| 287 |
ArrayRef<llvm::MCInst> Source = getSource(); |
| 288 |
const unsigned Iterations = Timeline.size() / Source.size(); |
| 289 |
for (unsigned Iteration = 0; Iteration < Iterations; ++Iteration) { |
| 290 |
for (const MCInst &Inst : Source) { |
| 291 |
const TimelineViewEntry &Entry = Timeline[IID]; |
| 292 |
// When an instruction is retired after timeline-max-cycles, |
| 293 |
// its CycleRetired is left at 0. However, it's possible for |
| 294 |
// a 0 latency instruction to be retired during cycle 0 and we |
| 295 |
// don't want to early exit in that case. The CycleExecuted |
| 296 |
// attribute is set correctly whether or not it is greater |
| 297 |
// than timeline-max-cycles so we can use that to ensure |
| 298 |
// we don't early exit because of a 0 latency instruction. |
| 299 |
if (Entry.CycleRetired == 0 && Entry.CycleExecuted != 0) { |
| 300 |
FOS << "Truncated display due to cycle limit\n"; |
| 301 |
return; |
| 302 |
} |
| 303 |
|
| 304 |
unsigned SourceIndex = IID % Source.size(); |
| 305 |
printTimelineViewEntry(FOS, Entry, Iteration, SourceIndex); |
| 306 |
FOS << " " << printInstructionString(Inst) << '\n'; |
| 307 |
FOS.flush(); |
| 308 |
|
| 309 |
++IID; |
| 310 |
} |
| 311 |
} |
| 312 |
} |
| 313 |
|
| 314 |
json::Value TimelineView::toJSON() const { |
| 315 |
json::Array TimelineInfo; |
| 316 |
|
| 317 |
for (const TimelineViewEntry &TLE : Timeline) { |
| 318 |
TimelineInfo.push_back( |
| 319 |
json::Object({{"CycleDispatched", TLE.CycleDispatched}, |
| 320 |
{"CycleReady", TLE.CycleReady}, |
| 321 |
{"CycleIssued", TLE.CycleIssued}, |
| 322 |
{"CycleExecuted", TLE.CycleExecuted}, |
| 323 |
{"CycleRetired", TLE.CycleRetired}})); |
| 324 |
} |
| 325 |
return json::Object({{"TimelineInfo", std::move(TimelineInfo)}}); |
| 326 |
} |
| 327 |
} // namespace mca |
| 328 |
} // namespace llvm |