Use wpi::mutex instead of std::mutex. (#730)

This uses a priority-aware mutex on Linux platforms.

Fixes #729.

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

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

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

@@ -1,92 +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
-
-// Allows usage with std::lock_guard without including <mutex> separately
-#include <mutex>
-
-#if !defined(__linux__)
-namespace hal {
-// We do not want to use pthreads if in the simulator; however, in the
-// simulator, we do not care about priority inversion.
-typedef std::mutex priority_mutex;
-typedef std::recursive_mutex priority_recursive_mutex;
-}  // namespace hal
-#else  // Covers rest of file.
-
-#include <pthread.h>
-
-namespace hal {
-
-class priority_recursive_mutex {
- public:
-  typedef pthread_mutex_t* native_handle_type;
-
-  constexpr priority_recursive_mutex() noexcept = default;
-  priority_recursive_mutex(const priority_recursive_mutex&) = delete;
-  priority_recursive_mutex& operator=(const priority_recursive_mutex&) = delete;
-
-  // Lock the mutex, blocking until it's available.
-  void lock();
-
-  // Unlock the mutex.
-  void unlock();
-
-  // Tries to lock the mutex.
-  bool try_lock() noexcept;
-
-  pthread_mutex_t* native_handle();
-
- private:
-// Do the equivalent of setting PTHREAD_PRIO_INHERIT and
-// PTHREAD_MUTEX_RECURSIVE_NP.
-#if __WORDSIZE == 64
-  pthread_mutex_t m_mutex = {
-      {0, 0, 0, 0, 0x20 | PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, {0, 0}}};
-#else
-  pthread_mutex_t m_mutex = {
-      {0, 0, 0, 0x20 | PTHREAD_MUTEX_RECURSIVE_NP, 0, {0}}};
-#endif
-};
-
-class priority_mutex {
- public:
-  typedef pthread_mutex_t* native_handle_type;
-
-  constexpr priority_mutex() noexcept = default;
-  priority_mutex(const priority_mutex&) = delete;
-  priority_mutex& operator=(const priority_mutex&) = delete;
-
-  // Lock the mutex, blocking until it's available.
-  void lock();
-
-  // Unlock the mutex.
-  void unlock();
-
-  // Tries to lock the mutex.
-  bool try_lock() noexcept;
-
-  pthread_mutex_t* native_handle();
-
- private:
-// Do the equivalent of setting PTHREAD_PRIO_INHERIT.
-#if __WORDSIZE == 64
-  pthread_mutex_t m_mutex = {{0, 0, 0, 0, 0x20, 0, 0, {0, 0}}};
-#else
-  pthread_mutex_t m_mutex = {{0, 0, 0, 0x20, 0, {0}}};
-#endif
-};
-}  // namespace hal
-
-#endif  // FRC_SIMULATOR
-
-// For backwards compatibility
-#ifndef NAMESPACED_PRIORITY
-using hal::priority_mutex;            // NOLINT
-using hal::priority_recursive_mutex;  // NOLINT
-#endif

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

@@ -11,7 +11,8 @@
 
 #include <array>
 #include <memory>
-#include <mutex>
+
+#include <support/mutex.h>
 
 #include "HAL/Errors.h"
 #include "HAL/Types.h"
@@ -48,7 +49,7 @@ class DigitalHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
-  std::array<std::mutex, size> m_handleMutexes;
+  std::array<wpi::mutex, size> m_handleMutexes;
 };
 
 template <typename THandle, typename TStruct, int16_t size>
@@ -59,7 +60,7 @@ THandle DigitalHandleResource<THandle, TStruct, size>::Allocate(
     *status = RESOURCE_OUT_OF_RANGE;
     return HAL_kInvalidHandle;
   }
-  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::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 +78,7 @@ std::shared_ptr<TStruct> DigitalHandleResource<THandle, TStruct, size>::Get(
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -90,14 +91,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<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::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<std::mutex> sync(m_handleMutexes[i]);
+    std::lock_guard<wpi::mutex> sync(m_handleMutexes[i]);
     m_structures[i].reset();
   }
   HandleBase::ResetHandles();

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

@@ -12,6 +12,8 @@
 #include <memory>
 #include <vector>
 
+#include <support/mutex.h>
+
 #include "HAL/Errors.h"
 #include "HAL/Types.h"
 #include "HAL/cpp/make_unique.h"
