openmp/tools/omptest/src/OmptAsserter.cpp - third_party/llvm-project - Git at Google

 //===- OmptAsserter.cpp - Asserter-related implementations ------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Implements all asserter-related class methods, like: notifications, handling
 /// of groups or determination of the testcase state.
 ///
 //===----------------------------------------------------------------------===//

 #include "OmptAsserter.h"
 #include "Logging.h"

 #include <algorithm>

 using namespace omptest;
 using namespace internal;

 // Initialize static members
 std::mutex OmptAsserter::StaticMemberAccessMutex;
 std::weak_ptr<OmptEventGroupInterface>
     OmptAsserter::EventGroupInterfaceInstance;
 std::weak_ptr<logging::Logger> OmptAsserter::LoggingInstance;

 OmptAsserter::OmptAsserter() {
   // Protect static members access
   std::lock_guard<std::mutex> Lock(StaticMemberAccessMutex);

   // Upgrade OmptEventGroupInterface weak_ptr to shared_ptr
   {
     EventGroups = EventGroupInterfaceInstance.lock();
     if (!EventGroups) {
       // Coordinator doesn't exist or was previously destroyed, create a new
       // one.
       EventGroups = std::make_shared<OmptEventGroupInterface>();
       // Store a weak reference to it
       EventGroupInterfaceInstance = EventGroups;
     }
     // EventGroups is now a valid shared_ptr, either to a new or existing
     // instance.
   }

   // Upgrade logging::Logger weak_ptr to shared_ptr
   {
     Log = LoggingInstance.lock();
     if (!Log) {
       // Coordinator doesn't exist or was previously destroyed, create a new
       // one.
       Log = std::make_shared<logging::Logger>();
       // Store a weak reference to it
       LoggingInstance = Log;
     }
     // Log is now a valid shared_ptr, either to a new or existing instance.
   }
 }

 void OmptListener::setActive(bool Enabled) { Active = Enabled; }

 bool OmptListener::isActive() { return Active; }

 bool OmptListener::isSuppressedEventType(EventTy EvTy) {
   return SuppressedEvents.find(EvTy) != SuppressedEvents.end();
 }

 void OmptListener::permitEvent(EventTy EvTy) { SuppressedEvents.erase(EvTy); }

 void OmptListener::suppressEvent(EventTy EvTy) {
   SuppressedEvents.insert(EvTy);
 }

 void OmptAsserter::insert(OmptAssertEvent &&AE) {
   assert(false && "Base class 'insert' has undefined semantics.");
 }

 void OmptAsserter::notify(OmptAssertEvent &&AE) {
   // Ignore notifications while inactive
   if (!isActive() || isSuppressedEventType(AE.getEventType()))
     return;

   this->notifyImpl(std::move(AE));
 }

 AssertState OmptAsserter::checkState() { return State; }

 bool OmptAsserter::verifyEventGroups(const OmptAssertEvent &ExpectedEvent,
                                      const OmptAssertEvent &ObservedEvent) {
   assert(ExpectedEvent.getEventType() == ObservedEvent.getEventType() &&
          "Type mismatch: Expected != Observed event type");
   assert(EventGroups && "Missing EventGroups interface");

   // Ignore all events within "default" group
   auto GroupName = ExpectedEvent.getEventGroup();

   if (GroupName == "default")
     return true;

   // Get a pointer to the observed internal event
   auto Event = ObservedEvent.getEvent();

   switch (Event->Type) {
   case EventTy::Target:
     if (auto E = static_cast<const internal::Target *>(Event)) {
       if (E->Endpoint == ompt_scope_begin) {
         // Add new group since we entered a Target Region
         EventGroups->addActiveEventGroup(GroupName,
                                          AssertEventGroup{E->TargetId});
       } else if (E->Endpoint == ompt_scope_end) {
         // Deprecate group since we return from a Target Region
         EventGroups->deprecateActiveEventGroup(GroupName);
       }
       return true;
     }
     return false;
   case EventTy::TargetEmi:
     if (auto E = static_cast<const internal::TargetEmi *>(Event)) {
       if (E->Endpoint == ompt_scope_begin) {
         // Add new group since we entered a Target Region
         EventGroups->addActiveEventGroup(
             GroupName, AssertEventGroup{E->TargetData->value});
       } else if (E->Endpoint == ompt_scope_end) {
         // Deprecate group since we return from a Target Region
         EventGroups->deprecateActiveEventGroup(GroupName);
       }
       return true;
     }
     return false;
   case EventTy::TargetDataOp:
     if (auto E = static_cast<const internal::TargetDataOp *>(Event))
       return EventGroups->checkActiveEventGroups(GroupName,
                                                  AssertEventGroup{E->TargetId});

     return false;
   case EventTy::TargetDataOpEmi:
     if (auto E = static_cast<const internal::TargetDataOpEmi *>(Event))
       return EventGroups->checkActiveEventGroups(
           GroupName, AssertEventGroup{E->TargetData->value});

     return false;
   case EventTy::TargetSubmit:
     if (auto E = static_cast<const internal::TargetSubmit *>(Event))
       return EventGroups->checkActiveEventGroups(GroupName,
                                                  AssertEventGroup{E->TargetId});

     return false;
   case EventTy::TargetSubmitEmi:
     if (auto E = static_cast<const internal::TargetSubmitEmi *>(Event))
       return EventGroups->checkActiveEventGroups(
           GroupName, AssertEventGroup{E->TargetData->value});

     return false;
   case EventTy::BufferRecord:
     // BufferRecords are delivered asynchronously: also check deprecated groups.
     if (auto E = static_cast<const internal::BufferRecord *>(Event))
       return (EventGroups->checkActiveEventGroups(
                   GroupName, AssertEventGroup{E->Record.target_id}) ||
               EventGroups->checkDeprecatedEventGroups(
                   GroupName, AssertEventGroup{E->Record.target_id}));
     return false;
   // Some event types do not need any handling
   case EventTy::ThreadBegin:
   case EventTy::ThreadEnd:
   case EventTy::ParallelBegin:
   case EventTy::ParallelEnd:
   case EventTy::Work:
   case EventTy::Dispatch:
   case EventTy::TaskCreate:
   case EventTy::Dependences:
   case EventTy::TaskDependence:
   case EventTy::TaskSchedule:
   case EventTy::ImplicitTask:
   case EventTy::Masked:
   case EventTy::SyncRegion:
   case EventTy::MutexAcquire:
   case EventTy::Mutex:
   case EventTy::NestLock:
   case EventTy::Flush:
   case EventTy::Cancel:
   case EventTy::DeviceInitialize:
   case EventTy::DeviceFinalize:
   case EventTy::DeviceLoad:
   case EventTy::DeviceUnload:
   case EventTy::BufferRequest:
   case EventTy::BufferComplete:
   case EventTy::BufferRecordDeallocation:
     return true;
   // Some event types must not be encountered
   case EventTy::None:
   case EventTy::AssertionSyncPoint:
   case EventTy::AssertionSuspend:
   default:
     Log->log("Observed invalid event type: " + Event->toString(),
              logging::Level::Critical);
     __builtin_unreachable();
   }

   return true;
 }

 void OmptAsserter::setOperationMode(AssertMode Mode) { OperationMode = Mode; }

 void OmptSequencedAsserter::insert(OmptAssertEvent &&AE) {
   std::lock_guard<std::mutex> Lock(AssertMutex);
   Events.emplace_back(std::move(AE));
 }

 void OmptSequencedAsserter::notifyImpl(OmptAssertEvent &&AE) {
   std::lock_guard<std::mutex> Lock(AssertMutex);
   // Ignore notifications while inactive, or for suppressed events
   if (Events.empty() || !isActive() || isSuppressedEventType(AE.getEventType()))
     return;

   ++NumNotifications;

   // Note: Order of these checks has semantic meaning.
   // (1) Synchronization points should fail if there are remaining events,
   // otherwise pass. (2) Regular notification while no further events are
   // expected: fail. (3) Assertion suspension relies on a next expected event
   // being available. (4) All other cases are considered 'regular' and match the
   // next expected against the observed event. (5+6) Depending on the state /
   // mode we signal failure if no other check has done already, or signaled pass
   // by early-exit.
   if (consumeSyncPoint(AE) ||               // Handle observed SyncPoint event
       checkExcessNotify(AE) ||              // Check for remaining expected
       consumeSuspend() ||                   // Handle requested suspend
       consumeRegularEvent(AE) ||            // Handle regular event
       AssertionSuspended ||                 // Ignore fail, if suspended
       OperationMode == AssertMode::Relaxed) // Ignore fail, if Relaxed op-mode
     return;

   Log->logEventMismatch("[OmptSequencedAsserter] The events are not equal",
                         Events[NextEvent], AE);
   State = AssertState::Fail;
 }

 bool OmptSequencedAsserter::consumeSyncPoint(
     const omptest::OmptAssertEvent &AE) {
   if (AE.getEventType() == EventTy::AssertionSyncPoint) {
     auto NumRemainingEvents = getRemainingEventCount();
     // Upon encountering a SyncPoint, all events should have been processed
     if (NumRemainingEvents == 0)
       return true;

     Log->logEventMismatch(
         "[OmptSequencedAsserter] Encountered SyncPoint while still awaiting " +
             std::to_string(NumRemainingEvents) + " events. Asserted " +
             std::to_string(NumSuccessfulAsserts) + "/" +
             std::to_string(Events.size()) + " events successfully.",
         AE);
     State = AssertState::Fail;
     return true;
   }

   // Nothing to process: continue.
   return false;
 }

 bool OmptSequencedAsserter::checkExcessNotify(
     const omptest::OmptAssertEvent &AE) {
   if (NextEvent >= Events.size()) {
     // If we are not expecting any more events and passively asserting: return
     if (AssertionSuspended)
       return true;

     Log->logEventMismatch(
         "[OmptSequencedAsserter] Too many events to check (" +
             std::to_string(NumNotifications) + "). Asserted " +
             std::to_string(NumSuccessfulAsserts) + "/" +
             std::to_string(Events.size()) + " events successfully.",
         AE);
     State = AssertState::Fail;
     return true;
   }

   // Remaining expected events present: continue.
   return false;
 }

 bool OmptSequencedAsserter::consumeSuspend() {
   // On AssertionSuspend -- enter 'passive' assertion.
   // Since we may encounter multiple, successive AssertionSuspend events, loop
   // until we hit the next non-AssertionSuspend event.
   while (Events[NextEvent].getEventType() == EventTy::AssertionSuspend) {
     AssertionSuspended = true;
     // We just hit the very last event: indicate early exit.
     if (++NextEvent >= Events.size())
       return true;
   }

   // Continue with remaining notification logic.
   return false;
 }

 bool OmptSequencedAsserter::consumeRegularEvent(
     const omptest::OmptAssertEvent &AE) {
   // If we are actively asserting, increment the event counter.
   // Otherwise: If passively asserting, we will keep waiting for a match.
   auto &E = Events[NextEvent];
   if (E == AE && verifyEventGroups(E, AE)) {
     if (E.getEventExpectedState() == ObserveState::Always) {
       ++NumSuccessfulAsserts;
     } else if (E.getEventExpectedState() == ObserveState::Never) {
       Log->logEventMismatch(
           "[OmptSequencedAsserter] Encountered forbidden event", E, AE);
       State = AssertState::Fail;
     }

     // Return to active assertion
     if (AssertionSuspended)
       AssertionSuspended = false;

     // Match found, increment index and indicate early exit (success).
     ++NextEvent;
     return true;
   }

   // Continue with remaining notification logic.
   return false;
 }

 size_t OmptSequencedAsserter::getRemainingEventCount() {
   return std::count_if(Events.begin(), Events.end(),
                        [](const omptest::OmptAssertEvent &E) {
                          return E.getEventExpectedState() ==
                                 ObserveState::Always;
                        }) -
          NumSuccessfulAsserts;
 }

 AssertState OmptSequencedAsserter::checkState() {
   // This is called after the testcase executed.
   // Once reached the number of successful notifications should be equal to the
   // number of expected events. However, there may still be excluded as well as
   // special asserter events remaining in the sequence.
   for (size_t i = NextEvent; i < Events.size(); ++i) {
     auto &E = Events[i];
     if (E.getEventExpectedState() == ObserveState::Always) {
       State = AssertState::Fail;
       Log->logEventMismatch("[OmptSequencedAsserter] Expected event was not "
                             "encountered (Remaining events: " +
                                 std::to_string(getRemainingEventCount()) + ")",
                             E);
       break;
     }
   }

   return State;
 }

 void OmptEventAsserter::insert(OmptAssertEvent &&AE) {
   std::lock_guard<std::mutex> Lock(AssertMutex);
   Events.emplace_back(std::move(AE));
 }

 void OmptEventAsserter::notifyImpl(OmptAssertEvent &&AE) {
   std::lock_guard<std::mutex> Lock(AssertMutex);
   if (Events.empty() || !isActive() || isSuppressedEventType(AE.getEventType()))
     return;

   if (NumEvents == 0)
     NumEvents = Events.size();

   ++NumNotifications;

   if (AE.getEventType() == EventTy::AssertionSyncPoint) {
     auto NumRemainingEvents = getRemainingEventCount();
     // Upon encountering a SyncPoint, all events should have been processed
     if (NumRemainingEvents == 0)
       return;

     Log->logEventMismatch(
         "[OmptEventAsserter] Encountered SyncPoint while still awaiting " +
             std::to_string(NumRemainingEvents) + " events. Asserted " +
             std::to_string(NumSuccessfulAsserts) + " events successfully.",
         AE);
     State = AssertState::Fail;
     return;
   }

   for (size_t i = 0; i < Events.size(); ++i) {
     auto &E = Events[i];
     if (E == AE && verifyEventGroups(E, AE)) {
       if (E.getEventExpectedState() == ObserveState::Always) {
         Events.erase(Events.begin() + i);
         ++NumSuccessfulAsserts;
       } else if (E.getEventExpectedState() == ObserveState::Never) {
         Log->logEventMismatch("[OmptEventAsserter] Encountered forbidden event",
                               E, AE);
         State = AssertState::Fail;
       }
       return;
     }
   }

   if (OperationMode == AssertMode::Strict) {
     Log->logEventMismatch("[OmptEventAsserter] Too many events to check (" +
                               std::to_string(NumNotifications) +
                               "). Asserted " +
                               std::to_string(NumSuccessfulAsserts) +
                               " events successfully. (Remaining events: " +
                               std::to_string(getRemainingEventCount()) + ")",
                           AE);
     State = AssertState::Fail;
     return;
   }
 }

 size_t OmptEventAsserter::getRemainingEventCount() {
   return std::count_if(
       Events.begin(), Events.end(), [](const omptest::OmptAssertEvent &E) {
         return E.getEventExpectedState() == ObserveState::Always;
       });
 }

 AssertState OmptEventAsserter::checkState() {
   // This is called after the testcase executed.
   // Once reached no more expected events should be in the queue
   for (const auto &E : Events) {
     // Check if any of the remaining events were expected to be observed
     if (E.getEventExpectedState() == ObserveState::Always) {
       State = AssertState::Fail;
       Log->logEventMismatch("[OmptEventAsserter] Expected event was not "
                             "encountered (Remaining events: " +
                                 std::to_string(getRemainingEventCount()) + ")",
                             E);
       break;
     }
   }

   return State;
 }

 void OmptEventReporter::notify(OmptAssertEvent &&AE) {
   if (!isActive() || isSuppressedEventType(AE.getEventType()))
     return;

   // Prepare notification, containing the newline to avoid stream interleaving.
   auto Notification{AE.toString()};
   Notification.push_back('\n');
   OutStream << Notification;
 }

 bool OmptEventGroupInterface::addActiveEventGroup(
     const std::string &GroupName, omptest::AssertEventGroup Group) {
   std::lock_guard<std::mutex> Lock(GroupMutex);
   auto EventGroup = ActiveEventGroups.find(GroupName);
   if (EventGroup != ActiveEventGroups.end() &&
       EventGroup->second.TargetRegion == Group.TargetRegion)
     return false;
   ActiveEventGroups.emplace(GroupName, Group);
   return true;
 }

 bool OmptEventGroupInterface::deprecateActiveEventGroup(
     const std::string &GroupName) {
   std::lock_guard<std::mutex> Lock(GroupMutex);
   auto EventGroup = ActiveEventGroups.find(GroupName);
   auto DeprecatedEventGroup = DeprecatedEventGroups.find(GroupName);
   if (EventGroup == ActiveEventGroups.end() &&
       DeprecatedEventGroup != DeprecatedEventGroups.end())
     return false;
   DeprecatedEventGroups.emplace(GroupName, EventGroup->second);
   ActiveEventGroups.erase(GroupName);
   return true;
 }

 bool OmptEventGroupInterface::checkActiveEventGroups(
     const std::string &GroupName, omptest::AssertEventGroup Group) {
   std::lock_guard<std::mutex> Lock(GroupMutex);
   auto EventGroup = ActiveEventGroups.find(GroupName);
   return (EventGroup != ActiveEventGroups.end() &&
           EventGroup->second.TargetRegion == Group.TargetRegion);
 }

 bool OmptEventGroupInterface::checkDeprecatedEventGroups(
     const std::string &GroupName, omptest::AssertEventGroup Group) {
   std::lock_guard<std::mutex> Lock(GroupMutex);
   auto EventGroup = DeprecatedEventGroups.find(GroupName);
   return (EventGroup != DeprecatedEventGroups.end() &&
           EventGroup->second.TargetRegion == Group.TargetRegion);
 }
	//===- OmptAsserter.cpp - Asserter-related implementations ------- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file
	/// Implements all asserter-related class methods, like: notifications, handling
	/// of groups or determination of the testcase state.
	///
	//===----------------------------------------------------------------------===//

	#include "OmptAsserter.h"
	#include "Logging.h"

	#include <algorithm>

	using namespace omptest;
	using namespace internal;

	// Initialize static members
	std::mutex OmptAsserter::StaticMemberAccessMutex;
	std::weak_ptr<OmptEventGroupInterface>
	OmptAsserter::EventGroupInterfaceInstance;
	std::weak_ptr<logging::Logger> OmptAsserter::LoggingInstance;

	OmptAsserter::OmptAsserter() {
	// Protect static members access
	std::lock_guard<std::mutex> Lock(StaticMemberAccessMutex);

	// Upgrade OmptEventGroupInterface weak_ptr to shared_ptr
	{
	EventGroups = EventGroupInterfaceInstance.lock();
	if (!EventGroups) {
	// Coordinator doesn't exist or was previously destroyed, create a new
	// one.
	EventGroups = std::make_shared<OmptEventGroupInterface>();
	// Store a weak reference to it
	EventGroupInterfaceInstance = EventGroups;
	}
	// EventGroups is now a valid shared_ptr, either to a new or existing
	// instance.
	}

	// Upgrade logging::Logger weak_ptr to shared_ptr
	{
	Log = LoggingInstance.lock();
	if (!Log) {
	// Coordinator doesn't exist or was previously destroyed, create a new
	// one.
	Log = std::make_shared<logging::Logger>();
	// Store a weak reference to it
	LoggingInstance = Log;
	}
	// Log is now a valid shared_ptr, either to a new or existing instance.
	}
	}

	void OmptListener::setActive(bool Enabled) { Active = Enabled; }

	bool OmptListener::isActive() { return Active; }

	bool OmptListener::isSuppressedEventType(EventTy EvTy) {
	return SuppressedEvents.find(EvTy) != SuppressedEvents.end();
	}

	void OmptListener::permitEvent(EventTy EvTy) { SuppressedEvents.erase(EvTy); }

	void OmptListener::suppressEvent(EventTy EvTy) {
	SuppressedEvents.insert(EvTy);
	}

	void OmptAsserter::insert(OmptAssertEvent &&AE) {
	assert(false && "Base class 'insert' has undefined semantics.");
	}

	void OmptAsserter::notify(OmptAssertEvent &&AE) {
	// Ignore notifications while inactive
	if (!isActive() \|\| isSuppressedEventType(AE.getEventType()))
	return;

	this->notifyImpl(std::move(AE));
	}

	AssertState OmptAsserter::checkState() { return State; }

	bool OmptAsserter::verifyEventGroups(const OmptAssertEvent &ExpectedEvent,
	const OmptAssertEvent &ObservedEvent) {
	assert(ExpectedEvent.getEventType() == ObservedEvent.getEventType() &&
	"Type mismatch: Expected != Observed event type");
	assert(EventGroups && "Missing EventGroups interface");

	// Ignore all events within "default" group
	auto GroupName = ExpectedEvent.getEventGroup();

	if (GroupName == "default")
	return true;

	// Get a pointer to the observed internal event
	auto Event = ObservedEvent.getEvent();

	switch (Event->Type) {
	case EventTy::Target:
	if (auto E = static_cast<const internal::Target *>(Event)) {
	if (E->Endpoint == ompt_scope_begin) {
	// Add new group since we entered a Target Region
	EventGroups->addActiveEventGroup(GroupName,
	AssertEventGroup{E->TargetId});
	} else if (E->Endpoint == ompt_scope_end) {
	// Deprecate group since we return from a Target Region
	EventGroups->deprecateActiveEventGroup(GroupName);
	}
	return true;
	}
	return false;
	case EventTy::TargetEmi:
	if (auto E = static_cast<const internal::TargetEmi *>(Event)) {
	if (E->Endpoint == ompt_scope_begin) {
	// Add new group since we entered a Target Region
	EventGroups->addActiveEventGroup(
	GroupName, AssertEventGroup{E->TargetData->value});
	} else if (E->Endpoint == ompt_scope_end) {
	// Deprecate group since we return from a Target Region
	EventGroups->deprecateActiveEventGroup(GroupName);
	}
	return true;
	}
	return false;
	case EventTy::TargetDataOp:
	if (auto E = static_cast<const internal::TargetDataOp *>(Event))
	return EventGroups->checkActiveEventGroups(GroupName,
	AssertEventGroup{E->TargetId});

	return false;
	case EventTy::TargetDataOpEmi:
	if (auto E = static_cast<const internal::TargetDataOpEmi *>(Event))
	return EventGroups->checkActiveEventGroups(
	GroupName, AssertEventGroup{E->TargetData->value});

	return false;
	case EventTy::TargetSubmit:
	if (auto E = static_cast<const internal::TargetSubmit *>(Event))
	return EventGroups->checkActiveEventGroups(GroupName,
	AssertEventGroup{E->TargetId});

	return false;
	case EventTy::TargetSubmitEmi:
	if (auto E = static_cast<const internal::TargetSubmitEmi *>(Event))
	return EventGroups->checkActiveEventGroups(
	GroupName, AssertEventGroup{E->TargetData->value});

	return false;
	case EventTy::BufferRecord:
	// BufferRecords are delivered asynchronously: also check deprecated groups.
	if (auto E = static_cast<const internal::BufferRecord *>(Event))
	return (EventGroups->checkActiveEventGroups(
	GroupName, AssertEventGroup{E->Record.target_id}) \|\|
	EventGroups->checkDeprecatedEventGroups(
	GroupName, AssertEventGroup{E->Record.target_id}));
	return false;
	// Some event types do not need any handling
	case EventTy::ThreadBegin:
	case EventTy::ThreadEnd:
	case EventTy::ParallelBegin:
	case EventTy::ParallelEnd:
	case EventTy::Work:
	case EventTy::Dispatch:
	case EventTy::TaskCreate:
	case EventTy::Dependences:
	case EventTy::TaskDependence:
	case EventTy::TaskSchedule:
	case EventTy::ImplicitTask:
	case EventTy::Masked:
	case EventTy::SyncRegion:
	case EventTy::MutexAcquire:
	case EventTy::Mutex:
	case EventTy::NestLock:
	case EventTy::Flush:
	case EventTy::Cancel:
	case EventTy::DeviceInitialize:
	case EventTy::DeviceFinalize:
	case EventTy::DeviceLoad:
	case EventTy::DeviceUnload:
	case EventTy::BufferRequest:
	case EventTy::BufferComplete:
	case EventTy::BufferRecordDeallocation:
	return true;
	// Some event types must not be encountered
	case EventTy::None:
	case EventTy::AssertionSyncPoint:
	case EventTy::AssertionSuspend:
	default:
	Log->log("Observed invalid event type: " + Event->toString(),
	logging::Level::Critical);
	__builtin_unreachable();
	}

	return true;
	}

	void OmptAsserter::setOperationMode(AssertMode Mode) { OperationMode = Mode; }

	void OmptSequencedAsserter::insert(OmptAssertEvent &&AE) {
	std::lock_guard<std::mutex> Lock(AssertMutex);
	Events.emplace_back(std::move(AE));
	}

	void OmptSequencedAsserter::notifyImpl(OmptAssertEvent &&AE) {
	std::lock_guard<std::mutex> Lock(AssertMutex);
	// Ignore notifications while inactive, or for suppressed events
	if (Events.empty() \|\| !isActive() \|\| isSuppressedEventType(AE.getEventType()))
	return;

	++NumNotifications;

	// Note: Order of these checks has semantic meaning.
	// (1) Synchronization points should fail if there are remaining events,
	// otherwise pass. (2) Regular notification while no further events are
	// expected: fail. (3) Assertion suspension relies on a next expected event
	// being available. (4) All other cases are considered 'regular' and match the
	// next expected against the observed event. (5+6) Depending on the state /
	// mode we signal failure if no other check has done already, or signaled pass
	// by early-exit.
	if (consumeSyncPoint(AE) \|\| // Handle observed SyncPoint event
	checkExcessNotify(AE) \|\| // Check for remaining expected
	consumeSuspend() \|\| // Handle requested suspend
	consumeRegularEvent(AE) \|\| // Handle regular event
	AssertionSuspended \|\| // Ignore fail, if suspended
	OperationMode == AssertMode::Relaxed) // Ignore fail, if Relaxed op-mode
	return;

	Log->logEventMismatch("[OmptSequencedAsserter] The events are not equal",
	Events[NextEvent], AE);
	State = AssertState::Fail;
	}

	bool OmptSequencedAsserter::consumeSyncPoint(
	const omptest::OmptAssertEvent &AE) {
	if (AE.getEventType() == EventTy::AssertionSyncPoint) {
	auto NumRemainingEvents = getRemainingEventCount();
	// Upon encountering a SyncPoint, all events should have been processed
	if (NumRemainingEvents == 0)
	return true;

	Log->logEventMismatch(
	"[OmptSequencedAsserter] Encountered SyncPoint while still awaiting " +
	std::to_string(NumRemainingEvents) + " events. Asserted " +
	std::to_string(NumSuccessfulAsserts) + "/" +
	std::to_string(Events.size()) + " events successfully.",
	AE);
	State = AssertState::Fail;
	return true;
	}

	// Nothing to process: continue.
	return false;
	}

	bool OmptSequencedAsserter::checkExcessNotify(
	const omptest::OmptAssertEvent &AE) {
	if (NextEvent >= Events.size()) {
	// If we are not expecting any more events and passively asserting: return
	if (AssertionSuspended)
	return true;

	Log->logEventMismatch(
	"[OmptSequencedAsserter] Too many events to check (" +
	std::to_string(NumNotifications) + "). Asserted " +
	std::to_string(NumSuccessfulAsserts) + "/" +
	std::to_string(Events.size()) + " events successfully.",
	AE);
	State = AssertState::Fail;
	return true;
	}

	// Remaining expected events present: continue.
	return false;
	}

	bool OmptSequencedAsserter::consumeSuspend() {
	// On AssertionSuspend -- enter 'passive' assertion.
	// Since we may encounter multiple, successive AssertionSuspend events, loop
	// until we hit the next non-AssertionSuspend event.
	while (Events[NextEvent].getEventType() == EventTy::AssertionSuspend) {
	AssertionSuspended = true;
	// We just hit the very last event: indicate early exit.
	if (++NextEvent >= Events.size())
	return true;
	}

	// Continue with remaining notification logic.
	return false;
	}

	bool OmptSequencedAsserter::consumeRegularEvent(
	const omptest::OmptAssertEvent &AE) {
	// If we are actively asserting, increment the event counter.
	// Otherwise: If passively asserting, we will keep waiting for a match.
	auto &E = Events[NextEvent];
	if (E == AE && verifyEventGroups(E, AE)) {
	if (E.getEventExpectedState() == ObserveState::Always) {
	++NumSuccessfulAsserts;
	} else if (E.getEventExpectedState() == ObserveState::Never) {
	Log->logEventMismatch(
	"[OmptSequencedAsserter] Encountered forbidden event", E, AE);
	State = AssertState::Fail;
	}

	// Return to active assertion
	if (AssertionSuspended)
	AssertionSuspended = false;

	// Match found, increment index and indicate early exit (success).
	++NextEvent;
	return true;
	}

	// Continue with remaining notification logic.
	return false;
	}

	size_t OmptSequencedAsserter::getRemainingEventCount() {
	return std::count_if(Events.begin(), Events.end(),
	[](const omptest::OmptAssertEvent &E) {
	return E.getEventExpectedState() ==
	ObserveState::Always;
	}) -
	NumSuccessfulAsserts;
	}

	AssertState OmptSequencedAsserter::checkState() {
	// This is called after the testcase executed.
	// Once reached the number of successful notifications should be equal to the
	// number of expected events. However, there may still be excluded as well as
	// special asserter events remaining in the sequence.
	for (size_t i = NextEvent; i < Events.size(); ++i) {
	auto &E = Events[i];
	if (E.getEventExpectedState() == ObserveState::Always) {
	State = AssertState::Fail;
	Log->logEventMismatch("[OmptSequencedAsserter] Expected event was not "
	"encountered (Remaining events: " +
	std::to_string(getRemainingEventCount()) + ")",
	E);
	break;
	}
	}

	return State;
	}

	void OmptEventAsserter::insert(OmptAssertEvent &&AE) {
	std::lock_guard<std::mutex> Lock(AssertMutex);
	Events.emplace_back(std::move(AE));
	}

	void OmptEventAsserter::notifyImpl(OmptAssertEvent &&AE) {
	std::lock_guard<std::mutex> Lock(AssertMutex);
	if (Events.empty() \|\| !isActive() \|\| isSuppressedEventType(AE.getEventType()))
	return;

	if (NumEvents == 0)
	NumEvents = Events.size();

	++NumNotifications;

	if (AE.getEventType() == EventTy::AssertionSyncPoint) {
	auto NumRemainingEvents = getRemainingEventCount();
	// Upon encountering a SyncPoint, all events should have been processed
	if (NumRemainingEvents == 0)
	return;

	Log->logEventMismatch(
	"[OmptEventAsserter] Encountered SyncPoint while still awaiting " +
	std::to_string(NumRemainingEvents) + " events. Asserted " +
	std::to_string(NumSuccessfulAsserts) + " events successfully.",
	AE);
	State = AssertState::Fail;
	return;
	}

	for (size_t i = 0; i < Events.size(); ++i) {
	auto &E = Events[i];
	if (E == AE && verifyEventGroups(E, AE)) {
	if (E.getEventExpectedState() == ObserveState::Always) {
	Events.erase(Events.begin() + i);
	++NumSuccessfulAsserts;
	} else if (E.getEventExpectedState() == ObserveState::Never) {
	Log->logEventMismatch("[OmptEventAsserter] Encountered forbidden event",
	E, AE);
	State = AssertState::Fail;
	}
	return;
	}
	}

	if (OperationMode == AssertMode::Strict) {
	Log->logEventMismatch("[OmptEventAsserter] Too many events to check (" +
	std::to_string(NumNotifications) +
	"). Asserted " +
	std::to_string(NumSuccessfulAsserts) +
	" events successfully. (Remaining events: " +
	std::to_string(getRemainingEventCount()) + ")",
	AE);
	State = AssertState::Fail;
	return;
	}
	}

	size_t OmptEventAsserter::getRemainingEventCount() {
	return std::count_if(
	Events.begin(), Events.end(), [](const omptest::OmptAssertEvent &E) {
	return E.getEventExpectedState() == ObserveState::Always;
	});
	}

	AssertState OmptEventAsserter::checkState() {
	// This is called after the testcase executed.
	// Once reached no more expected events should be in the queue
	for (const auto &E : Events) {
	// Check if any of the remaining events were expected to be observed
	if (E.getEventExpectedState() == ObserveState::Always) {
	State = AssertState::Fail;
	Log->logEventMismatch("[OmptEventAsserter] Expected event was not "
	"encountered (Remaining events: " +
	std::to_string(getRemainingEventCount()) + ")",
	E);
	break;
	}
	}

	return State;
	}

	void OmptEventReporter::notify(OmptAssertEvent &&AE) {
	if (!isActive() \|\| isSuppressedEventType(AE.getEventType()))
	return;

	// Prepare notification, containing the newline to avoid stream interleaving.
	auto Notification{AE.toString()};
	Notification.push_back('\n');
	OutStream << Notification;
	}

	bool OmptEventGroupInterface::addActiveEventGroup(
	const std::string &GroupName, omptest::AssertEventGroup Group) {
	std::lock_guard<std::mutex> Lock(GroupMutex);
	auto EventGroup = ActiveEventGroups.find(GroupName);
	if (EventGroup != ActiveEventGroups.end() &&
	EventGroup->second.TargetRegion == Group.TargetRegion)
	return false;
	ActiveEventGroups.emplace(GroupName, Group);
	return true;
	}

	bool OmptEventGroupInterface::deprecateActiveEventGroup(
	const std::string &GroupName) {
	std::lock_guard<std::mutex> Lock(GroupMutex);
	auto EventGroup = ActiveEventGroups.find(GroupName);
	auto DeprecatedEventGroup = DeprecatedEventGroups.find(GroupName);
	if (EventGroup == ActiveEventGroups.end() &&
	DeprecatedEventGroup != DeprecatedEventGroups.end())
	return false;
	DeprecatedEventGroups.emplace(GroupName, EventGroup->second);
	ActiveEventGroups.erase(GroupName);
	return true;
	}

	bool OmptEventGroupInterface::checkActiveEventGroups(
	const std::string &GroupName, omptest::AssertEventGroup Group) {
	std::lock_guard<std::mutex> Lock(GroupMutex);
	auto EventGroup = ActiveEventGroups.find(GroupName);
	return (EventGroup != ActiveEventGroups.end() &&
	EventGroup->second.TargetRegion == Group.TargetRegion);
	}

	bool OmptEventGroupInterface::checkDeprecatedEventGroups(
	const std::string &GroupName, omptest::AssertEventGroup Group) {
	std::lock_guard<std::mutex> Lock(GroupMutex);
	auto EventGroup = DeprecatedEventGroups.find(GroupName);
	return (EventGroup != DeprecatedEventGroups.end() &&
	EventGroup->second.TargetRegion == Group.TargetRegion);
	}