Merge remote-tracking branch 'upstream/master' into ppu_llvm_recompiler

Conflicts:
	Utilities/BEType.h
	rpcs3/Emu/Cell/PPUInterpreter.h
	rpcs3/emucore.vcxproj.filters

Utilities/SQueue.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "Utilities/SMutex.h"
+static const volatile bool sq_no_wait = true;
 
 template<typename T, u32 SQSize = 666>
 class SQueue
@@ -22,13 +22,13 @@ public:
 		return SQSize;
 	}
 
-	bool Push(const T& data)
+	bool Push(const T& data, const volatile bool* do_exit)
 	{
 		while (true)
 		{
 			if (m_count >= SQSize)
 			{
-				if (Emu.IsStopped())
+				if (Emu.IsStopped() || do_exit && *do_exit)
 				{
 					return false;
 				}
@@ -49,13 +49,13 @@ public:
 		}
 	}
 
-	bool Pop(T& data)
+	bool Pop(T& data, const volatile bool* do_exit)
 	{
 		while (true)
 		{
 			if (!m_count)
 			{
-				if (Emu.IsStopped())
+				if (Emu.IsStopped() || do_exit && *do_exit)
 				{
 					return false;
 				}
@@ -78,38 +78,21 @@ public:
 		}
 	}
 
-	u32 GetCount()
-	{
-		std::lock_guard<std::mutex> lock(m_mutex);
-		return m_count;
-	}
-
-	u32 GetCountUnsafe()
-	{
-		return m_count;
-	}
-
-	bool IsEmpty()
-	{
-		std::lock_guard<std::mutex> lock(m_mutex);
-		return !m_count;
-	}
-
 	void Clear()
 	{
 		std::lock_guard<std::mutex> lock(m_mutex);
 		m_count = 0;
 	}
 
-	T& Peek(u32 pos = 0)
+	bool Peek(T& data, const volatile bool* do_exit, u32 pos = 0)
 	{
 		while (true)
 		{
 			if (m_count <= pos)
 			{
-				if (Emu.IsStopped())
+				if (Emu.IsStopped() || do_exit && *do_exit)
 				{
-					break;
+					return false;
 				}
 				
 				std::this_thread::sleep_for(std::chrono::milliseconds(1));
@@ -124,21 +107,7 @@ public:
 				}
 			}
 		}
-		return m_data[(m_pos + pos) % SQSize];
-	}
-
-	T& PeekIfExist(u32 pos = 0)
-	{
-		static T def_value;
-
-		std::lock_guard<std::mutex> lock(m_mutex);
-		if (m_count <= pos)
-		{
-			return def_value;
-		}
-		else
-		{
-			return m_data[(m_pos + pos) % SQSize];
-		}
+		data = m_data[(m_pos + pos) % SQSize];
+		return true;
 	}
 };

Utilities/Thread.cpp

@@ -219,11 +219,12 @@ bool waiter_map_t::is_stopped(u64 signal_id)
 	return false;
 }
 
-waiter_map_t::waiter_reg_t::waiter_reg_t(waiter_map_t& map, u64 signal_id)
-	: signal_id(signal_id)
-	, thread(GetCurrentNamedThread())
-	, map(map)
+void waiter_map_t::waiter_reg_t::init()
 {
+	if (thread) return;
+
+	thread = GetCurrentNamedThread();
+
 	std::lock_guard<std::mutex> lock(map.m_mutex);
 
 	// add waiter
@@ -232,10 +233,12 @@ waiter_map_t::waiter_reg_t::waiter_reg_t(waiter_map_t& map, u64 signal_id)
 
 waiter_map_t::waiter_reg_t::~waiter_reg_t()
 {
+	if (!thread) return;
+
 	std::lock_guard<std::mutex> lock(map.m_mutex);
 
 	// remove waiter
-	for (size_t i = map.m_waiters.size() - 1; i >= 0; i--)
+	for (s64 i = map.m_waiters.size() - 1; i >= 0; i--)
 	{
 		if (map.m_waiters[i].signal_id == signal_id && map.m_waiters[i].thread == thread)
 		{

Utilities/Thread.h

@@ -71,6 +71,48 @@ public:
 	bool joinable() const;
 };
 
+class s_mutex_t
+{
+
+};
+
+class s_shared_mutex_t
+{
+
+};
+
+class s_cond_var_t
+{
+	
+//public:
+//	s_cond_var_t();
+//	~s_cond_var_t();
+//
+//	s_cond_var_t(s_cond_var_t& right) = delete;
+//	s_cond_var_t& operator = (s_cond_var_t& right) = delete;
+//
+//	void wait();
+//	void wait_for();
+//
+//	void notify();
+//	void notify_all();
+};
+
+class slw_mutex_t
+{
+
+};
+
+class slw_recursive_mutex_t
+{
+
+};
+
+class slw_shared_mutex_t
+{
+
+};
+
 class waiter_map_t
 {
 	// TODO: optimize (use custom lightweight readers-writer lock)
@@ -88,34 +130,43 @@ class waiter_map_t
 
 	struct waiter_reg_t
 	{
+		NamedThreadBase* thread;
 		const u64 signal_id;
-		NamedThreadBase* const thread;
 		waiter_map_t& map;
 
-		waiter_reg_t(waiter_map_t& map, u64 signal_id);
+		waiter_reg_t(waiter_map_t& map, u64 signal_id)
+			: thread(nullptr)
+			, signal_id(signal_id)
+			, map(map)
+		{
+		}
+
 		~waiter_reg_t();
+
+		void init();
 	};
 
 	bool is_stopped(u64 signal_id);
 
 public:
-	waiter_map_t(const char* name) : m_name(name) {}
+	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 wait_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)
+		// check condition or if emulator is stopped
+		while (!waiter_func() && !is_stopped(signal_id))
 		{
+			// initialize waiter (only first time)
+			waiter.init();
 			// wait for 1 ms or until signal arrived
 			waiter.thread->WaitForAnySignal(1);
-			if (is_stopped(signal_id)) break;
-			if (waiter_func()) break;
 		}
 	}