Merge pull request #271 from delroth/threading-stuff

Threading improvements: add Common::Flag and improve Common::Event

Source/Core/Common/Event.h

@@ -0,0 +1,76 @@
+// Copyright 2014 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+// Multithreaded event class. This allows waiting in a thread for an event to
+// be triggered in another thread. While waiting, the CPU will be available for
+// other tasks.
+// * Set(): triggers the event and wakes up the waiting thread.
+// * Wait(): waits for the event to be triggered.
+// * Reset(): tries to reset the event before the waiting thread sees it was
+//            triggered. Usually a bad idea.
+
+#pragma once
+
+#ifdef _WIN32
+#include <concrt.h>
+#endif
+
+#include "Common/Flag.h"
+#include "Common/StdConditionVariable.h"
+#include "Common/StdMutex.h"
+
+namespace Common {
+
+// Windows uses a specific implementation because std::condition_variable has
+// terrible performance for this kind of workload with MSVC++ 2013.
+#ifndef _WIN32
+class Event final
+{
+public:
+	void Set()
+	{
+		if (m_flag.TestAndSet())
+		{
+			std::lock_guard<std::mutex> lk(m_mutex);
+			m_condvar.notify_one();
+		}
+	}
+
+	void Wait()
+	{
+		if (m_flag.TestAndClear())
+			return;
+
+		std::unique_lock<std::mutex> lk(m_mutex);
+		m_condvar.wait(lk, [&]{ return m_flag.IsSet(); });
+		m_flag.Clear();
+	}
+
+	void Reset()
+	{
+		// no other action required, since wait loops on
+		// the predicate and any lingering signal will get
+		// cleared on the first iteration
+		m_flag.Clear();
+	}
+
+private:
+	Flag m_flag;
+	std::condition_variable m_condvar;
+	std::mutex m_mutex;
+};
+#else
+class Event final
+{
+public:
+	void Set() { m_event.set(); }
+	void Wait() { m_event.wait(); m_event.reset(); }
+	void Reset() { m_event.reset(); }
+
+private:
+	concurrency::event m_event;
+};
+#endif
+
+}  // namespace Common

Source/Core/Common/Flag.h

@@ -0,0 +1,66 @@
+// Copyright 2014 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+// Abstraction for a simple flag that can be toggled in a multithreaded way.
+//
+// Simple API:
+// * Set(bool = true): sets the Flag
+// * IsSet(): tests if the flag is set
+// * Clear(): clears the flag (equivalent to Set(false)).
+//
+// More advanced features:
+// * TestAndSet(bool = true): sets the flag to the given value. If a change was
+//                            needed (the flag did not already have this value)
+//                            the function returns true. Else, false.
+// * TestAndClear(): alias for TestAndSet(false).
+
+#pragma once
+
+#include <atomic>
+
+namespace Common {
+
+class Flag final
+{
+public:
+	// Declared as explicit since we do not want "= true" to work on a flag
+	// object - it should be made explicit that a flag is *not* a normal
+	// variable.
+	explicit Flag(bool initial_value = false) : m_val(initial_value) {}
+
+	void Set(bool val = true)
+	{
+		m_val.store(val);
+	}
+
+	void Clear()
+	{
+		Set(false);
+	}
+
+	bool IsSet() const
+	{
+		return m_val.load();
+	}
+
+	bool TestAndSet(bool val = true)
+	{
+		bool expected = !val;
+		return m_val.compare_exchange_strong(expected, val);
+	}
+
+	bool TestAndClear()
+	{
+		return TestAndSet(false);
+	}
+
+private:
+	// We are not using std::atomic_bool here because MSVC sucks as of VC++
+	// 2013 and does not implement the std::atomic_bool(bool) constructor.
+	//
+	// Re-evaluate next time we upgrade that piece of shit.
+	std::atomic<bool> m_val;
+};
+
+}  // namespace Common

Source/Core/Common/Thread.h

@@ -32,45 +32,6 @@ int CurrentThreadId();
 void SetThreadAffinity(std::thread::native_handle_type thread, u32 mask);
 void SetCurrentThreadAffinity(u32 mask);
 
-class Event
-{
-public:
-	Event()
-		: is_set(false)
-	{}
-
-	void Set()
-	{
-		std::lock_guard<std::mutex> lk(m_mutex);
-		if (!is_set)
-		{
-			is_set = true;
-			m_condvar.notify_one();
-		}
-	}
-
-	void Wait()
-	{
-		std::unique_lock<std::mutex> lk(m_mutex);
-		m_condvar.wait(lk, [&]{ return is_set; });
-		is_set = false;
-	}
-
-	void Reset()
-	{
-		std::unique_lock<std::mutex> lk(m_mutex);
-		// no other action required, since wait loops on
-		// the predicate and any lingering signal will get
-		// cleared on the first iteration
-		is_set = false;
-	}
-
-private:
-	volatile bool is_set;
-	std::condition_variable m_condvar;
-	std::mutex m_mutex;
-};
-
 // TODO: doesn't work on windows with (count > 2)
 class Barrier
 {