Refactor reduceLock/reducerLock -> reductionLock.

Author: jblueh

include/opdi/backend/macro/macroBackend.cpp

@@ -34,14 +34,14 @@ std::stack<void*> opdi::DataTools::taskData;
 
 std::stack<bool> opdi::ImplicitBarrierTools::implicitBarrierStack;
 
-omp_lock_t opdi::ReductionTools::globalReducerLock;
-std::list<omp_nest_lock_t*> opdi::ReductionTools::individualReducerLocks;
+omp_lock_t opdi::ReductionTools::globalReductionLock;
+std::list<omp_nest_lock_t*> opdi::ReductionTools::individualReductionLocks;
 std::stack<bool> opdi::ReductionTools::hasReductions;
 std::stack<bool> opdi::ReductionTools::needsBarrierBeforeReductions;
 std::stack<bool> opdi::ReductionTools::needsBarrierAfterReductions;
 
 template<typename Type, int identifier>
-omp_nest_lock_t opdi::Reducer<Type, identifier>::reduceLock;
+omp_nest_lock_t opdi::Reducer<Type, identifier>::reductionLock;
 
 template<typename Type, int identifier>
 bool opdi::Reducer<Type, identifier>::isInitialized = false;

include/opdi/backend/macro/macroBackend.hpp

@@ -57,7 +57,7 @@ namespace opdi {
       // remaining functions from backend interface
 
       void init() {
-        opdi_init_lock(&ReductionTools::globalReducerLock);
+        opdi_init_lock(&ReductionTools::globalReductionLock);
 
         // task data for initial implicit task is created in the logic layer
       }
@@ -67,15 +67,15 @@ namespace opdi {
         DataTools::popTaskData();
         assert(DataTools::getTaskData() == nullptr);
 
-        opdi_set_lock(&ReductionTools::globalReducerLock);
+        opdi_set_lock(&ReductionTools::globalReductionLock);
 
-        for (auto lock : ReductionTools::individualReducerLocks) {
+        for (auto lock : ReductionTools::individualReductionLocks) {
           opdi_destroy_nest_lock(lock);
         }
 
-        opdi_unset_lock(&ReductionTools::globalReducerLock);
+        opdi_unset_lock(&ReductionTools::globalReductionLock);
 
-        opdi_destroy_lock(&ReductionTools::globalReducerLock);
+        opdi_destroy_lock(&ReductionTools::globalReductionLock);
       }
 
       void* getParallelData() {

include/opdi/backend/macro/reductionTools.hpp

@@ -39,8 +39,8 @@ namespace opdi {
 
   struct ReductionTools {
     public:
-      static omp_lock_t globalReducerLock;
-      static std::list<omp_nest_lock_t*> individualReducerLocks;
+      static omp_lock_t globalReductionLock;
+      static std::list<omp_nest_lock_t*> individualReductionLocks;
 
       /* item indicates a construct that might have a reduction clause */
       /* its value indicates whether there is a reduction clause */
@@ -108,7 +108,7 @@ namespace opdi {
   template<typename Type, int identifier>
   struct Reducer {
     public:
-      static omp_nest_lock_t reduceLock;
+      static omp_nest_lock_t reductionLock;
       static bool isInitialized;
 
       Type& value;
@@ -121,35 +121,35 @@ namespace opdi {
 
         if (!initialized) {
 
-          opdi_set_lock(&ReductionTools::globalReducerLock);
+          opdi_set_lock(&ReductionTools::globalReductionLock);
 
           #pragma omp atomic read
           initialized = Reducer::isInitialized;
 
           if (!initialized) {
-            opdi_init_nest_lock(&Reducer::reduceLock);
-            ReductionTools::individualReducerLocks.push_back(&Reducer::reduceLock);
+            opdi_init_nest_lock(&Reducer::reductionLock);
+            ReductionTools::individualReductionLocks.push_back(&Reducer::reductionLock);
 
             #pragma omp atomic write
             Reducer::isInitialized = true;
           }
 
-          opdi_unset_lock(&ReductionTools::globalReducerLock);
+          opdi_unset_lock(&ReductionTools::globalReductionLock);
         }
       }
 
       Reducer(Type& value) : value(value) {
         /* push barrier prior to first reduction-related operation */
         ReductionTools::addBarrierBeforeReductionsIfNeeded();
         this->checkInitialized();
-        opdi_set_nest_lock(&reduceLock);
+        opdi_set_nest_lock(&reductionLock);
       }
 
       Reducer& operator=(Type const& rhs) {
         value = rhs;
-        opdi_unset_nest_lock(&reduceLock);
-        opdi_unset_nest_lock(&reduceLock);
-        opdi_unset_nest_lock(&reduceLock);
+        opdi_unset_nest_lock(&reductionLock);
+        opdi_unset_nest_lock(&reductionLock);
+        opdi_unset_nest_lock(&reductionLock);
         return *this;
       }
   };