LLVM 17.0.0git
FDRRecords.h
Go to the documentation of this file.
1//===- FDRRecords.h - XRay Flight Data Recorder Mode Records --------------===//
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// Define types and operations on these types that represent the different kinds
10// of records we encounter in XRay flight data recorder mode traces.
11//
12//===----------------------------------------------------------------------===//
13#ifndef LLVM_XRAY_FDRRECORDS_H
14#define LLVM_XRAY_FDRRECORDS_H
15
16#include <cstdint>
17#include <string>
18
19#include "llvm/ADT/StringRef.h"
22#include "llvm/Support/Error.h"
24
25namespace llvm {
26namespace xray {
27
28class RecordVisitor;
29class RecordInitializer;
30
31class Record {
32public:
33 enum class RecordKind {
48 };
49
51
52private:
53 const RecordKind T;
54
55public:
56 Record(const Record &) = delete;
57 Record(Record &&) = delete;
58 Record &operator=(const Record &) = delete;
59 Record &operator=(Record &&) = delete;
60 explicit Record(RecordKind T) : T(T) {}
61
62 RecordKind getRecordType() const { return T; }
63
64 // Each Record should be able to apply an abstract visitor, and choose the
65 // appropriate function in the visitor to invoke, given its own type.
66 virtual Error apply(RecordVisitor &V) = 0;
67
68 virtual ~Record() = default;
69};
70
71class MetadataRecord : public Record {
72public:
73 enum class MetadataType : unsigned {
74 Unknown,
78 TSCWrap,
80 CallArg,
85 };
86
87protected:
88 static constexpr int kMetadataBodySize = 15;
89 friend class RecordInitializer;
90
91private:
92 const MetadataType MT;
93
94public:
95 explicit MetadataRecord(RecordKind T, MetadataType M) : Record(T), MT(M) {}
96
97 static bool classof(const Record *R) {
98 return R->getRecordType() >= RecordKind::RK_Metadata &&
99 R->getRecordType() <= RecordKind::RK_Metadata_LastMetadata;
100 }
101
102 MetadataType metadataType() const { return MT; }
103
104 virtual ~MetadataRecord() = default;
105};
106
107// What follows are specific Metadata record types which encapsulate the
108// information associated with specific metadata record types in an FDR mode
109// log.
111 uint64_t Size = 0;
112 friend class RecordInitializer;
113
114public:
118
122 Size(S) {}
123
124 uint64_t size() const { return Size; }
125
126 Error apply(RecordVisitor &V) override;
127
128 static bool classof(const Record *R) {
129 return R->getRecordType() == RecordKind::RK_Metadata_BufferExtents;
130 }
131};
132
134 uint64_t Seconds = 0;
135 uint32_t Nanos = 0;
136 friend class RecordInitializer;
137
138public:
142
146 Seconds(S), Nanos(N) {}
147
148 uint64_t seconds() const { return Seconds; }
149 uint32_t nanos() const { return Nanos; }
150
151 Error apply(RecordVisitor &V) override;
152
153 static bool classof(const Record *R) {
154 return R->getRecordType() == RecordKind::RK_Metadata_WallClockTime;
155 }
156};
157
159 uint16_t CPUId = 0;
160 uint64_t TSC = 0;
161 friend class RecordInitializer;
162
163public:
167
171 CPUId(C), TSC(T) {}
172
173 uint16_t cpuid() const { return CPUId; }
174
175 uint64_t tsc() const { return TSC; }
176
177 Error apply(RecordVisitor &V) override;
178
179 static bool classof(const Record *R) {
180 return R->getRecordType() == RecordKind::RK_Metadata_NewCPUId;
181 }
182};
183
185 uint64_t BaseTSC = 0;
186 friend class RecordInitializer;
187
188public:
191 }
192
195 BaseTSC(B) {}
196
197 uint64_t tsc() const { return BaseTSC; }
198
199 Error apply(RecordVisitor &V) override;
200
201 static bool classof(const Record *R) {
202 return R->getRecordType() == RecordKind::RK_Metadata_TSCWrap;
203 }
204};
205
207 int32_t Size = 0;
208 uint64_t TSC = 0;
209 uint16_t CPU = 0;
210 std::string Data{};
211 friend class RecordInitializer;
212
213public:
217
218 explicit CustomEventRecord(uint64_t S, uint64_t T, uint16_t C, std::string D)
221 Size(S), TSC(T), CPU(C), Data(std::move(D)) {}
222
223 int32_t size() const { return Size; }
224 uint64_t tsc() const { return TSC; }
225 uint16_t cpu() const { return CPU; }
226 StringRef data() const { return Data; }
227
228 Error apply(RecordVisitor &V) override;
229
230 static bool classof(const Record *R) {
231 return R->getRecordType() == RecordKind::RK_Metadata_CustomEvent;
232 }
233};
234
236 int32_t Size = 0;
237 int32_t Delta = 0;
238 std::string Data{};
239 friend class RecordInitializer;
240
241public:
245
246 explicit CustomEventRecordV5(int32_t S, int32_t D, std::string P)
249 Size(S), Delta(D), Data(std::move(P)) {}
250
251 int32_t size() const { return Size; }
252 int32_t delta() const { return Delta; }
253 StringRef data() const { return Data; }
254
255 Error apply(RecordVisitor &V) override;
256
257 static bool classof(const Record *R) {
258 return R->getRecordType() == RecordKind::RK_Metadata_CustomEventV5;
259 }
260};
261
263 int32_t Size = 0;
264 int32_t Delta = 0;
265 uint16_t EventType = 0;
266 std::string Data{};
267 friend class RecordInitializer;
268
269public:
273
274 explicit TypedEventRecord(int32_t S, int32_t D, uint16_t E, std::string P)
277 Size(S), Delta(D), Data(std::move(P)) {}
278
279 int32_t size() const { return Size; }
280 int32_t delta() const { return Delta; }
281 uint16_t eventType() const { return EventType; }
282 StringRef data() const { return Data; }
283
284 Error apply(RecordVisitor &V) override;
285
286 static bool classof(const Record *R) {
287 return R->getRecordType() == RecordKind::RK_Metadata_TypedEvent;
288 }
289};
290
292 uint64_t Arg = 0;
293 friend class RecordInitializer;
294
295public:
298 }
299
302 Arg(A) {}
303
304 uint64_t arg() const { return Arg; }
305
306 Error apply(RecordVisitor &V) override;
307
308 static bool classof(const Record *R) {
309 return R->getRecordType() == RecordKind::RK_Metadata_CallArg;
310 }
311};
312
313class PIDRecord : public MetadataRecord {
314 int32_t PID = 0;
315 friend class RecordInitializer;
316
317public:
321
322 explicit PIDRecord(int32_t P)
325 PID(P) {}
326
327 int32_t pid() const { return PID; }
328
329 Error apply(RecordVisitor &V) override;
330
331 static bool classof(const Record *R) {
332 return R->getRecordType() == RecordKind::RK_Metadata_PIDEntry;
333 }
334};
335
337 int32_t TID = 0;
338 friend class RecordInitializer;
339
340public:
344
345 explicit NewBufferRecord(int32_t T)
348 TID(T) {}
349
350 int32_t tid() const { return TID; }
351
352 Error apply(RecordVisitor &V) override;
353
354 static bool classof(const Record *R) {
355 return R->getRecordType() == RecordKind::RK_Metadata_NewBuffer;
356 }
357};
358
360public:
364
365 Error apply(RecordVisitor &V) override;
366
367 static bool classof(const Record *R) {
368 return R->getRecordType() == RecordKind::RK_Metadata_EndOfBuffer;
369 }
370};
371
372class FunctionRecord : public Record {
373 RecordTypes Kind;
374 int32_t FuncId = 0;
375 uint32_t Delta = 0;
376 friend class RecordInitializer;
377
378 static constexpr unsigned kFunctionRecordSize = 8;
379
380public:
382
383 explicit FunctionRecord(RecordTypes K, int32_t F, uint32_t D)
384 : Record(RecordKind::RK_Function), Kind(K), FuncId(F), Delta(D) {}
385
386 // A function record is a concrete record type which has a number of common
387 // properties.
388 RecordTypes recordType() const { return Kind; }
389 int32_t functionId() const { return FuncId; }
390 uint32_t delta() const { return Delta; }
391
392 Error apply(RecordVisitor &V) override;
393
394 static bool classof(const Record *R) {
395 return R->getRecordType() == RecordKind::RK_Function;
396 }
397};
398
400public:
401 virtual ~RecordVisitor() = default;
402
403 // Support all specific kinds of records:
404 virtual Error visit(BufferExtents &) = 0;
406 virtual Error visit(NewCPUIDRecord &) = 0;
407 virtual Error visit(TSCWrapRecord &) = 0;
409 virtual Error visit(CallArgRecord &) = 0;
410 virtual Error visit(PIDRecord &) = 0;
413 virtual Error visit(FunctionRecord &) = 0;
416};
417
419 DataExtractor &E;
420 uint64_t &OffsetPtr;
421 uint16_t Version;
422
423public:
424 static constexpr uint16_t DefaultVersion = 5u;
425
427 : E(DE), OffsetPtr(OP), Version(V) {}
428
431
432 Error visit(BufferExtents &) override;
433 Error visit(WallclockRecord &) override;
434 Error visit(NewCPUIDRecord &) override;
435 Error visit(TSCWrapRecord &) override;
436 Error visit(CustomEventRecord &) override;
437 Error visit(CallArgRecord &) override;
438 Error visit(PIDRecord &) override;
439 Error visit(NewBufferRecord &) override;
440 Error visit(EndBufferRecord &) override;
441 Error visit(FunctionRecord &) override;
442 Error visit(CustomEventRecordV5 &) override;
443 Error visit(TypedEventRecord &) override;
444};
445
446} // namespace xray
447} // namespace llvm
448
449#endif // LLVM_XRAY_FDRRECORDS_H
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
uint64_t Size
#define F(x, y, z)
Definition: MD5.cpp:55
#define P(N)
Profile::FuncID FuncId
Definition: Profile.cpp:321
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:18
uint64_t size() const
Definition: FDRRecords.h:124
static bool classof(const Record *R)
Definition: FDRRecords.h:128
static bool classof(const Record *R)
Definition: FDRRecords.h:308
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:23
uint64_t arg() const
Definition: FDRRecords.h:304
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:28
static bool classof(const Record *R)
Definition: FDRRecords.h:257
CustomEventRecordV5(int32_t S, int32_t D, std::string P)
Definition: FDRRecords.h:246
static bool classof(const Record *R)
Definition: FDRRecords.h:230
StringRef data() const
Definition: FDRRecords.h:226
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:22
CustomEventRecord(uint64_t S, uint64_t T, uint16_t C, std::string D)
Definition: FDRRecords.h:218
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:26
static bool classof(const Record *R)
Definition: FDRRecords.h:367
RecordTypes recordType() const
Definition: FDRRecords.h:388
uint32_t delta() const
Definition: FDRRecords.h:390
int32_t functionId() const
Definition: FDRRecords.h:389
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:27
FunctionRecord(RecordTypes K, int32_t F, uint32_t D)
Definition: FDRRecords.h:383
static bool classof(const Record *R)
Definition: FDRRecords.h:394
MetadataRecord(RecordKind T, MetadataType M)
Definition: FDRRecords.h:95
MetadataType metadataType() const
Definition: FDRRecords.h:102
static constexpr int kMetadataBodySize
Definition: FDRRecords.h:88
static bool classof(const Record *R)
Definition: FDRRecords.h:97
virtual ~MetadataRecord()=default
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:25
static bool classof(const Record *R)
Definition: FDRRecords.h:354
uint64_t tsc() const
Definition: FDRRecords.h:175
uint16_t cpuid() const
Definition: FDRRecords.h:173
NewCPUIDRecord(uint16_t C, uint64_t T)
Definition: FDRRecords.h:168
static bool classof(const Record *R)
Definition: FDRRecords.h:179
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:20
static bool classof(const Record *R)
Definition: FDRRecords.h:331
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:24
int32_t pid() const
Definition: FDRRecords.h:327
PIDRecord(int32_t P)
Definition: FDRRecords.h:322
static constexpr uint16_t DefaultVersion
Definition: FDRRecords.h:424
Error visit(BufferExtents &) override
RecordInitializer(DataExtractor &DE, uint64_t &OP)
Definition: FDRRecords.h:429
RecordInitializer(DataExtractor &DE, uint64_t &OP, uint16_t V)
Definition: FDRRecords.h:426
virtual Error visit(TSCWrapRecord &)=0
virtual Error visit(CallArgRecord &)=0
virtual Error visit(TypedEventRecord &)=0
virtual Error visit(CustomEventRecord &)=0
virtual Error visit(PIDRecord &)=0
virtual Error visit(WallclockRecord &)=0
virtual Error visit(FunctionRecord &)=0
virtual Error visit(NewBufferRecord &)=0
virtual ~RecordVisitor()=default
virtual Error visit(BufferExtents &)=0
virtual Error visit(CustomEventRecordV5 &)=0
virtual Error visit(NewCPUIDRecord &)=0
virtual Error visit(EndBufferRecord &)=0
static StringRef kindToString(RecordKind K)
Definition: FDRRecords.cpp:31
Record(const Record &)=delete
virtual Error apply(RecordVisitor &V)=0
Record & operator=(Record &&)=delete
virtual ~Record()=default
RecordKind getRecordType() const
Definition: FDRRecords.h:62
Record(RecordKind T)
Definition: FDRRecords.h:60
Record & operator=(const Record &)=delete
Record(Record &&)=delete
uint64_t tsc() const
Definition: FDRRecords.h:197
static bool classof(const Record *R)
Definition: FDRRecords.h:201
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:21
TypedEventRecord(int32_t S, int32_t D, uint16_t E, std::string P)
Definition: FDRRecords.h:274
static bool classof(const Record *R)
Definition: FDRRecords.h:286
StringRef data() const
Definition: FDRRecords.h:282
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:29
uint16_t eventType() const
Definition: FDRRecords.h:281
uint64_t seconds() const
Definition: FDRRecords.h:148
uint32_t nanos() const
Definition: FDRRecords.h:149
static bool classof(const Record *R)
Definition: FDRRecords.h:153
WallclockRecord(uint64_t S, uint32_t N)
Definition: FDRRecords.h:143
Error apply(RecordVisitor &V) override
Definition: FDRRecords.cpp:19
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
RecordTypes
Determines the supported types of records that could be seen in XRay traces.
Definition: XRayRecord.h:57
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1862
Definition: BitVector.h:851
#define N
#define OP(n)
Definition: regex2.h:73