The rest

Utilities/sync.h

@@ -0,0 +1,192 @@
+#pragma once
+
+/* For internal use. Don't include. */
+
+#include "types.h"
+#include "Macro.h"
+#include "Atomic.h"
+
+#ifdef _WIN32
+
+#include <Windows.h>
+
+#define DYNAMIC_IMPORT(handle, name) do { name = reinterpret_cast<decltype(name)>(GetProcAddress(handle, #name)); } while (0)
+
+static NTSTATUS(*NtSetTimerResolution)(ULONG DesiredResolution, BOOLEAN SetResolution, PULONG CurrentResolution);
+static NTSTATUS(*NtWaitForKeyedEvent)(HANDLE Handle, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout);
+static NTSTATUS(*NtReleaseKeyedEvent)(HANDLE Handle, PVOID Key, BOOLEAN Alertable, PLARGE_INTEGER Timeout);
+
+namespace util
+{
+	static const bool keyed_init = []
+	{
+		const auto handle = LoadLibraryA("ntdll.dll");
+		DYNAMIC_IMPORT(handle, NtSetTimerResolution);
+		DYNAMIC_IMPORT(handle, NtWaitForKeyedEvent);
+		DYNAMIC_IMPORT(handle, NtReleaseKeyedEvent);
+		FreeLibrary(handle);
+
+		ULONG res = 100;
+		NtSetTimerResolution(100, TRUE, &res);
+
+		return NtWaitForKeyedEvent && NtReleaseKeyedEvent;
+	}();
+
+	// Wait for specified condition. func() acknowledges success by value modification.
+	template<typename F>
+	inline void keyed_wait(atomic_t<u32>& key, F&& func)
+	{
+		while (true)
+		{
+			NtWaitForKeyedEvent(NULL, &key, FALSE, NULL);
+
+			u32 read = key.load();
+			u32 copy = read;
+
+			while (pred(read), read != copy)
+			{
+				read = key.compare_and_swap(copy, read);
+				
+				if (copy == read)
+				{
+					break;
+				}
+				
+				copy = read;
+			}
+		}
+	}
+
+	// Try to wake up a thread.
+	inline bool keyed_post(atomic_t<u32>& key, u32 acknowledged_value)
+	{
+		LARGE_INTEGER zero;
+		zero.QuadPart = 0;
+
+		while (UNLIKELY(NtReleaseKeyedEvent(NULL, &key, FALSE, &zero) == WAIT_TIMEOUT))
+		{
+			if (key.load() != acknowledged_value)
+				return false;
+
+			//NtReleaseKeyedEvent(NULL, &key, FALSE, NULL);
+			//return true;
+		}
+
+		return true;
+	}
+
+	struct native_rwlock
+	{
+		SRWLOCK rwlock = SRWLOCK_INIT;
+
+		constexpr native_rwlock() = default;
+
+		native_rwlock(const native_rwlock&) = delete;
+
+		void lock()
+		{
+			AcquireSRWLockExclusive(&rwlock);
+		}
+
+		bool try_lock()
+		{
+			return TryAcquireSRWLockExclusive(&rwlock) != 0;
+		}
+
+		void unlock()
+		{
+			ReleaseSRWLockExclusive(&rwlock);
+		}
+
+		void lock_shared()
+		{
+			AcquireSRWLockShared(&rwlock);
+		}
+
+		bool try_lock_shared()
+		{
+			return TryAcquireSRWLockShared(&rwlock) != 0;
+		}
+
+		void unlock_shared()
+		{
+			ReleaseSRWLockShared(&rwlock);
+		}
+	};
+
+	struct native_cond
+	{
+		CONDITION_VARIABLE cond = CONDITION_VARIABLE_INIT;
+
+		constexpr native_cond() = default;
+
+		native_cond(const native_cond&) = delete;
+
+		void notify_one()
+		{
+			WakeConditionVariable(&cond);
+		}
+
+		void notify_all()
+		{
+			WakeAllConditionVariable(&cond);
+		}
+
+		void wait(native_rwlock& rwlock)
+		{
+			SleepConditionVariableSRW(&cond, &rwlock.rwlock, INFINITE, 0);
+		}
+
+		void wait_shared(native_rwlock& rwlock)
+		{
+			SleepConditionVariableSRW(&cond, &rwlock.rwlock, INFINITE, CONDITION_VARIABLE_LOCKMODE_SHARED);
+		}
+	};
+
+	class exclusive_lock
+	{
+		native_rwlock& m_rwlock;
+
+	public:
+		exclusive_lock(native_rwlock& rwlock)
+			: m_rwlock(rwlock)
+		{
+			m_rwlock.lock();
+		}
+
+		~exclusive_lock()
+		{
+			m_rwlock.unlock();
+		}
+	};
+
+	class shared_lock
+	{
+		native_rwlock& m_rwlock;
+
+	public:
+		shared_lock(native_rwlock& rwlock)
+			: m_rwlock(rwlock)
+		{
+			m_rwlock.lock_shared();
+		}
+
+		~shared_lock()
+		{
+			m_rwlock.unlock_shared();
+		}
+	};
+}
+
+#else
+
+namespace util
+{
+	struct native_rwlock;
+	struct native_cond;
+}
+
+#endif
+
+CHECK_SIZE_ALIGN(util::native_rwlock, sizeof(void*), alignof(void*));
+CHECK_SIZE_ALIGN(util::native_cond, sizeof(void*), alignof(void*));