585 lines · cpp
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-exception6//7//===----------------------------------------------------------------------===//8///9/// \file10/// 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 }28}29 30OmptAssertEvent::OmptAssertEvent(const std::string &Name,31 const std::string &Group,32 const ObserveState &Expected,33 internal::InternalEvent *IE)34 : Name(Name), Group(Group), ExpectedState(Expected), TheEvent(IE) {}35 36OmptAssertEvent OmptAssertEvent::AssertionSyncPoint(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 45OmptAssertEvent46OmptAssertEvent::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,52 new internal::AssertionSuspend());53}54 55OmptAssertEvent OmptAssertEvent::ThreadBegin(const std::string &Name,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 65OmptAssertEvent OmptAssertEvent::ThreadEnd(const std::string &Name,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 73OmptAssertEvent OmptAssertEvent::ParallelBegin(const std::string &Name,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 83OmptAssertEvent OmptAssertEvent::ParallelEnd(const std::string &Name,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 97OmptAssertEvent98OmptAssertEvent::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 110OmptAssertEvent111OmptAssertEvent::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 122OmptAssertEvent OmptAssertEvent::TaskCreate(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 135OmptAssertEvent OmptAssertEvent::TaskSchedule(const std::string &Name,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 143OmptAssertEvent OmptAssertEvent::ImplicitTask(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 156OmptAssertEvent OmptAssertEvent::SyncRegion(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 168OmptAssertEvent169OmptAssertEvent::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 181OmptAssertEvent182OmptAssertEvent::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 195OmptAssertEvent OmptAssertEvent::TargetDataOp(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,203 new internal::TargetDataOp(204 TargetId, HostOpId, OpType, SrcAddr, SrcDeviceNum,205 DstAddr, DstDeviceNum, Bytes, CodeptrRA));206}207 208OmptAssertEvent OmptAssertEvent::TargetDataOp(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,216 new internal::TargetDataOp(217 TargetId, HostOpId, OpType, SrcAddr, SrcDeviceNum,218 DstAddr, DstDeviceNum, Bytes, CodeptrRA));219}220 221OmptAssertEvent OmptAssertEvent::TargetDataOpEmi(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 236OmptAssertEvent OmptAssertEvent::TargetDataOpEmi(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 251OmptAssertEvent OmptAssertEvent::TargetSubmit(const std::string &Name,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 264OmptAssertEvent OmptAssertEvent::TargetSubmit(const std::string &Name,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 277OmptAssertEvent OmptAssertEvent::TargetSubmitEmi(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 290OmptAssertEvent OmptAssertEvent::TargetSubmitEmi(const std::string &Name,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 305OmptAssertEvent OmptAssertEvent::ControlTool(const std::string &Name,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 313OmptAssertEvent OmptAssertEvent::DeviceInitialize(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 326OmptAssertEvent OmptAssertEvent::DeviceFinalize(const std::string &Name,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 336OmptAssertEvent337OmptAssertEvent::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 350OmptAssertEvent OmptAssertEvent::DeviceUnload(const std::string &Name,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 358OmptAssertEvent OmptAssertEvent::BufferRequest(const std::string &Name,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 370OmptAssertEvent OmptAssertEvent::BufferComplete(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 381OmptAssertEvent OmptAssertEvent::BufferRecord(const std::string &Name,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 391OmptAssertEvent OmptAssertEvent::BufferRecord(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 418OmptAssertEvent OmptAssertEvent::BufferRecord(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 449OmptAssertEvent OmptAssertEvent::BufferRecord(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 462OmptAssertEvent OmptAssertEvent::BufferRecord(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 record484 // We can only check for Type -- since all other properties are set to default485 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 535OmptAssertEvent OmptAssertEvent::BufferRecord(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 545OmptAssertEvent OmptAssertEvent::BufferRecordDeallocation(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,551 new internal::BufferRecordDeallocation(Buffer));552}553 554std::string OmptAssertEvent::getEventName() const { return Name; }555 556std::string OmptAssertEvent::getEventGroup() const { return Group; }557 558ObserveState OmptAssertEvent::getEventExpectedState() const {559 return ExpectedState;560}561 562internal::EventTy OmptAssertEvent::getEventType() const {563 return TheEvent->Type;564}565 566internal::InternalEvent *OmptAssertEvent::getEvent() const {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 578bool omptest::operator==(const OmptAssertEvent &A, const OmptAssertEvent &B) {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}585