waiter_map_t : concept changed

Purpose-specific waiter_map_t objects instead of global one. SM_Sleep()
removed.

Utilities/SMutex.cpp

@@ -8,15 +8,3 @@ bool SM_IsAborted()
 {
 	return Emu.IsStopped();
 }
-
-void SM_Sleep()
-{
-	if (NamedThreadBase* t = GetCurrentNamedThread())
-	{
-		t->WaitForAnySignal();
-	}
-	else
-	{
-		std::this_thread::sleep_for(std::chrono::milliseconds(1));
-	}
-}

Utilities/SMutex.h

@@ -2,7 +2,6 @@
 #include "Emu/Memory/atomic_type.h"
 
 bool SM_IsAborted();
-void SM_Sleep();
 
 enum SMutexResult
 {
@@ -20,8 +19,7 @@ template
 <
 	typename T,
 	const u64 free_value = 0,
-	const u64 dead_value = 0xffffffffffffffffull,
-	void (*wait)() = SM_Sleep
+	const u64 dead_value = 0xffffffffffffffffull
 >
 class SMutexBase
 {
@@ -118,7 +116,7 @@ public:
 				default: return res;
 			}
 
-			if (wait != nullptr) wait();
+			std::this_thread::sleep_for(std::chrono::milliseconds(1));
 
 			if (timeout && counter++ > timeout)
 			{

Utilities/SQueue.h

@@ -33,7 +33,7 @@ public:
 					return false;
 				}
 
-				SM_Sleep();
+				std::this_thread::sleep_for(std::chrono::milliseconds(1));
 				continue;
 			}
 
@@ -60,7 +60,7 @@ public:
 					return false;
 				}
 
-				SM_Sleep();
+				std::this_thread::sleep_for(std::chrono::milliseconds(1));
 				continue;
 			}
 
@@ -112,7 +112,7 @@ public:
 					break;
 				}
 				
-				SM_Sleep();
+				std::this_thread::sleep_for(std::chrono::milliseconds(1));
 				continue;
 			}
 

Utilities/Thread.cpp

@@ -209,63 +209,53 @@ bool thread::joinable() const
 	return m_thr.joinable();
 }
 
-struct g_waiter_map_t
-{
-	// TODO: optimize (use custom lightweight readers-writer lock)
-
-	std::mutex m_mutex;
-	
-	struct waiter
-	{
-		u64 signal_id;
-		NamedThreadBase* thread;
-	};
-
-	std::vector<waiter> m_waiters;
-
-} g_waiter_map;
-
-bool waiter_is_stopped(const char* func_name, u64 signal_id)
+bool waiter_map_t::is_stopped(u64 signal_id)
 {
 	if (Emu.IsStopped())
 	{
-		LOG_WARNING(Log::HLE, "%s() aborted (signal_id=0x%llx)", func_name, signal_id);
+		LOG_WARNING(Log::HLE, "%s.waiter_op() aborted (signal_id=0x%llx)", m_name.c_str(), signal_id);
 		return true;
 	}
 	return false;
 }
 
-waiter_reg_t::waiter_reg_t(u64 signal_id)
+waiter_map_t::waiter_reg_t::waiter_reg_t(waiter_map_t& map, u64 signal_id)
 	: signal_id(signal_id)
 	, thread(GetCurrentNamedThread())
+	, map(map)
 {
-	std::lock_guard<std::mutex> lock(g_waiter_map.m_mutex);
+	std::lock_guard<std::mutex> lock(map.m_mutex);
 
 	// add waiter
-	g_waiter_map.m_waiters.push_back({ signal_id, thread });
+	map.m_waiters.push_back({ signal_id, thread });
 }
 
