shared_mutex cleanup

Rewrite to use unsigned arithmetic, shrink to u32
Ensure zero default unlocked state (will need it later)
Inline all public methods, rewrite lock_upgrade()
Remove try_lock_degrade(), lock_degrade() methods
Implement lock_downgrade() (now trivial)
Remove is_reading(), added is_free()
Added reader_lock::try_upgrade()

Utilities/mutex.h

@@ -4,39 +4,41 @@
 #include "types.h"
 #include "Atomic.h"
 
-// Shared mutex.
+// Shared mutex with small size (u32).
 class shared_mutex final
 {
-	enum : s64
+	enum : u32
 	{
-		c_one = 1ull << 31, // Fixed-point 1.0 value (one writer)
-		c_min = 0x00000001, // Fixed-point 1.0/max_readers value
-		c_sig = 1ull << 62,
-		c_max = c_one
+		c_one = 1u << 7, // Fixed-point 1.0 value (one writer, 1.0/(max_readers+1) is 1)
+		c_sig = 1u << 30,
+		c_err = 1u << 31,
 	};
 
-	atomic_t<s64> m_value{c_one}; // Semaphore-alike counter
-
-	void imp_lock_shared(s64 _old);
-	void imp_unlock_shared(s64 _old);
-	void imp_wait(s64 _old);
-	void imp_lock(s64 _old);
-	void imp_unlock(s64 _old);
+	atomic_t<u32> m_value{};
 
+	void imp_lock_shared(u32 val);
+	void imp_unlock_shared(u32 old);
+	void imp_wait();
+	void imp_lock(u32 val);
+	void imp_unlock(u32 old);
 	void imp_lock_upgrade();
-	void imp_lock_degrade();
 
 public:
 	constexpr shared_mutex() = default;
 
-	bool try_lock_shared();
+	bool try_lock_shared()
+	{
+		const u32 value = m_value.load();
+
+		// Conditional increment
+		return value < c_one - 1 && m_value.compare_and_swap_test(value, value + 1);
+	}
 
 	void lock_shared()
 	{
-		const s64 value = m_value.load();
+		const u32 value = m_value.load();
 
-		// Fast path: decrement if positive
-		if (UNLIKELY(value < c_min || value > c_one || !m_value.compare_and_swap_test(value, value - c_min)))
+		if (UNLIKELY(value >= c_one - 1 || !m_value.compare_and_swap_test(value, value + 1)))
 		{
 			imp_lock_shared(value);
 		}
@@ -44,23 +46,25 @@ public:
 
 	void unlock_shared()
 	{
-		// Unconditional increment
-		const s64 value = m_value.fetch_add(c_min);
+		// Unconditional decrement (can result in broken state)
+		const u32 value = m_value.fetch_sub(1);
 
-		if (value < 0 || value > c_one - c_min)
+		if (UNLIKELY(value >= c_one))
 		{
 			imp_unlock_shared(value);
 		}
 	}
 
-	bool try_lock();
+	bool try_lock()
+	{
+		return m_value == 0 && m_value.compare_and_swap_test(0, c_one);
+	}
 
 	void lock()
 	{
-		// Try to lock
-		const s64 value = m_value.compare_and_swap(c_one, 0);
+		const u32 value = m_value.compare_and_swap(0, c_one);
 
-		if (value != c_one)
+		if (UNLIKELY(value))
 		{
 			imp_lock(value);
 		}
@@ -68,43 +72,47 @@ public:
 
 	void unlock()
 	{
-		// Unconditional increment
-		const s64 value = m_value.fetch_add(c_one);
+		// Unconditional decrement (can result in broken state)
+		const u32 value = m_value.fetch_sub(c_one);
 
-		if (value != 0)
+		if (UNLIKELY(value != c_one))
 		{
 			imp_unlock(value);
 		}
 	}
 
-	bool try_lock_upgrade();
+	bool try_lock_upgrade()
+	{
+		const u32 value = m_value.load();
+
+		// Conditional increment, try to convert a single reader into a writer, ignoring other writers
+		return (value + c_one - 1) % c_one == 0 && m_value.compare_and_swap_test(value, value + c_one - 1);
+	}
 
 	void lock_upgrade()
 	{
-		if (!m_value.compare_and_swap_test(c_one - c_min, 0))
+		if (UNLIKELY(!try_lock_upgrade()))
 		{
 			imp_lock_upgrade();
 		}
 	}
 
-	bool try_lock_degrade();
-
-	void lock_degrade()
+	void lock_downgrade()
 	{
-		if (!m_value.compare_and_swap_test(0, c_one - c_min))
-		{
-			imp_lock_degrade();
-		}
+		// Convert to reader lock (can result in broken state)
+		m_value -= c_one - 1;
 	}
 
-	bool is_reading() const
+	// Check whether can immediately obtain an exclusive (writer) lock
+	bool is_free() const
 	{
-		return (m_value.load() % c_one) != 0;
+		return m_value.load() == 0;
 	}
 
+	// Check whether can immediately obtain a shared (reader) lock
 	bool is_lockable() const
 	{
-		return m_value.load() >= c_min;
+		return m_value.load() < c_one - 1;
 	}
 };
 
@@ -117,13 +125,15 @@ class reader_lock final
 public:
 	reader_lock(const reader_lock&) = delete;
 
+	reader_lock& operator=(const reader_lock&) = delete;
+
 	explicit reader_lock(shared_mutex& mutex)
 		: m_mutex(mutex)
 	{
 		m_mutex.lock_shared();
 	}
 
-	// One-way lock upgrade
+	// One-way lock upgrade; note that the observed state could have been changed
 	void upgrade()
 	{
 		if (!m_upgraded)
@@ -133,6 +143,12 @@ public:
 		}
 	}
 
+	// Try to upgrade; if it succeeds, the observed state has NOT been changed
+	bool try_upgrade()
+	{
+		return m_upgraded || (m_upgraded = m_mutex.try_lock_upgrade());
+	}
+
 	~reader_lock()
 	{
 		m_upgraded ? m_mutex.unlock() : m_mutex.unlock_shared();