Instrumentation for actions always uses AD data.

Consolidations in SyncRegionOmpLogic.

Author: jblueh

include/opdi/logic/omp/instrument/ompLogicInstrumentInterface.hpp

@@ -52,13 +52,13 @@ namespace opdi {
 
       virtual void onMutexAcquired(MutexOmpLogic::Data* /*data*/) {}
       virtual void onMutexReleased(MutexOmpLogic::Data* /*data*/) {}
-      virtual void onMutexDestroyed(LogicInterface::MutexKind /*kind*/, std::size_t /*waitId*/) {}
+      virtual void onMutexDestroyed(MutexOmpLogic::Data* /*data*/) {}
 
-      virtual void onSyncRegion(LogicInterface::SyncRegionKind /*kind*/, LogicInterface::ScopeEndpoint /*endpoint*/) {}
+      virtual void onSyncRegion(SyncRegionOmpLogic::Data* /*data*/) {}
 
-      virtual void onMasked(LogicInterface::ScopeEndpoint /*endpoint*/) {}
+      virtual void onMasked(MaskedOmpLogic::Data* /*data*/) {}
 
-      virtual void onWork(LogicInterface::WorksharingKind /*kind*/, LogicInterface::ScopeEndpoint /*endpoint*/) {}
+      virtual void onWork(WorkOmpLogic::Data* /*data*/) {}
 
       /* instrumentation of reverse actions */
 

include/opdi/logic/omp/instrument/ompLogicOutputInstrument.hpp

@@ -122,22 +122,22 @@ namespace opdi {
                            "at", data->counter);
       }
 
-      virtual void onMutexDestroyed(LogicInterface::MutexKind kind, std::size_t waitId) {
+      virtual void onMutexDestroyed(MutexOmpLogic::Data* data) {
         TapedOutput::print("F MDES t", omp_get_thread_num(),
-                           "kind", kind,
-                           "id", waitId);
+                           "kind", data->mutexKind,
+                           "id", data->waitId);
       }
 