@@ -51,7 +53,7 @@ class IndexedClassedHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>[], size> m_structures;
-  std::array<std::mutex[], size> m_handleMutexes;
+  std::array<wpi::mutex[], size> m_handleMutexes;
 };
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -59,7 +61,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<std::mutex[]>(size);
+  m_handleMutexes = std::make_unique<wpi::mutex[]>(size);
 }
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -72,7 +74,7 @@ IndexedClassedHandleResource<THandle, TStruct, size, enumValue>::Allocate(
     *status = RESOURCE_OUT_OF_RANGE;
     return HAL_kInvalidHandle;
   }
-  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_handleMutexes[index]);
   // check for allocation, otherwise allocate and return a valid handle
   if (m_structures[index] != nullptr) {
     *status = RESOURCE_IS_ALLOCATED;
@@ -92,7 +94,7 @@ IndexedClassedHandleResource<THandle, TStruct, size, enumValue>::Get(
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -106,7 +108,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<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_handleMutexes[index]);
   m_structures[index].reset();
 }
 
@@ -115,7 +117,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<std::mutex> sync(m_handleMutexes[i]);
+    std::lock_guard<wpi::mutex> sync(m_handleMutexes[i]);
     m_structures[i].reset();
   }
   HandleBase::ResetHandles();

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

@@ -11,7 +11,8 @@
 
 #include <array>
 #include <memory>
-#include <mutex>
+
+#include <support/mutex.h>
 
 #include "HAL/Errors.h"
 #include "HAL/Types.h"
@@ -49,7 +50,7 @@ class IndexedHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
-  std::array<std::mutex, size> m_handleMutexes;
+  std::array<wpi::mutex, size> m_handleMutexes;
 };
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -61,7 +62,7 @@ THandle IndexedHandleResource<THandle, TStruct, size, enumValue>::Allocate(
     *status = RESOURCE_OUT_OF_RANGE;
     return HAL_kInvalidHandle;
   }
-  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::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 +81,7 @@ IndexedHandleResource<THandle, TStruct, size, enumValue>::Get(THandle handle) {
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -94,7 +95,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<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_handleMutexes[index]);
   m_structures[index].reset();
 }
 
@@ -102,7 +103,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<std::mutex> sync(m_handleMutexes[i]);
+    std::lock_guard<wpi::mutex> sync(m_handleMutexes[i]);
     m_structures[i].reset();
   }
   HandleBase::ResetHandles();

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

@@ -11,7 +11,8 @@
 
 #include <array>
 #include <memory>
-#include <mutex>
+
+#include <support/mutex.h>
 
 #include "HAL/Types.h"
 #include "HAL/cpp/make_unique.h"
@@ -48,8 +49,8 @@ class LimitedClassedHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
-  std::array<std::mutex, size> m_handleMutexes;
-  std::mutex m_allocateMutex;
+  std::array<wpi::mutex, size> m_handleMutexes;
+  wpi::mutex m_allocateMutex;
 };
 
 template <typename THandle, typename TStruct, int16_t size,
@@ -58,12 +59,12 @@ THandle
 LimitedClassedHandleResource<THandle, TStruct, size, enumValue>::Allocate(
     std::shared_ptr<TStruct> toSet) {
   // globally lock to loop through indices
-  std::lock_guard<std::mutex> sync(m_allocateMutex);
+  std::lock_guard<wpi::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<std::mutex> sync(m_handleMutexes[i]);
+      std::lock_guard<wpi::mutex> sync(m_handleMutexes[i]);
       m_structures[i] = toSet;
       return static_cast<THandle>(createHandle(i, enumValue, m_version));
     }
@@ -81,7 +82,7 @@ LimitedClassedHandleResource<THandle, TStruct, size, enumValue>::Get(
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -95,8 +96,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<std::mutex> sync(m_allocateMutex);
-  std::lock_guard<std::mutex> lock(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_allocateMutex);
+  std::lock_guard<wpi::mutex> lock(m_handleMutexes[index]);
   m_structures[index].reset();
 }
 
