|
207
|
1 //===-- JSON serialization routines ---------------------------------------===//
|
|
|
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 "JSON.h"
|
|
|
10 #include "LibcBenchmark.h"
|
|
|
11 #include "llvm/ADT/DenseSet.h"
|
|
|
12 #include "llvm/ADT/SmallVector.h"
|
|
|
13 #include "llvm/ADT/StringRef.h"
|
|
|
14 #include "llvm/ADT/StringSwitch.h"
|
|
|
15 #include "llvm/Support/Errc.h"
|
|
|
16 #include "llvm/Support/Error.h"
|
|
|
17 #include "llvm/Support/ErrorHandling.h"
|
|
|
18 #include "llvm/Support/JSON.h"
|
|
|
19 #include "llvm/Support/MathExtras.h"
|
|
|
20
|
|
|
21 #include <chrono>
|
|
|
22 #include <limits>
|
|
|
23 #include <memory>
|
|
|
24 #include <string>
|
|
|
25 #include <vector>
|
|
|
26
|
|
|
27 namespace llvm {
|
|
|
28 namespace libc_benchmarks {
|
|
|
29
|
|
|
30 template <typename T>
|
|
|
31 static Error intFromJsonTemplate(const json::Value &V, T &Out) {
|
|
|
32 if (const auto &MaybeInt64 = V.getAsInteger()) {
|
|
|
33 int64_t Value = *MaybeInt64;
|
|
|
34 if (Value < std::numeric_limits<T>::min() ||
|
|
|
35 Value > std::numeric_limits<T>::max())
|
|
|
36 return createStringError(errc::io_error, "Out of bound Integer");
|
|
|
37 Out = Value;
|
|
|
38 return Error::success();
|
|
|
39 }
|
|
|
40 return createStringError(errc::io_error, "Can't parse Integer");
|
|
|
41 }
|
|
|
42
|
|
|
43 static Error fromJson(const json::Value &V, bool &Out) {
|
|
|
44 if (auto B = V.getAsBoolean()) {
|
|
|
45 Out = *B;
|
|
|
46 return Error::success();
|
|
|
47 }
|
|
|
48 return createStringError(errc::io_error, "Can't parse Boolean");
|
|
|
49 }
|
|
|
50
|
|
|
51 static Error fromJson(const json::Value &V, double &Out) {
|
|
|
52 if (auto S = V.getAsNumber()) {
|
|
|
53 Out = *S;
|
|
|
54 return Error::success();
|
|
|
55 }
|
|
|
56 return createStringError(errc::io_error, "Can't parse Double");
|
|
|
57 }
|
|
|
58
|
|
|
59 static Error fromJson(const json::Value &V, std::string &Out) {
|
|
|
60 if (auto S = V.getAsString()) {
|
|
|
61 Out = std::string(*S);
|
|
|
62 return Error::success();
|
|
|
63 }
|
|
|
64 return createStringError(errc::io_error, "Can't parse String");
|
|
|
65 }
|
|
|
66
|
|
|
67 static Error fromJson(const json::Value &V, uint32_t &Out) {
|
|
|
68 return intFromJsonTemplate(V, Out);
|
|
|
69 }
|
|
|
70
|
|
|
71 static Error fromJson(const json::Value &V, int &Out) {
|
|
|
72 return intFromJsonTemplate(V, Out);
|
|
|
73 }
|
|
|
74
|
|
|
75 static Error fromJson(const json::Value &V, libc_benchmarks::Duration &D) {
|
|
|
76 if (V.kind() != json::Value::Kind::Number)
|
|
|
77 return createStringError(errc::io_error, "Can't parse Duration");
|
|
|
78 D = libc_benchmarks::Duration(*V.getAsNumber());
|
|
|
79 return Error::success();
|
|
|
80 }
|
|
|
81
|
|
|
82 static Error fromJson(const json::Value &V, MaybeAlign &Out) {
|
|
|
83 const auto MaybeInt = V.getAsInteger();
|
|
|
84 if (!MaybeInt)
|
|
|
85 return createStringError(errc::io_error,
|
|
|
86 "Can't parse Align, not an Integer");
|
|
|
87 const int64_t Value = *MaybeInt;
|
|
|
88 if (!Value) {
|
|
|
89 Out = None;
|
|
|
90 return Error::success();
|
|
|
91 }
|
|
|
92 if (isPowerOf2_64(Value)) {
|
|
|
93 Out = Align(Value);
|
|
|
94 return Error::success();
|
|
|
95 }
|
|
|
96 return createStringError(errc::io_error,
|
|
|
97 "Can't parse Align, not a power of two");
|
|
|
98 }
|
|
|
99
|
|
|
100 static Error fromJson(const json::Value &V,
|
|
|
101 libc_benchmarks::BenchmarkLog &Out) {
|
|
|
102 if (V.kind() != json::Value::Kind::String)
|
|
|
103 return createStringError(errc::io_error,
|
|
|
104 "Can't parse BenchmarkLog, not a String");
|
|
|
105 const auto String = *V.getAsString();
|
|
|
106 auto Parsed =
|
|
|
107 llvm::StringSwitch<Optional<libc_benchmarks::BenchmarkLog>>(String)
|
|
|
108 .Case("None", libc_benchmarks::BenchmarkLog::None)
|
|
|
109 .Case("Last", libc_benchmarks::BenchmarkLog::Last)
|
|
|
110 .Case("Full", libc_benchmarks::BenchmarkLog::Full)
|
|
|
111 .Default(None);
|
|
|
112 if (!Parsed)
|
|
|
113 return createStringError(errc::io_error,
|
|
|
114 Twine("Can't parse BenchmarkLog, invalid value '")
|
|
|
115 .concat(String)
|
|
|
116 .concat("'"));
|
|
|
117 Out = *Parsed;
|
|
|
118 return Error::success();
|
|
|
119 }
|
|
|
120
|
|
|
121 template <typename C>
|
|
|
122 Error vectorFromJsonTemplate(const json::Value &V, C &Out) {
|
|
|
123 auto *A = V.getAsArray();
|
|
|
124 if (!A)
|
|
|
125 return createStringError(errc::io_error, "Can't parse Array");
|
|
|
126 Out.clear();
|
|
|
127 Out.resize(A->size());
|
|
|
128 for (auto InOutPair : llvm::zip(*A, Out))
|
|
|
129 if (auto E = fromJson(std::get<0>(InOutPair), std::get<1>(InOutPair)))
|
|
|
130 return std::move(E);
|
|
|
131 return Error::success();
|
|
|
132 }
|
|
|
133
|
|
|
134 template <typename T>
|
|
|
135 static Error fromJson(const json::Value &V, std::vector<T> &Out) {
|
|
|
136 return vectorFromJsonTemplate(V, Out);
|
|
|
137 }
|
|
|
138
|
|
|
139 // Same as llvm::json::ObjectMapper but adds a finer error reporting mechanism.
|
|
|
140 class JsonObjectMapper {
|
|
|
141 const json::Object *O;
|
|
|
142 Error E;
|
|
|
143 SmallDenseSet<StringRef> SeenFields;
|
|
|
144
|
|
|
145 public:
|
|
|
146 explicit JsonObjectMapper(const json::Value &V)
|
|
|
147 : O(V.getAsObject()),
|
|
|
148 E(O ? Error::success()
|
|
|
149 : createStringError(errc::io_error, "Expected JSON Object")) {}
|
|
|
150
|
|
|
151 Error takeError() {
|
|
|
152 if (E)
|
|
|
153 return std::move(E);
|
|
|
154 for (const auto &Itr : *O) {
|
|
|
155 const StringRef Key = Itr.getFirst();
|
|
|
156 if (!SeenFields.count(Key))
|
|
|
157 E = createStringError(errc::io_error,
|
|
|
158 Twine("Unknown field: ").concat(Key));
|
|
|
159 }
|
|
|
160 return std::move(E);
|
|
|
161 }
|
|
|
162
|
|
|
163 template <typename T> void map(StringRef Key, T &Out) {
|
|
|
164 if (E)
|
|
|
165 return;
|
|
|
166 if (const json::Value *Value = O->get(Key)) {
|
|
|
167 SeenFields.insert(Key);
|
|
|
168 E = fromJson(*Value, Out);
|
|
|
169 }
|
|
|
170 }
|
|
|
171 };
|
|
|
172
|
|
|
173 static Error fromJson(const json::Value &V,
|
|
|
174 libc_benchmarks::BenchmarkOptions &Out) {
|
|
|
175 JsonObjectMapper O(V);
|
|
|
176 O.map("MinDuration", Out.MinDuration);
|
|
|
177 O.map("MaxDuration", Out.MaxDuration);
|
|
|
178 O.map("InitialIterations", Out.InitialIterations);
|
|
|
179 O.map("MaxIterations", Out.MaxIterations);
|
|
|
180 O.map("MinSamples", Out.MinSamples);
|
|
|
181 O.map("MaxSamples", Out.MaxSamples);
|
|
|
182 O.map("Epsilon", Out.Epsilon);
|
|
|
183 O.map("ScalingFactor", Out.ScalingFactor);
|
|
|
184 O.map("Log", Out.Log);
|
|
|
185 return O.takeError();
|
|
|
186 }
|
|
|
187
|
|
|
188 static Error fromJson(const json::Value &V,
|
|
|
189 libc_benchmarks::StudyConfiguration &Out) {
|
|
|
190 JsonObjectMapper O(V);
|
|
|
191 O.map("Function", Out.Function);
|
|
|
192 O.map("NumTrials", Out.NumTrials);
|
|
|
193 O.map("IsSweepMode", Out.IsSweepMode);
|
|
|
194 O.map("SweepModeMaxSize", Out.SweepModeMaxSize);
|
|
|
195 O.map("SizeDistributionName", Out.SizeDistributionName);
|
|
|
196 O.map("AccessAlignment", Out.AccessAlignment);
|
|
|
197 O.map("MemcmpMismatchAt", Out.MemcmpMismatchAt);
|
|
|
198 return O.takeError();
|
|
|
199 }
|
|
|
200
|
|
|
201 static Error fromJson(const json::Value &V, libc_benchmarks::CacheInfo &Out) {
|
|
|
202 JsonObjectMapper O(V);
|
|
|
203 O.map("Type", Out.Type);
|
|
|
204 O.map("Level", Out.Level);
|
|
|
205 O.map("Size", Out.Size);
|
|
|
206 O.map("NumSharing", Out.NumSharing);
|
|
|
207 return O.takeError();
|
|
|
208 }
|
|
|
209
|
|
|
210 static Error fromJson(const json::Value &V, libc_benchmarks::HostState &Out) {
|
|
|
211 JsonObjectMapper O(V);
|
|
|
212 O.map("CpuName", Out.CpuName);
|
|
|
213 O.map("CpuFrequency", Out.CpuFrequency);
|
|
|
214 O.map("Caches", Out.Caches);
|
|
|
215 return O.takeError();
|
|
|
216 }
|
|
|
217
|
|
|
218 static Error fromJson(const json::Value &V, libc_benchmarks::Runtime &Out) {
|
|
|
219 JsonObjectMapper O(V);
|
|
|
220 O.map("Host", Out.Host);
|
|
|
221 O.map("BufferSize", Out.BufferSize);
|
|
|
222 O.map("BatchParameterCount", Out.BatchParameterCount);
|
|
|
223 O.map("BenchmarkOptions", Out.BenchmarkOptions);
|
|
|
224 return O.takeError();
|
|
|
225 }
|
|
|
226
|
|
|
227 static Error fromJson(const json::Value &V, libc_benchmarks::Study &Out) {
|
|
|
228 JsonObjectMapper O(V);
|
|
|
229 O.map("StudyName", Out.StudyName);
|
|
|
230 O.map("Runtime", Out.Runtime);
|
|
|
231 O.map("Configuration", Out.Configuration);
|
|
|
232 O.map("Measurements", Out.Measurements);
|
|
|
233 return O.takeError();
|
|
|
234 }
|
|
|
235
|
|
|
236 static double seconds(const Duration &D) {
|
|
|
237 return std::chrono::duration<double>(D).count();
|
|
|
238 }
|
|
|
239
|
|
|
240 Expected<Study> parseJsonStudy(StringRef Content) {
|
|
|
241 Expected<json::Value> EV = json::parse(Content);
|
|
|
242 if (!EV)
|
|
|
243 return EV.takeError();
|
|
|
244 Study S;
|
|
|
245 if (Error E = fromJson(*EV, S))
|
|
|
246 return std::move(E);
|
|
|
247 return S;
|
|
|
248 }
|
|
|
249
|
|
|
250 static StringRef serialize(const BenchmarkLog &L) {
|
|
|
251 switch (L) {
|
|
|
252 case BenchmarkLog::None:
|
|
|
253 return "None";
|
|
|
254 case BenchmarkLog::Last:
|
|
|
255 return "Last";
|
|
|
256 case BenchmarkLog::Full:
|
|
|
257 return "Full";
|
|
|
258 }
|
|
|
259 llvm_unreachable("Unhandled BenchmarkLog value");
|
|
|
260 }
|
|
|
261
|
|
|
262 static void serialize(const BenchmarkOptions &BO, json::OStream &JOS) {
|
|
|
263 JOS.attribute("MinDuration", seconds(BO.MinDuration));
|
|
|
264 JOS.attribute("MaxDuration", seconds(BO.MaxDuration));
|
|
|
265 JOS.attribute("InitialIterations", BO.InitialIterations);
|
|
|
266 JOS.attribute("MaxIterations", BO.MaxIterations);
|
|
|
267 JOS.attribute("MinSamples", BO.MinSamples);
|
|
|
268 JOS.attribute("MaxSamples", BO.MaxSamples);
|
|
|
269 JOS.attribute("Epsilon", BO.Epsilon);
|
|
|
270 JOS.attribute("ScalingFactor", BO.ScalingFactor);
|
|
|
271 JOS.attribute("Log", serialize(BO.Log));
|
|
|
272 }
|
|
|
273
|
|
|
274 static void serialize(const CacheInfo &CI, json::OStream &JOS) {
|
|
|
275 JOS.attribute("Type", CI.Type);
|
|
|
276 JOS.attribute("Level", CI.Level);
|
|
|
277 JOS.attribute("Size", CI.Size);
|
|
|
278 JOS.attribute("NumSharing", CI.NumSharing);
|
|
|
279 }
|
|
|
280
|
|
|
281 static void serialize(const StudyConfiguration &SC, json::OStream &JOS) {
|
|
|
282 JOS.attribute("Function", SC.Function);
|
|
|
283 JOS.attribute("NumTrials", SC.NumTrials);
|
|
|
284 JOS.attribute("IsSweepMode", SC.IsSweepMode);
|
|
|
285 JOS.attribute("SweepModeMaxSize", SC.SweepModeMaxSize);
|
|
|
286 JOS.attribute("SizeDistributionName", SC.SizeDistributionName);
|
|
|
287 JOS.attribute("AccessAlignment",
|
|
|
288 static_cast<int64_t>(SC.AccessAlignment->value()));
|
|
|
289 JOS.attribute("MemcmpMismatchAt", SC.MemcmpMismatchAt);
|
|
|
290 }
|
|
|
291
|
|
|
292 static void serialize(const HostState &HS, json::OStream &JOS) {
|
|
|
293 JOS.attribute("CpuName", HS.CpuName);
|
|
|
294 JOS.attribute("CpuFrequency", HS.CpuFrequency);
|
|
|
295 JOS.attributeArray("Caches", [&]() {
|
|
|
296 for (const auto &CI : HS.Caches)
|
|
|
297 JOS.object([&]() { serialize(CI, JOS); });
|
|
|
298 });
|
|
|
299 }
|
|
|
300
|
|
|
301 static void serialize(const Runtime &RI, json::OStream &JOS) {
|
|
|
302 JOS.attributeObject("Host", [&]() { serialize(RI.Host, JOS); });
|
|
|
303 JOS.attribute("BufferSize", RI.BufferSize);
|
|
|
304 JOS.attribute("BatchParameterCount", RI.BatchParameterCount);
|
|
|
305 JOS.attributeObject("BenchmarkOptions",
|
|
|
306 [&]() { serialize(RI.BenchmarkOptions, JOS); });
|
|
|
307 }
|
|
|
308
|
|
|
309 void serializeToJson(const Study &S, json::OStream &JOS) {
|
|
|
310 JOS.object([&]() {
|
|
|
311 JOS.attribute("StudyName", S.StudyName);
|
|
|
312 JOS.attributeObject("Runtime", [&]() { serialize(S.Runtime, JOS); });
|
|
|
313 JOS.attributeObject("Configuration",
|
|
|
314 [&]() { serialize(S.Configuration, JOS); });
|
|
|
315 if (!S.Measurements.empty()) {
|
|
|
316 JOS.attributeArray("Measurements", [&]() {
|
|
|
317 for (const auto &M : S.Measurements)
|
|
|
318 JOS.value(seconds(M));
|
|
|
319 });
|
|
|
320 }
|
|
|
321 });
|
|
|
322 }
|
|
|
323
|
|
|
324 } // namespace libc_benchmarks
|
|
|
325 } // namespace llvm
|
