LLVM  9.0.0svn
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_LIB_XRAY_FDRRECORDS_H_
14 #define LLVM_LIB_XRAY_FDRRECORDS_H_
15 
16 #include <cstdint>
17 #include <string>
18 
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Support/Casting.h"
22 #include "llvm/Support/Error.h"
23 #include "llvm/XRay/XRayRecord.h"
24 
25 namespace llvm {
26 namespace xray {
27 
28 class RecordVisitor;
29 class RecordInitializer;
30 
31 class Record {
32 public:
33  enum class RecordKind {
48  };
49 
51 
52 private:
53  const RecordKind T;
54 
55 public:
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 
71 class MetadataRecord : public Record {
72 public:
73  enum class MetadataType : unsigned {
74  Unknown,
76  WallClockTime,
77  NewCPUId,
78  TSCWrap,
79  CustomEvent,
80  CallArg,
81  PIDEntry,
82  NewBuffer,
83  EndOfBuffer,
84  TypedEvent,
85  };
86 
87 protected:
88  static constexpr int kMetadataBodySize = 15;
89  friend class RecordInitializer;
90 
91 private:
92  const MetadataType MT;
93 
94 public:
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 &&
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 
114 public:
118 
119  explicit BufferExtents(uint64_t S)
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) {
130  }
131 };
132 
134  uint64_t Seconds = 0;
135  uint32_t Nanos = 0;
136  friend class RecordInitializer;
137 
138 public:
141  MetadataType::WallClockTime) {}
142 
143  explicit WallclockRecord(uint64_t S, uint32_t N)
145  MetadataType::WallClockTime),
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) {
155  }
156 };
157 
159  uint16_t CPUId = 0;
160  uint64_t TSC = 0;
161  friend class RecordInitializer;
162 
163 public:
166  MetadataType::NewCPUId) {}
167 
168  NewCPUIDRecord(uint16_t C, uint64_t T)
170  MetadataType::NewCPUId),
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) {
181  }
182 };
183 
185  uint64_t BaseTSC = 0;
186  friend class RecordInitializer;
187 
188 public:
191  }
192 
193  explicit TSCWrapRecord(uint64_t B)
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) {
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 
213 public:
216  MetadataType::CustomEvent) {}
217 
218  explicit CustomEventRecord(uint64_t S, uint64_t T, uint16_t C, std::string D)
220  MetadataType::CustomEvent),
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) {
232  }
233 };
234 
236  int32_t Size = 0;
237  int32_t Delta = 0;
238  std::string Data{};
239  friend class RecordInitializer;
240 
241 public:
244  MetadataType::CustomEvent) {}
245 
246  explicit CustomEventRecordV5(int32_t S, int32_t D, std::string P)
248  MetadataType::CustomEvent),
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) {
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 
269 public:
272  MetadataType::TypedEvent) {}
273 
274  explicit TypedEventRecord(int32_t S, int32_t D, uint16_t E, std::string P)
276  MetadataType::TypedEvent),
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) {
288  }
289 };
290 
292  uint64_t Arg;
293  friend class RecordInitializer;
294 
295 public:
298  }
299 
300  explicit CallArgRecord(uint64_t A)
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) {
310  }
311 };
312 
313 class PIDRecord : public MetadataRecord {
314  int32_t PID = 0;
315  friend class RecordInitializer;
316 
317 public:
320  MetadataType::PIDEntry) {}
321 
322  explicit PIDRecord(int32_t P)
324  MetadataType::PIDEntry),
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) {
333  }
334 };
335 
337  int32_t TID = 0;
338  friend class RecordInitializer;
339 
340 public:
343  MetadataType::NewBuffer) {}
344 
345  explicit NewBufferRecord(int32_t T)
347  MetadataType::NewBuffer),
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) {
356  }
357 };
358 
360 public:
363  MetadataType::EndOfBuffer) {}
364 
365  Error apply(RecordVisitor &V) override;
366 
367  static bool classof(const Record *R) {
369  }
370 };
371 
372 class FunctionRecord : public Record {
374  int32_t FuncId;
375  uint32_t Delta;
376  friend class RecordInitializer;
377 
378  static constexpr unsigned kFunctionRecordSize = 8;
379 
380 public:
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 
400 public:
401  virtual ~RecordVisitor() = default;
402 
403  // Support all specific kinds of records:
404  virtual Error visit(BufferExtents &) = 0;
405  virtual Error visit(WallclockRecord &) = 0;
406  virtual Error visit(NewCPUIDRecord &) = 0;
407  virtual Error visit(TSCWrapRecord &) = 0;
408  virtual Error visit(CustomEventRecord &) = 0;
409  virtual Error visit(CallArgRecord &) = 0;
410  virtual Error visit(PIDRecord &) = 0;
411  virtual Error visit(NewBufferRecord &) = 0;
412  virtual Error visit(EndBufferRecord &) = 0;
413  virtual Error visit(FunctionRecord &) = 0;
414  virtual Error visit(CustomEventRecordV5 &) = 0;
415  virtual Error visit(TypedEventRecord &) = 0;
416 };
417 
419  DataExtractor &E;
420  uint32_t &OffsetPtr;
421  uint16_t Version;
422 
423 public:
424  static constexpr uint16_t DefaultVersion = 5u;
425 
426  explicit RecordInitializer(DataExtractor &DE, uint32_t &OP, uint16_t V)
427  : RecordVisitor(), E(DE), OffsetPtr(OP), Version(V) {}
428 
430  : RecordInitializer(DE, OP, DefaultVersion) {}
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_LIB_XRAY_FDRRECORDS_H_
int32_t functionId() const
Definition: FDRRecords.h:389
uint64_t CallInst * C
Profile::FuncID FuncId
Definition: Profile.cpp:320
RecordKind getRecordType() const
Definition: FDRRecords.h:62
RecordInitializer(DataExtractor &DE, uint32_t &OP)
Definition: FDRRecords.h:429
virtual ~Record()=default
This class represents lattice values for constants.
Definition: AllocatorList.h:23
uint16_t cpuid() const
Definition: FDRRecords.h:173
RecordTypes recordType() const
Definition: FDRRecords.h:388
F(f)
CustomEventRecordV5(int32_t S, int32_t D, std::string P)
Definition: FDRRecords.h:246
static bool classof(const Record *R)
Definition: FDRRecords.h:308
uint64_t arg() const
Definition: FDRRecords.h:304
Definition: BitVector.h:937
WallclockRecord(uint64_t S, uint32_t N)
Definition: FDRRecords.h:143
int32_t pid() const
Definition: FDRRecords.h:327
Record(RecordKind T)
Definition: FDRRecords.h:60
static bool classof(const Record *R)
Definition: FDRRecords.h:201
static bool classof(const Record *R)
Definition: FDRRecords.h:331
TypedEventRecord(int32_t S, int32_t D, uint16_t E, std::string P)
Definition: FDRRecords.h:274
PIDRecord(int32_t P)
Definition: FDRRecords.h:322
MetadataRecord(RecordKind T, MetadataType M)
Definition: FDRRecords.h:95
CustomEventRecord(uint64_t S, uint64_t T, uint16_t C, std::string D)
Definition: FDRRecords.h:218
static bool classof(const Record *R)
Definition: FDRRecords.h:286
uint64_t seconds() const
Definition: FDRRecords.h:148
static bool classof(const Record *R)
Definition: FDRRecords.h:257
NewCPUIDRecord(uint16_t C, uint64_t T)
Definition: FDRRecords.h:168
static bool classof(const Record *R)
Definition: FDRRecords.h:354
static bool classof(const Record *R)
Definition: FDRRecords.h:128
virtual Error apply(RecordVisitor &V)=0
static bool classof(const Record *R)
Definition: FDRRecords.h:367
#define P(N)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static bool classof(const Record *R)
Definition: FDRRecords.h:97
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
uint64_t tsc() const
Definition: FDRRecords.h:175
uint16_t eventType() const
Definition: FDRRecords.h:281
RecordTypes
Determines the supported types of records that could be seen in XRay traces.
Definition: XRayRecord.h:57
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Record & operator=(const Record &)=delete
FunctionRecord(RecordTypes K, int32_t F, uint32_t D)
Definition: FDRRecords.h:383
uint64_t tsc() const
Definition: FDRRecords.h:197
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static bool classof(const Record *R)
Definition: FDRRecords.h:153
StringRef data() const
Definition: FDRRecords.h:282
uint32_t nanos() const
Definition: FDRRecords.h:149
MetadataType metadataType() const
Definition: FDRRecords.h:102
static bool classof(const Record *R)
Definition: FDRRecords.h:394
StringRef data() const
Definition: FDRRecords.h:226
#define N
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
uint32_t Size
Definition: Profile.cpp:46
uint32_t delta() const
Definition: FDRRecords.h:390
static bool classof(const Record *R)
Definition: FDRRecords.h:179
Record(const Record &)=delete
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
uint64_t size() const
Definition: FDRRecords.h:124
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
RecordInitializer(DataExtractor &DE, uint32_t &OP, uint16_t V)
Definition: FDRRecords.h:426
static StringRef kindToString(RecordKind K)
Definition: FDRRecords.cpp:31
const uint64_t Version
Definition: InstrProf.h:904
#define OP(n)
Definition: regex2.h:73
static bool classof(const Record *R)
Definition: FDRRecords.h:230