1//===-- LatencyBenchmarkRunner.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
9#include "LatencyBenchmarkRunner.h"
10
11#include "BenchmarkRunner.h"
12#include "Target.h"
13#include "llvm/ADT/Twine.h"
14#include "llvm/Support/Error.h"
15
16#define DEBUG_TYPE "exegesis-latency-benchmarkrunner"
17
18namespace llvm {
19namespace exegesis {
20
21LatencyBenchmarkRunner::LatencyBenchmarkRunner(
22 const LLVMState &State, Benchmark::ModeE Mode,
23 BenchmarkPhaseSelectorE BenchmarkPhaseSelector,
24 Benchmark::ResultAggregationModeE ResultAgg, ExecutionModeE ExecutionMode,
25 ArrayRef<ValidationEvent> ValCounters, unsigned BenchmarkRepeatCount)
26 : BenchmarkRunner(State, Mode, BenchmarkPhaseSelector, ExecutionMode,
27 ValCounters) {
28 assert((Mode == Benchmark::Latency || Mode == Benchmark::InverseThroughput) &&
29 "invalid mode");
30 ResultAggMode = ResultAgg;
31 NumMeasurements = BenchmarkRepeatCount;
32}
33
34LatencyBenchmarkRunner::~LatencyBenchmarkRunner() = default;
35
36static double computeVariance(const SmallVector<int64_t, 4> &Values) {
37 if (Values.empty())
38 return 0.0;
39 double Sum = std::accumulate(first: Values.begin(), last: Values.end(), init: 0.0);
40
41 const double Mean = Sum / Values.size();
42 double Ret = 0;
43 for (const auto &V : Values) {
44 double Delta = V - Mean;
45 Ret += Delta * Delta;
46 }
47 return Ret / Values.size();
48}
49
50static int64_t findMin(const SmallVector<int64_t, 4> &Values) {
51 if (Values.empty())
52 return 0;
53 return *llvm::min_element(Range: Values);
54}
55
56static int64_t findMax(const SmallVector<int64_t, 4> &Values) {
57 if (Values.empty())
58 return 0;
59 return *llvm::max_element(Range: Values);
60}
61
62static int64_t findMean(const SmallVector<int64_t, 4> &Values) {
63 if (Values.empty())
64 return 0;
65 return std::accumulate(first: Values.begin(), last: Values.end(), init: 0.0) /
66 static_cast<double>(Values.size());
67}
68
69Expected<std::vector<BenchmarkMeasure>> LatencyBenchmarkRunner::runMeasurements(
70 const FunctionExecutor &Executor) const {
71 // Cycle measurements include some overhead from the kernel. Repeat the
72 // measure several times and return the aggregated value, as specified by
73 // ResultAggMode.
74 SmallVector<int64_t, 4> AccumulatedValues;
75 double MinVariance = std::numeric_limits<double>::infinity();
76 const PfmCountersInfo &PCI = State.getPfmCounters();
77 const char *CounterName = PCI.CycleCounter;
78
79 SmallVector<const char *> ValCountersToRun;
80 Error ValCounterErr = getValidationCountersToRun(ValCountersToRun);
81 if (ValCounterErr)
82 return std::move(ValCounterErr);
83
84 SmallVector<int64_t> ValCounterValues(ValCountersToRun.size(), 0);
85 // Values count for each run.
86 int ValuesCount = 0;
87 for (size_t I = 0; I < NumMeasurements; ++I) {
88 SmallVector<int64_t> IterationValCounterValues(ValCountersToRun.size(), -1);
89 auto ExpectedCounterValues = Executor.runAndSample(
90 Counters: CounterName, ValidationCounters: ValCountersToRun, ValidationCounterValues&: IterationValCounterValues);
91 if (!ExpectedCounterValues)
92 return ExpectedCounterValues.takeError();
93 ValuesCount = ExpectedCounterValues.get().size();
94 if (ValuesCount == 1) {
95 LLVM_DEBUG(dbgs() << "Latency value: " << ExpectedCounterValues.get()[0]
96 << "\n");
97 AccumulatedValues.push_back(Elt: ExpectedCounterValues.get()[0]);
98 } else {
99 // We'll keep the reading with lowest variance (ie., most stable)
100 double Variance = computeVariance(Values: *ExpectedCounterValues);
101 if (MinVariance > Variance) {
102 AccumulatedValues = std::move(ExpectedCounterValues.get());
103 MinVariance = Variance;
104 }
105 }
106
107 for (size_t I = 0; I < ValCounterValues.size(); ++I) {
108 LLVM_DEBUG(dbgs() << getValidationEventName(ValidationCounters[I]) << ": "
109 << IterationValCounterValues[I] << "\n");
110 ValCounterValues[I] += IterationValCounterValues[I];
111 }
112 }
113
114 std::map<ValidationEvent, int64_t> ValidationInfo;
115 for (size_t I = 0; I < ValidationCounters.size(); ++I)
116 ValidationInfo[ValidationCounters[I]] = ValCounterValues[I];
117
118 std::string ModeName;
119 switch (Mode) {
120 case Benchmark::Latency:
121 ModeName = "latency";
122 break;
123 case Benchmark::InverseThroughput:
124 ModeName = "inverse_throughput";
125 break;
126 default:
127 break;
128 }
129
130 switch (ResultAggMode) {
131 case Benchmark::MinVariance: {
132 if (ValuesCount == 1)
133 errs() << "Each sample only has one value. result-aggregation-mode "
134 "of min-variance is probably non-sensical\n";
135 std::vector<BenchmarkMeasure> Result;
136 Result.reserve(n: AccumulatedValues.size());
137 for (const int64_t Value : AccumulatedValues)
138 Result.push_back(
139 x: BenchmarkMeasure::Create(Key: ModeName, Value, ValCounters: ValidationInfo));
140 return std::move(Result);
141 }
142 case Benchmark::Min: {
143 std::vector<BenchmarkMeasure> Result;
144 Result.push_back(x: BenchmarkMeasure::Create(
145 Key: ModeName, Value: findMin(Values: AccumulatedValues), ValCounters: ValidationInfo));
146 return std::move(Result);
147 }
148 case Benchmark::Max: {
149 std::vector<BenchmarkMeasure> Result;
150 Result.push_back(x: BenchmarkMeasure::Create(
151 Key: ModeName, Value: findMax(Values: AccumulatedValues), ValCounters: ValidationInfo));
152 return std::move(Result);
153 }
154 case Benchmark::Mean: {
155 std::vector<BenchmarkMeasure> Result;
156 Result.push_back(x: BenchmarkMeasure::Create(
157 Key: ModeName, Value: findMean(Values: AccumulatedValues), ValCounters: ValidationInfo));
158 return std::move(Result);
159 }
160 }
161 return make_error<Failure>(Args: Twine("Unexpected benchmark mode(")
162 .concat(Suffix: std::to_string(val: Mode))
163 .concat(Suffix: " and unexpected ResultAggMode ")
164 .concat(Suffix: std::to_string(val: ResultAggMode)));
165}
166
167} // namespace exegesis
168} // namespace llvm
169