Refactor NestedLock -> NestLock.

Author: jblueh

include/opdi/backend/backendInterface.hpp

@@ -39,7 +39,7 @@ namespace opdi {
       virtual void finalize() = 0;
 
       virtual std::size_t getLockIdentifier(omp_lock_t* lock) = 0;
-      virtual std::size_t getNestedLockIdentifier(omp_nest_lock_t* lock) = 0;
+      virtual std::size_t getNestLockIdentifier(omp_nest_lock_t* lock) = 0;
 
       virtual void* getParallelData() = 0;
       virtual void* getTaskData() = 0;

include/opdi/backend/macro/macroBackend.cpp

@@ -69,8 +69,8 @@ namespace opdi {
 
   void opdi_destroy_nest_lock(omp_nest_lock_t* lock) {
     omp_destroy_nest_lock(lock);
-    opdi::logic->onMutexDestroyed(LogicInterface::MutexKind::NestedLock,
-                                  opdi::backend->getNestedLockIdentifier(lock));
+    opdi::logic->onMutexDestroyed(LogicInterface::MutexKind::NestLock,
+                                  opdi::backend->getNestLockIdentifier(lock));
   }
 
   void opdi_set_lock(omp_lock_t* lock) {
@@ -82,8 +82,8 @@ namespace opdi {
     omp_set_nest_lock(lock);
     int lockCount = omp_test_nest_lock(lock); // user triggered locks plus lock caused by test
     if (lockCount == 2) {
-      opdi::logic->onMutexAcquired(LogicInterface::MutexKind::NestedLock,
-                                   opdi::backend->getNestedLockIdentifier(lock));
+      opdi::logic->onMutexAcquired(LogicInterface::MutexKind::NestLock,
+                                   opdi::backend->getNestLockIdentifier(lock));
     }
     omp_unset_nest_lock(lock); // revert lock caused by test
   }
@@ -96,8 +96,8 @@ namespace opdi {
   void opdi_unset_nest_lock(omp_nest_lock_t* lock) {
     int lockCount = omp_test_nest_lock(lock); // user triggered locks plus lock caused by test
     if (lockCount == 2) {
-      opdi::logic->onMutexReleased(LogicInterface::MutexKind::NestedLock,
-                                   opdi::backend->getNestedLockIdentifier(lock));
+      opdi::logic->onMutexReleased(LogicInterface::MutexKind::NestLock,
+                                   opdi::backend->getNestLockIdentifier(lock));
     }
     omp_unset_nest_lock(lock); // revert lock caused by test
     omp_unset_nest_lock(lock); // user triggered unlock
@@ -114,8 +114,8 @@ namespace opdi {
   int opdi_test_nest_lock(omp_nest_lock_t* lock) {
     int lockCount = omp_test_nest_lock(lock);
     if (lockCount == 1) {
-      opdi::logic->onMutexAcquired(LogicInterface::MutexKind::NestedLock,
-                                   opdi::backend->getNestedLockIdentifier(lock));
+      opdi::logic->onMutexAcquired(LogicInterface::MutexKind::NestLock,
+                                   opdi::backend->getNestLockIdentifier(lock));
     }
     return lockCount;
   }

include/opdi/backend/macro/mutexIdentifiers.hpp

@@ -71,7 +71,7 @@ namespace opdi {
         return reinterpret_cast<std::size_t>(lock);
       }
 
-      std::size_t getNestedLockIdentifier(omp_nest_lock_t* lock) {
+      std::size_t getNestLockIdentifier(omp_nest_lock_t* lock) {
         return reinterpret_cast<std::size_t>(lock);
       }
   };

include/opdi/backend/ompt/mutexCallbacks.hpp

@@ -58,7 +58,7 @@ namespace opdi {
             break;
           case ompt_mutex_nest_lock:
           case ompt_mutex_test_nest_lock:
-            logic->onMutexDestroyed(LogicInterface::MutexKind::NestedLock, waitId);
+            logic->onMutexDestroyed(LogicInterface::MutexKind::NestLock, waitId);
             break;
           case ompt_mutex_critical:
             logic->onMutexDestroyed(LogicInterface::MutexKind::Critical, waitId);
@@ -86,7 +86,7 @@ namespace opdi {
             break;
           case ompt_mutex_nest_lock:
           case ompt_mutex_test_nest_lock:
-            logic->onMutexAcquired(LogicInterface::MutexKind::NestedLock, waitId);
+            logic->onMutexAcquired(LogicInterface::MutexKind::NestLock, waitId);
             break;
           case ompt_mutex_critical:
             logic->onMutexAcquired(LogicInterface::MutexKind::Critical, waitId);
@@ -114,7 +114,7 @@ namespace opdi {
             break;
           case ompt_mutex_nest_lock:
           case ompt_mutex_test_nest_lock:
-            logic->onMutexReleased(LogicInterface::MutexKind::NestedLock, waitId);
+            logic->onMutexReleased(LogicInterface::MutexKind::NestLock, waitId);
             break;
           case ompt_mutex_critical:
             logic->onMutexReleased(LogicInterface::MutexKind::Critical, waitId);

include/opdi/backend/ompt/omptBackend.hpp

@@ -151,7 +151,7 @@ namespace opdi {
         return (std::size_t) waitId;
       }
 
-      std::size_t getNestedLockIdentifier(omp_nest_lock_t* lock) {
+      std::size_t getNestLockIdentifier(omp_nest_lock_t* lock) {
 
         ompt_wait_id_t waitId;
         WaitIdExtractor::begin(&waitId);

include/opdi/logic/logicInterface.hpp

@@ -34,7 +34,7 @@ namespace opdi {
     public:
 
       enum MutexKind : std::size_t {
-        Critical = 0, Lock, NestedLock, Ordered, Reduction, Custom
+        Critical = 0, Lock, NestLock, Ordered, Reduction, Custom
       };
 
       static constexpr std::size_t nMutexKind = 6;

tests/tests/TestNestedLock.hpp

@@ -28,10 +28,10 @@
 #include "testBase.hpp"
 
 template<typename _Case>
-struct TestNestedLock : public TestBase<4, 1, 3, TestNestedLock<_Case>> {
+struct TestNestLock : public TestBase<4, 1, 3, TestNestLock<_Case>> {
   public:
     using Case = _Case;
-    using Base = TestBase<4, 1, 3, TestNestedLock<Case>>;
+    using Base = TestBase<4, 1, 3, TestNestLock<Case>>;
 
     template<typename T>
     static void job(int i, std::array<T, Base::nIn> const& in, T& result1, T& result2,
@@ -105,7 +105,7 @@ struct TestNestedLock : public TestBase<4, 1, 3, TestNestedLock<_Case>> {
         int end = std::min(N, ((N - 1) / nThreads + 1) * (omp_get_thread_num() + 1));
 
         for (int i = start; i < end; ++i) {
-          TestNestedLock::job(i, in, out1, out2, &lock1, &lock2);
+          TestNestLock::job(i, in, out1, out2, &lock1, &lock2);
         }
       }
       OPDI_END_PARALLEL