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) {
21 case ObserveState::Generated:
22 return "Generated";
23 case ObserveState::Always:
24 return "Always";
25 case ObserveState::Never:
26 return "Never";
27 default:
28 assert(false && "Requested string representation for unknown ObserveState");
29 return "UNKNOWN";
30 }
31}
32
33OmptAssertEvent::OmptAssertEvent(const std::string &Name,
34 const std::string &Group,
35 const ObserveState &Expected,
37 : Name(Name), Group(Group), ExpectedState(Expected), TheEvent(IE) {}
38
40 const std::string &Name, const std::string &Group,
41 const ObserveState &Expected, const std::string &SyncPointName) {
42 auto EName = getName(Name);
43 auto EGroup = getGroup(Group);
44 return OmptAssertEvent(EName, EGroup, Expected,
45 new internal::AssertionSyncPoint(SyncPointName));
46}
47
49OmptAssertEvent::AssertionSuspend(const std::string &Name,
50 const std::string &Group,
51 const ObserveState &Expected) {
52 auto EName = getName(Name);
53 auto EGroup = getGroup(Group);
54 return OmptAssertEvent(EName, EGroup, Expected,
56}
57
59 const std::string &Group,
60 const ObserveState &Expected,
61 ompt_thread_t ThreadType) {
62 auto EName = getName(Name);
63 auto EGroup = getGroup(Group);
64 return OmptAssertEvent(EName, EGroup, Expected,
65 new internal::ThreadBegin(ThreadType));
66}
67
69 const std::string &Group,
70 const ObserveState &Expected) {
71 auto EName = getName(Name);
72 auto EGroup = getGroup(Group);
73 return OmptAssertEvent(EName, EGroup, Expected, new internal::ThreadEnd());
74}
75
77 const std::string &Group,
78 const ObserveState &Expected,
79 int NumThreads) {
80 auto EName = getName(Name);
81 auto EGroup = getGroup(Group);
82 return OmptAssertEvent(EName, EGroup, Expected,
83 new internal::ParallelBegin(NumThreads));
84}
85
87 const std::string &Group,
88 const ObserveState &Expected,
89 ompt_data_t *ParallelData,
90 ompt_data_t *EncounteringTaskData,
91 int Flags, const void *CodeptrRA) {
92 auto EName = getName(Name);
93 auto EGroup = getGroup(Group);
94 return OmptAssertEvent(EName, EGroup, Expected,
95 new internal::ParallelEnd(ParallelData,
96 EncounteringTaskData, Flags,
97 CodeptrRA));
98}
99
101OmptAssertEvent::Work(const std::string &Name, const std::string &Group,
102 const ObserveState &Expected, ompt_work_t WorkType,
103 ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData,
104 ompt_data_t *TaskData, uint64_t Count,
105 const void *CodeptrRA) {
106 auto EName = getName(Name);
107 auto EGroup = getGroup(Group);
108 return OmptAssertEvent(EName, EGroup, Expected,
109 new internal::Work(WorkType, Endpoint, ParallelData,
110 TaskData, Count, CodeptrRA));
111}
112
114OmptAssertEvent::Dispatch(const std::string &Name, const std::string &Group,
115 const ObserveState &Expected,
116 ompt_data_t *ParallelData, ompt_data_t *TaskData,
117 ompt_dispatch_t Kind, ompt_data_t Instance) {
118 auto EName = getName(Name);
119 auto EGroup = getGroup(Group);
120 return OmptAssertEvent(
121 EName, EGroup, Expected,
122 new internal::Dispatch(ParallelData, TaskData, Kind, Instance));
123}
124
126 const std::string &Name, const std::string &Group,
127 const ObserveState &Expected, ompt_data_t *EncounteringTaskData,
128 const ompt_frame_t *EncounteringTaskFrame, ompt_data_t *NewTaskData,
129 int Flags, int HasDependences, const void *CodeptrRA) {
130 auto EName = getName(Name);
131 auto EGroup = getGroup(Group);
132 return OmptAssertEvent(
133 EName, EGroup, Expected,
134 new internal::TaskCreate(EncounteringTaskData, EncounteringTaskFrame,
135 NewTaskData, Flags, HasDependences, CodeptrRA));
136}
137
139 const std::string &Group,
140 const ObserveState &Expected) {
141 auto EName = getName(Name);
142 auto EGroup = getGroup(Group);
143 return OmptAssertEvent(EName, EGroup, Expected, new internal::TaskSchedule());
144}
145
147 const std::string &Name, const std::string &Group,
148 const ObserveState &Expected, ompt_scope_endpoint_t Endpoint,
149 ompt_data_t *ParallelData, ompt_data_t *TaskData,
150 unsigned int ActualParallelism, unsigned int Index, int Flags) {
151 auto EName = getName(Name);
152 auto EGroup = getGroup(Group);
153 return OmptAssertEvent(EName, EGroup, Expected,
154 new internal::ImplicitTask(Endpoint, ParallelData,
155 TaskData, ActualParallelism,
156 Index, Flags));
157}
158
160 const std::string &Name, const std::string &Group,
161 const ObserveState &Expected, ompt_sync_region_t Kind,
162 ompt_scope_endpoint_t Endpoint, ompt_data_t *ParallelData,
163 ompt_data_t *TaskData, const void *CodeptrRA) {
164 auto EName = getName(Name);
165 auto EGroup = getGroup(Group);
166 return OmptAssertEvent(EName, EGroup, Expected,
167 new internal::SyncRegion(Kind, Endpoint, ParallelData,
168 TaskData, CodeptrRA));
169}
170
172OmptAssertEvent::Target(const std::string &Name, const std::string &Group,
173 const ObserveState &Expected, ompt_target_t Kind,
174 ompt_scope_endpoint_t Endpoint, int DeviceNum,
175 ompt_data_t *TaskData, ompt_id_t TargetId,
176 const void *CodeptrRA) {
177 auto EName = getName(Name);
178 auto EGroup = getGroup(Group);
179 return OmptAssertEvent(EName, EGroup, Expected,
180 new internal::Target(Kind, Endpoint, DeviceNum,
181 TaskData, TargetId, CodeptrRA));
182}
183
185OmptAssertEvent::TargetEmi(const std::string &Name, const std::string &Group,
186 const ObserveState &Expected, ompt_target_t Kind,
187 ompt_scope_endpoint_t Endpoint, int DeviceNum,
188 ompt_data_t *TaskData, ompt_data_t *TargetTaskData,
189 ompt_data_t *TargetData, const void *CodeptrRA) {
190 auto EName = getName(Name);
191 auto EGroup = getGroup(Group);
192 return OmptAssertEvent(EName, EGroup, Expected,
193 new internal::TargetEmi(Kind, Endpoint, DeviceNum,
194 TaskData, TargetTaskData,
195 TargetData, CodeptrRA));
196}
197
199 const std::string &Name, const std::string &Group,
200 const ObserveState &Expected, ompt_id_t TargetId, ompt_id_t HostOpId,
201 ompt_target_data_op_t OpType, void *SrcAddr, int SrcDeviceNum,
202 void *DstAddr, int DstDeviceNum, size_t Bytes, const void *CodeptrRA) {
203 auto EName = getName(Name);
204 auto EGroup = getGroup(Group);
205 return OmptAssertEvent(EName, EGroup, Expected,
207 TargetId, HostOpId, OpType, SrcAddr, SrcDeviceNum,
208 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
209}
210
212 const std::string &Name, const std::string &Group,
213 const ObserveState &Expected, ompt_target_data_op_t OpType, size_t Bytes,
214 void *SrcAddr, void *DstAddr, int SrcDeviceNum, int DstDeviceNum,
215 ompt_id_t TargetId, ompt_id_t HostOpId, const void *CodeptrRA) {
216 auto EName = getName(Name);
217 auto EGroup = getGroup(Group);
218 return OmptAssertEvent(EName, EGroup, Expected,
220 TargetId, HostOpId, OpType, SrcAddr, SrcDeviceNum,
221 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
222}
223
225 const std::string &Name, const std::string &Group,
226 const ObserveState &Expected, ompt_scope_endpoint_t Endpoint,
227 ompt_data_t *TargetTaskData, ompt_data_t *TargetData, ompt_id_t *HostOpId,
228 ompt_target_data_op_t OpType, void *SrcAddr, int SrcDeviceNum,
229 void *DstAddr, int DstDeviceNum, size_t Bytes, const void *CodeptrRA) {
230 auto EName = getName(Name);
231 auto EGroup = getGroup(Group);
232 return OmptAssertEvent(
233 EName, EGroup, Expected,
234 new internal::TargetDataOpEmi(Endpoint, TargetTaskData, TargetData,
235 HostOpId, OpType, SrcAddr, SrcDeviceNum,
236 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
237}
238
240 const std::string &Name, const std::string &Group,
241 const ObserveState &Expected, ompt_target_data_op_t OpType,
242 ompt_scope_endpoint_t Endpoint, size_t Bytes, void *SrcAddr, void *DstAddr,
243 int SrcDeviceNum, int DstDeviceNum, ompt_data_t *TargetTaskData,
244 ompt_data_t *TargetData, ompt_id_t *HostOpId, const void *CodeptrRA) {
245 auto EName = getName(Name);
246 auto EGroup = getGroup(Group);
247 return OmptAssertEvent(
248 EName, EGroup, Expected,
249 new internal::TargetDataOpEmi(Endpoint, TargetTaskData, TargetData,
250 HostOpId, OpType, SrcAddr, SrcDeviceNum,
251 DstAddr, DstDeviceNum, Bytes, CodeptrRA));
252}
253
255 const std::string &Group,
256 const ObserveState &Expected,
257 ompt_id_t TargetId,
258 ompt_id_t HostOpId,
259 unsigned int RequestedNumTeams) {
260 auto EName = getName(Name);
261 auto EGroup = getGroup(Group);
262 return OmptAssertEvent(
263 EName, EGroup, Expected,
264 new internal::TargetSubmit(TargetId, HostOpId, RequestedNumTeams));
265}
266
268 const std::string &Group,
269 const ObserveState &Expected,
270 unsigned int RequestedNumTeams,
271 ompt_id_t TargetId,
272 ompt_id_t HostOpId) {
273 auto EName = getName(Name);
274 auto EGroup = getGroup(Group);
275 return OmptAssertEvent(
276 EName, EGroup, Expected,
277 new internal::TargetSubmit(TargetId, HostOpId, RequestedNumTeams));
278}
279
281 const std::string &Name, const std::string &Group,
282 const ObserveState &Expected, ompt_scope_endpoint_t Endpoint,
283 ompt_data_t *TargetData, ompt_id_t *HostOpId,
284 unsigned int RequestedNumTeams) {
285 auto EName = getName(Name);
286 auto EGroup = getGroup(Group);
287 return OmptAssertEvent(EName, EGroup, Expected,
288 new internal::TargetSubmitEmi(Endpoint, TargetData,
289 HostOpId,
290 RequestedNumTeams));
291}
292
294 const std::string &Group,
295 const ObserveState &Expected,
296 unsigned int RequestedNumTeams,
297 ompt_scope_endpoint_t Endpoint,
298 ompt_data_t *TargetData,
299 ompt_id_t *HostOpId) {
300 auto EName = getName(Name);
301 auto EGroup = getGroup(Group);
302 return OmptAssertEvent(EName, EGroup, Expected,
303 new internal::TargetSubmitEmi(Endpoint, TargetData,
304 HostOpId,
305 RequestedNumTeams));
306}
307
309 const std::string &Group,
310 const ObserveState &Expected) {
311 auto EName = getName(Name);
312 auto EGroup = getGroup(Group);
313 return OmptAssertEvent(EName, EGroup, Expected, new internal::ControlTool());
314}
315
317 const std::string &Name, const std::string &Group,
318 const ObserveState &Expected, int DeviceNum, const char *Type,
319 ompt_device_t *Device, ompt_function_lookup_t LookupFn,
320 const char *DocumentationStr) {
321 auto EName = getName(Name);
322 auto EGroup = getGroup(Group);
323 return OmptAssertEvent(EName, EGroup, Expected,
324 new internal::DeviceInitialize(DeviceNum, Type, Device,
325 LookupFn,
326 DocumentationStr));
327}
328
330 const std::string &Group,
331 const ObserveState &Expected,
332 int DeviceNum) {
333 auto EName = getName(Name);
334 auto EGroup = getGroup(Group);
335 return OmptAssertEvent(EName, EGroup, Expected,
336 new internal::DeviceFinalize(DeviceNum));
337}
338
340OmptAssertEvent::DeviceLoad(const std::string &Name, const std::string &Group,
341 const ObserveState &Expected, int DeviceNum,
342 const char *Filename, int64_t OffsetInFile,
343 void *VmaInFile, size_t Bytes, void *HostAddr,
344 void *DeviceAddr, uint64_t ModuleId) {
345 auto EName = getName(Name);
346 auto EGroup = getGroup(Group);
347 return OmptAssertEvent(
348 EName, EGroup, Expected,
349 new internal::DeviceLoad(DeviceNum, Filename, OffsetInFile, VmaInFile,
350 Bytes, HostAddr, DeviceAddr, ModuleId));
351}
352
354 const std::string &Group,
355 const ObserveState &Expected) {
356 auto EName = getName(Name);
357 auto EGroup = getGroup(Group);
358 return OmptAssertEvent(EName, EGroup, Expected, new internal::DeviceUnload());
359}
360
362 const std::string &Group,
363 const ObserveState &Expected,
364 int DeviceNum,
365 ompt_buffer_t **Buffer,
366 size_t *Bytes) {
367 auto EName = getName(Name);
368 auto EGroup = getGroup(Group);
369 return OmptAssertEvent(EName, EGroup, Expected,
370 new internal::BufferRequest(DeviceNum, Buffer, Bytes));
371}
372
374 const std::string &Name, const std::string &Group,
375 const ObserveState &Expected, int DeviceNum, ompt_buffer_t *Buffer,
376 size_t Bytes, ompt_buffer_cursor_t Begin, int BufferOwned) {
377 auto EName = getName(Name);
378 auto EGroup = getGroup(Group);
379 return OmptAssertEvent(EName, EGroup, Expected,
380 new internal::BufferComplete(DeviceNum, Buffer, Bytes,
381 Begin, BufferOwned));
382}
383
385 const std::string &Group,
386 const ObserveState &Expected,
387 ompt_record_ompt_t *Record) {
388 auto EName = getName(Name);
389 auto EGroup = getGroup(Group);
390 return OmptAssertEvent(EName, EGroup, Expected,
391 new internal::BufferRecord(Record));
392}
393
395 const std::string &Name, const std::string &Group,
396 const ObserveState &Expected, ompt_callbacks_t Type, ompt_target_t Kind,
397 ompt_scope_endpoint_t Endpoint, int DeviceNum, ompt_id_t TaskId,
398 ompt_id_t TargetId, const void *CodeptrRA) {
399 auto EName = getName(Name);
400 auto EGroup = getGroup(Group);
401
402 if (Type != ompt_callback_target)
403 assert(false && "CTOR only suited for type: 'ompt_callback_target'");
404
405 ompt_record_target_t Subrecord{Kind, Endpoint, DeviceNum,
406 TaskId, TargetId, CodeptrRA};
407
408 ompt_record_ompt_t *RecordPtr =
409 (ompt_record_ompt_t *)malloc(sizeof(ompt_record_ompt_t));
410 memset(RecordPtr, 0, sizeof(ompt_record_ompt_t));
411 RecordPtr->type = Type;
412 RecordPtr->time = expectedDefault(ompt_device_time_t);
413 RecordPtr->thread_id = expectedDefault(ompt_id_t);
414 RecordPtr->target_id = TargetId;
415 RecordPtr->record.target = Subrecord;
416
417 return OmptAssertEvent(EName, EGroup, Expected,
418 new internal::BufferRecord(RecordPtr));
419}
420
422 const std::string &Name, const std::string &Group,
423 const ObserveState &Expected, ompt_callbacks_t Type,
424 ompt_target_data_op_t OpType, size_t Bytes,
425 std::pair<ompt_device_time_t, ompt_device_time_t> Timeframe, void *SrcAddr,
426 void *DstAddr, int SrcDeviceNum, int DstDeviceNum, ompt_id_t TargetId,
427 ompt_id_t HostOpId, const void *CodeptrRA) {
428 auto EName = getName(Name);
429 auto EGroup = getGroup(Group);
430
431 if (Type != ompt_callback_target_data_op)
432 assert(false &&
433 "CTOR only suited for type: 'ompt_callback_target_data_op'");
434
435 ompt_record_target_data_op_t Subrecord{
436 HostOpId, OpType, SrcAddr, SrcDeviceNum, DstAddr,
437 DstDeviceNum, Bytes, Timeframe.second, CodeptrRA};
438
439 ompt_record_ompt_t *RecordPtr =
440 (ompt_record_ompt_t *)malloc(sizeof(ompt_record_ompt_t));
441 memset(RecordPtr, 0, sizeof(ompt_record_ompt_t));
442 RecordPtr->type = Type;
443 RecordPtr->time = Timeframe.first;
444 RecordPtr->thread_id = expectedDefault(ompt_id_t);
445 RecordPtr->target_id = TargetId;
446 RecordPtr->record.target_data_op = Subrecord;
447
448 return OmptAssertEvent(EName, EGroup, Expected,
449 new internal::BufferRecord(RecordPtr));
450}
451
453 const std::string &Name, const std::string &Group,
454 const ObserveState &Expected, ompt_callbacks_t Type,
455 ompt_target_data_op_t OpType, size_t Bytes,
456 ompt_device_time_t MinimumTimeDelta, void *SrcAddr, void *DstAddr,
457 int SrcDeviceNum, int DstDeviceNum, ompt_id_t TargetId, ompt_id_t HostOpId,
458 const void *CodeptrRA) {
459 return BufferRecord(Name, Group, Expected, Type, OpType, Bytes,
460 {MinimumTimeDelta, expectedDefault(ompt_device_time_t)},
461 SrcAddr, DstAddr, SrcDeviceNum, DstDeviceNum, TargetId,
462 HostOpId, CodeptrRA);
463}
464
466 const std::string &Name, const std::string &Group,
467 const ObserveState &Expected, ompt_callbacks_t Type,
468 std::pair<ompt_device_time_t, ompt_device_time_t> Timeframe,
469 unsigned int RequestedNumTeams, unsigned int GrantedNumTeams,
470 ompt_id_t TargetId, ompt_id_t HostOpId) {
471 auto EName = getName(Name);
472 auto EGroup = getGroup(Group);
473
474 bool isDefault = (Timeframe.first == expectedDefault(ompt_device_time_t));
475 isDefault &= (Timeframe.second == expectedDefault(ompt_device_time_t));
476 isDefault &= (RequestedNumTeams == expectedDefault(unsigned int));
477 isDefault &= (GrantedNumTeams == expectedDefault(unsigned int));
478 isDefault &= (TargetId == expectedDefault(ompt_id_t));
479 isDefault &= (HostOpId == expectedDefault(ompt_id_t));
480
481 ompt_record_ompt_t *RecordPtr =
482 (ompt_record_ompt_t *)malloc(sizeof(ompt_record_ompt_t));
483 memset(RecordPtr, 0, sizeof(ompt_record_ompt_t));
484 RecordPtr->type = Type;
485
486 // This handles the simplest occurrence of a device tracing record
487 // We can only check for Type -- since all other properties are set to default
488 if (isDefault) {
489 RecordPtr->time = expectedDefault(ompt_device_time_t);
490 RecordPtr->thread_id = expectedDefault(ompt_id_t);
491 RecordPtr->target_id = expectedDefault(ompt_id_t);
492 if (Type == ompt_callback_target) {
493 ompt_record_target_t Subrecord{expectedDefault(ompt_target_t),
494 expectedDefault(ompt_scope_endpoint_t),
495 expectedDefault(int),
496 expectedDefault(ompt_id_t),
497 expectedDefault(ompt_id_t),
498 expectedDefault(void *)};
499 RecordPtr->record.target = Subrecord;
500 }
501
502 if (Type == ompt_callback_target_data_op) {
503 ompt_record_target_data_op_t Subrecord{
504 expectedDefault(ompt_id_t), expectedDefault(ompt_target_data_op_t),
505 expectedDefault(void *), expectedDefault(int),
506 expectedDefault(void *), expectedDefault(int),
507 expectedDefault(size_t), expectedDefault(ompt_device_time_t),
508 expectedDefault(void *)};
509 RecordPtr->record.target_data_op = Subrecord;
510 }
511
512 if (Type == ompt_callback_target_submit) {
513 ompt_record_target_kernel_t Subrecord{
514 expectedDefault(ompt_id_t), expectedDefault(unsigned int),
515 expectedDefault(unsigned int), expectedDefault(ompt_device_time_t)};
516 RecordPtr->record.target_kernel = Subrecord;
517 }
518
519 return OmptAssertEvent(EName, EGroup, Expected,
520 new internal::BufferRecord(RecordPtr));
521 }
522
523 if (Type != ompt_callback_target_submit)
524 assert(false && "CTOR only suited for type: 'ompt_callback_target_submit'");
525
526 ompt_record_target_kernel_t Subrecord{HostOpId, RequestedNumTeams,
527 GrantedNumTeams, Timeframe.second};
528
529 RecordPtr->time = Timeframe.first;
530 RecordPtr->thread_id = expectedDefault(ompt_id_t);
531 RecordPtr->target_id = TargetId;
532 RecordPtr->record.target_kernel = Subrecord;
533
534 return OmptAssertEvent(EName, EGroup, Expected,
535 new internal::BufferRecord(RecordPtr));
536}
537
539 const std::string &Name, const std::string &Group,
540 const ObserveState &Expected, ompt_callbacks_t Type,
541 ompt_device_time_t MinimumTimeDelta, unsigned int RequestedNumTeams,
542 unsigned int GrantedNumTeams, ompt_id_t TargetId, ompt_id_t HostOpId) {
543 return BufferRecord(Name, Group, Expected, Type,
544 {MinimumTimeDelta, expectedDefault(ompt_device_time_t)},
545 RequestedNumTeams, GrantedNumTeams, TargetId, HostOpId);
546}
547
549 const std::string &Name, const std::string &Group,
550 const ObserveState &Expected, ompt_buffer_t *Buffer) {
551 auto EName = getName(Name);
552 auto EGroup = getGroup(Group);
553 return OmptAssertEvent(EName, EGroup, Expected,
555}
556
557std::string OmptAssertEvent::getEventName() const { return Name; }
558
559std::string OmptAssertEvent::getEventGroup() const { return Group; }
560
562 return ExpectedState;
563}
564
566 return TheEvent->Type;
567}
568
570 return TheEvent.get();
571}
572
573std::string OmptAssertEvent::toString(bool PrefixEventName) const {
574 std::string S;
575 if (PrefixEventName)
576 S.append(getEventName()).append(": ");
577 S.append((TheEvent == nullptr) ? "OmptAssertEvent" : TheEvent->toString());
578 return S;
579}
580
582 assert(A.TheEvent.get() != nullptr && "A is valid");
583 assert(B.TheEvent.get() != nullptr && "B is valid");
584
585 return A.TheEvent->Type == B.TheEvent->Type &&
586 A.TheEvent->equals(B.TheEvent.get());
587}
#define expectedDefault(TypeName)
Definition: InternalEvent.h:23
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.