@@ -105,9 +106,9 @@ template <typename THandle, typename TStruct, int16_t size,
 void LimitedClassedHandleResource<THandle, TStruct, size,
                                   enumValue>::ResetHandles() {
   {
-    std::lock_guard<std::mutex> lock(m_allocateMutex);
+    std::lock_guard<wpi::mutex> lock(m_allocateMutex);
     for (int i = 0; i < size; i++) {
-      std::lock_guard<std::mutex> sync(m_handleMutexes[i]);
+      std::lock_guard<wpi::mutex> sync(m_handleMutexes[i]);
       m_structures[i].reset();
     }
   }

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

@@ -11,7 +11,8 @@
 
 #include <array>
 #include <memory>
-#include <mutex>
+
+#include <support/mutex.h>
 
 #include "HAL/Types.h"
 #include "HAL/cpp/make_unique.h"
@@ -46,20 +47,20 @@ class LimitedHandleResource : public HandleBase {
 
  private:
   std::array<std::shared_ptr<TStruct>, size> m_structures;
-  std::array<std::mutex, size> m_handleMutexes;
-  std::mutex m_allocateMutex;
+  std::array<wpi::mutex, size> m_handleMutexes;
+  wpi::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<std::mutex> sync(m_allocateMutex);
+  std::lock_guard<wpi::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<std::mutex> sync(m_handleMutexes[i]);
+      std::lock_guard<wpi::mutex> sync(m_handleMutexes[i]);
       m_structures[i] = std::make_shared<TStruct>();
       return static_cast<THandle>(createHandle(i, enumValue, m_version));
     }
@@ -76,7 +77,7 @@ LimitedHandleResource<THandle, TStruct, size, enumValue>::Get(THandle handle) {
   if (index < 0 || index >= size) {
     return nullptr;
   }
-  std::lock_guard<std::mutex> sync(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_handleMutexes[index]);
   // return structure. Null will propogate correctly, so no need to manually
   // check.
   return m_structures[index];
@@ -90,8 +91,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<std::mutex> sync(m_allocateMutex);
-  std::lock_guard<std::mutex> lock(m_handleMutexes[index]);
+  std::lock_guard<wpi::mutex> sync(m_allocateMutex);
+  std::lock_guard<wpi::mutex> lock(m_handleMutexes[index]);
   m_structures[index].reset();
 }
 
@@ -99,9 +100,9 @@ template <typename THandle, typename TStruct, int16_t size,
           HAL_HandleEnum enumValue>
 void LimitedHandleResource<THandle, TStruct, size, enumValue>::ResetHandles() {
   {
-    std::lock_guard<std::mutex> lock(m_allocateMutex);
+    std::lock_guard<wpi::mutex> lock(m_allocateMutex);
     for (int i = 0; i < size; i++) {
-      std::lock_guard<std::mutex> sync(m_handleMutexes[i]);
+      std::lock_guard<wpi::mutex> sync(m_handleMutexes[i]);
       m_structures[i].reset();
     }
   }

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

@@ -10,9 +10,10 @@
 #include <stdint.h>
 
 #include <memory>
-#include <mutex>
 #include <vector>
 
+#include <support/mutex.h>
+
 #include "HAL/Types.h"
 #include "HAL/handles/HandlesInternal.h"
 
@@ -48,13 +49,13 @@ class UnlimitedHandleResource : public HandleBase {
 
  private:
   std::vector<std::shared_ptr<TStruct>> m_structures;
-  std::mutex m_handleMutex;
+  wpi::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<std::mutex> sync(m_handleMutex);
+  std::lock_guard<wpi::mutex> sync(m_handleMutex);
   size_t i;
   for (i = 0; i < m_structures.size(); i++) {
     if (m_structures[i] == nullptr) {
@@ -73,7 +74,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<std::mutex> sync(m_handleMutex);
+  std::lock_guard<wpi::mutex> sync(m_handleMutex);
   if (index < 0 || index >= static_cast<int16_t>(m_structures.size()))
     return nullptr;
   return m_structures[index];
@@ -83,7 +84,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<std::mutex> sync(m_handleMutex);
+  std::lock_guard<wpi::mutex> sync(m_handleMutex);
   if (index < 0 || index >= static_cast<int16_t>(m_structures.size())) return;
   m_structures[index].reset();
 }
@@ -91,7 +92,7 @@ void UnlimitedHandleResource<THandle, TStruct, enumValue>::Free(
 template <typename THandle, typename TStruct, HAL_HandleEnum enumValue>
 void UnlimitedHandleResource<THandle, TStruct, enumValue>::ResetHandles() {
   {
-    std::lock_guard<std::mutex> lock(m_handleMutex);
+    std::lock_guard<wpi::mutex> lock(m_handleMutex);
     for (size_t i = 0; i < m_structures.size(); i++) {
       m_structures[i].reset();
     }

hal/src/main/native/include/MockData/NotifyListenerVector.h

@@ -8,7 +8,6 @@
 #pragma once
 
 #include <memory>
-#include <mutex>
 #include <queue>
 #include <vector>