LLVM OpenMP 22.0.0git
OmptCallbackHandler.cpp
Go to the documentation of this file.
1//===- OmptCallbackHandler.cpp - OMPT Callback handling impl. ---*- 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/// This file contains the OMPT callback handling implementations.
11///
12//===----------------------------------------------------------------------===//
13
14#include "OmptCallbackHandler.h"
15
16using namespace omptest;
17
19
21 if (Handler == nullptr)
23
24 return *Handler;
25}
26
28 Subscribers.push_back(Listener);
29}
30
32 replay();
33
34 Subscribers.clear();
35}
36
38 if (!RecordAndReplay)
39 return;
40
41 for (auto &E : RecordedEvents)
42 for (const auto &S : Subscribers)
43 S->notify(std::move(E));
44}
45
46void OmptCallbackHandler::handleThreadBegin(ompt_thread_t ThreadType,
47 ompt_data_t *ThreadData) {
48 if (RecordAndReplay) {
50 "Thread Begin", "", ObserveState::Generated, ThreadType));
51 return;
52 }
53
54 // Initial thread event likely to preceed assertion registration, so skip
55 if (ThreadType == ompt_thread_initial)
56 return;
57 for (const auto &S : Subscribers)
59 "Thread Begin", "", ObserveState::Generated, ThreadType));
60}
61
62void OmptCallbackHandler::handleThreadEnd(ompt_data_t *ThreadData) {
63 if (RecordAndReplay) {
64 recordEvent(
66 return;
67 }
68
69 for (const auto &S : Subscribers)
70 S->notify(
72}
73
75 ompt_data_t *EncounteringTaskData,
76 const ompt_frame_t *EncounteringTaskFrame, ompt_data_t *NewTaskData,
77 int Flags, int HasDependences, const void *CodeptrRA) {
78 if (RecordAndReplay) {
80 "Task Create", "", ObserveState::Generated, EncounteringTaskData,
81 EncounteringTaskFrame, NewTaskData, Flags, HasDependences, CodeptrRA));
82 return;
83 }
84
85 for (const auto &S : Subscribers)
87 "Task Create", "", ObserveState::Generated, EncounteringTaskData,
88 EncounteringTaskFrame, NewTaskData, Flags, HasDependences, CodeptrRA));
89}
90
91void OmptCallbackHandler::handleTaskSchedule(ompt_data_t *PriorTaskData,
92 ompt_task_status_t PriorTaskStatus,
93 ompt_data_t *NextTaskData) {
94 if (RecordAndReplay) {
95 recordEvent(OmptAssertEvent::TaskSchedule("Task Schedule", "",
97 return;
98 }
99
100 for (const auto &S : Subscribers)
101 S->notify(OmptAssertEvent::TaskSchedule("Task Schedule", "",
103}
104
105void OmptCallbackHandler::handleImplicitTask(ompt_scope_endpoint_t Endpoint,
106 ompt_data_t *ParallelData,
107 ompt_data_t *TaskData,
108 unsigned int ActualParallelism,
109 unsigned int Index, int Flags) {
110 if (RecordAndReplay) {
112 "Implicit Task", "", ObserveState::Generated, Endpoint, ParallelData,
113 TaskData, ActualParallelism, Index, Flags));
114 return;
115 }
116
117 for (const auto &S : Subscribers)
119 "Implicit Task", "", ObserveState::Generated, Endpoint, ParallelData,
120 TaskData, ActualParallelism, Index, Flags));
121}
122
124 ompt_data_t *EncounteringTaskData,
125 const ompt_frame_t *EncounteringTaskFrame, ompt_data_t *ParallelData,
126 unsigned int RequestedParallelism, int Flags, const void *CodeptrRA) {
127 if (RecordAndReplay) {
129 "Parallel Begin", "", ObserveState::Generated, RequestedParallelism));
130 return;
131 }
132
133 for (const auto &S : Subscribers)
135 "Parallel Begin", "", ObserveState::Generated, RequestedParallelism));
136}
137
138void OmptCallbackHandler::handleParallelEnd(ompt_data_t *ParallelData,
139 ompt_data_t *EncounteringTaskData,
140 int Flags, const void *CodeptrRA) {
141 if (RecordAndReplay) {
142 recordEvent(OmptAssertEvent::ParallelEnd("Parallel End", "",
144 return;
145 }
146
147 for (const auto &S : Subscribers)
148 S->notify(OmptAssertEvent::ParallelEnd("Parallel End", "",
150}
151
153 int DeviceNum, const char *Type, ompt_device_t *Device,
154 ompt_function_lookup_t LookupFn, const char *DocumentationStr) {
155 if (RecordAndReplay) {
157 "Device Inititalize", "", ObserveState::Generated, DeviceNum, Type,
158 Device, LookupFn, DocumentationStr));
159 return;
160 }
161
162 for (const auto &S : Subscribers)
164 "Device Inititalize", "", ObserveState::Generated, DeviceNum, Type,
165 Device, LookupFn, DocumentationStr));
166}
167
169 if (RecordAndReplay) {
171 "Device Finalize", "", ObserveState::Generated, DeviceNum));
172 return;
173 }
174
175 for (const auto &S : Subscribers)
177 "Device Finalize", "", ObserveState::Generated, DeviceNum));
178}
179
180void OmptCallbackHandler::handleTarget(ompt_target_t Kind,
181 ompt_scope_endpoint_t Endpoint,
182 int DeviceNum, ompt_data_t *TaskData,
183 ompt_id_t TargetId,
184 const void *CodeptrRA) {
185 if (RecordAndReplay) {
186 recordEvent(OmptAssertEvent::Target("Target", "", ObserveState::Generated,
187 Kind, Endpoint, DeviceNum, TaskData,
188 TargetId, CodeptrRA));
189 return;
190 }
191
192 for (const auto &S : Subscribers)
194 Kind, Endpoint, DeviceNum, TaskData,
195 TargetId, CodeptrRA));
196}
197
199 ompt_scope_endpoint_t Endpoint,
200 int DeviceNum, ompt_data_t *TaskData,
201 ompt_data_t *TargetTaskData,
202 ompt_data_t *TargetData,
203 const void *CodeptrRA) {
204 if (RecordAndReplay) {
205 recordEvent(OmptAssertEvent::TargetEmi(
206 "Target EMI", "", ObserveState::Generated, Kind, Endpoint, DeviceNum,
207 TaskData, TargetTaskData, TargetData, CodeptrRA));
208 return;
209 }
210
211 for (const auto &S : Subscribers)
213 "Target EMI", "", ObserveState::Generated, Kind, Endpoint, DeviceNum,
214 TaskData, TargetTaskData, TargetData, CodeptrRA));
215}
216
218 ompt_id_t HostOpId,
219 unsigned int RequestedNumTeams) {
220 if (RecordAndReplay) {
221 recordEvent(OmptAssertEvent::TargetSubmit("Target Submit", "",
222 ObserveState::Generated, TargetId,
223 HostOpId, RequestedNumTeams));
224 return;
225 }
226
227 for (const auto &S : Subscribers)
228 S->notify(OmptAssertEvent::TargetSubmit("Target Submit", "",
229 ObserveState::Generated, TargetId,
230 HostOpId, RequestedNumTeams));
231}
232
234 ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetData,
235 ompt_id_t *HostOpId, unsigned int RequestedNumTeams) {
236 if (RecordAndReplay) {
238 "Target Submit EMI", "", ObserveState::Generated, Endpoint, TargetData,
239 HostOpId, RequestedNumTeams));
240 return;
241 }
242
243 for (const auto &S : Subscribers)
245 "Target Submit EMI", "", ObserveState::Generated, Endpoint, TargetData,
246 HostOpId, RequestedNumTeams));
247}
248
250 ompt_id_t TargetId, ompt_id_t HostOpId, ompt_target_data_op_t OpType,
251 void *SrcAddr, int SrcDeviceNum, void *DstAddr, int DstDeviceNum,
252 size_t Bytes, const void *CodeptrRA) {
253 if (RecordAndReplay) {
255 "Target Data Op", "", ObserveState::Generated, TargetId, HostOpId,
256 OpType, SrcAddr, SrcDeviceNum, DstAddr, DstDeviceNum, Bytes,
257 CodeptrRA));
258 return;
259 }
260
261 for (const auto &S : Subscribers)
263 "Target Data Op", "", ObserveState::Generated, TargetId, HostOpId,
264 OpType, SrcAddr, SrcDeviceNum, DstAddr, DstDeviceNum, Bytes,
265 CodeptrRA));
266}
267
269 ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetTaskData,
270 ompt_data_t *TargetData, ompt_id_t *HostOpId, ompt_target_data_op_t OpType,
271 void *SrcAddr, int SrcDeviceNum, void *DstAddr, int DstDeviceNum,
272 size_t Bytes, const void *CodeptrRA) {
273 if (RecordAndReplay) {
275 "Target Data Op EMI", "", ObserveState::Generated, Endpoint,
276 TargetTaskData, TargetData, HostOpId, OpType, SrcAddr, SrcDeviceNum,
277 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
278 return;
279 }
280
281 for (const auto &S : Subscribers)
283 "Target Data Op EMI", "", ObserveState::Generated, Endpoint,
284 TargetTaskData, TargetData, HostOpId, OpType, SrcAddr, SrcDeviceNum,
285 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
286}
287
288void OmptCallbackHandler::handleDeviceLoad(int DeviceNum, const char *Filename,
289 int64_t OffsetInFile,
290 void *VmaInFile, size_t Bytes,
291 void *HostAddr, void *DeviceAddr,
292 uint64_t ModuleId) {
293 if (RecordAndReplay) {
294 recordEvent(OmptAssertEvent::DeviceLoad(
295 "Device Load", "", ObserveState::Generated, DeviceNum, Filename,
296 OffsetInFile, VmaInFile, Bytes, HostAddr, DeviceAddr, ModuleId));
297 return;
298 }
299
300 for (const auto &S : Subscribers)
302 "Device Load", "", ObserveState::Generated, DeviceNum, Filename,
303 OffsetInFile, VmaInFile, Bytes, HostAddr, DeviceAddr, ModuleId));
304}
305
306void OmptCallbackHandler::handleDeviceUnload(int DeviceNum, uint64_t ModuleId) {
307 if (RecordAndReplay) {
308 recordEvent(OmptAssertEvent::DeviceUnload("Device Unload", "",
310 return;
311 }
312
313 for (const auto &S : Subscribers)
314 S->notify(OmptAssertEvent::DeviceUnload("Device Unload", "",
316}
317
319 ompt_buffer_t **Buffer,
320 size_t *Bytes) {
321 if (RecordAndReplay) {
322 recordEvent(OmptAssertEvent::BufferRequest("Buffer Request", "",
324 DeviceNum, Buffer, Bytes));
325 return;
326 }
327
328 for (const auto &S : Subscribers)
329 S->notify(OmptAssertEvent::BufferRequest("Buffer Request", "",
330 ObserveState::Generated, DeviceNum,
331 Buffer, Bytes));
332}
333
335 ompt_buffer_t *Buffer,
336 size_t Bytes,
337 ompt_buffer_cursor_t Begin,
338 int BufferOwned) {
339 if (RecordAndReplay) {
341 "Buffer Complete", "", ObserveState::Generated, DeviceNum, Buffer,
342 Bytes, Begin, BufferOwned));
343 return;
344 }
345
346 for (const auto &S : Subscribers)
348 "Buffer Complete", "", ObserveState::Generated, DeviceNum, Buffer,
349 Bytes, Begin, BufferOwned));
350}
351
352void OmptCallbackHandler::handleBufferRecord(ompt_record_ompt_t *Record) {
353 if (RecordAndReplay) {
354 recordEvent(OmptAssertEvent::BufferRecord("Buffer Record", "",
355 ObserveState::Generated, Record));
356 return;
357 }
358
359 for (const auto &S : Subscribers)
360 S->notify(OmptAssertEvent::BufferRecord("Buffer Record", "",
361 ObserveState::Generated, Record));
362}
363
365 ompt_buffer_t *Buffer) {
366 if (RecordAndReplay) {
368 "Buffer Deallocation", "", ObserveState::Generated, Buffer));
369 return;
370 }
371
372 for (const auto &S : Subscribers)
374 "Buffer Deallocation", "", ObserveState::Generated, Buffer));
375}
376
377void OmptCallbackHandler::handleWork(ompt_work_t WorkType,
378 ompt_scope_endpoint_t Endpoint,
379 ompt_data_t *ParallelData,
380 ompt_data_t *TaskData, uint64_t Count,
381 const void *CodeptrRA) {
382 if (RecordAndReplay) {
383 recordEvent(OmptAssertEvent::Work("Work", "", ObserveState::Generated,
384 WorkType, Endpoint, ParallelData,
385 TaskData, Count, CodeptrRA));
386 return;
387 }
388
389 for (const auto &S : Subscribers)
391 WorkType, Endpoint, ParallelData, TaskData,
392 Count, CodeptrRA));
393}
394
395void OmptCallbackHandler::handleSyncRegion(ompt_sync_region_t Kind,
396 ompt_scope_endpoint_t Endpoint,
397 ompt_data_t *ParallelData,
398 ompt_data_t *TaskData,
399 const void *CodeptrRA) {
400 if (RecordAndReplay) {
401 recordEvent(OmptAssertEvent::SyncRegion(
402 "SyncRegion", "", ObserveState::Generated, Kind, Endpoint, ParallelData,
403 TaskData, CodeptrRA));
404 return;
405 }
406
407 for (const auto &S : Subscribers)
409 "SyncRegion", "", ObserveState::Generated, Kind, Endpoint, ParallelData,
410 TaskData, CodeptrRA));
411}
412
413void OmptCallbackHandler::handleDispatch(ompt_data_t *ParallelData,
414 ompt_data_t *TaskData,
415 ompt_dispatch_t Kind,
416 ompt_data_t Instance) {
417 if (RecordAndReplay) {
418 recordEvent(OmptAssertEvent::Dispatch("Dispatch", "",
419 ObserveState::Generated, ParallelData,
420 TaskData, Kind, Instance));
421 return;
422 }
423
424 for (const auto &S : Subscribers)
426 ParallelData, TaskData, Kind,
427 Instance));
428}
429
431 const std::string &SyncPointName) {
432 if (RecordAndReplay) {
434 "Assertion SyncPoint", "", ObserveState::Generated, SyncPointName));
435 return;
436 }
437
438 for (const auto &S : Subscribers)
440 "Assertion SyncPoint", "", ObserveState::Generated, SyncPointName));
441}
442
443void OmptCallbackHandler::recordEvent(OmptAssertEvent &&Event) {
444 RecordedEvents.emplace_back(std::forward<OmptAssertEvent>(Event));
445}
OmptCallbackHandler * Handler
This file provides the OMPT callback handling declarations.
omptest::OmptCallbackHandler * Handler
Handler class to do whatever is needed to be done when a callback is invoked by the OMP runtime Suppo...
void handleAssertionSyncPoint(const std::string &SyncPointName)
Special asserter callback which checks that upon encountering the synchronization point,...
void handleImplicitTask(ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData, ompt_data_t *TaskData, unsigned int ActualParallelism, unsigned int Index, int Flags)
void handleDeviceFinalize(int DeviceNum)
void replay()
When the record and replay mechanism is enabled this replays all OMPT events.
void handleTaskCreate(ompt_data_t *EncounteringTaskData, const ompt_frame_t *EncounteringTaskFrame, ompt_data_t *NewTaskData, int Flags, int HasDependences, const void *CodeptrRA)
void handleTargetSubmitEmi(ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetData, ompt_id_t *HostOpId, unsigned int RequestedNumTeams)
void handleThreadEnd(ompt_data_t *ThreadData)
void subscribe(OmptListener *Listener)
Subscribe a listener to be notified for OMPT events.
void handleBufferComplete(int DeviceNum, ompt_buffer_t *Buffer, size_t Bytes, ompt_buffer_cursor_t Begin, int BufferOwned)
void handleDeviceUnload(int DeviceNum, uint64_t ModuleId)
void handleTargetSubmit(ompt_id_t TargetId, ompt_id_t HostOpId, unsigned int RequestedNumTeams)
void handleSyncRegion(ompt_sync_region_t Kind, ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData, ompt_data_t *TaskData, const void *CodeptrRA)
void clearSubscribers()
Remove all subscribers.
void handleThreadBegin(ompt_thread_t ThreadType, ompt_data_t *ThreadData)
void handleDispatch(ompt_data_t *ParallelData, ompt_data_t *TaskData, ompt_dispatch_t Kind, ompt_data_t Instance)
void handleBufferRecord(ompt_record_ompt_t *Record)
void handleTaskSchedule(ompt_data_t *PriorTaskData, ompt_task_status_t PriorTaskStatus, ompt_data_t *NextTaskData)
void handleBufferRequest(int DeviceNum, ompt_buffer_t **Buffer, size_t *Bytes)
void handleTargetDataOp(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)
void handleBufferRecordDeallocation(ompt_buffer_t *Buffer)
void handleTarget(ompt_target_t Kind, ompt_scope_endpoint_t Endpoint, int DeviceNum, ompt_data_t *TaskData, ompt_id_t TargetId, const void *CodeptrRA)
void handleParallelEnd(ompt_data_t *ParallelData, ompt_data_t *EncounteringTaskData, int Flags, const void *CodeptrRA)
void handleDeviceLoad(int DeviceNum, const char *Filename, int64_t OffsetInFile, void *VmaInFile, size_t Bytes, void *HostAddr, void *DeviceAddr, uint64_t ModuleId)
void handleTargetEmi(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)
void handleTargetDataOpEmi(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)
void handleDeviceInitialize(int DeviceNum, const char *Type, ompt_device_t *Device, ompt_function_lookup_t LookupFn, const char *DocumentationStr)
void handleParallelBegin(ompt_data_t *EncounteringTaskData, const ompt_frame_t *EncounteringTaskFrame, ompt_data_t *ParallelData, unsigned int RequestedParallelism, int Flags, const void *CodeptrRA)
static OmptCallbackHandler & get()
Singleton handler.
void handleWork(ompt_work_t WorkType, ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData, ompt_data_t *TaskData, uint64_t Count, const void *CodeptrRA)
Not needed for a conforming minimal OMPT implementation.
General base class for the subscriber/notification pattern in OmptCallbackHandler.
Definition: OmptAsserter.h:37
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain ITT_FORMAT p const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_string_handle unsigned long long ITT_FORMAT lu const __itt_domain __itt_id __itt_string_handle __itt_metadata_type size_t void ITT_FORMAT p const __itt_domain __itt_id __itt_string_handle const wchar_t size_t ITT_FORMAT lu const __itt_domain __itt_id __itt_relation __itt_id ITT_FORMAT p const wchar_t int ITT_FORMAT __itt_group_mark S
unsigned * Index(unsigned *p, unsigned i, unsigned j, unsigned bound2)
Assertion event struct, provides statically callable CTORs.
static OmptAssertEvent TargetDataOpEmi(const std::string &Name, const std::string &Group, const ObserveState &Expected, 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)
static OmptAssertEvent SyncRegion(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_sync_region_t Kind, ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData=expectedDefault(ompt_data_t *), ompt_data_t *TaskData=expectedDefault(ompt_data_t *), const void *CodeptrRA=expectedDefault(const void *))
static OmptAssertEvent BufferRecord(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_record_ompt_t *Record)
static OmptAssertEvent TargetSubmit(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_id_t TargetId, ompt_id_t HostOpId, unsigned int RequestedNumTeams)
static OmptAssertEvent Dispatch(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_data_t *ParallelData=expectedDefault(ompt_data_t *), ompt_data_t *TaskData=expectedDefault(ompt_data_t *), ompt_dispatch_t Kind=expectedDefault(ompt_dispatch_t), ompt_data_t Instance=expectedDefault(ompt_data_t))
static OmptAssertEvent AssertionSyncPoint(const std::string &Name, const std::string &Group, const ObserveState &Expected, const std::string &SyncPointName)
static OmptAssertEvent TaskSchedule(const std::string &Name, const std::string &Group, const ObserveState &Expected)
static OmptAssertEvent BufferRequest(const std::string &Name, const std::string &Group, const ObserveState &Expected, int DeviceNum, ompt_buffer_t **Buffer, size_t *Bytes)
static OmptAssertEvent DeviceUnload(const std::string &Name, const std::string &Group, const ObserveState &Expected)
static OmptAssertEvent ParallelEnd(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_data_t *ParallelData=expectedDefault(ompt_data_t *), ompt_data_t *EncounteringTaskData=expectedDefault(ompt_data_t *), int Flags=expectedDefault(int), const void *CodeptrRA=expectedDefault(const void *))
static OmptAssertEvent DeviceLoad(const std::string &Name, const std::string &Group, const ObserveState &Expected, int DeviceNum, const char *Filename=expectedDefault(const char *), int64_t OffsetInFile=expectedDefault(int64_t), void *VmaInFile=expectedDefault(void *), size_t Bytes=expectedDefault(size_t), void *HostAddr=expectedDefault(void *), void *DeviceAddr=expectedDefault(void *), uint64_t ModuleId=expectedDefault(int64_t))
static OmptAssertEvent TargetSubmitEmi(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_scope_endpoint_t Endpoint, ompt_data_t *TargetData, ompt_id_t *HostOpId, unsigned int RequestedNumTeams)
static OmptAssertEvent TargetEmi(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_target_t Kind, ompt_scope_endpoint_t Endpoint, int DeviceNum=expectedDefault(int), ompt_data_t *TaskData=expectedDefault(ompt_data_t *), ompt_data_t *TargetTaskData=expectedDefault(ompt_data_t *), ompt_data_t *TargetData=expectedDefault(ompt_data_t *), const void *CodeptrRA=expectedDefault(void *))
static OmptAssertEvent TargetDataOp(const std::string &Name, const std::string &Group, const ObserveState &Expected, 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)
static OmptAssertEvent Work(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_work_t WorkType, ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData=expectedDefault(ompt_data_t *), ompt_data_t *TaskData=expectedDefault(ompt_data_t *), uint64_t Count=expectedDefault(uint64_t), const void *CodeptrRA=expectedDefault(const void *))
static OmptAssertEvent DeviceFinalize(const std::string &Name, const std::string &Group, const ObserveState &Expected, int DeviceNum)
static OmptAssertEvent BufferRecordDeallocation(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_buffer_t *Buffer)
static OmptAssertEvent DeviceInitialize(const std::string &Name, const std::string &Group, const ObserveState &Expected, int DeviceNum, const char *Type=expectedDefault(const char *), ompt_device_t *Device=expectedDefault(ompt_device_t *), ompt_function_lookup_t LookupFn=expectedDefault(ompt_function_lookup_t), const char *DocumentationStr=expectedDefault(const char *))
static OmptAssertEvent BufferComplete(const std::string &Name, const std::string &Group, const ObserveState &Expected, int DeviceNum, ompt_buffer_t *Buffer, size_t Bytes, ompt_buffer_cursor_t Begin, int BufferOwned)
static OmptAssertEvent ThreadEnd(const std::string &Name, const std::string &Group, const ObserveState &Expected)
static OmptAssertEvent ParallelBegin(const std::string &Name, const std::string &Group, const ObserveState &Expected, int NumThreads)
static OmptAssertEvent TaskCreate(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_data_t *EncounteringTaskData=expectedDefault(ompt_data_t *), const ompt_frame_t *EncounteringTaskFrame=expectedDefault(ompt_frame_t *), ompt_data_t *NewTaskData=expectedDefault(ompt_data_t *), int Flags=expectedDefault(int), int HasDependences=expectedDefault(int), const void *CodeptrRA=expectedDefault(const void *))
static OmptAssertEvent ThreadBegin(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_thread_t ThreadType)
static OmptAssertEvent ImplicitTask(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData=expectedDefault(ompt_data_t *), ompt_data_t *TaskData=expectedDefault(ompt_data_t *), unsigned int ActualParallelism=expectedDefault(unsigned int), unsigned int Index=expectedDefault(unsigned int), int Flags=expectedDefault(int))
static OmptAssertEvent Target(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_target_t Kind, ompt_scope_endpoint_t Endpoint, int DeviceNum=expectedDefault(int), ompt_data_t *TaskData=expectedDefault(ompt_data_t *), ompt_id_t TargetId=expectedDefault(ompt_id_t), const void *CodeptrRA=expectedDefault(void *))