Create task data for initial implicit tasks.

Backend support for querying the current task's data.
Support mutexes prior to tool initialization (OMPT backend).
Adapt output instrument.

Merge branch 'feature/initialImplicitTask' into develop

Author: jblueh

include/opdi/backend/backendInterface.hpp

@@ -42,6 +42,9 @@ namespace opdi {
       virtual std::size_t getNestedLockIdentifier(omp_nest_lock_t* lock) = 0;
 
       virtual void* getParallelData() = 0;
+      virtual void* getTaskData() = 0;
+
+      virtual void setInitialImplicitTaskData(void* data) = 0;
   };
 
   extern BackendInterface* backend;

include/opdi/backend/macro/macroBackend.hpp

@@ -25,6 +25,8 @@
 
 #pragma once
 
+#include <cassert>
+
 #include "../../config.hpp"
 
 #ifdef OPDI_BACKEND
@@ -57,9 +59,15 @@ namespace opdi {
 
       void init() {
         opdi_init_lock(&ReductionTools::globalReducerLock);
+
+        // task data for initial implicit task is created in the logic layer
       }
 
       void finalize() {
+        // pop task data associated with initial implicit task
+        DataTools::popTaskData();
+        assert(DataTools::getTaskData() == nullptr);
+
         opdi_set_lock(&ReductionTools::globalReducerLock);
 
         for (auto lock : ReductionTools::individualReducerLocks) {
@@ -74,6 +82,15 @@ namespace opdi {
       void* getParallelData() {
         return DataTools::getParallelData();
       }
+
+      void* getTaskData() {
+        return DataTools::getTaskData();
+      }
+
+      void setInitialImplicitTaskData(void* data) {
+        assert(DataTools::getTaskData() == nullptr);
+        DataTools::pushTaskData(data);
+      }
   };
 
 }

include/opdi/backend/macro/probes.hpp

@@ -70,7 +70,8 @@ namespace opdi {
         tool->getTapePosition(oldTape, currentPosition);
 
         DataTools::pushParallelData(this->parallelData);
-        this->taskData = logic->onImplicitTaskBegin(omp_get_num_threads(), omp_get_thread_num(), this->parallelData);
+        this->taskData = logic->onImplicitTaskBegin(false, omp_get_num_threads(), omp_get_thread_num(),
+                                                    this->parallelData);
         DataTools::pushTaskData(this->taskData);
 
         // check if copy statements have been recorded before the correct tape was set

include/opdi/backend/ompt/implicitTaskCallbacks.hpp

@@ -50,13 +50,14 @@ namespace opdi {
           unsigned int index,
           int flags) {
 
-        // no callback treatment for initial task
+        // logic layer is in general not yet set up when the initial implicit task is created
+        // initial implicit task handling takes place independently in the logic layer
         if (flags & ompt_task_initial) {
           return;
         }
 
         if (ompt_scope_begin == endpoint) {
-          taskData->ptr = logic->onImplicitTaskBegin(actualParallelism, index, parallelData->ptr);
+          taskData->ptr = logic->onImplicitTaskBegin(false, actualParallelism, index, parallelData->ptr);
         }
         else {
           logic->onImplicitTaskEnd(taskData->ptr);

include/opdi/backend/ompt/omptBackend.cpp

@@ -36,6 +36,7 @@ ompt_set_callback_t opdi::CallbacksBase::setCallback;
 ompt_get_callback_t opdi::CallbacksBase::getCallback;
 
 ompt_get_parallel_info_t opdi::OmptBackend::getParallelInfo = NULL;
+ompt_get_task_info_t opdi::OmptBackend::getTaskInfo = NULL;
 ompt_finalize_tool_t opdi::OmptBackend::finalizeTool = NULL;
 
 // ompt entry point

include/opdi/backend/ompt/omptBackend.hpp

@@ -33,6 +33,7 @@
   #define OPDI_BACKEND OPDI_OMPT_BACKEND
 #endif
 
+#include <cassert>
 #include <iostream>
 
 #include "../../helpers/exceptions.hpp"
@@ -72,6 +73,7 @@ namespace opdi {
       // runtime entry points to be queried in addition to the ones stored in CallbacksBase
 
       static ompt_get_parallel_info_t getParallelInfo;
+      static ompt_get_task_info_t getTaskInfo;
       static ompt_finalize_tool_t finalizeTool;
 
     public:
@@ -89,6 +91,7 @@ namespace opdi {
         ompt_set_callback_t setCallback = (ompt_set_callback_t) lookup("ompt_set_callback");
         ompt_get_callback_t getCallback = (ompt_get_callback_t) lookup("ompt_get_callback");
         OmptBackend::getParallelInfo = (ompt_get_parallel_info_t) lookup("ompt_get_parallel_info");
+        OmptBackend::getTaskInfo = (ompt_get_task_info_t) lookup("ompt_get_task_info");
         OmptBackend::finalizeTool = (ompt_finalize_tool_t) lookup("ompt_finalize_tool");
 
         // initialize base
@@ -157,12 +160,40 @@ namespace opdi {
 
         int result = getParallelInfo(0, &parallelData, &teamSize);
 
-        if (result != 2) {
-          return nullptr;
-        }
+        assert(result == 2);
 
         return parallelData->ptr;
       }
+
+      void* getTaskData() {
+        int flags;
+        ompt_data_t* taskData;
+        ompt_frame_t* taskFrame;
+        ompt_data_t* parallelData;
+        int threadNum;
+
+        int result = getTaskInfo(0, &flags, &taskData, &taskFrame, &parallelData, &threadNum);
+
+        assert(result == 2);
+
+        return taskData->ptr;
+      }
+
+      void setInitialImplicitTaskData(void* data) {
+        int flags;
+        ompt_data_t* taskData;
+        ompt_frame_t* taskFrame;
+        ompt_data_t* parallelData;
+        int threadNum;
+
+        int result = getTaskInfo(0, &flags, &taskData, &taskFrame, &parallelData, &threadNum);
+
+        assert(result == 2);
+        assert(flags & ompt_task_initial);
+        assert(taskData->ptr == nullptr);
+
+        taskData->ptr = data;
+      }
   };
 }
 

include/opdi/logic/logicInterface.hpp

@@ -58,7 +58,8 @@ namespace opdi {
       virtual void* onParallelBegin(void* encounteringTaskData, int maxThreads) = 0;
       virtual void onParallelEnd(void* data) = 0;
 
-      virtual void* onImplicitTaskBegin(int actualParallelism, int index, void* parallelData) = 0;
+      virtual void* onImplicitTaskBegin(bool initialImplicitTask, int actualParallelism, int index,
+                                        void* parallelData) = 0;
       virtual void onImplicitTaskEnd(void* data) = 0;
 
       virtual void onMutexDestroyed(MutexKind kind, std::size_t waitId) = 0;

include/opdi/logic/omp/implicitTaskOmpLogic.cpp

@@ -40,45 +40,62 @@ void opdi::ImplicitTaskOmpLogic::internalFinalize() {
   this->tapePool.finalize();
 }
 
-void* opdi::ImplicitTaskOmpLogic::onImplicitTaskBegin(int actualParallelism, int index, void* parallelDataPtr) {
+void* opdi::ImplicitTaskOmpLogic::onImplicitTaskBegin(bool initialImplicitTask, int actualParallelism, int index,
+                                                      void* parallelDataPtr) {
 
   ParallelData* parallelData = (ParallelData*) parallelDataPtr;
 
-  if (parallelData != nullptr) {
-    if (index == 0) {
-      parallelData->actualThreads = actualParallelism;
-    }
+  // check if the handling of the parallel region was skipped
+  if (parallelData != nullptr || initialImplicitTask) {
 
     Data* data = new Data;
+    data->initialImplicitTask = initialImplicitTask;
     data->level = omp_get_level();
     data->index = index;
-    data->oldTape = tool->getThreadLocalTape();
-    data->parallelData = parallelData;
 
-    void* newTape = this->tapePool.getTape(parallelData->parentTape, index);
+    // OpDiLib does not interfere with the initial implicit task AD-wise, e.g., does not track its tape / does not assume
+    // that the tape does not change. OpDiLib uses the initial implicit task's data primarily to track its adjoint access
+    // mode.
+    if (!initialImplicitTask) {
+      if (index == 0) {
+        parallelData->actualThreads = actualParallelism;
+      }
 
-    if (parallelData->activeParallelRegion) {
-      tool->setActive(newTape, true);
-    }
+      data->oldTape = tool->getThreadLocalTape();
+      data->parallelData = parallelData;
 
-    data->tape = newTape;
+      void* newTape = this->tapePool.getTape(parallelData->parentTape, index);
 
-    data->positions.push_back(tool->allocPosition());
-    tool->getTapePosition(newTape, data->positions.back());
+      if (parallelData->activeParallelRegion) {
+        tool->setActive(newTape, true);
+      }
 
-    tool->setThreadLocalTape(newTape);
+      data->tape = newTape;
 
-    AdjointAccessControl::pushMode(parallelData->parentAdjointAccessMode);
-    data->adjointAccessModes.push_back(parallelData->parentAdjointAccessMode);
+      data->positions.push_back(tool->allocPosition());
+      tool->getTapePosition(newTape, data->positions.back());
+
+      tool->setThreadLocalTape(newTape);
+
+      AdjointAccessControl::pushMode(parallelData->parentAdjointAccessMode);
+      data->adjointAccessModes.push_back(parallelData->parentAdjointAccessMode);
+
+      parallelData->childTasks[index] = data;
+    }
+    else {
+      data->oldTape = nullptr;
+      data->tape = nullptr;
+      data->parallelData = nullptr;
+
+      data->adjointAccessModes.push_back(ImplicitTaskOmpLogic::defaultAdjointAccessMode);
+    }
 
     #if OPDI_OMP_LOGIC_INSTRUMENT
       for (auto& instrument : ompLogicInstruments) {
         instrument->onImplicitTaskBegin(data);
       }
     #endif
 
-    parallelData->childTasks[index] = data;
-
     return data;
   }
 
@@ -90,35 +107,41 @@ void opdi::ImplicitTaskOmpLogic::onImplicitTaskEnd(void* dataPtr) {
   if (dataPtr != nullptr) {
     Data* data = (Data*) dataPtr;
 
+    #if OPDI_OMP_LOGIC_INSTRUMENT
+      for (auto& instrument : ompLogicInstruments) {
+        instrument->onImplicitTaskEnd(data);
+      }
+    #endif
+
     AdjointAccessMode lastAccessMode = AdjointAccessControl::currentMode();
     AdjointAccessControl::popMode();
     AdjointAccessControl::currentMode() = lastAccessMode;
 
-    tool->setThreadLocalTape(data->oldTape);
+    if (!data->initialImplicitTask) {
+      tool->setThreadLocalTape(data->oldTape);
 
-    data->positions.push_back(tool->allocPosition());
-    tool->getTapePosition(data->tape, data->positions.back());
+      data->positions.push_back(tool->allocPosition());
+      tool->getTapePosition(data->tape, data->positions.back());
 
-    if (!data->parallelData->activeParallelRegion) {
-      if (tool->comparePosition(data->positions.front(), data->positions.back()) != 0) {
-        OPDI_WARNING("Something became active during a passive parallel region. This is not supported and will not be ",
-                     "differentiated correctly.");
+      if (!data->parallelData->activeParallelRegion) {
+        if (tool->comparePosition(data->positions.front(), data->positions.back()) != 0) {
+          OPDI_WARNING("Something became active during a passive parallel region. This is not supported and will not be ",
+                       "differentiated correctly.");
+        }
       }
-    }
 
-    #if OPDI_OMP_LOGIC_INSTRUMENT
-      for (auto& instrument : ompLogicInstruments) {
-        instrument->onImplicitTaskEnd(data);
-      }
-    #endif
+      tool->setActive(data->tape, false);
 
-    tool->setActive(data->tape, false);
+      // ensure that the most recent activity change *per thread* reflects the current activity
+      if (data->oldTape == data->parallelData->parentTape && data->parallelData->activeParallelRegion) {
+        tool->setActive(data->oldTape, true);
+      }
 
-    // ensure that the most recent activity change *per thread* reflects the current activity
-    if (data->oldTape == data->parallelData->parentTape && data->parallelData->activeParallelRegion) {
-      tool->setActive(data->oldTape, true);
+      // do not delete data, it is deleted as part of parallel regions
+    }
+    else {
+      // delete task data, there is no parallel region to do so
+      delete data;
     }
-
-    // do not delete data, it is deleted as part of parallel regions
   }
 }

include/opdi/logic/omp/implicitTaskOmpLogic.hpp

@@ -48,10 +48,13 @@ namespace opdi {
 
       using LogicInterface::AdjointAccessMode;
 
+      static AdjointAccessMode const defaultAdjointAccessMode;
+
       using ParallelData = typename ParallelOmpLogic::Data;
 
       struct Data {
         public:
+          bool initialImplicitTask;
           int level;
           int index;
           void* oldTape;
@@ -61,7 +64,8 @@ namespace opdi {
           std::deque<AdjointAccessMode> adjointAccessModes;
       };
 
-      virtual void* onImplicitTaskBegin(int actualParallelism, int index, void* parallelDataPtr);
+      virtual void* onImplicitTaskBegin(bool initialImplicitTask, int actualParallelism, int index,
+                                        void* parallelDataPtr);
       virtual void onImplicitTaskEnd(void* dataPtr);
   };
 }