LLVM OpenMP 22.0.0git
OmptAssertEvent.cpp
Go to the documentation of this file.
1//===- OmptAssertEvent.cpp - Assertion event implementations ----*- 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/// Implements assertion event CTORs, for generally all observable events.
11///
12//===----------------------------------------------------------------------===//
13
14#include "OmptAssertEvent.h"
15#include <omp-tools.h>
16
17using namespace omptest;
18
19const char *omptest::to_string(ObserveState State) {
20 switch (State) {
22 return "Generated";
24 return "Always";
26 return "Never";
27 }
28}
29
30OmptAssertEvent::OmptAssertEvent(const std::string &Name,
31 const std::string &Group,
32 const ObserveState &Expected,
34 : Name(Name), Group(Group), ExpectedState(Expected), TheEvent(IE) {}
35
37 const std::string &Name, const std::string &Group,
38 const ObserveState &Expected, const std::string &SyncPointName) {
39 auto EName = getName(Name);
40 auto EGroup = getGroup(Group);
41 return OmptAssertEvent(EName, EGroup, Expected,
42 new internal::AssertionSyncPoint(SyncPointName));
43}
44
46OmptAssertEvent::AssertionSuspend(const std::string &Name,
47 const std::string &Group,
48 const ObserveState &Expected) {
49 auto EName = getName(Name);
50 auto EGroup = getGroup(Group);
51 return OmptAssertEvent(EName, EGroup, Expected,
53}
54
56 const std::string &Group,
57 const ObserveState &Expected,
58 ompt_thread_t ThreadType) {
59 auto EName = getName(Name);
60 auto EGroup = getGroup(Group);
61 return OmptAssertEvent(EName, EGroup, Expected,
62 new internal::ThreadBegin(ThreadType));
63}
64
66 const std::string &Group,
67 const ObserveState &Expected) {
68 auto EName = getName(Name);
69 auto EGroup = getGroup(Group);
70 return OmptAssertEvent(EName, EGroup, Expected, new internal::ThreadEnd());
71}
72
74 const std::string &Group,
75 const ObserveState &Expected,
76 int NumThreads) {
77 auto EName = getName(Name);
78 auto EGroup = getGroup(Group);
79 return OmptAssertEvent(EName, EGroup, Expected,
80 new internal::ParallelBegin(NumThreads));
81}
82
84 const std::string &Group,
85 const ObserveState &Expected,
86 ompt_data_t *ParallelData,
87 ompt_data_t *EncounteringTaskData,
88 int Flags, const void *CodeptrRA) {
89 auto EName = getName(Name);
90 auto EGroup = getGroup(Group);
91 return OmptAssertEvent(EName, EGroup, Expected,
92 new internal::ParallelEnd(ParallelData,
93 EncounteringTaskData, Flags,
94 CodeptrRA));
95}
96
98OmptAssertEvent::Work(const std::string &Name, const std::string &Group,
99 const ObserveState &Expected, ompt_work_t WorkType,
100 ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData,
101 ompt_data_t *TaskData, uint64_t Count,
102 const void *CodeptrRA) {
103 auto EName = getName(Name);
104 auto EGroup = getGroup(Group);
105 return OmptAssertEvent(EName, EGroup, Expected,
106 new internal::Work(WorkType, Endpoint, ParallelData,
107 TaskData, Count, CodeptrRA));
108}
109
111OmptAssertEvent::Dispatch(const std::string &Name, const std::string &Group,
112 const ObserveState &Expected,
113 ompt_data_t *ParallelData, ompt_data_t *TaskData,
114 ompt_dispatch_t Kind, ompt_data_t Instance) {
115 auto EName = getName(Name);
116 auto EGroup = getGroup(Group);
117 return OmptAssertEvent(
118 EName, EGroup, Expected,
119 new internal::Dispatch(ParallelData, TaskData, Kind, Instance));
120}
121
123 const std::string &Name, const std::string &Group,
124 const ObserveState &Expected, ompt_data_t *EncounteringTaskData,
125 const ompt_frame_t *EncounteringTaskFrame, ompt_data_t *NewTaskData,
126 int Flags, int HasDependences, const void *CodeptrRA) {
127 auto EName = getName(Name);
128 auto EGroup = getGroup(Group);
129 return OmptAssertEvent(
130 EName, EGroup, Expected,
131 new internal::TaskCreate(EncounteringTaskData, EncounteringTaskFrame,
132 NewTaskData, Flags, HasDependences, CodeptrRA));
133}
134
136 const std::string &Group,
137 const ObserveState &Expected) {
138 auto EName = getName(Name);
139 auto EGroup = getGroup(Group);
140 return OmptAssertEvent(EName, EGroup, Expected, new internal::TaskSchedule());
141}
142
144 const std::string &Name, const std::string &Group,
145 const ObserveState &Expected, ompt_scope_endpoint_t Endpoint,
146 ompt_data_t *ParallelData, ompt_data_t *TaskData,
147 unsigned int ActualParallelism, unsigned int Index, int Flags) {
148 auto EName = getName(Name);
149 auto EGroup = getGroup(Group);
150 return OmptAssertEvent(EName, EGroup, Expected,
151 new internal::ImplicitTask(Endpoint, ParallelData,
152 TaskData, ActualParallelism,
153 Index, Flags));
154}
155
157 const std::string &Name, const std::string &Group,
158 const ObserveState &Expected, ompt_sync_region_t Kind,
159 ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData,
160 ompt_data_t *TaskData, const void *CodeptrRA) {
161 auto EName = getName(Name);
162 auto EGroup = getGroup(Group);
163 return OmptAssertEvent(EName, EGroup, Expected,
164 new internal::SyncRegion(Kind, Endpoint, ParallelData,
165 TaskData, CodeptrRA));
166}
167
169OmptAssertEvent::Target(const std::string &Name, const std::string &Group,
170 const ObserveState &Expected, ompt_target_t Kind,
171 ompt_scope_endpoint_t Endpoint, int DeviceNum,
172 ompt_data_t *TaskData, ompt_id_t TargetId,
173 const void *CodeptrRA) {
174 auto EName = getName(Name);
175 auto EGroup = getGroup(Group);
176 return OmptAssertEvent(EName, EGroup, Expected,
177 new internal::Target(Kind, Endpoint, DeviceNum,
178 TaskData, TargetId, CodeptrRA));
179}
180
182OmptAssertEvent::TargetEmi(const std::string &Name, const std::string &Group,
183 const ObserveState &Expected, ompt_target_t Kind,
184 ompt_scope_endpoint_t Endpoint, int DeviceNum,
185 ompt_data_t *TaskData, ompt_data_t *TargetTaskData,
186 ompt_data_t *TargetData, const void *CodeptrRA) {
187 auto EName = getName(Name);
188 auto EGroup = getGroup(Group);
189 return OmptAssertEvent(EName, EGroup, Expected,
190 new internal::TargetEmi(Kind, Endpoint, DeviceNum,
191 TaskData, TargetTaskData,
192 TargetData, CodeptrRA));
193}
194
196 const std::string &Name, const std::string &Group,
197 const ObserveState &Expected, ompt_id_t TargetId, ompt_id_t HostOpId,
198 ompt_target_data_op_t OpType, void *SrcAddr, int SrcDeviceNum,
199 void *DstAddr, int DstDeviceNum, size_t Bytes, const void *CodeptrRA) {
200 auto EName = getName(Name);
201 auto EGroup = getGroup(Group);
202 return OmptAssertEvent(EName, EGroup, Expected,
204 TargetId, HostOpId, OpType, SrcAddr, SrcDeviceNum,
205 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
206}
207
209 const std::string &Name, const std::string &Group,
210 const ObserveState &Expected, ompt_target_data_op_t OpType, size_t Bytes,
211 void *SrcAddr, void *DstAddr, int SrcDeviceNum, int DstDeviceNum,
212 ompt_id_t TargetId, ompt_id_t HostOpId, const void *CodeptrRA) {
213 auto EName = getName(Name);
214 auto EGroup = getGroup(Group);
215 return OmptAssertEvent(EName, EGroup, Expected,
217 TargetId, HostOpId, OpType, SrcAddr, SrcDeviceNum,
218 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
219}
220
222 const std::string &Name, const std::string &Group,
223 const ObserveState &Expected, ompt_scope_endpoint_t Endpoint,
224 ompt_data_t *TargetTaskData, ompt_data_t *TargetData, ompt_id_t *HostOpId,
225 ompt_target_data_op_t OpType, void *SrcAddr, int SrcDeviceNum,
226 void *DstAddr, int DstDeviceNum, size_t Bytes, const void *CodeptrRA) {
227 auto EName = getName(Name);
228 auto EGroup = getGroup(Group);
229 return OmptAssertEvent(
230 EName, EGroup, Expected,
231 new internal::TargetDataOpEmi(Endpoint, TargetTaskData, TargetData,
232 HostOpId, OpType, SrcAddr, SrcDeviceNum,
233 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
234}
235
237 const std::string &Name, const std::string &Group,
238 const ObserveState &Expected, ompt_target_data_op_t OpType,
239 ompt_scope_endpoint_t Endpoint, size_t Bytes, void *SrcAddr, void *DstAddr,
240 int SrcDeviceNum, int DstDeviceNum, ompt_data_t *TargetTaskData,
241 ompt_data_t *TargetData, ompt_id_t *HostOpId, const void *CodeptrRA) {
242 auto EName = getName(Name);
243 auto EGroup = getGroup(Group);
244 return OmptAssertEvent(
245 EName, EGroup, Expected,
246 new internal::TargetDataOpEmi(Endpoint, TargetTaskData, TargetData,
247 HostOpId, OpType, SrcAddr, SrcDeviceNum,
248 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
249}
250
252 const std::string &Group,
253 const ObserveState &Expected,
254 ompt_id_t TargetId,
255 ompt_id_t HostOpId,
256 unsigned int RequestedNumTeams) {
257 auto EName = getName(Name);
258 auto EGroup = getGroup(Group);
259 return OmptAssertEvent(
260 EName, EGroup, Expected,
261 new internal::TargetSubmit(TargetId, HostOpId, RequestedNumTeams));
262}
263
265 const std::string &Group,
266 const ObserveState &Expected,
267 unsigned int RequestedNumTeams,
268 ompt_id_t TargetId,
269 ompt_id_t HostOpId) {
270 auto EName = getName(Name);
271 auto EGroup = getGroup(Group);
272 return OmptAssertEvent(
273 EName, EGroup, Expected,
274 new internal::TargetSubmit(TargetId, HostOpId, RequestedNumTeams));
275}
276
278 const std::string &Name, const std::string &Group,
279 const ObserveState &Expected, ompt_scope_endpoint_t Endpoint,
280 ompt_data_t *TargetData, ompt_id_t *HostOpId,
281 unsigned int RequestedNumTeams) {
282 auto EName = getName(Name);
283 auto EGroup = getGroup(Group);
284 return OmptAssertEvent(EName, EGroup, Expected,
285 new internal::TargetSubmitEmi(Endpoint, TargetData,
286 HostOpId,
287 RequestedNumTeams));
288}
289
291 const std::string &Group,
292 const ObserveState &Expected,
293 unsigned int RequestedNumTeams,
294 ompt_scope_endpoint_t Endpoint,
295 ompt_data_t *TargetData,
296 ompt_id_t *HostOpId) {
297 auto EName = getName(Name);
298 auto EGroup = getGroup(Group);
299 return OmptAssertEvent(EName, EGroup, Expected,
300 new internal::TargetSubmitEmi(Endpoint, TargetData,
301 HostOpId,
302 RequestedNumTeams));
303}
304
306 const std::string &Group,
307 const ObserveState &Expected) {
308 auto EName = getName(Name);
309 auto EGroup = getGroup(Group);
310 return OmptAssertEvent(EName, EGroup, Expected, new internal::ControlTool());
311}
312
314 const std::string &Name, const std::string &Group,
315 const ObserveState &Expected, int DeviceNum, const char *Type,
316 ompt_device_t *Device, ompt_function_lookup_t LookupFn,
317 const char *DocumentationStr) {
318 auto EName = getName(Name);
319 auto EGroup = getGroup(Group);
320 return OmptAssertEvent(EName, EGroup, Expected,
321 new internal::DeviceInitialize(DeviceNum, Type, Device,
322 LookupFn,
323 DocumentationStr));
324}
325
327 const std::string &Group,
328 const ObserveState &Expected,
329 int DeviceNum) {
330 auto EName = getName(Name);
331 auto EGroup = getGroup(Group);
332 return OmptAssertEvent(EName, EGroup, Expected,
333 new internal::DeviceFinalize(DeviceNum));
334}
335
337OmptAssertEvent::DeviceLoad(const std::string &Name, const std::string &Group,
338 const ObserveState &Expected, int DeviceNum,
339 const char *Filename, int64_t OffsetInFile,
340 void *VmaInFile, size_t Bytes, void *HostAddr,
341 void *DeviceAddr, uint64_t ModuleId) {
342 auto EName = getName(Name);
343 auto EGroup = getGroup(Group);
344 return OmptAssertEvent(
345 EName, EGroup, Expected,
346 new internal::DeviceLoad(DeviceNum, Filename, OffsetInFile, VmaInFile,
347 Bytes, HostAddr, DeviceAddr, ModuleId));
348}
349
351 const std::string &Group,
352 const ObserveState &Expected) {
353 auto EName = getName(Name);
354 auto EGroup = getGroup(Group);
355 return OmptAssertEvent(EName, EGroup, Expected, new internal::DeviceUnload());
356}
357
359 const std::string &Group,
360 const ObserveState &Expected,
361 int DeviceNum,
362 ompt_buffer_t **Buffer,
363 size_t *Bytes) {
364 auto EName = getName(Name);
365 auto EGroup = getGroup(Group);
366 return OmptAssertEvent(EName, EGroup, Expected,
367 new internal::BufferRequest(DeviceNum, Buffer, Bytes));
368}
369
371 const std::string &Name, const std::string &Group,
372 const ObserveState &Expected, int DeviceNum, ompt_buffer_t *Buffer,
373 size_t Bytes, ompt_buffer_cursor_t Begin, int BufferOwned) {
374 auto EName = getName(Name);
375 auto EGroup = getGroup(Group);
376 return OmptAssertEvent(EName, EGroup, Expected,
377 new internal::BufferComplete(DeviceNum, Buffer, Bytes,
378 Begin, BufferOwned));
379}
380
382 const std::string &Group,
383 const ObserveState &Expected,
384 ompt_record_ompt_t *Record) {
385 auto EName = getName(Name);
386 auto EGroup = getGroup(Group);
387 return OmptAssertEvent(EName, EGroup, Expected,
388 new internal::BufferRecord(Record));
389}
390
392 const std::string &Name, const std::string &Group,
393 const ObserveState &Expected, ompt_callbacks_t Type, ompt_target_t Kind,
394 ompt_scope_endpoint_t Endpoint, int DeviceNum, ompt_id_t TaskId,
395 ompt_id_t TargetId, const void *CodeptrRA) {
396 auto EName = getName(Name);
397 auto EGroup = getGroup(Group);
398
399 if (Type != ompt_callback_target)
400 assert(false && "CTOR only suited for type: 'ompt_callback_target'");
401
402 ompt_record_target_t Subrecord{Kind, Endpoint, DeviceNum,
403 TaskId, TargetId, CodeptrRA};
404
405 ompt_record_ompt_t *RecordPtr =
406 (ompt_record_ompt_t *)malloc(sizeof(ompt_record_ompt_t));
407 memset(RecordPtr, 0, sizeof(ompt_record_ompt_t));
408 RecordPtr->type = Type;
409 RecordPtr->time = expectedDefault(ompt_device_time_t);
410 RecordPtr->thread_id = expectedDefault(ompt_id_t);
411 RecordPtr->target_id = TargetId;
412 RecordPtr->record.target = Subrecord;
413
414 return OmptAssertEvent(EName, EGroup, Expected,
415 new internal::BufferRecord(RecordPtr));
416}
417
419 const std::string &Name, const std::string &Group,
420 const ObserveState &Expected, ompt_callbacks_t Type,
421 ompt_target_data_op_t OpType, size_t Bytes,
422 std::pair<ompt_device_time_t, ompt_device_time_t> Timeframe, void *SrcAddr,
423 void *DstAddr, int SrcDeviceNum, int DstDeviceNum, ompt_id_t TargetId,
424 ompt_id_t HostOpId, const void *CodeptrRA) {
425 auto EName = getName(Name);
426 auto EGroup = getGroup(Group);
427
428 if (Type != ompt_callback_target_data_op)
429 assert(false &&
430 "CTOR only suited for type: 'ompt_callback_target_data_op'");
431
432 ompt_record_target_data_op_t Subrecord{
433 HostOpId, OpType, SrcAddr, SrcDeviceNum, DstAddr,
434 DstDeviceNum, Bytes, Timeframe.second, CodeptrRA};
435
436 ompt_record_ompt_t *RecordPtr =
437 (ompt_record_ompt_t *)malloc(sizeof(ompt_record_ompt_t));
438 memset(RecordPtr, 0, sizeof(ompt_record_ompt_t));
439 RecordPtr->type = Type;
440 RecordPtr->time = Timeframe.first;
441 RecordPtr->thread_id = expectedDefault(ompt_id_t);
442 RecordPtr->target_id = TargetId;
443 RecordPtr->record.target_data_op = Subrecord;
444
445 return OmptAssertEvent(EName, EGroup, Expected,
446 new internal::BufferRecord(RecordPtr));
447}
448
450 const std::string &Name, const std::string &Group,
451 const ObserveState &Expected, ompt_callbacks_t Type,
452 ompt_target_data_op_t OpType, size_t Bytes,
453 ompt_device_time_t MinimumTimeDelta, void *SrcAddr, void *DstAddr,
454 int SrcDeviceNum, int DstDeviceNum, ompt_id_t TargetId, ompt_id_t HostOpId,
455 const void *CodeptrRA) {
456 return BufferRecord(Name, Group, Expected, Type, OpType, Bytes,
457 {MinimumTimeDelta, expectedDefault(ompt_device_time_t)},
458 SrcAddr, DstAddr, SrcDeviceNum, DstDeviceNum, TargetId,
459 HostOpId, CodeptrRA);
460}
461
463 const std::string &Name, const std::string &Group,
464 const ObserveState &Expected, ompt_callbacks_t Type,
465 std::pair<ompt_device_time_t, ompt_device_time_t> Timeframe,
466 unsigned int RequestedNumTeams, unsigned int GrantedNumTeams,
467 ompt_id_t TargetId, ompt_id_t HostOpId) {
468 auto EName = getName(Name);
469 auto EGroup = getGroup(Group);
470
471 bool isDefault = (Timeframe.first == expectedDefault(ompt_device_time_t));
472 isDefault &= (Timeframe.second == expectedDefault(ompt_device_time_t));
473 isDefault &= (RequestedNumTeams == expectedDefault(unsigned int));
474 isDefault &= (GrantedNumTeams == expectedDefault(unsigned int));
475 isDefault &= (TargetId == expectedDefault(ompt_id_t));
476 isDefault &= (HostOpId == expectedDefault(ompt_id_t));
477
478 ompt_record_ompt_t *RecordPtr =
479 (ompt_record_ompt_t *)malloc(sizeof(ompt_record_ompt_t));
480 memset(RecordPtr, 0, sizeof(ompt_record_ompt_t));
481 RecordPtr->type = Type;
482
483 // This handles the simplest occurrence of a device tracing record
484 // We can only check for Type -- since all other properties are set to default
485 if (isDefault) {
486 RecordPtr->time = expectedDefault(ompt_device_time_t);
487 RecordPtr->thread_id = expectedDefault(ompt_id_t);
488 RecordPtr->target_id = expectedDefault(ompt_id_t);
489 if (Type == ompt_callback_target) {
490 ompt_record_target_t Subrecord{expectedDefault(ompt_target_t),
491 expectedDefault(ompt_scope_endpoint_t),
492 expectedDefault(int),
493 expectedDefault(ompt_id_t),
494 expectedDefault(ompt_id_t),
495 expectedDefault(void *)};
496 RecordPtr->record.target = Subrecord;
497 }
498
499 if (Type == ompt_callback_target_data_op) {
500 ompt_record_target_data_op_t Subrecord{
501 expectedDefault(ompt_id_t), expectedDefault(ompt_target_data_op_t),
502 expectedDefault(void *), expectedDefault(int),
503 expectedDefault(void *), expectedDefault(int),
504 expectedDefault(size_t), expectedDefault(ompt_device_time_t),
505 expectedDefault(void *)};
506 RecordPtr->record.target_data_op = Subrecord;
507 }
508
509 if (Type == ompt_callback_target_submit) {
510 ompt_record_target_kernel_t Subrecord{
511 expectedDefault(ompt_id_t), expectedDefault(unsigned int),
512 expectedDefault(unsigned int), expectedDefault(ompt_device_time_t)};
513 RecordPtr->record.target_kernel = Subrecord;
514 }
515
516 return OmptAssertEvent(EName, EGroup, Expected,
517 new internal::BufferRecord(RecordPtr));
518 }
519
520 if (Type != ompt_callback_target_submit)
521 assert(false && "CTOR only suited for type: 'ompt_callback_target_submit'");
522
523 ompt_record_target_kernel_t Subrecord{HostOpId, RequestedNumTeams,
524 GrantedNumTeams, Timeframe.second};
525
526 RecordPtr->time = Timeframe.first;
527 RecordPtr->thread_id = expectedDefault(ompt_id_t);
528 RecordPtr->target_id = TargetId;
529 RecordPtr->record.target_kernel = Subrecord;
530
531 return OmptAssertEvent(EName, EGroup, Expected,
532 new internal::BufferRecord(RecordPtr));
533}
534
536 const std::string &Name, const std::string &Group,
537 const ObserveState &Expected, ompt_callbacks_t Type,
538 ompt_device_time_t MinimumTimeDelta, unsigned int RequestedNumTeams,
539 unsigned int GrantedNumTeams, ompt_id_t TargetId, ompt_id_t HostOpId) {
540 return BufferRecord(Name, Group, Expected, Type,
541 {MinimumTimeDelta, expectedDefault(ompt_device_time_t)},
542 RequestedNumTeams, GrantedNumTeams, TargetId, HostOpId);
543}
544
546 const std::string &Name, const std::string &Group,
547 const ObserveState &Expected, ompt_buffer_t *Buffer) {
548 auto EName = getName(Name);
549 auto EGroup = getGroup(Group);
550 return OmptAssertEvent(EName, EGroup, Expected,
552}
553
554std::string OmptAssertEvent::getEventName() const { return Name; }
555
556std::string OmptAssertEvent::getEventGroup() const { return Group; }
557
559 return ExpectedState;
560}
561
563 return TheEvent->Type;
564}
565
567 return TheEvent.get();
568}
569
570std::string OmptAssertEvent::toString(bool PrefixEventName) const {
571 std::string S;
572 if (PrefixEventName)
573 S.append(getEventName()).append(": ");
574 S.append((TheEvent == nullptr) ? "OmptAssertEvent" : TheEvent->toString());
575 return S;
576}
577
579 assert(A.TheEvent.get() != nullptr && "A is valid");
580 assert(B.TheEvent.get() != nullptr && "B is valid");
581
582 return A.TheEvent->Type == B.TheEvent->Type &&
583 A.TheEvent->equals(B.TheEvent.get());
584}
#define expectedDefault(TypeName)
Contains assertion event constructors, for generally all observable events.
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
EventTy
Enum values are used for comparison of observed and asserted events List is based on OpenMP 5....
bool operator==(const OmptAssertEvent &A, const OmptAssertEvent &B)
const char * to_string(ObserveState State)
Helper function, returning an ObserveState string representation.
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)
OmptAssertEvent(OmptAssertEvent &&o)=default
Allow move construction (due to std::unique_ptr)
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 *))
std::string getEventName() const
Get the event's name.
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 AssertionSuspend(const std::string &Name, const std::string &Group, const ObserveState &Expected)
static OmptAssertEvent ControlTool(const std::string &Name, const std::string &Group, const ObserveState &Expected)
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)
std::string toString(bool PrefixEventName=false) const
Returns the string representation of the event.
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))
ObserveState getEventExpectedState() const
Get the event's expected observation state.
internal::EventTy getEventType() const
Return the actual event type enum value.
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)
internal::InternalEvent * getEvent() const
Get a pointer to the internal event.
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 *))
std::string getEventGroup() const
Get the event's group name.
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 *))
Base event class Offers default CTOR, DTOR and CTOR which assigns the actual event type.