-waiter_reg_t::~waiter_reg_t()
+waiter_map_t::waiter_reg_t::~waiter_reg_t()
 {
-	std::lock_guard<std::mutex> lock(g_waiter_map.m_mutex);
+	std::lock_guard<std::mutex> lock(map.m_mutex);
 
 	// remove waiter
-	for (size_t i = g_waiter_map.m_waiters.size() - 1; i >= 0; i--)
+	for (size_t i = map.m_waiters.size() - 1; i >= 0; i--)
 	{
-		if (g_waiter_map.m_waiters[i].signal_id == signal_id && g_waiter_map.m_waiters[i].thread == thread)
+		if (map.m_waiters[i].signal_id == signal_id && map.m_waiters[i].thread == thread)
 		{
-			g_waiter_map.m_waiters.erase(g_waiter_map.m_waiters.begin() + i);
+			map.m_waiters.erase(map.m_waiters.begin() + i);
 			return;
 		}
 	}
+
+	LOG_ERROR(HLE, "%s(): waiter not found (signal_id=0x%llx, map='%s')", __FUNCTION__, signal_id, map.m_name.c_str());
+	Emu.Pause();
 }
 
-void waiter_signal(u64 signal_id)
+void waiter_map_t::notify(u64 signal_id)
 {
-	std::lock_guard<std::mutex> lock(g_waiter_map.m_mutex);
+	if (!m_waiters.size()) return;
+
+	std::lock_guard<std::mutex> lock(m_mutex);
 
 	// find waiter and signal
-	for (auto& v : g_waiter_map.m_waiters)
+	for (auto& v : m_waiters)
 	{
 		if (v.signal_id == signal_id)
 		{

Utilities/Thread.h

@@ -71,35 +71,54 @@ public:
 	bool joinable() const;
 };
 
-// for internal use (checks if Emu is stopped)
-bool waiter_is_stopped(const char* func_name, u64 signal_id);
-
-struct waiter_reg_t
+class waiter_map_t
 {
-	const u64 signal_id;
-	NamedThreadBase* const thread;
+	// TODO: optimize (use custom lightweight readers-writer lock)
+	std::mutex m_mutex;
 
-	waiter_reg_t(u64 signal_id);
-	~waiter_reg_t();
-};
-
-// wait until waiter_func() returns true, signal_id is an arbitrary number
-template<typename WT> static __forceinline void waiter_op(const char* func_name, u64 signal_id, const WT waiter_func)
-{
-	// check condition
-	if (waiter_func()) return;
-
-	// register waiter
-	waiter_reg_t waiter(signal_id);
-
-	while (true)
+	struct waiter_t
 	{
-		// wait for 1 ms or until signal arrived
-		waiter.thread->WaitForAnySignal(1);
-		if (waiter_is_stopped(func_name, signal_id)) break;
-		if (waiter_func()) break;
-	}
-}
+		u64 signal_id;
+		NamedThreadBase* thread;
+	};
 
-// signal all threads waiting on waiter_op() with the same signal_id (signaling only hints those threads that corresponding conditions are *probably* met)
-void waiter_signal(u64 signal_id);
+	std::vector<waiter_t> m_waiters;
+
+	std::string m_name;
+
+	struct waiter_reg_t
+	{
+		const u64 signal_id;
+		NamedThreadBase* const thread;
+		waiter_map_t& map;
+
+		waiter_reg_t(waiter_map_t& map, u64 signal_id);
+		~waiter_reg_t();
+	};
+
+	bool is_stopped(u64 signal_id);
+
+public:
+	waiter_map_t(const char* name) : m_name(name) {}
+
+	// wait until waiter_func() returns true, signal_id is an arbitrary number
+	template<typename WT> __forceinline void waiter_op(u64 signal_id, const WT waiter_func)
+	{
+		// check condition
+		if (waiter_func()) return;
+
+		// register waiter
+		waiter_reg_t waiter(*this, signal_id);
+
+		while (true)
+		{
+			// wait for 1 ms or until signal arrived
+			waiter.thread->WaitForAnySignal(1);
+			if (is_stopped(signal_id)) break;
+			if (waiter_func()) break;
+		}
+	}
+
+	// signal all threads waiting on waiter_op() with the same signal_id (signaling only hints those threads that corresponding conditions are *probably* met)
+	void notify(u64 signal_id);
+};