Restructure Concurrency

src/AudioTools/AudioLibs/Concurrency.h

@@ -4,4 +4,4 @@
  * @ingroup main
  * @brief Multicore support
  */
-#include "AudioTools/Concurrency/All.h"
+#include "AudioTools/Concurrency/RTOS.h"

src/AudioTools/Concurrency/LockGuard.h

@@ -1,83 +1,10 @@
 #pragma once
 #include "AudioConfig.h"
 #include "AudioTools/CoreAudio/AudioLogger.h"
-
-#ifdef USE_STD_CONCURRENCY
-#  include <mutex>
-#endif
-
-#ifdef ESP32
-#  include "freertos/FreeRTOS.h"
-#  include "freertos/semphr.h"
-#else
-#  include "FreeRTOS.h"
-#  include "semphr.h"
-#endif
+#include "Mutex.h"
 
 namespace audio_tools {
 
-/**
- * @brief Empty Mutex implementation which does nothing
- * @ingroup concurrency
- * @author Phil Schatzmann
- * @copyright GPLv3
- */
-class MutexBase {
-public:
-  virtual void lock() {}
-  virtual void unlock() {}
-};
-
-#if defined(USE_STD_CONCURRENCY) 
-
-/**
- * @brief Mutex implemntation based on std::mutex
- * @ingroup concurrency
- * @author Phil Schatzmann
- * @copyright GPLv3
- */
-class StdMutex : public MutexBase {
-public:
-  void lock() override { std_mutex.lock(); }
-  void unlock() override { std_mutex.unlock(); }
-
-protected:
-  std::mutex std_mutex;
-};
-
-#endif
-
-
-/**
- * @brief Mutex implemntation using FreeRTOS
- * @ingroup concurrency
- * @author Phil Schatzmann
- * @copyright GPLv3 *
- */
-class Mutex : public MutexBase {
-public:
-  Mutex() {
-    TRACED();
-    xSemaphore = xSemaphoreCreateBinary();
-    xSemaphoreGive(xSemaphore);
-  }
-  ~Mutex() {
-    TRACED();
-    vSemaphoreDelete(xSemaphore);
-  }
-  void lock() override {
-    TRACED();
-    xSemaphoreTake(xSemaphore, portMAX_DELAY);
-  }
-  void unlock() override {
-    TRACED();
-    xSemaphoreGive(xSemaphore);
-  }
-
-protected:
-  SemaphoreHandle_t xSemaphore = NULL;
-};
-
 
 /**
  * @brief RAII implementaion using a Mutex: Only a few microcontrollers provide
@@ -90,23 +17,25 @@ class Mutex : public MutexBase {
  */
 class LockGuard {
 public:
-  LockGuard(Mutex &mutex) {
+  LockGuard(MutexBase &mutex) {
     TRACED();
     p_mutex = &mutex;
     p_mutex->lock();
   }
-  LockGuard(Mutex *mutex) {
+  LockGuard(MutexBase *mutex) {
     TRACED();
     p_mutex = mutex;
-    p_mutex->lock();
+    if (p_mutex != nullptr)
+      p_mutex->lock();
   }
   ~LockGuard() {
     TRACED();
-    p_mutex->unlock();
+    if (p_mutex != nullptr)
+      p_mutex->unlock();
   }
 
 protected:
-  Mutex *p_mutex = nullptr;
+  MutexBase *p_mutex = nullptr;
 };
 
 }

src/AudioTools/Concurrency/Mutex.h

@@ -0,0 +1,76 @@
+#pragma once
+#include "AudioConfig.h"
+#include <atomic>
+
+#ifdef USE_STD_CONCURRENCY
+#  include <mutex>
+#endif
+
+namespace audio_tools {
+
+/**
+ * @brief Empty Mutex implementation which does nothing
+ * @ingroup concurrency
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+class MutexBase {
+public:
+  virtual void lock() {}
+  virtual void unlock() {}
+};
+
+
+class SpinLock : public MutexBase {
+  std::atomic<bool> lock_ = {0};
+
+  void lock() {
+    for (;;) {
+      // Optimistically assume the lock is free on the first try
+      if (!lock_.exchange(true, std::memory_order_acquire)) {
+        return;
+      }
+      // Wait for lock to be released without generating cache misses
+      while (lock_.load(std::memory_order_relaxed)) {
+        // Issue X86 PAUSE or ARM YIELD instruction to reduce contention between
+        // hyper-threads
+        //__builtin_ia32_pause();
+        delay(1);
+      }
+    }
+  }
+
+  bool try_lock() {
+    // First do a relaxed load to check if lock is free in order to prevent
+    // unnecessary cache misses if someone does while(!try_lock())
+    return !lock_.load(std::memory_order_relaxed) &&
+           !lock_.exchange(true, std::memory_order_acquire);
+  }
+
+  void unlock() {
+    lock_.store(false, std::memory_order_release);
+  }
+};
+
+
+#if defined(USE_STD_CONCURRENCY) 
+
+/**
+ * @brief Mutex implemntation based on std::mutex
+ * @ingroup concurrency
+ * @author Phil Schatzmann
+ * @copyright GPLv3
+ */
+class StdMutex : public MutexBase {
+public:
+  void lock() override { std_mutex.lock(); }
+  void unlock() override { std_mutex.unlock(); }
+
+protected:
+  std::mutex std_mutex;
+};
+
+#endif
+
+
+}

src/AudioTools/Concurrency/MutexRTOS.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "AudioConfig.h"
+#include "Mutex.h"
+
+#ifdef ESP32
+#  include "freertos/FreeRTOS.h"
+#  include "freertos/semphr.h"
+#else
+#  include "FreeRTOS.h"
+#  include "semphr.h"
+#endif
+
+namespace audio_tools {
+
+/**
+ * @brief Mutex implemntation using FreeRTOS
+ * @ingroup concurrency
+ * @author Phil Schatzmann
+ * @copyright GPLv3 *
+ */
+class Mutex : public MutexBase {
+public:
+  Mutex() {
+    TRACED();
+    xSemaphore = xSemaphoreCreateBinary();
+    xSemaphoreGive(xSemaphore);
+  }
+  ~Mutex() {
+    TRACED();
+    vSemaphoreDelete(xSemaphore);
+  }
+  void lock() override {
+    TRACED();
+    xSemaphoreTake(xSemaphore, portMAX_DELAY);
+  }
+  void unlock() override {
+    TRACED();
+    xSemaphoreGive(xSemaphore);
+  }
+
+protected:
+  SemaphoreHandle_t xSemaphore = NULL;
+};
+
+}

src/AudioTools/Concurrency/All.h → src/AudioTools/Concurrency/RTOS.h

@@ -3,4 +3,5 @@
 #include "AudioTools/Concurrency/BufferRTOS.h"
 #include "AudioTools/Concurrency/SynchronizedBuffers.h"
 #include "AudioTools/Concurrency/Task.h"
+#include "MutexRTOS.h"
 #include "AudioTools/Concurrency/LockGuard.h"

src/AudioTools/Concurrency/SynchronizedBuffers.h

@@ -5,6 +5,7 @@
 #include "AudioTools/CoreAudio/Buffers.h"
 #include "AudioTools/CoreAudio/AudioLogger.h"
 
+
 #ifdef ESP32
 #  include "freertos/FreeRTOS.h"
 #  include "AudioTools/Concurrency/QueueRTOS.h"
@@ -15,6 +16,7 @@
 #  include "stream_buffer.h"
 #endif
 
+#include "Mutex.h"
 #include "LockGuard.h"
 
 namespace audio_tools {
@@ -31,7 +33,7 @@ namespace audio_tools {
 template <typename T> 
 class SynchronizedBuffer : public BaseBuffer<T> {
 public:
-  SynchronizedBuffer(BaseBuffer<T> &buffer, Mutex &mutex, bool syncAvailable=false) {
+  SynchronizedBuffer(BaseBuffer<T> &buffer, MutexBase &mutex, bool syncAvailable=false) {
     p_buffer = &buffer;
     p_mutex = &mutex;
     is_sync_available = syncAvailable;
@@ -120,7 +122,7 @@ class SynchronizedBuffer : public BaseBuffer<T> {
 
 protected:
   BaseBuffer<T> *p_buffer = nullptr;
-  Mutex *p_mutex = nullptr;
+  MutexBase *p_mutex = nullptr;
   bool is_sync_available = false;
 };