LLVM OpenMP 22.0.0git
InternalEvent.h
Go to the documentation of this file.
1//===- InternalEvent.h - Internal event representation ----------*- 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/// \file
10/// Declares internal event representations along the default CTOR definition.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef OPENMP_TOOLS_OMPTEST_INCLUDE_INTERNALEVENT_H
15#define OPENMP_TOOLS_OMPTEST_INCLUDE_INTERNALEVENT_H
16
17#include "InternalEventCommon.h"
18
19#include <cstring>
20#include <limits>
21#include <omp-tools.h>
22
23#define expectedDefault(TypeName) std::numeric_limits<TypeName>::min()
24
25namespace omptest {
26
27namespace util {
28
29/// String manipulation helper function. Takes up to 8 bytes of data and returns
30/// their hexadecimal representation as string. The data can be expanded to the
31/// given size in bytes and will by default be prefixed with '0x'.
32std::string makeHexString(uint64_t Data, bool IsPointer = true,
33 size_t DataBytes = 0, bool ShowHexBase = true);
34
35} // namespace util
36
37namespace internal {
38struct AssertionSyncPoint : public EventBase<AssertionSyncPoint> {
39 std::string toString() const override;
40 AssertionSyncPoint(const std::string &Name) : Name(Name) {}
41 const std::string Name;
42};
43
44struct AssertionSuspend : public EventBase<AssertionSuspend> {
45 AssertionSuspend() = default;
46};
47
48struct ThreadBegin : public EventBase<ThreadBegin> {
49 std::string toString() const override;
51 ompt_thread_t ThreadType;
52};
53
54struct ThreadEnd : public EventBase<ThreadEnd> {
55 std::string toString() const override;
56 ThreadEnd() = default;
57};
58
59struct ParallelBegin : public EventBase<ParallelBegin> {
60 std::string toString() const override;
62 unsigned int NumThreads;
63};
64
65struct ParallelEnd : public EventBase<ParallelEnd> {
66 std::string toString() const override;
67 ParallelEnd(ompt_data_t *ParallelData, ompt_data_t *EncounteringTaskData,
68 int Flags, const void *CodeptrRA)
71 ompt_data_t *ParallelData;
73 int Flags;
74 const void *CodeptrRA;
75};
76
77struct Work : public EventBase<Work> {
78 std::string toString() const override;
79 Work(ompt_work_t WorkType, ompt_scope_endpoint_t Endpoint,
80 ompt_data_t *ParallelData, ompt_data_t *TaskData, uint64_t Count,
81 const void *CodeptrRA)
84 ompt_work_t WorkType;
85 ompt_scope_endpoint_t Endpoint;
86 ompt_data_t *ParallelData;
87 ompt_data_t *TaskData;
88 uint64_t Count;
89 const void *CodeptrRA;
90};
91
92struct Dispatch : public EventBase<Dispatch> {
93 std::string toString() const override;
94 Dispatch(ompt_data_t *ParallelData, ompt_data_t *TaskData,
95 ompt_dispatch_t Kind, ompt_data_t Instance)
98 ompt_data_t *ParallelData;
99 ompt_data_t *TaskData;
100 ompt_dispatch_t Kind;
101 ompt_data_t Instance;
102};
103
104struct TaskCreate : public EventBase<TaskCreate> {
105 std::string toString() const override;
107 const ompt_frame_t *EncounteringTaskFrame,
108 ompt_data_t *NewTaskData, int Flags, int HasDependences,
109 const void *CodeptrRA)
114 const ompt_frame_t *EncounteringTaskFrame;
115 ompt_data_t *NewTaskData;
116 int Flags;
118 const void *CodeptrRA;
119};
120
121struct Dependences : public EventBase<Dependences> {
122 Dependences() = default;
123};
124
125struct TaskDependence : public EventBase<TaskDependence> {
126 TaskDependence() = default;
127};
128
129struct TaskSchedule : public EventBase<TaskSchedule> {
130 TaskSchedule() = default;
131};
132
133struct ImplicitTask : public EventBase<ImplicitTask> {
134 std::string toString() const override;
135 ImplicitTask(ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData,
136 ompt_data_t *TaskData, unsigned int ActualParallelism,
137 unsigned int Index, int Flags)
140 ompt_scope_endpoint_t Endpoint;
141 ompt_data_t *ParallelData;
142 ompt_data_t *TaskData;
143 unsigned int ActualParallelism;
144 unsigned int Index;
145 int Flags;
146};
147
148struct Masked : public EventBase<Masked> {
149 Masked() = default;
150};
151
152struct SyncRegion : public EventBase<SyncRegion> {
153 std::string toString() const override;
154 SyncRegion(ompt_sync_region_t Kind, ompt_scope_endpoint_t Endpoint,
155 ompt_data_t *ParallelData, ompt_data_t *TaskData,
156 const void *CodeptrRA)
159 ompt_sync_region_t Kind;
160 ompt_scope_endpoint_t Endpoint;
161 ompt_data_t *ParallelData;
162 ompt_data_t *TaskData;
163 const void *CodeptrRA;
164};
165
166struct MutexAcquire : public EventBase<MutexAcquire> {
167 MutexAcquire() = default;
168};
169
170struct Mutex : public EventBase<Mutex> {
171 Mutex() = default;
172};
173
174struct NestLock : public EventBase<NestLock> {
175 NestLock() = default;
176};
177
178struct Flush : public EventBase<Flush> {
179 Flush() = default;
180};
181
182struct Cancel : public EventBase<Cancel> {
183 Cancel() = default;
184};
185
186struct Target : public EventBase<Target> {
187 std::string toString() const override;
188 Target(ompt_target_t Kind, ompt_scope_endpoint_t Endpoint, int DeviceNum,
189 ompt_data_t *TaskData, ompt_id_t TargetId, const void *CodeptrRA)
192 ompt_target_t Kind;
193 ompt_scope_endpoint_t Endpoint;
195 ompt_data_t *TaskData;
196 ompt_id_t TargetId;
197 const void *CodeptrRA;
198};
199
200struct TargetEmi : public EventBase<TargetEmi> {
201 std::string toString() const override;
202 TargetEmi(ompt_target_t Kind, ompt_scope_endpoint_t Endpoint, int DeviceNum,
203 ompt_data_t *TaskData, ompt_data_t *TargetTaskData,
204 ompt_data_t *TargetData, const void *CodeptrRA)
208 ompt_target_t Kind;
209 ompt_scope_endpoint_t Endpoint;
211 ompt_data_t *TaskData;
212 ompt_data_t *TargetTaskData;
213 ompt_data_t *TargetData;
214 const void *CodeptrRA;
215};
216
217struct TargetDataOp : public EventBase<TargetDataOp> {
218 std::string toString() const override;
219 TargetDataOp(ompt_id_t TargetId, ompt_id_t HostOpId,
220 ompt_target_data_op_t OpType, void *SrcAddr, int SrcDeviceNum,
221 void *DstAddr, int DstDeviceNum, size_t Bytes,
222 const void *CodeptrRA)
226 ompt_id_t TargetId;
227 ompt_id_t HostOpId;
228 ompt_target_data_op_t OpType;
229 void *SrcAddr;
231 void *DstAddr;
233 size_t Bytes;
234 const void *CodeptrRA;
235};
236
237struct TargetDataOpEmi : public EventBase<TargetDataOpEmi> {
238 std::string toString() const override;
239 TargetDataOpEmi(ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetTaskData,
240 ompt_data_t *TargetData, ompt_id_t *HostOpId,
241 ompt_target_data_op_t OpType, void *SrcAddr, int SrcDeviceNum,
242 void *DstAddr, int DstDeviceNum, size_t Bytes,
243 const void *CodeptrRA)
248 ompt_scope_endpoint_t Endpoint;
249 ompt_data_t *TargetTaskData;
250 ompt_data_t *TargetData;
251 ompt_id_t *HostOpId;
252 ompt_target_data_op_t OpType;
253 void *SrcAddr;
255 void *DstAddr;
257 size_t Bytes;
258 const void *CodeptrRA;
259};
260
261struct TargetSubmit : public EventBase<TargetSubmit> {
262 std::string toString() const override;
263 TargetSubmit(ompt_id_t TargetId, ompt_id_t HostOpId,
264 unsigned int RequestedNumTeams)
267 ompt_id_t TargetId;
268 ompt_id_t HostOpId;
269 unsigned int RequestedNumTeams;
270};
271
272struct TargetSubmitEmi : public EventBase<TargetSubmitEmi> {
273 std::string toString() const override;
274 TargetSubmitEmi(ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetData,
275 ompt_id_t *HostOpId, unsigned int RequestedNumTeams)
278 ompt_scope_endpoint_t Endpoint;
279 ompt_data_t *TargetData;
280 ompt_id_t *HostOpId;
281 unsigned int RequestedNumTeams;
282};
283
284struct ControlTool : public EventBase<ControlTool> {
285 ControlTool() = default;
286};
287
288struct DeviceInitialize : public EventBase<DeviceInitialize> {
289 std::string toString() const override;
290 DeviceInitialize(int DeviceNum, const char *Type, ompt_device_t *Device,
291 ompt_function_lookup_t LookupFn, const char *DocStr)
293 DocStr(DocStr) {}
295 const char *Type;
296 ompt_device_t *Device;
297 ompt_function_lookup_t LookupFn;
298 const char *DocStr;
299};
300
301struct DeviceFinalize : public EventBase<DeviceFinalize> {
302 std::string toString() const override;
305};
306
307struct DeviceLoad : public EventBase<DeviceLoad> {
308 std::string toString() const override;
309 DeviceLoad(int DeviceNum, const char *Filename, int64_t OffsetInFile,
310 void *VmaInFile, size_t Bytes, void *HostAddr, void *DeviceAddr,
311 uint64_t ModuleId)
316 const char *Filename;
319 size_t Bytes;
320 void *HostAddr;
322 uint64_t ModuleId;
323};
324
325struct DeviceUnload : public EventBase<DeviceUnload> {
326 DeviceUnload() = default;
327};
328
329struct BufferRequest : public EventBase<BufferRequest> {
330 std::string toString() const override;
331 BufferRequest(int DeviceNum, ompt_buffer_t **Buffer, size_t *Bytes)
334 ompt_buffer_t **Buffer;
335 size_t *Bytes;
336};
337
338struct BufferComplete : public EventBase<BufferComplete> {
339 std::string toString() const override;
340 BufferComplete(int DeviceNum, ompt_buffer_t *Buffer, size_t Bytes,
341 ompt_buffer_cursor_t Begin, int BufferOwned)
345 ompt_buffer_t *Buffer;
346 size_t Bytes;
347 ompt_buffer_cursor_t Begin;
349};
350
351struct BufferRecord : public EventBase<BufferRecord> {
352 std::string toString() const override;
353 BufferRecord(ompt_record_ompt_t *RecordPtr) : RecordPtr(RecordPtr) {
354 if (RecordPtr != nullptr)
355 Record = *RecordPtr;
356 else
357 memset(&Record, 0, sizeof(ompt_record_ompt_t));
358 }
359 ompt_record_ompt_t Record;
360 ompt_record_ompt_t *RecordPtr;
361};
362
363struct BufferRecordDeallocation : public EventBase<BufferRecordDeallocation> {
364 std::string toString() const override;
366 ompt_buffer_t *Buffer;
367};
368
369// Add specialized event equality operators here.
370// Note: Placement of these forward declarations is important as they need to
371// take precedence over the following default equality operator definition.
372bool operator==(const ParallelBegin &, const ParallelBegin &);
373bool operator==(const Work &, const Work &);
374bool operator==(const ImplicitTask &, const ImplicitTask &);
375bool operator==(const SyncRegion &, const SyncRegion &);
376bool operator==(const Target &, const Target &);
377bool operator==(const TargetEmi &, const TargetEmi &);
378bool operator==(const TargetDataOp &, const TargetDataOp &);
379bool operator==(const TargetDataOpEmi &, const TargetDataOpEmi &);
380bool operator==(const TargetSubmit &, const TargetSubmit &);
381bool operator==(const TargetSubmitEmi &, const TargetSubmitEmi &);
382bool operator==(const DeviceInitialize &, const DeviceInitialize &);
383bool operator==(const DeviceFinalize &, const DeviceFinalize &);
384bool operator==(const DeviceLoad &, const DeviceLoad &);
385bool operator==(const BufferRequest &, const BufferRequest &);
386bool operator==(const BufferComplete &, const BufferComplete &);
387bool operator==(const BufferRecord &, const BufferRecord &);
388
389/// Default (fallback) event equality operator definition.
390template <typename Event> bool operator==(const Event &, const Event &) {
391 return true;
392}
393
394// clang-format off
395event_type_trait(AssertionSyncPoint)
396event_type_trait(AssertionSuspend)
397event_type_trait(ThreadBegin)
398event_type_trait(ThreadEnd)
399event_type_trait(ParallelBegin)
400event_type_trait(ParallelEnd)
402event_type_trait(Dispatch)
403event_type_trait(TaskCreate)
404event_type_trait(Dependences)
405event_type_trait(TaskDependence)
406event_type_trait(TaskSchedule)
407event_type_trait(ImplicitTask)
408event_type_trait(Masked)
409event_type_trait(SyncRegion)
410event_type_trait(MutexAcquire)
411event_type_trait(Mutex)
412event_type_trait(NestLock)
413event_type_trait(Flush)
414event_type_trait(Cancel)
415event_type_trait(Target)
416event_type_trait(TargetEmi)
417event_type_trait(TargetDataOp)
418event_type_trait(TargetDataOpEmi)
419event_type_trait(TargetSubmit)
420event_type_trait(TargetSubmitEmi)
421event_type_trait(ControlTool)
422event_type_trait(DeviceInitialize)
423event_type_trait(DeviceFinalize)
424event_type_trait(DeviceLoad)
425event_type_trait(DeviceUnload)
426event_type_trait(BufferRequest)
427event_type_trait(BufferComplete)
428event_type_trait(BufferRecord)
429event_type_trait(BufferRecordDeallocation)
430// clang-format on
431
432} // namespace internal
433
434} // namespace omptest
435
436#endif
Provides event types, and class/operator declaration macros.
#define event_type_trait(EvTy)
Actual definition macro for EventTypeOf.
CRTP (Curiously Recurring Template Pattern) intermediate class Adding a new event type can be achieve...
bool operator==(const ParallelBegin &, const ParallelBegin &)
std::string makeHexString(uint64_t Data, bool IsPointer=true, size_t DataBytes=0, bool ShowHexBase=true)
String manipulation helper function.
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
AssertionSyncPoint(const std::string &Name)
Definition: InternalEvent.h:40
BufferComplete(int DeviceNum, ompt_buffer_t *Buffer, size_t Bytes, ompt_buffer_cursor_t Begin, int BufferOwned)
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
BufferRecordDeallocation(ompt_buffer_t *Buffer)
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
ompt_record_ompt_t * RecordPtr
BufferRecord(ompt_record_ompt_t *RecordPtr)
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
BufferRequest(int DeviceNum, ompt_buffer_t **Buffer, size_t *Bytes)
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
DeviceInitialize(int DeviceNum, const char *Type, ompt_device_t *Device, ompt_function_lookup_t LookupFn, const char *DocStr)
ompt_function_lookup_t LookupFn
DeviceLoad(int DeviceNum, const char *Filename, int64_t OffsetInFile, void *VmaInFile, size_t Bytes, void *HostAddr, void *DeviceAddr, uint64_t ModuleId)
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
Dispatch(ompt_data_t *ParallelData, ompt_data_t *TaskData, ompt_dispatch_t Kind, ompt_data_t Instance)
Definition: InternalEvent.h:94
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
ImplicitTask(ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData, ompt_data_t *TaskData, unsigned int ActualParallelism, unsigned int Index, int Flags)
ompt_scope_endpoint_t Endpoint
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
ParallelEnd(ompt_data_t *ParallelData, ompt_data_t *EncounteringTaskData, int Flags, const void *CodeptrRA)
Definition: InternalEvent.h:67
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
ompt_scope_endpoint_t Endpoint
SyncRegion(ompt_sync_region_t Kind, ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData, ompt_data_t *TaskData, const void *CodeptrRA)
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
TargetDataOpEmi(ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetTaskData, ompt_data_t *TargetData, ompt_id_t *HostOpId, ompt_target_data_op_t OpType, void *SrcAddr, int SrcDeviceNum, void *DstAddr, int DstDeviceNum, size_t Bytes, const void *CodeptrRA)
ompt_scope_endpoint_t Endpoint
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
TargetDataOp(ompt_id_t TargetId, ompt_id_t HostOpId, ompt_target_data_op_t OpType, void *SrcAddr, int SrcDeviceNum, void *DstAddr, int DstDeviceNum, size_t Bytes, const void *CodeptrRA)
ompt_target_data_op_t OpType
ompt_scope_endpoint_t Endpoint
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
TargetEmi(ompt_target_t Kind, ompt_scope_endpoint_t Endpoint, int DeviceNum, ompt_data_t *TaskData, ompt_data_t *TargetTaskData, ompt_data_t *TargetData, const void *CodeptrRA)
TargetSubmitEmi(ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetData, ompt_id_t *HostOpId, unsigned int RequestedNumTeams)
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
ompt_scope_endpoint_t Endpoint
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
TargetSubmit(ompt_id_t TargetId, ompt_id_t HostOpId, unsigned int RequestedNumTeams)
Target(ompt_target_t Kind, ompt_scope_endpoint_t Endpoint, int DeviceNum, ompt_data_t *TaskData, ompt_id_t TargetId, const void *CodeptrRA)
ompt_scope_endpoint_t Endpoint
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
TaskCreate(ompt_data_t *EncounteringTaskData, const ompt_frame_t *EncounteringTaskFrame, ompt_data_t *NewTaskData, int Flags, int HasDependences, const void *CodeptrRA)
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
const ompt_frame_t * EncounteringTaskFrame
ThreadBegin(ompt_thread_t ThreadType)
Definition: InternalEvent.h:50
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
std::string toString() const override
Basic toString method, which may be overridden with own implementations.
ompt_data_t * ParallelData
Definition: InternalEvent.h:86
ompt_data_t * TaskData
Definition: InternalEvent.h:87
ompt_scope_endpoint_t Endpoint
Definition: InternalEvent.h:85
Work(ompt_work_t WorkType, ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData, ompt_data_t *TaskData, uint64_t Count, const void *CodeptrRA)
Definition: InternalEvent.h:79
std::string toString() const override
Basic toString method, which may be overridden with own implementations.