Refactoring regarding implicit task.

jblueh · jblueh · commit af5d6a93987c · 2025-10-17T22:41:58.000+02:00
getTaskData -&gt; getImplicitTaskData
resetTask -&gt; resetImplicitTask
taskData -&gt; implicitTaskData
diff --git a/include/opdi/backend/backendInterface.hpp b/include/opdi/backend/backendInterface.hpp
@@ -45,7 +45,7 @@ namespace opdi {
       virtual std::size_t getOrderedIdentifier() = 0;
 
       virtual void* getParallelData() = 0;
-      virtual void* getTaskData() = 0;
+      virtual void* getImplicitTaskData() = 0;
 
       virtual void setInitialImplicitTaskData(void* data) = 0;
   };
diff --git a/include/opdi/backend/macro/dataTools.hpp b/include/opdi/backend/macro/dataTools.hpp
@@ -34,8 +34,8 @@ namespace opdi {
       static std::stack<void*> parallelData;
       #pragma omp threadprivate(parallelData)
 
-      static std::stack<void*> taskData;
-      #pragma omp threadprivate(taskData)
+      static std::stack<void*> implicitTaskData;
+      #pragma omp threadprivate(implicitTaskData)
 
     public:
       static void pushParallelData(void* parallelData) {
@@ -54,20 +54,20 @@ namespace opdi {
         return DataTools::parallelData.top();
       }
 
-      static void pushTaskData(void* taskData) {
-        DataTools::taskData.push(taskData);
+      static void pushTaskData(void* implicitTaskData) {
+        DataTools::implicitTaskData.push(implicitTaskData);
       }
 
       static void popTaskData() {
-        DataTools::taskData.pop();
+        DataTools::implicitTaskData.pop();
       }
 
-      static void* getTaskData() {
-        if (DataTools::taskData.empty()) {
+      static void* getImplicitTaskData() {
+        if (DataTools::implicitTaskData.empty()) {
           return nullptr;
         }
 
-        return DataTools::taskData.top();
+        return DataTools::implicitTaskData.top();
       }
   };
 }
diff --git a/include/opdi/backend/macro/macroBackend.cpp b/include/opdi/backend/macro/macroBackend.cpp
@@ -30,7 +30,7 @@
 // static macro backend members
 
 std::stack<void*> opdi::DataTools::parallelData;
-std::stack<void*> opdi::DataTools::taskData;
+std::stack<void*> opdi::DataTools::implicitTaskData;
 
 std::stack<bool> opdi::ImplicitBarrierTools::implicitBarrierStack;
 
diff --git a/include/opdi/backend/macro/macroBackend.hpp b/include/opdi/backend/macro/macroBackend.hpp
@@ -65,7 +65,7 @@ namespace opdi {
       void finalize() {
         // pop task data associated with initial implicit task
         DataTools::popTaskData();
-        assert(DataTools::getTaskData() == nullptr);
+        assert(DataTools::getImplicitTaskData() == nullptr);
 
         opdi_set_lock(&ReductionTools::globalReductionLock);
 
@@ -82,12 +82,12 @@ namespace opdi {
         return DataTools::getParallelData();
       }
 
-      void* getTaskData() {
-        return DataTools::getTaskData();
+      void* getImplicitTaskData() {
+        return DataTools::getImplicitTaskData();
       }
 
       void setInitialImplicitTaskData(void* data) {
-        assert(DataTools::getTaskData() == nullptr);
+        assert(DataTools::getImplicitTaskData() == nullptr);
         DataTools::pushTaskData(data);
       }
   };
diff --git a/include/opdi/backend/macro/macros.hpp b/include/opdi/backend/macro/macros.hpp
@@ -39,7 +39,7 @@
 
 #define OPDI_PARALLEL(...) \
   { \
-    void* opdiInternalParallelData = opdi::logic->onParallelBegin(opdi::DataTools::getTaskData(), omp_get_max_threads()); \
+    void* opdiInternalParallelData = opdi::logic->onParallelBegin(opdi::DataTools::getImplicitTaskData(), omp_get_max_threads()); \
     opdi::ImplicitTaskProbe opdiInternalImplicitTaskProbe(opdiInternalParallelData); \
     OPDI_PRAGMA(omp parallel __VA_ARGS__ firstprivate(opdiInternalImplicitTaskProbe))
 
diff --git a/include/opdi/backend/ompt/omptBackend.hpp b/include/opdi/backend/ompt/omptBackend.hpp
@@ -191,7 +191,7 @@ namespace opdi {
         return parallelData->ptr;
       }
 
-      void* getTaskData() {
+      void* getImplicitTaskData() {
         int flags;
         ompt_data_t* taskData;
         ompt_frame_t* taskFrame;
diff --git a/include/opdi/logic/logicInterface.hpp b/include/opdi/logic/logicInterface.hpp
@@ -90,7 +90,7 @@ namespace opdi {
       virtual void setAdjointAccessMode(AdjointAccessMode mode) = 0;
       virtual AdjointAccessMode getAdjointAccessMode() const = 0;
 
-      virtual void resetTask(void* position, AdjointAccessMode mode) = 0;
+      virtual void resetImplicitTask(void* position, AdjointAccessMode mode) = 0;
 
       virtual void addReverseBarrier() = 0;
       virtual void addReverseFlush() = 0;
diff --git a/include/opdi/logic/omp/implicitTaskOmpLogic.cpp b/include/opdi/logic/omp/implicitTaskOmpLogic.cpp
@@ -177,9 +177,9 @@ void opdi::ImplicitTaskOmpLogic::onImplicitTaskEnd(void* implicitTaskDataPtr) {
   }
 }
 
-void opdi::ImplicitTaskOmpLogic::resetTask(void* position, opdi::LogicInterface::AdjointAccessMode mode) {
+void opdi::ImplicitTaskOmpLogic::resetImplicitTask(void* position, opdi::LogicInterface::AdjointAccessMode mode) {
 
-  void* implicitTaskDataPtr = backend->getTaskData();
+  void* implicitTaskDataPtr = backend->getImplicitTaskData();
 
   if (implicitTaskDataPtr != nullptr) {
     ImplicitTaskData* implicitTaskData = static_cast<ImplicitTaskData*>(implicitTaskDataPtr);
diff --git a/include/opdi/logic/omp/implicitTaskOmpLogic.hpp b/include/opdi/logic/omp/implicitTaskOmpLogic.hpp
@@ -64,6 +64,6 @@ namespace opdi {
                                         void* parallelData);
       virtual void onImplicitTaskEnd(void* implicitTaskData);
 
-      virtual void resetTask(void* position, AdjointAccessMode mode);
+      virtual void resetImplicitTask(void* position, AdjointAccessMode mode);
   };
 }
diff --git a/include/opdi/logic/omp/ompLogic.hpp b/include/opdi/logic/omp/ompLogic.hpp
@@ -72,7 +72,7 @@ namespace opdi {
 
       virtual void finalize() {
         // finalize initial implicit task
-        ImplicitTaskData* initialImplicitTaskData = static_cast<ImplicitTaskData*>(backend->getTaskData());
+        ImplicitTaskData* initialImplicitTaskData = static_cast<ImplicitTaskData*>(backend->getImplicitTaskData());
 
         assert(initialImplicitTaskData->isInitialImplicitTask);
 
diff --git a/include/opdi/logic/omp/parallelOmpLogic.cpp b/include/opdi/logic/omp/parallelOmpLogic.cpp
@@ -252,7 +252,7 @@ void opdi::ParallelOmpLogic::onParallelEnd(void* parallelDataPtr) {
 void opdi::ParallelOmpLogic::setAdjointAccessMode(opdi::LogicInterface::AdjointAccessMode mode) {
 
   #if OPDI_VARIABLE_ADJOINT_ACCESS_MODE
-    void* implicitTaskDataPtr = backend->getTaskData();
+    void* implicitTaskDataPtr = backend->getImplicitTaskData();
     if (implicitTaskDataPtr != nullptr) {  // nullptr if called during tape evaluation
       #if OPDI_OMP_LOGIC_INSTRUMENT
         for (auto& instrument : ompLogicInstruments) {
@@ -266,7 +266,7 @@ void opdi::ParallelOmpLogic::setAdjointAccessMode(opdi::LogicInterface::AdjointA
 }
 
 opdi::LogicInterface::AdjointAccessMode opdi::ParallelOmpLogic::getAdjointAccessMode() const {
-  void* implicitTaskDataPtr = backend->getTaskData();
+  void* implicitTaskDataPtr = backend->getImplicitTaskData();
   if (implicitTaskDataPtr != nullptr) {  // nullptr if called during tape evaluation
     return internalGetAdjointAccessMode(static_cast<ImplicitTaskData*>(implicitTaskDataPtr));
   } else {
diff --git a/tests/tests/TestExternalFunctionLogicCalls.hpp b/tests/tests/TestExternalFunctionLogicCalls.hpp
@@ -83,7 +83,7 @@ struct TestExternalFunctionLogicCalls : public TestBase<4, 1, 3, TestExternalFun
         opdi::tool->getTapePosition(opdi::tool->getThreadLocalTape(), newPosition);
         assert(opdi::tool->comparePosition(position, newPosition) == 0);
 
-        opdi::logic->resetTask(&position, mode);
+        opdi::logic->resetImplicitTask(&position, mode);
         newMode = opdi::logic->getAdjointAccessMode();
         assert(mode == newMode);
         opdi::tool->getTapePosition(opdi::tool->getThreadLocalTape(), newPosition);
diff --git a/tests/tests/TestTaskReset.hpp b/tests/tests/TestTaskReset.hpp
@@ -108,7 +108,7 @@ struct TestTaskReset : public TestBase<4, 1, 3, TestTaskReset<_Case>> {
         T::getTape().resetTo(position);
 
         #if _OPENMP
-          opdi::logic->resetTask(&position, mode);
+          opdi::logic->resetImplicitTask(&position, mode);
         #endif
 
         assertAdjointAccessMode(opdi::LogicInterface::AdjointAccessMode::Classical);

Original file line number	Diff line number	Diff line change
`@@ -34,8 +34,8 @@ namespace opdi {`
`34`	`34`	`static std::stack<void*> parallelData;`
`35`	`35`	`#pragma omp threadprivate(parallelData)`
`36`	`36`
`37`		`- static std::stack<void*> taskData;`
`38`		`- #pragma omp threadprivate(taskData)`
	`37`	`+ static std::stack<void*> implicitTaskData;`
	`38`	`+ #pragma omp threadprivate(implicitTaskData)`
`39`	`39`
`40`	`40`	`public:`
`41`	`41`	`static void pushParallelData(void* parallelData) {`
`@@ -54,20 +54,20 @@ namespace opdi {`
`54`	`54`	`return DataTools::parallelData.top();`
`55`	`55`	`}`
`56`	`56`
`57`		`- static void pushTaskData(void* taskData) {`
`58`		`- DataTools::taskData.push(taskData);`
	`57`	`+ static void pushTaskData(void* implicitTaskData) {`
	`58`	`+ DataTools::implicitTaskData.push(implicitTaskData);`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`static void popTaskData() {`
`62`		`- DataTools::taskData.pop();`
	`62`	`+ DataTools::implicitTaskData.pop();`
`63`	`63`	`}`
`64`	`64`
`65`		`- static void* getTaskData() {`
`66`		`- if (DataTools::taskData.empty()) {`
	`65`	`+ static void* getImplicitTaskData() {`
	`66`	`+ if (DataTools::implicitTaskData.empty()) {`
`67`	`67`	`return nullptr;`
`68`	`68`	`}`
`69`	`69`
`70`		`- return DataTools::taskData.top();`
	`70`	`+ return DataTools::implicitTaskData.top();`
`71`	`71`	`}`
`72`	`72`	`};`
`73`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ namespace opdi {`
`191`	`191`	`return parallelData->ptr;`
`192`	`192`	`}`
`193`	`193`
`194`		`- void* getTaskData() {`
	`194`	`+ void* getImplicitTaskData() {`
`195`	`195`	`int flags;`
`196`	`196`	`ompt_data_t* taskData;`
`197`	`197`	`ompt_frame_t* taskFrame;`
Original file line number	Diff line number	Diff line change
`@@ -177,9 +177,9 @@ void opdi::ImplicitTaskOmpLogic::onImplicitTaskEnd(void* implicitTaskDataPtr) {`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`180`		`-void opdi::ImplicitTaskOmpLogic::resetTask(void* position, opdi::LogicInterface::AdjointAccessMode mode) {`
	`180`	`+void opdi::ImplicitTaskOmpLogic::resetImplicitTask(void* position, opdi::LogicInterface::AdjointAccessMode mode) {`
`181`	`181`
`182`		`- void* implicitTaskDataPtr = backend->getTaskData();`
	`182`	`+ void* implicitTaskDataPtr = backend->getImplicitTaskData();`
`183`	`183`
`184`	`184`	`if (implicitTaskDataPtr != nullptr) {`
`185`	`185`	`ImplicitTaskData* implicitTaskData = static_cast<ImplicitTaskData*>(implicitTaskDataPtr);`
Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,6 @@ namespace opdi {`
`64`	`64`	`void* parallelData);`
`65`	`65`	`virtual void onImplicitTaskEnd(void* implicitTaskData);`
`66`	`66`
`67`		`- virtual void resetTask(void* position, AdjointAccessMode mode);`
	`67`	`+ virtual void resetImplicitTask(void* position, AdjointAccessMode mode);`
`68`	`68`	`};`
`69`	`69`	`}`