Refactor NestedLock -> NestLock for consistency with OpenMP.

Merge branch 'refactor/nestLock' into develop

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;