utils: Different lock initialisation for Windows

Rewrite code to initialise mutexes in Windows.
To allow static initialisation of mutex MCS locks were used.
However the implementation required potentially (in case of
contention) resource usages (Windows events) and more system
calls.

As before is there are no contention no system calls are
needed (except InitializeCriticalSection).

Advantages:
- reduced code;
- reduced tds_raw_mutex structure size;
- no allocation needed;
- less atomic operations needed in case of no contention.

Disadvantages:
- for systems till Vista on contention polling is used; however
  there should not be much contention anyway and there should be
  very few use cases of such old systems.

Signed-off-by: Frediano Ziglio <freddy77@gmail.com>

Author: freddy77

README.Windows

@@ -14,7 +14,7 @@ These instructions should suffice in order to set up any project file you need.
 2. Every library have a proper directory where you can include every C file you find
 inside (not recursively)
 
-  * replacements here there is an exception, do not include ptw32_MCS_lock.c file
+  * replacements
   * tds
   * dblib
   * ctlib

include/freetds/thread.h

@@ -128,49 +128,46 @@ static inline int tds_thread_is_current(tds_thread_id th)
 #define ETIMEDOUT 138
 #endif
 
-struct ptw32_mcs_node_t_;
-
-typedef struct {
-	struct ptw32_mcs_node_t_ *lock;
+typedef struct
+{
 	LONG done;
 	DWORD thread_id;
 	CRITICAL_SECTION crit;
 } tds_raw_mutex;
 
-#define TDS_RAW_MUTEX_INITIALIZER { NULL, 0, 0 }
+#define TDS_RAW_MUTEX_INITIALIZER { 0, 0 }
 
 static inline int
 tds_raw_mutex_init(tds_raw_mutex *mtx)
 {
-	mtx->lock = NULL;
 	mtx->done = 0;
 	mtx->thread_id = 0;
 	return 0;
 }
 
-void tds_win_mutex_lock(tds_raw_mutex *mutex);
+void tds_win_mutex_init(tds_raw_mutex * mutex);
 
-static inline void tds_raw_mutex_lock(tds_raw_mutex *mtx)
+static inline void
+tds_raw_mutex_lock(tds_raw_mutex *mtx)
 {
-	if (mtx->done) {
-		EnterCriticalSection(&mtx->crit);
-		mtx->thread_id = GetCurrentThreadId();
-	} else {
-		tds_win_mutex_lock(mtx);
-	}
+	if (mtx->done >= 0)
+		tds_win_mutex_init(mtx);
+	EnterCriticalSection(&mtx->crit);
+	mtx->thread_id = GetCurrentThreadId();
 }
 
-int tds_raw_mutex_trylock(tds_raw_mutex *mtx);
+int tds_raw_mutex_trylock(tds_raw_mutex * mtx);
 
 static inline void tds_raw_mutex_unlock(tds_raw_mutex *mtx)
 {
 	mtx->thread_id = 0;
 	LeaveCriticalSection(&mtx->crit);
 }
 
-static inline void tds_raw_mutex_free(tds_raw_mutex *mtx)
+static inline void
+tds_raw_mutex_free(tds_raw_mutex *mtx)
 {
-	if (mtx->done) {
+	if (mtx->done < 0) {
 		DeleteCriticalSection(&mtx->crit);
 		mtx->done = 0;
 	}

src/utils/Makefile.am

@@ -25,5 +25,4 @@ libtdsutils_la_SOURCES += win_mutex.c
 endif
 EXTRA_DIST = \
 	CMakeLists.txt \
-	ptw32_MCS_lock.c \
 	$(NULL)

src/utils/ptw32_MCS_lock.c

@@ -29,41 +29,72 @@
 #include <string.h>
 #endif /* HAVE_STRING_H */
 
+#include <limits.h>
+
 #include <freetds/windows.h>
+#include <freetds/macros.h>
 #include <freetds/thread.h>
+#include <freetds/bool.h>
+
+typedef BOOL WINAPI WaitOnAddressFunc(volatile VOID * Address, PVOID CompareAddress, SIZE_T AddressSize, DWORD dwMilliseconds);
+typedef VOID WINAPI WakeByAddressAllFunc(PVOID Address);
+
+static WaitOnAddressFunc *pWaitOnAddress = NULL;
+static WakeByAddressAllFunc *pWakeByAddressAll = NULL;
 
-#include "ptw32_MCS_lock.c"
+static bool wait_funcs_initialized = false;
 
 void
-tds_win_mutex_lock(tds_raw_mutex * mutex)
+tds_win_mutex_init(tds_raw_mutex *mutex)
 {
-	if (!InterlockedExchangeAdd(&mutex->done, 0)) {	/* MBR fence */
-		ptw32_mcs_local_node_t node;
+	long l;
 
-		ptw32_mcs_lock_acquire(&mutex->lock, &node);
-		if (!mutex->done) {
-			InitializeCriticalSection(&mutex->crit);
-			mutex->done = 1;
+	/* Get functions we need.
+	 * Potentially executed multiple times if called at the same time from
+	 * multiple threads but will do the same things.
+	 */
+	if (TDS_UNLIKELY(!wait_funcs_initialized)) {
+		HANDLE mod = GetModuleHandle("API-MS-Win-Core-Synch-l1-2-0.dll");
+
+		if (mod) {
+			pWaitOnAddress = (WaitOnAddressFunc *) GetProcAddress(mod, "WaitOnAddress");
+			pWakeByAddressAll = (WakeByAddressAllFunc *) GetProcAddress(mod, "WakeByAddressAll");
 		}
-		ptw32_mcs_lock_release(&node);
+		wait_funcs_initialized = true;
+	}
+
+	/* Count number of initializers. */
+	l = _InterlockedIncrement(&mutex->done) - 1;
+
+	/* If not initialized do it. */
+	if (l == 0) {
+		InitializeCriticalSection(&mutex->crit);
+		l = _InterlockedExchange(&mutex->done, LONG_MIN);
+		/* Notify other threads (only if there are any). */
+		if (l != 1 && pWakeByAddressAll)
+			pWakeByAddressAll((void *) &mutex->done);
+		return;
+	}
+
+	/* In the unlikely case multiple threads need to initialize the structure
+	 * at the same time wait till the other thread initialize it. */
+	while (l >= 0) {
+		if (pWaitOnAddress)
+			/* From Windows 8, wait variable change. */
+			pWaitOnAddress(&mutex->done, &l, sizeof(l), INFINITE);
+		else
+			/* Older versions, poll. Pretty unlikely anyways. */
+			Sleep(0);
+		l = mutex->done;
 	}
-	EnterCriticalSection(&mutex->crit);
-	mutex->thread_id = GetCurrentThreadId();
 }
 
 int
-tds_raw_mutex_trylock(tds_raw_mutex * mutex)
+tds_raw_mutex_trylock(tds_raw_mutex *mutex)
 {
-	if (!mutex->done && !InterlockedExchangeAdd(&mutex->done, 0)) {	/* MBR fence */
-		ptw32_mcs_local_node_t node;
+	if (mutex->done >= 0)
+		tds_win_mutex_init(mutex);
 
-		ptw32_mcs_lock_acquire(&mutex->lock, &node);
-		if (!mutex->done) {
-			InitializeCriticalSection(&mutex->crit);
-			mutex->done = 1;
-		}
-		ptw32_mcs_lock_release(&node);
-	}
 	if (TryEnterCriticalSection(&mutex->crit)) {
 		DWORD thread_id = GetCurrentThreadId();
 		if (mutex->thread_id == thread_id) {