Revisit and improve reductions, primarily in the macro backend.

Treatment via both opening/closing macros and the reduction probe.
Less dependent on probe order.
Remove ProbeScopeStatus.
Update to the OpenMP 6.0 way of declaring reductions.
Less overhead in combiner expressions.
Replace nestable locks by counting constructor calls.
Introduce calls for querying further mutex identifiers in the backend layer.
Reductions use address of parallel data as mutex identifier (both backends).
Drop ID in declaration of custom reductions.

Merge branch 'revisit/reductionsMacroBackend' into develop

Author: jblueh

include/opdi/backend/backendInterface.hpp

@@ -40,6 +40,8 @@ namespace opdi {
 
       virtual std::size_t getLockIdentifier(omp_lock_t* lock) = 0;
       virtual std::size_t getNestLockIdentifier(omp_nest_lock_t* lock) = 0;
+      virtual std::size_t getCriticalIdentifier(std::string const& name) = 0;
+      virtual std::size_t getReductionIdentifier() = 0;
 
       virtual void* getParallelData() = 0;
       virtual void* getTaskData() = 0;

include/opdi/backend/macro/macroBackend.cpp

@@ -34,17 +34,15 @@ 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;
-std::stack<bool> opdi::ReductionTools::reductionBarrierStack;
-
-template<typename Type, int identifier>
-omp_nest_lock_t opdi::Reducer<Type, identifier>::reduceLock;
-
-template<typename Type, int identifier>
-bool opdi::Reducer<Type, identifier>::isInitialized = false;
-
-std::stack<opdi::ProbeScopeStatus::Status> opdi::ProbeScopeStatus::statusStack;
+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;
+int opdi::ReductionTools::implicitTaskNestingDepth = 0;
+
+template<typename Type>
+size_t opdi::Reducer<Type>::nConstructorCalls = 0;
 
 // global macro backend variables
 

include/opdi/backend/macro/macroBackend.hpp

@@ -45,7 +45,6 @@
 #include "macros.hpp"
 #include "mutexIdentifiers.hpp"
 #include "probes.hpp"
-#include "probeTools.hpp"
 #include "reductionTools.hpp"
 
 namespace opdi {
@@ -58,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
       }
@@ -68,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/macros.hpp

@@ -49,16 +49,20 @@
 
 #define OPDI_FOR(...) \
   opdi::ImplicitBarrierTools::beginRegionWithImplicitBarrier(); \
+  opdi::ReductionTools::beginRegionThatSupportsReductions(true); \
   OPDI_PRAGMA(omp for __VA_ARGS__ private(opdi::internalLoopProbe))
 
 #define OPDI_END_FOR \
+  opdi::ReductionTools::endRegionThatSupportsReductions(); \
   opdi::ImplicitBarrierTools::endRegionWithImplicitBarrier();
 
 #define OPDI_SECTIONS(...) \
   opdi::ImplicitBarrierTools::beginRegionWithImplicitBarrier(); \
+  opdi::ReductionTools::beginRegionThatSupportsReductions(true); \
   OPDI_PRAGMA(omp sections private(opdi::internalSectionsProbe) __VA_ARGS__)
 
 #define OPDI_END_SECTIONS \
+  opdi::ReductionTools::endRegionThatSupportsReductions(); \
   opdi::ImplicitBarrierTools::endRegionWithImplicitBarrier();
 
 #define OPDI_SINGLE(...) \
@@ -161,15 +165,13 @@
 #define OPDI_CRITICAL_NAME(name) \
   OPDI_PRAGMA(omp critical (name)) \
   { \
-    std::size_t const opdiInternalCriticalIdentifier = \
-        dynamic_cast<opdi::MacroBackend*>(opdi::backend)->getCriticalIdentifier(std::string(#name)); \
+    std::size_t const opdiInternalCriticalIdentifier = opdi::backend->getCriticalIdentifier(std::string(#name)); \
     opdi::logic->onMutexAcquired(opdi::LogicInterface::MutexKind::Critical, opdiInternalCriticalIdentifier);
 
 #define OPDI_CRITICAL_NAME_ARGS(name, ...) \
   OPDI_PRAGMA(omp critical (name) __VA_ARGS__) \
   { \
-    std::size_t const opdiInternalCriticalIdentifier = \
-        dynamic_cast<opdi::MacroBackend*>(opdi::backend)->getCriticalIdentifier(std::string(#name)); \
+    std::size_t const opdiInternalCriticalIdentifier = opdi::backend->getCriticalIdentifier(std::string(#name)); \
     opdi::logic->onMutexAcquired(opdi::LogicInterface::MutexKind::Critical, opdiInternalCriticalIdentifier);
 
 #define OPDI_END_CRITICAL \
@@ -231,18 +233,27 @@
 
 // reduction macros
 
-#define OPDI_INTERNAL_DECLARE_REDUCTION(OP_NAME, TYPE, OP, INIT, ID) \
-  TYPE operator OP (opdi::Reducer<TYPE, ID> const& lhs, \
-                    opdi::Reducer<TYPE, ID> const& rhs) { \
-    return lhs.value OP rhs.value; \
-  } \
-  \
-  OPDI_PRAGMA(omp declare reduction(OP_NAME : TYPE : \
-      opdi::Reducer<TYPE, ID>(omp_out) = opdi::Reducer<TYPE, ID>(omp_out) OP opdi::Reducer<TYPE, ID>(omp_in)) \
-      initializer(omp_priv = INIT))
-
-#define OPDI_DECLARE_REDUCTION(OP_NAME, TYPE, OP, INIT) \
-  OPDI_INTERNAL_DECLARE_REDUCTION(OP_NAME, TYPE, OP, INIT, __COUNTER__)
+#if _OPENMP >= 202411
+  #define OPDI_DECLARE_REDUCTION(OP_NAME, TYPE, OP, INIT) \
+    TYPE operator OP (opdi::Reducer<TYPE> const& lhs, \
+                      opdi::Reducer<TYPE> const& rhs) { \
+          return lhs.value OP rhs.value; \
+    } \
+    \
+    OPDI_PRAGMA(omp declare_reduction(OP_NAME : TYPE) \
+        combiner(opdi::Reducer(omp_out) = opdi::Reducer(omp_out) OP opdi::Reducer(omp_in)) \
+        initializer(omp_priv = INIT))
+#else
+  #define OPDI_DECLARE_REDUCTION(OP_NAME, TYPE, OP, INIT) \
+    TYPE operator OP (opdi::Reducer<TYPE> const& lhs, \
+                      opdi::Reducer<TYPE> const& rhs) { \
+      return lhs.value OP rhs.value; \
+    } \
+    \
+    OPDI_PRAGMA(omp declare reduction(OP_NAME : TYPE : \
+        opdi::Reducer(omp_out) = opdi::Reducer(omp_out) OP opdi::Reducer(omp_in)) \
+        initializer(omp_priv = INIT))
+#endif
 
 #define OPDI_REDUCTION private(opdi::internalReductionProbe)
 

include/opdi/backend/macro/mutexIdentifiers.hpp

@@ -36,9 +36,7 @@ namespace opdi {
     private:
 
       omp_lock_t criticalLock;
-
       std::map<std::string, std::size_t> criticalIdentifiers;
-
       std::size_t nextCriticalIdentifier;
 
     public:
@@ -67,6 +65,10 @@ namespace opdi {
         return result;
       }
 
+      std::size_t getReductionIdentifier() {
+        return reinterpret_cast<std::size_t>(opdi::backend->getParallelData());
+      }
+
       std::size_t getLockIdentifier(omp_lock_t* lock) {
         return reinterpret_cast<std::size_t>(lock);
       }