Remove priority mutex (#644)

* Removed hal::priority_condition_variable

* Replaced uses of priority mutexes with std::mutex and std::recursive_mutex

This allowed replacing a use of std::condition_variable_any with
std::condition_variable.

* Replaced all uses of std::recursive_mutex with std::mutex equivalents

hal/src/main/native/include/HAL/cpp/SerialHelper.h

@@ -9,6 +9,7 @@
 
 #include <stdint.h>
 
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -16,7 +17,6 @@
 #include <llvm/SmallVector.h>
 
 #include "HAL/SerialPort.h"
-#include "HAL/cpp/priority_mutex.h"
 
 namespace hal {
 class SerialHelper {
@@ -46,7 +46,7 @@ class SerialHelper {
 
   int32_t m_resourceHandle;
 
-  static hal::priority_mutex m_nameMutex;
+  static std::mutex m_nameMutex;
   static std::string m_usbNames[2];
 };
 }  // namespace hal

hal/src/main/native/include/HAL/cpp/priority_condition_variable.h

@@ -1,141 +0,0 @@
-/*----------------------------------------------------------------------------*/
-/* Copyright (c) 2016-2017 FIRST. All Rights Reserved.                        */
-/* Open Source Software - may be modified and shared by FRC teams. The code   */
-/* must be accompanied by the FIRST BSD license file in the root directory of */
-/* the project.                                                               */
-/*----------------------------------------------------------------------------*/
-
-#pragma once
-
-/* std::condition_variable provides the native_handle() method to return its
- * underlying pthread_cond_t*. WPILib uses this to interface with the FRC
- * network communication library. Since WPILib uses a custom mutex class and
- * not std::mutex, std::condition_variable_any must be used instead.
- * std::condition_variable_any doesn't expose its internal handle, so this
- * class provides the same interface and implementation in addition to a
- * native_handle() method.
- */
-
-#include <condition_variable>
-#include <memory>
-#include <utility>
-
-#include "priority_mutex.h"
-
-namespace hal {
-
-class priority_condition_variable {
-  typedef std::chrono::system_clock clock;
-
- public:
-  typedef std::condition_variable::native_handle_type native_handle_type;
-
-  priority_condition_variable() : m_mutex(std::make_shared<std::mutex>()) {}
-  ~priority_condition_variable() = default;
-
-  priority_condition_variable(const priority_condition_variable&) = delete;
-  priority_condition_variable& operator=(const priority_condition_variable&) =
-      delete;
-
-  void notify_one() noexcept {
-    std::lock_guard<std::mutex> lock(*m_mutex);
-    m_cond.notify_one();
-  }
-
-  void notify_all() noexcept {
-    std::lock_guard<std::mutex> lock(*m_mutex);
-    m_cond.notify_all();
-  }
-
-  template <typename Lock>
-  void wait(Lock& _lock) {
-    std::shared_ptr<std::mutex> _mutex = m_mutex;
-    std::unique_lock<std::mutex> my_lock(*_mutex);
-    Unlock<Lock> unlock(_lock);
-
-    // *mutex must be unlocked before re-locking _lock so move
-    // ownership of *_mutex lock to an object with shorter lifetime.
-    std::unique_lock<std::mutex> my_lock2(std::move(my_lock));
-    m_cond.wait(my_lock2);
-  }
-
-  template <typename Lock, typename Predicate>
-  void wait(Lock& lock, Predicate p) {
-    while (!p()) {
-      wait(lock);
-    }
-  }
-
-  template <typename Lock, typename Clock, typename Duration>
-  std::cv_status wait_until(
-      Lock& _lock, const std::chrono::time_point<Clock, Duration>& atime) {
-    std::shared_ptr<std::mutex> _mutex = m_mutex;
-    std::unique_lock<std::mutex> my_lock(*_mutex);
-    Unlock<Lock> unlock(_lock);
-
-    // *_mutex must be unlocked before re-locking _lock so move
-    // ownership of *_mutex lock to an object with shorter lifetime.
-    std::unique_lock<std::mutex> my_lock2(std::move(my_lock));
-    return m_cond.wait_until(my_lock2, atime);
-  }
-
-  template <typename Lock, typename Clock, typename Duration,
-            typename Predicate>
-  bool wait_until(Lock& lock,
-                  const std::chrono::time_point<Clock, Duration>& atime,
-                  Predicate p) {
-    while (!p()) {
-      if (wait_until(lock, atime) == std::cv_status::timeout) {
-        return p();
-      }
-    }
-    return true;
-  }
-
-  template <typename Lock, typename Rep, typename Period>
-  std::cv_status wait_for(Lock& lock,
-                          const std::chrono::duration<Rep, Period>& rtime) {
-    return wait_until(lock, clock::now() + rtime);
-  }
-
-  template <typename Lock, typename Rep, typename Period, typename Predicate>
-  bool wait_for(Lock& lock, const std::chrono::duration<Rep, Period>& rtime,
-                Predicate p) {
-    return wait_until(lock, clock::now() + rtime, std::move(p));
-  }
-
-  native_handle_type native_handle() { return m_cond.native_handle(); }
-
- private:
-  std::condition_variable m_cond;
-  std::shared_ptr<std::mutex> m_mutex;
-
-  // scoped unlock - unlocks in ctor, re-locks in dtor
-  template <typename Lock>
-  struct Unlock {
-    explicit Unlock(Lock& lk) : m_lock(lk) { lk.unlock(); }
-
-    ~Unlock() /*noexcept(false)*/ {
-      if (std::uncaught_exception()) {
-        try {
-          m_lock.lock();
-        } catch (...) {
-        }
-      } else {
-        m_lock.lock();
-      }
-    }
-
-    Unlock(const Unlock&) = delete;
-    Unlock& operator=(const Unlock&) = delete;
-
-    Lock& m_lock;
-  };
-};
-
-}  // namespace hal
-
-// For backwards compatibility
-#ifndef NAMESPACED_PRIORITY
-using hal::priority_condition_variable;  // NOLINT
-#endif

hal/src/main/native/include/HAL/handles/DigitalHandleResource.h

@@ -11,11 +11,11 @@
 
 #include <array>
 #include <memory>
+#include <mutex>
 
 #include "HAL/Errors.h"
 #include "HAL/Types.h"
 #include "HAL/cpp/make_unique.h"
-#include "HAL/cpp/priority_mutex.h"
 #include "HAL/handles/HandlesInternal.h"
 
 namespace hal {
@@ -48,7 +48,7 @@ class DigitalHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
-  std::array<hal::priority_mutex, size> m_handleMutexes;
+  std::array<std::mutex, size> m_handleMutexes;
 };
 
 template <typename THandle, typename TStruct, int16_t size>
@@ -59,7 +59,7 @@ THandle DigitalHandleResource<THandle, TStruct, size>::Allocate(
     *status = RESOURCE_OUT_OF_RANGE;
     return HAL_kInvalidHandle;
   }
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   // check for allocation, otherwise allocate and return a valid handle
   if (m_structures[index] != nullptr) {
     *status = RESOURCE_IS_ALLOCATED;
@@ -77,7 +77,7 @@ std::shared_ptr<TStruct> DigitalHandleResource<THandle, TStruct, size>::Get(
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -90,14 +90,14 @@ void DigitalHandleResource<THandle, TStruct, size>::Free(
   int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   m_structures[index].reset();
 }
 
 template <typename THandle, typename TStruct, int16_t size>
 void DigitalHandleResource<THandle, TStruct, size>::ResetHandles() {
   for (int i = 0; i < size; i++) {
-    std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+    std::lock_guard<std::mutex> sync(m_handleMutexes[i]);
     m_structures[i].reset();
   }
   HandleBase::ResetHandles();

hal/src/main/native/include/HAL/handles/IndexedClassedHandleResource.h

@@ -51,7 +51,7 @@ class IndexedClassedHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>[], size> m_structures;
-  std::array<hal::priority_mutex[], size> m_handleMutexes;
+  std::array<std::mutex[], size> m_handleMutexes;
 };
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -59,7 +59,7 @@ template <typename THandle, typename TStruct, int16_t size,
 IndexedClassedHandleResource<THandle, TStruct, size,
                              enumValue>::IndexedClassedHandleResource() {
   m_structures = std::make_unique<std::shared_ptr<TStruct>[]>(size);
-  m_handleMutexes = std::make_unique<hal::priority_mutex[]>(size);
+  m_handleMutexes = std::make_unique<std::mutex[]>(size);
 }
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -72,7 +72,7 @@ IndexedClassedHandleResource<THandle, TStruct, size, enumValue>::Allocate(
     *status = RESOURCE_OUT_OF_RANGE;
     return HAL_kInvalidHandle;
   }
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   // check for allocation, otherwise allocate and return a valid handle
   if (m_structures[index] != nullptr) {
     *status = RESOURCE_IS_ALLOCATED;
@@ -91,7 +91,7 @@ std::shared_ptr<TStruct> IndexedClassedHandleResource<
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -105,7 +105,7 @@ void IndexedClassedHandleResource<THandle, TStruct, size, enumValue>::Free(
   int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   m_structures[index].reset();
 }
 
@@ -114,7 +114,7 @@ template <typename THandle, typename TStruct, int16_t size,
 void IndexedClassedHandleResource<THandle, TStruct, size,
                                   enumValue>::ResetHandles() {
   for (int i = 0; i < size; i++) {
-    std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+    std::lock_guard<std::mutex> sync(m_handleMutexes[i]);
     m_structures[i].reset();
   }
   HandleBase::ResetHandles();

hal/src/main/native/include/HAL/handles/IndexedHandleResource.h

@@ -11,11 +11,11 @@
 
 #include <array>
 #include <memory>
+#include <mutex>
 
 #include "HAL/Errors.h"
 #include "HAL/Types.h"
 #include "HAL/cpp/make_unique.h"
-#include "HAL/cpp/priority_mutex.h"
 #include "HAL/handles/HandlesInternal.h"
 
 namespace hal {
@@ -49,7 +49,7 @@ class IndexedHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
-  std::array<hal::priority_mutex, size> m_handleMutexes;
+  std::array<std::mutex, size> m_handleMutexes;
 };
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -61,7 +61,7 @@ THandle IndexedHandleResource<THandle, TStruct, size, enumValue>::Allocate(
     *status = RESOURCE_OUT_OF_RANGE;
     return HAL_kInvalidHandle;
   }
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   // check for allocation, otherwise allocate and return a valid handle
   if (m_structures[index] != nullptr) {
     *status = RESOURCE_IS_ALLOCATED;
@@ -80,7 +80,7 @@ IndexedHandleResource<THandle, TStruct, size, enumValue>::Get(THandle handle) {
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -94,7 +94,7 @@ void IndexedHandleResource<THandle, TStruct, size, enumValue>::Free(
   int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   m_structures[index].reset();
 }
 
@@ -102,7 +102,7 @@ template <typename THandle, typename TStruct, int16_t size,
           HAL_HandleEnum enumValue>
 void IndexedHandleResource<THandle, TStruct, size, enumValue>::ResetHandles() {
   for (int i = 0; i < size; i++) {
-    std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+    std::lock_guard<std::mutex> sync(m_handleMutexes[i]);
     m_structures[i].reset();
   }
   HandleBase::ResetHandles();

hal/src/main/native/include/HAL/handles/LimitedClassedHandleResource.h

@@ -11,10 +11,10 @@
 
 #include <array>
 #include <memory>
+#include <mutex>
 
 #include "HAL/Types.h"
 #include "HAL/cpp/make_unique.h"
-#include "HAL/cpp/priority_mutex.h"
 #include "HAL/handles/HandlesInternal.h"
 
 namespace hal {
@@ -48,8 +48,8 @@ class LimitedClassedHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
-  std::array<hal::priority_mutex, size> m_handleMutexes;
-  hal::priority_mutex m_allocateMutex;
+  std::array<std::mutex, size> m_handleMutexes;
+  std::mutex m_allocateMutex;
 };
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -58,12 +58,12 @@ THandle
 LimitedClassedHandleResource<THandle, TStruct, size, enumValue>::Allocate(
     std::shared_ptr<TStruct> toSet) {
   // globally lock to loop through indices
-  std::lock_guard<hal::priority_mutex> sync(m_allocateMutex);
+  std::lock_guard<std::mutex> sync(m_allocateMutex);
   for (int16_t i = 0; i < size; i++) {
     if (m_structures[i] == nullptr) {
       // if a false index is found, grab its specific mutex
       // and allocate it.
-      std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+      std::lock_guard<std::mutex> sync(m_handleMutexes[i]);
       m_structures[i] = toSet;
       return static_cast<THandle>(createHandle(i, enumValue, m_version));
     }
@@ -80,7 +80,7 @@ std::shared_ptr<TStruct> LimitedClassedHandleResource<
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -94,8 +94,8 @@ void LimitedClassedHandleResource<THandle, TStruct, size, enumValue>::Free(
   int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
-  std::lock_guard<hal::priority_mutex> sync(m_allocateMutex);
-  std::lock_guard<hal::priority_mutex> lock(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_allocateMutex);
+  std::lock_guard<std::mutex> lock(m_handleMutexes[index]);
   m_structures[index].reset();
 }
 
@@ -104,9 +104,9 @@ template <typename THandle, typename TStruct, int16_t size,
 void LimitedClassedHandleResource<THandle, TStruct, size,
                                   enumValue>::ResetHandles() {
   {
-    std::lock_guard<hal::priority_mutex> lock(m_allocateMutex);
+    std::lock_guard<std::mutex> lock(m_allocateMutex);
     for (int i = 0; i < size; i++) {
-      std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+      std::lock_guard<std::mutex> sync(m_handleMutexes[i]);
       m_structures[i].reset();
     }
   }

hal/src/main/native/include/HAL/handles/LimitedHandleResource.h

@@ -11,10 +11,10 @@
 
 #include <array>
 #include <memory>
+#include <mutex>
 
 #include "HAL/Types.h"
 #include "HAL/cpp/make_unique.h"
-#include "HAL/cpp/priority_mutex.h"
 #include "HandlesInternal.h"
 
 namespace hal {
@@ -46,20 +46,20 @@ class LimitedHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
-  std::array<hal::priority_mutex, size> m_handleMutexes;
-  hal::priority_mutex m_allocateMutex;
+  std::array<std::mutex, size> m_handleMutexes;
+  std::mutex m_allocateMutex;
 };
 
 template <typename THandle, typename TStruct, int16_t size,
           HAL_HandleEnum enumValue>
 THandle LimitedHandleResource<THandle, TStruct, size, enumValue>::Allocate() {
   // globally lock to loop through indices
-  std::lock_guard<hal::priority_mutex> sync(m_allocateMutex);
+  std::lock_guard<std::mutex> sync(m_allocateMutex);
   for (int16_t i = 0; i < size; i++) {
     if (m_structures[i] == nullptr) {
       // if a false index is found, grab its specific mutex
       // and allocate it.
-      std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+      std::lock_guard<std::mutex> sync(m_handleMutexes[i]);
       m_structures[i] = std::make_shared<TStruct>();
       return static_cast<THandle>(createHandle(i, enumValue, m_version));
     }
@@ -76,7 +76,7 @@ LimitedHandleResource<THandle, TStruct, size, enumValue>::Get(THandle handle) {
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -90,8 +90,8 @@ void LimitedHandleResource<THandle, TStruct, size, enumValue>::Free(
   int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
   if (index < 0 || index >= size) return;
   // lock and deallocated handle
-  std::lock_guard<hal::priority_mutex> sync(m_allocateMutex);
-  std::lock_guard<hal::priority_mutex> lock(m_handleMutexes[index]);
+  std::lock_guard<std::mutex> sync(m_allocateMutex);
+  std::lock_guard<std::mutex> lock(m_handleMutexes[index]);
   m_structures[index].reset();
 }
 
@@ -99,9 +99,9 @@ template <typename THandle, typename TStruct, int16_t size,
           HAL_HandleEnum enumValue>
 void LimitedHandleResource<THandle, TStruct, size, enumValue>::ResetHandles() {
   {
-    std::lock_guard<hal::priority_mutex> lock(m_allocateMutex);
+    std::lock_guard<std::mutex> lock(m_allocateMutex);
     for (int i = 0; i < size; i++) {
-      std::lock_guard<hal::priority_mutex> sync(m_handleMutexes[i]);
+      std::lock_guard<std::mutex> sync(m_handleMutexes[i]);
       m_structures[i].reset();
     }
   }

hal/src/main/native/include/HAL/handles/UnlimitedHandleResource.h

@@ -10,10 +10,10 @@
 #include <stdint.h>
 
 #include <memory>
+#include <mutex>
 #include <vector>
 
 #include "HAL/Types.h"
-#include "HAL/cpp/priority_mutex.h"
 #include "HAL/handles/HandlesInternal.h"
 
 namespace hal {
@@ -48,13 +48,13 @@ class UnlimitedHandleResource : public HandleBase {
 
  private:
   std::vector<std::shared_ptr<TStruct>> m_structures;
-  hal::priority_mutex m_handleMutex;
+  std::mutex m_handleMutex;
 };
 
 template <typename THandle, typename TStruct, HAL_HandleEnum enumValue>
 THandle UnlimitedHandleResource<THandle, TStruct, enumValue>::Allocate(
     std::shared_ptr<TStruct> structure) {
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutex);
+  std::lock_guard<std::mutex> sync(m_handleMutex);
   size_t i;
   for (i = 0; i < m_structures.size(); i++) {
     if (m_structures[i] == nullptr) {
@@ -73,7 +73,7 @@ template <typename THandle, typename TStruct, HAL_HandleEnum enumValue>
 std::shared_ptr<TStruct>
 UnlimitedHandleResource<THandle, TStruct, enumValue>::Get(THandle handle) {
   int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutex);
+  std::lock_guard<std::mutex> sync(m_handleMutex);
   if (index < 0 || index >= static_cast<int16_t>(m_structures.size()))
     return nullptr;
   return m_structures[index];
@@ -83,7 +83,7 @@ template <typename THandle, typename TStruct, HAL_HandleEnum enumValue>
 void UnlimitedHandleResource<THandle, TStruct, enumValue>::Free(
     THandle handle) {
   int16_t index = getHandleTypedIndex(handle, enumValue, m_version);
-  std::lock_guard<hal::priority_mutex> sync(m_handleMutex);
+  std::lock_guard<std::mutex> sync(m_handleMutex);
   if (index < 0 || index >= static_cast<int16_t>(m_structures.size())) return;
   m_structures[index].reset();
 }
@@ -91,7 +91,7 @@ void UnlimitedHandleResource<THandle, TStruct, enumValue>::Free(
 template <typename THandle, typename TStruct, HAL_HandleEnum enumValue>
 void UnlimitedHandleResource<THandle, TStruct, enumValue>::ResetHandles() {
   {
-    std::lock_guard<hal::priority_mutex> lock(m_handleMutex);
+    std::lock_guard<std::mutex> lock(m_handleMutex);
     for (size_t i = 0; i < m_structures.size(); i++) {
       m_structures[i].reset();
     }