[resumable] Remove unnecessary dependency on atomic fiber mutex

Author: salkinium

src/modm/processing/fiber/mutex.hpp

@@ -22,14 +22,6 @@
 #include <atomic>
 #include <mutex>
 
-/// @cond
-namespace modm
-{
-template< uint8_t Functions > class Resumable;
-template< uint8_t Levels > class NestedResumable;
-}
-/// @endcond
-
 namespace modm::fiber
 {
 
@@ -40,9 +32,6 @@ namespace modm::fiber
 /// @see https://en.cppreference.com/w/cpp/thread/mutex
 class mutex
 {
-	template< uint8_t Functions > friend class ::modm::Resumable;
-	template< uint8_t Levels > friend class ::modm::NestedResumable;
-
 	mutex(const mutex&) = delete;
 	mutex& operator=(const mutex&) = delete;
 
@@ -98,9 +87,6 @@ class timed_mutex : public mutex
 /// @see https://en.cppreference.com/w/cpp/thread/recursive_mutex
 class recursive_mutex
 {
-	template< uint8_t Functions > friend class ::modm::Resumable;
-	template< uint8_t Levels > friend class ::modm::NestedResumable;
-
 	recursive_mutex(const recursive_mutex&) = delete;
 	recursive_mutex& operator=(const recursive_mutex&) = delete;
 	using count_t = uint16_t;

src/modm/processing/resumable/macros_fiber.hpp

@@ -13,7 +13,7 @@
 #define MODM_RF_MACROS_FIBER_HPP
 
 #include <modm/processing/fiber.hpp>
-#include <modm/processing/fiber/mutex.hpp>
+#include <mutex>
 
 /// @ingroup modm_processing_resumable
 /// @{
@@ -109,12 +109,12 @@
 
 #define RF_BEGIN_0() \
 	this->template checkRfType<true>(); \
-	modm::fiber::lock_guard rfLockGuardState{this->rfState};
+	::std::lock_guard rfLockGuardState{this->rfState};
 
 #define RF_BEGIN_1(index) \
 	this->template checkRfType<false>(); \
 	this->template checkRfFunctions<index>(); \
-	modm::fiber::lock_guard rfLockGuardState{this->rfStateArray[index]};
+	::std::lock_guard rfLockGuardState{this->rfStateArray[index]};
 
 #define MODM_RF_GET_MACRO(_0, _1, NAME, ...) NAME
 #define RF_BEGIN(...) MODM_RF_GET_MACRO(_0 __VA_OPT__(,) __VA_ARGS__, RF_BEGIN_1, RF_BEGIN_0)(__VA_ARGS__)

src/modm/processing/resumable/resumable_fiber.hpp

@@ -24,6 +24,33 @@ namespace modm
 /// @ingroup	modm_processing_resumable
 /// @{
 
+/// @cond
+// Reimplementations of modm::fiber::(recursive_)mutex without atomics
+struct ResumableMutex
+{
+	bool locked{false};
+	void inline lock() { while(locked) modm::this_fiber::yield(); locked = true; }
+	void inline unlock() { locked = false; }
+};
+struct ResumableRecursiveMutex
+{
+	using count_t = uint16_t;
+	static constexpr fiber::id NoOwner{fiber::id(-1)};
+	fiber::id owner{NoOwner};
+	static constexpr count_t countMax{count_t(-1)};
+	count_t count{1};
+	bool inline try_lock()
+	{
+		const auto id = modm::this_fiber::get_id();
+		if (owner == NoOwner) { owner = id; return true; }
+		if (owner == id and count < countMax) { count++; return true; }
+		return false;
+	}
+	void inline lock() { while(not try_lock()) modm::this_fiber::yield(); }
+	void inline unlock() { if (count > 1) count--; else owner = NoOwner; }
+};
+/// @endcond
+
 /// Resumable functions implemented via fibers return like a normal function
 template < typename T >
 using ResumableResult = T;
@@ -33,80 +60,80 @@ template< uint8_t Functions = 1 >
 class Resumable
 {
 public:
-    bool isResumableRunning(uint8_t id) const
-    {
-        return id < Functions and rfStateArray[id].locked;
-    }
-    bool areAnyResumablesRunning() const
-    {
-        for (const auto &state : rfStateArray) if (state.locked) return true;
-        return false;
-    }
-    bool areAnyResumablesRunning(std::initializer_list<uint8_t> ids) const
-    {
-        for (uint8_t id : ids) if (isResumableRunning(id)) return true;
-        return false;
-    }
-    bool areAllResumablesRunning(std::initializer_list<uint8_t> ids) const
-    {
-        for (uint8_t id : ids) if (not isResumableRunning(id)) return false;
-        return true;
-    }
-    bool joinResumables(std::initializer_list<uint8_t> ids) const
-    {
-        modm::this_fiber::poll([&]{ return not areAnyResumablesRunning(ids); });
-        return true;
-    }
-    // unimplementable with fibers, but may be stubbed by user application
-    void stopAllResumables();
-    bool stopResumable(uint8_t id);
+	bool isResumableRunning(uint8_t id) const
+	{
+		return id < Functions and rfStateArray[id].locked;
+	}
+	bool areAnyResumablesRunning() const
+	{
+		for (const auto &state : rfStateArray) if (state.locked) return true;
+		return false;
+	}
+	bool areAnyResumablesRunning(std::initializer_list<uint8_t> ids) const
+	{
+		for (uint8_t id : ids) if (isResumableRunning(id)) return true;
+		return false;
+	}
+	bool areAllResumablesRunning(std::initializer_list<uint8_t> ids) const
+	{
+		for (uint8_t id : ids) if (not isResumableRunning(id)) return false;
+		return true;
+	}
+	bool joinResumables(std::initializer_list<uint8_t> ids) const
+	{
+		modm::this_fiber::poll([&]{ return not areAnyResumablesRunning(ids); });
+		return true;
+	}
+	// unimplementable with fibers, but may be stubbed by user application
+	void stopAllResumables();
+	bool stopResumable(uint8_t id);
 
 protected:
-    /// @cond
-    template<uint8_t index>
-    static void
-    checkRfFunctions()
-    {
-        static_assert(index < Functions,
-                "Index out of bounds! Increase the `Functions` template argument of your Resumable class.");
-    }
-    template<bool isNested>
-    static void
-    checkRfType()
-    {
-        static_assert(isNested == false, "You must declare an index for this resumable function!");
-    }
-    modm::fiber::mutex rfStateArray[Functions];
-    /// @endcond
+	/// @cond
+	template<uint8_t index>
+	static void
+	checkRfFunctions()
+	{
+		static_assert(index < Functions,
+				"Index out of bounds! Increase the `Functions` template argument of your Resumable class.");
+	}
+	template<bool isNested>
+	static void
+	checkRfType()
+	{
+		static_assert(isNested == false, "You must declare an index for this resumable function!");
+	}
+	ResumableMutex rfStateArray[Functions];
+	/// @endcond
 };
 
 /// Resumable functions implemented via fibers are normal functions
 template< uint8_t Levels = 1 >
 class NestedResumable
 {
 public:
-    bool isResumableRunning() const
-    {
-        return rfState.owner != rfState.NoOwner;
-    }
-    int8_t getResumableDepth() const
-    {
-        return isResumableRunning() ? rfState.count - 1 : -1;
-    }
-    // unimplementable with fibers, but may be stubbed by user application
-    void stopResumable();
+	bool isResumableRunning() const
+	{
+		return rfState.owner != rfState.NoOwner;
+	}
+	int8_t getResumableDepth() const
+	{
+		return isResumableRunning() ? rfState.count - 1 : -1;
+	}
+	// unimplementable with fibers, but may be stubbed by user application
+	void stopResumable();
 
 protected:
-    /// @cond
-    template<bool isNested>
-    static void
-    checkRfType()
-    {
-        static_assert(isNested == true, "You cannot declare an index for a _nested_ resumable function!");
-    }
+	/// @cond
+	template<bool isNested>
+	static void
+	checkRfType()
+	{
+		static_assert(isNested == true, "You cannot declare an index for a _nested_ resumable function!");
+	}
 
-    modm::fiber::recursive_mutex rfState;
-    /// @endcond
+	ResumableRecursiveMutex rfState;
+	/// @endcond
 };
 
 /// @}