-      virtual void onSyncRegion(LogicInterface::SyncRegionKind kind, LogicInterface::ScopeEndpoint endpoint) {
-        TapedOutput::print("F SYNC t", omp_get_thread_num(), "kind", kind, "endp", endpoint);
+      virtual void onSyncRegion(SyncRegionOmpLogic::Data* data) {
+        TapedOutput::print("F SYNC t", omp_get_thread_num(), "kind", data->kind, "endp", data->endpoint);
       }
 
-      virtual void onMasked(LogicInterface::ScopeEndpoint endpoint) {
-        TapedOutput::print("F MASK t", omp_get_thread_num(), "endp", endpoint);
+      virtual void onMasked(MaskedOmpLogic::Data* data) {
+        TapedOutput::print("F MASK t", omp_get_thread_num(), "endp", data->endpoint);
       }
 
-      virtual void onWork(LogicInterface::WorksharingKind kind, LogicInterface::ScopeEndpoint endpoint) {
-        TapedOutput::print("F WORK t", omp_get_thread_num(), "kind", kind, "endp", endpoint);
+      virtual void onWork(WorkOmpLogic::Data* data) {
+        TapedOutput::print("F WORK t", omp_get_thread_num(), "kind", data->kind, "endp", data->endpoint);
       }
 
       /* instrumentation of reverse actions */

include/opdi/logic/omp/maskedOmpLogic.cpp

@@ -56,13 +56,13 @@ void opdi::MaskedOmpLogic::onMasked(ScopeEndpoint endpoint) {
   #if OPDI_OMP_LOGIC_INSTRUMENT
     if (tool != nullptr && tool->getThreadLocalTape() != nullptr && tool->isActive(tool->getThreadLocalTape())) {
 
-      for (auto& instrument : ompLogicInstruments) {
-        instrument->onMasked(endpoint);
-      }
-
       Data* data = new Data;
       data->endpoint = endpoint;
 
+      for (auto& instrument : ompLogicInstruments) {
+        instrument->onMasked(data);
+      }
+
       Handle* handle = new Handle;
       handle->data = static_cast<void*>(data);
       handle->reverseFunc = MaskedOmpLogic::reverseFunc;

include/opdi/logic/omp/mutexOmpLogic.cpp

@@ -118,8 +118,9 @@ void opdi::MutexOmpLogic::internalFinalize() {
 void opdi::MutexOmpLogic::onMutexDestroyed(MutexKind mutexKind, WaitId waitId) {
 
   #if OPDI_OMP_LOGIC_INSTRUMENT
+    Data data = {mutexKind, waitId, 0};
     for (auto& instrument : ompLogicInstruments) {
-      instrument->onMutexDestroyed(mutexKind, waitId);
+      instrument->onMutexDestroyed(&data);
     }
   #endif
 

include/opdi/logic/omp/syncRegionOmpLogic.cpp

@@ -50,20 +50,6 @@ void opdi::SyncRegionOmpLogic::deleteFunc(void* dataPtr) {
   delete data;
 }
 
-void opdi::SyncRegionOmpLogic::internalPushHandle(SyncRegionKind kind, ScopeEndpoint endpoint) {
-
-  Data* data = new Data;
-  data->kind = kind;
-  data->endpoint = endpoint;
-
-  Handle* handle = new Handle;
-  handle->data = static_cast<void*>(data);
-  handle->reverseFunc = SyncRegionOmpLogic::reverseFunc;
-  handle->deleteFunc = SyncRegionOmpLogic::deleteFunc;
-
-  tool->pushExternalFunction(tool->getThreadLocalTape(), handle);
-}
-
 bool opdi::SyncRegionOmpLogic::requiresReverseBarrier(SyncRegionKind kind, ScopeEndpoint endpoint) {
 
   static std::size_t constexpr syncRegionBehaviour[] = {
@@ -84,14 +70,26 @@ void opdi::SyncRegionOmpLogic::onSyncRegion(SyncRegionKind kind, ScopeEndpoint e
 
   if (tool != nullptr && tool->getThreadLocalTape() != nullptr && tool->isActive(tool->getThreadLocalTape())) {
 
+    Data* data = new Data;
+    data->kind = kind;
+    data->endpoint = endpoint;
+
     #if OPDI_OMP_LOGIC_INSTRUMENT
-        for (auto& instrument : ompLogicInstruments) {
-          instrument->onSyncRegion(kind, endpoint);
-        }
+      for (auto& instrument : ompLogicInstruments) {
+        instrument->onSyncRegion(data);
+      }
     #endif
 
     if (requiresReverseBarrier(kind, endpoint)) {
-      internalPushHandle(kind, endpoint);
+      Handle* handle = new Handle;
+      handle->data = static_cast<void*>(data);
+      handle->reverseFunc = SyncRegionOmpLogic::reverseFunc;
+      handle->deleteFunc = SyncRegionOmpLogic::deleteFunc;
+
+      tool->pushExternalFunction(tool->getThreadLocalTape(), handle);
+    }
+    else {
+      delete data;
     }
   }
 }

include/opdi/logic/omp/syncRegionOmpLogic.hpp

@@ -50,8 +50,6 @@ namespace opdi {
       static void reverseFunc(void* dataPtr);
       static void deleteFunc(void* dataPtr);
 
-      void internalPushHandle(SyncRegionKind kind, ScopeEndpoint endpoint);
-
     public:
 
       virtual void onSyncRegion(SyncRegionKind kind, ScopeEndpoint endpoint);

include/opdi/logic/omp/workOmpLogic.cpp

@@ -55,14 +55,14 @@ void opdi::WorkOmpLogic::onWork(WorksharingKind kind, ScopeEndpoint endpoint) {
   #if OPDI_OMP_LOGIC_INSTRUMENT
     if (tool != nullptr && tool->getThreadLocalTape() != nullptr && tool->isActive(tool->getThreadLocalTape())) {
 
-        for (auto& instrument : ompLogicInstruments) {
-          instrument->onWork(kind, endpoint);
-        }
-
         Data* data = new Data;
         data->kind = kind;
         data->endpoint = endpoint;
 
+        for (auto& instrument : ompLogicInstruments) {
+          instrument->onWork(data);
+        }
+
         Handle* handle = new Handle;
         handle->data = static_cast<void*>(data);
         handle->reverseFunc = WorkOmpLogic::reverseFunc;