Refactor ParallelOmpLogic and ImplicitTaskOmpLogic.

More expressive names for variables and parameters.
Fewer void* pointers within the logic implementation.

Merge branch 'refactor/parallelRegionsImplicitTasks' into develop

Author: jblueh

include/opdi/logic/logicInterface.hpp

@@ -60,11 +60,11 @@ namespace opdi {
       virtual ~LogicInterface() {}
 
       virtual void* onParallelBegin(void* encounteringTaskData, int maxThreads) = 0;
-      virtual void onParallelEnd(void* data) = 0;
+      virtual void onParallelEnd(void* parallelData) = 0;
 
-      virtual void* onImplicitTaskBegin(bool initialImplicitTask, int actualParallelism, int index,
+      virtual void* onImplicitTaskBegin(bool isInitialImplicitTask, int actualSizeOfTeam, int indexInTeam,
                                         void* parallelData) = 0;
-      virtual void onImplicitTaskEnd(void* data) = 0;
+      virtual void onImplicitTaskEnd(void* implicitTaskData) = 0;
 
       virtual void onMutexDestroyed(MutexKind kind, WaitId waitId) = 0;
       virtual void onMutexAcquired(MutexKind kind, WaitId waitId) = 0;

include/opdi/logic/omp/implicitTaskOmpLogic.cpp

@@ -43,130 +43,131 @@ void opdi::ImplicitTaskOmpLogic::internalFinalize() {
   this->tapePool.finalize();
 }
 
-void* opdi::ImplicitTaskOmpLogic::onImplicitTaskBegin(bool initialImplicitTask, int actualParallelism, int index,
+void* opdi::ImplicitTaskOmpLogic::onImplicitTaskBegin(bool isInitialImplicitTask, int actualSizeOfTeam, int indexInTeam,
                                                       void* parallelDataPtr) {
 
-  ParallelData* parallelData = (ParallelData*) parallelDataPtr;
+  ParallelData* parallelData = static_cast<ParallelData*>(parallelDataPtr);
 
   // check if the handling of the parallel region was skipped
-  if (parallelData != nullptr || initialImplicitTask) {
+  if (parallelData != nullptr || isInitialImplicitTask) {
 
-    Data* data = new Data;
-    data->initialImplicitTask = initialImplicitTask;
-    data->level = omp_get_level();
-    data->index = index;
+    ImplicitTaskData* implicitTaskData = new ImplicitTaskData;
+    implicitTaskData->isInitialImplicitTask = isInitialImplicitTask;
+    implicitTaskData->level = omp_get_level();
+    implicitTaskData->indexInTeam = indexInTeam;
 
     // 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) {
-        if (parallelData->maxThreads < actualParallelism) {
+    if (!isInitialImplicitTask) {
+      if (indexInTeam == 0) {
+        if (parallelData->maximumSizeOfTeam < actualSizeOfTeam) {
           OPDI_ERROR("Actual number of threads exceeds maximum number of threads.");
         }
-        parallelData->actualThreads = actualParallelism;
+        parallelData->actualSizeOfTeam = actualSizeOfTeam;
       }
 
-      data->oldTape = tool->getThreadLocalTape();
-      data->parallelData = parallelData;
+      implicitTaskData->oldTape = tool->getThreadLocalTape();
+      implicitTaskData->parallelData = parallelData;
 
-      void* newTape = this->tapePool.getTape(parallelData->parentTape, index);
+      void* newTape = this->tapePool.getTape(parallelData->encounteringTaskTape, indexInTeam);
 
-      if (parallelData->activeParallelRegion) {
-        //most recent tape activity change *per thread* reflects the current activity
-        if (index == 0) {
-          tool->setActive(data->oldTape, false);  // suspend recording on encountering task's tape
+      if (parallelData->isActiveParallelRegion) {
+        // most recent tape activity change *per thread* reflects the current activity
+        if (indexInTeam == 0) {
+          tool->setActive(implicitTaskData->oldTape, false);  // suspend recording on encountering task's tape
         }
         tool->setActive(newTape, true);
       }
 
-      data->tape = newTape;
+      implicitTaskData->newTape = newTape;
 
-      data->positions.push_back(tool->allocPosition());
-      tool->getTapePosition(newTape, data->positions.back());
+      implicitTaskData->positions.push_back(tool->allocPosition());
+      tool->getTapePosition(newTape, implicitTaskData->positions.back());
 
       tool->setThreadLocalTape(newTape);
 
-      data->adjointAccessModes.push_back(parallelData->parentAdjointAccessMode);
+      implicitTaskData->adjointAccessModes.push_back(parallelData->encounteringTaskAdjointAccessMode);
 
-      parallelData->childTasks[index] = data;
+      parallelData->childTaskData[indexInTeam] = implicitTaskData;
     }
     else {
-      data->oldTape = nullptr;
-      data->tape = nullptr;
-      data->parallelData = nullptr;
+      implicitTaskData->oldTape = nullptr;
+      implicitTaskData->newTape = nullptr;
+      implicitTaskData->parallelData = nullptr;
 
-      data->adjointAccessModes.push_back(ImplicitTaskOmpLogic::defaultAdjointAccessMode);
+      implicitTaskData->adjointAccessModes.push_back(ImplicitTaskOmpLogic::defaultAdjointAccessMode);
     }
 
     #if OPDI_OMP_LOGIC_INSTRUMENT
       for (auto& instrument : ompLogicInstruments) {
-        instrument->onImplicitTaskBegin(data);
+        instrument->onImplicitTaskBegin(implicitTaskData);
       }
     #endif
 
-    return data;
+    return static_cast<void*>(implicitTaskData);
   }
 
   return nullptr;
 }
 
-void opdi::ImplicitTaskOmpLogic::onImplicitTaskEnd(void* dataPtr) {
+void opdi::ImplicitTaskOmpLogic::onImplicitTaskEnd(void* implicitTaskDataPtr) {
 
-  if (dataPtr != nullptr) {
-    Data* data = (Data*) dataPtr;
+  if (implicitTaskDataPtr != nullptr) {
+
+    ImplicitTaskData* implicitTaskData = static_cast<ImplicitTaskData*>(implicitTaskDataPtr);
 
     #if OPDI_OMP_LOGIC_INSTRUMENT
       for (auto& instrument : ompLogicInstruments) {
-        instrument->onImplicitTaskEnd(data);
+        instrument->onImplicitTaskEnd(implicitTaskData);
       }
     #endif
 
-    if (!data->initialImplicitTask) {
-      tool->setThreadLocalTape(data->oldTape);
+    if (!implicitTaskData->isInitialImplicitTask) {
+      tool->setThreadLocalTape(implicitTaskData->oldTape);
 
-      data->positions.push_back(tool->allocPosition());
-      tool->getTapePosition(data->tape, data->positions.back());
+      implicitTaskData->positions.push_back(tool->allocPosition());
+      tool->getTapePosition(implicitTaskData->newTape, implicitTaskData->positions.back());
 
-      if (!data->parallelData->activeParallelRegion) {
-        if (tool->comparePosition(data->positions.front(), data->positions.back()) != 0) {
+      if (!implicitTaskData->parallelData->isActiveParallelRegion) {
+        if (tool->comparePosition(implicitTaskData->positions.front(), implicitTaskData->positions.back()) != 0) {
           OPDI_ERROR("Something became active during a passive parallel region. This is not supported and will not be",
                      "differentiated correctly.");
         }
       }
       else {
-        //most recent tape activity change *per thread* reflects the current activity
-        tool->setActive(data->tape, false);
-        if (data->index == 0) {
-          tool->setActive(data->oldTape, true);  // resume recording on encountering task's tape
+        // most recent tape activity change *per thread* reflects the current activity
+        tool->setActive(implicitTaskData->newTape, false);
+        if (implicitTaskData->indexInTeam == 0) {
+          tool->setActive(implicitTaskData->oldTape, true);  // resume recording on encountering task's tape
         }
       }
 
       // 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;
+      delete implicitTaskData;
     }
   }
 }
 
 void opdi::ImplicitTaskOmpLogic::resetTask(void* position, opdi::LogicInterface::AdjointAccessMode mode) {
 
-  void* taskDataPtr = backend->getTaskData();
+  void* implicitTaskDataPtr = backend->getTaskData();
 
-  if (taskDataPtr != nullptr) {
-    opdi::ImplicitTaskOmpLogic::Data* taskData = reinterpret_cast<opdi::ImplicitTaskOmpLogic::Data*>(taskDataPtr);
+  if (implicitTaskDataPtr != nullptr) {
+    ImplicitTaskData* implicitTaskData = static_cast<ImplicitTaskData*>(implicitTaskDataPtr);
 
-    if (!taskData->initialImplicitTask) {
-      assert(tool->comparePosition(taskData->positions.front(), position) <= 0);
+    if (!implicitTaskData->isInitialImplicitTask) {
+      assert(tool->comparePosition(implicitTaskData->positions.front(), position) <= 0);
 
-      while (tool->comparePosition(taskData->positions.back(), position) > 0) {
-        taskData->positions.pop_back();
-        taskData->adjointAccessModes.pop_back();
+      while (tool->comparePosition(implicitTaskData->positions.back(), position) > 0) {
+        implicitTaskData->positions.pop_back();
+        implicitTaskData->adjointAccessModes.pop_back();
       }
     }
 
-    taskData->adjointAccessModes.back() = mode;
+    implicitTaskData->adjointAccessModes.back() = mode;
   }
 }

include/opdi/logic/omp/implicitTaskOmpLogic.hpp

@@ -35,6 +35,18 @@
 
 namespace opdi {
 
+  struct ImplicitTaskData {
+    public:
+      bool isInitialImplicitTask;
+      int level;
+      int indexInTeam;
+      void* oldTape;
+      void* newTape;
+      ParallelData* parallelData;
+      std::deque<void*> positions;
+      std::deque<LogicInterface::AdjointAccessMode> adjointAccessModes;
+  };
+
   struct ImplicitTaskOmpLogic : public virtual LogicInterface {
     protected:
       TapePool tapePool;
@@ -48,23 +60,9 @@ namespace opdi {
 
       static AdjointAccessMode const defaultAdjointAccessMode;
 
-      using ParallelData = typename ParallelOmpLogic::Data;
-
-      struct Data {
-        public:
-          bool initialImplicitTask;
-          int level;
-          int index;
-          void* oldTape;
-          void* tape;
-          ParallelData* parallelData;
-          std::deque<void*> positions;
-          std::deque<AdjointAccessMode> adjointAccessModes;
-      };
-
-      virtual void* onImplicitTaskBegin(bool initialImplicitTask, int actualParallelism, int index,
-                                        void* parallelDataPtr);
-      virtual void onImplicitTaskEnd(void* dataPtr);
+      virtual void* onImplicitTaskBegin(bool isInitialImplicitTask, int actualSizeOfTeam, int indexInTeam,
+                                        void* parallelData);
+      virtual void onImplicitTaskEnd(void* implicitTaskData);
 
       virtual void resetTask(void* position, AdjointAccessMode mode);
   };

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

@@ -45,22 +45,22 @@ namespace opdi {
 
       virtual void reverseFlush() {}
 
-      virtual void reverseImplicitTaskBegin(ImplicitTaskOmpLogic::Data* /*data*/) {}
-      virtual void reverseImplicitTaskEnd(ImplicitTaskOmpLogic::Data* /*data*/) {}
-      virtual void reverseImplicitTaskPart(ImplicitTaskOmpLogic::Data* /*data*/, std::size_t /*part*/) {}
-      virtual void onImplicitTaskBegin(ImplicitTaskOmpLogic::Data* /*data*/) {}
-      virtual void onImplicitTaskEnd(ImplicitTaskOmpLogic::Data* /*data*/) {}
+      virtual void reverseImplicitTaskBegin(ImplicitTaskData* /*data*/) {}
+      virtual void reverseImplicitTaskEnd(ImplicitTaskData* /*data*/) {}
+      virtual void reverseImplicitTaskPart(ImplicitTaskData* /*data*/, std::size_t /*part*/) {}
+      virtual void onImplicitTaskBegin(ImplicitTaskData* /*data*/) {}
+      virtual void onImplicitTaskEnd(ImplicitTaskData* /*data*/) {}
 
       virtual void reverseMutexWait(MutexOmpLogic::Data* /*data*/) {}
       virtual void reverseMutexDecrement(MutexOmpLogic::Data* /*data*/) {}
       virtual void onMutexDestroyed(LogicInterface::MutexKind /*kind*/, std::size_t /*waitId*/) {}
       virtual void onMutexAcquired(MutexOmpLogic::Data* /*data*/) {}
       virtual void onMutexReleased(MutexOmpLogic::Data* /*data*/) {}
 
-      virtual void reverseParallelBegin(ParallelOmpLogic::Data* /*data*/) {}
-      virtual void reverseParallelEnd(ParallelOmpLogic::Data* /*data*/) {}
-      virtual void onParallelBegin(ParallelOmpLogic::Data* /*data*/) {}
-      virtual void onParallelEnd(ParallelOmpLogic::Data* /*data*/) {}
+      virtual void reverseParallelBegin(ParallelData* /*data*/) {}
+      virtual void reverseParallelEnd(ParallelData* /*data*/) {}
+      virtual void onParallelBegin(ParallelData* /*data*/) {}
+      virtual void onParallelEnd(ParallelData* /*data*/) {}
 
       virtual void reverseSyncRegion(SyncRegionOmpLogic::Data* /*data*/) {}
       virtual void onSyncRegion(LogicInterface::SyncRegionKind /*kind*/, LogicInterface::ScopeEndpoint /*endpoint*/) {}