Refactoring.

master -> encounteringTaskTape
TaskProbe -> ImplicitTaskProbe

Author: jblueh

include/opdi/backend/macro/macros.hpp

@@ -40,8 +40,8 @@
 #define OPDI_PARALLEL(...) \
   { \
     void* opdiInternalParallelData = opdi::logic->onParallelBegin(opdi::DataTools::getTaskData(), omp_get_max_threads()); \
-    opdi::TaskProbe opdiInternalTaskProbe(opdiInternalParallelData); \
-    OPDI_PRAGMA(omp parallel __VA_ARGS__ firstprivate(opdiInternalTaskProbe))
+    opdi::ImplicitTaskProbe opdiInternalImplicitTaskProbe(opdiInternalParallelData); \
+    OPDI_PRAGMA(omp parallel __VA_ARGS__ firstprivate(opdiInternalImplicitTaskProbe))
 
 #define OPDI_END_PARALLEL \
     opdi::logic->onParallelEnd(opdiInternalParallelData); \

include/opdi/backend/macro/probes.hpp

@@ -35,18 +35,18 @@
 
 namespace opdi {
 
-  struct TaskProbe {
+  struct ImplicitTaskProbe {
     public:
 
       void* parallelData;
       void* taskData;
       bool needsAction;
 
-      TaskProbe() : parallelData(nullptr), taskData(nullptr), needsAction(false) {}
+      ImplicitTaskProbe() : parallelData(nullptr), taskData(nullptr), needsAction(false) {}
 
-      TaskProbe(void* parallelData) : parallelData(parallelData), taskData(nullptr), needsAction(false) {}
+      ImplicitTaskProbe(void* parallelData) : parallelData(parallelData), taskData(nullptr), needsAction(false) {}
 
-      TaskProbe(TaskProbe const& other) : parallelData(other.parallelData), needsAction(true) {
+      ImplicitTaskProbe(ImplicitTaskProbe const& other) : parallelData(other.parallelData), needsAction(true) {
 
         DataTools::pushParallelData(this->parallelData);
         this->taskData = logic->onImplicitTaskBegin(false, omp_get_num_threads(), omp_get_thread_num(),
@@ -56,7 +56,7 @@ namespace opdi {
         assert(ReductionTools::implicitTaskNestingDepth <= omp_get_level());
 
         if (ReductionTools::implicitTaskNestingDepth != omp_get_level()) {
-          /* TaskProbe constructor before ReductionProbe constructor (if any) */
+          /* ImplicitTaskProbe constructor before ReductionProbe constructor (if any) */
           do {
             ++ReductionTools::implicitTaskNestingDepth;
           } while (ReductionTools::implicitTaskNestingDepth != omp_get_level());
@@ -65,7 +65,7 @@ namespace opdi {
         }
       }
 
-      ~TaskProbe() {
+      ~ImplicitTaskProbe() {
         if (needsAction) {
           assert(ReductionTools::implicitTaskNestingDepth == omp_get_level());
 
@@ -122,7 +122,7 @@ namespace opdi {
 
         if (ReductionTools::implicitTaskNestingDepth != omp_get_level()) {
           /* this condition can only be satisfied by probes on a parallel construct */
-          /* ReductionProbe constructor before TaskProbe constructor */
+          /* ReductionProbe constructor before ImplicitTaskProbe constructor */
           do {
             ++ReductionTools::implicitTaskNestingDepth;
           } while (ReductionTools::implicitTaskNestingDepth != omp_get_level());

include/opdi/backend/macro/reductionTools.hpp

@@ -59,7 +59,7 @@ namespace opdi {
       static std::stack<bool> needsBarrierAfterReductions;
       #pragma omp threadprivate(needsBarrierAfterReductions)
 
-      /* resolves ordering issues between TaskProbe and ReductionProbe constructors */
+      /* resolves ordering issues between ImplicitTaskProbe and ReductionProbe constructors */
       static int implicitTaskNestingDepth;
       #pragma omp threadprivate(implicitTaskNestingDepth)
 

include/opdi/misc/tapePool.hpp

@@ -59,16 +59,16 @@ namespace opdi {
         return &this->lock;
       }
 
-      void* getTape(void* master, int index) {
+      void* getTape(void* encounteringTaskTape, int index) {
         omp_set_lock(&this->lock);
 
-        if (this->tapes[master].find(index) == this->tapes[master].end()) {
+        if (this->tapes[encounteringTaskTape].find(index) == this->tapes[encounteringTaskTape].end()) {
           void* newTape = tool->createTape();
-          this->tapes[master][index] = newTape;
+          this->tapes[encounteringTaskTape][index] = newTape;
           this->createdTapes.insert(newTape);
         }
 
-        void* result = this->tapes[master][index];
+        void* result = this->tapes[encounteringTaskTape][index];
         omp_unset_lock(&this->lock);
         return result;
       }