PATCH: Improve performance of gthr-win32

[Wu Yongwei <adah at sh163 dot net>]

This is my attempt to solve the performance overhead of __gthread_mutex
functions.  On Win32, in order to support __gthread_mutex_trylock,
currently MUTEXs instead of CRITICAL_SECTIONs are used to represent the
__gthread_mutex_t, but MUTEXs are far slower.  According to my own
measurement, the overhead is about 60:1.

When my first attempt to address this problem by implementing
TryEnterCriticalSection on Windows 9x failed, Thomas Pfaff showed
another way:

http://article.gmane.org/gmane.comp.gnu.mingw.devel/803

And I have finally done this.  Please have a check.  There are the
patch, two test files, and my test log.  The only drawback is that it
requires Windows 98 or later, and Windows NT 4 or later.  I do not think
it a problem, but I am willing to write another patch to solve the
problem using inline assembly if people here insist that Windows 95 is
important.

Best regards,

Wu Yongwei

Index: gcc/gthr-win32.h
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/gthr-win32.h,v
retrieving revision 1.21
diff -u -r1.21 gthr-win32.h
--- gcc/gthr-win32.h	21 May 2003 22:16:03 -0000	1.21
+++ gcc/gthr-win32.h	14 Mar 2004 13:03:57 -0000
@@ -54,10 +54,9 @@
       This may cause incorrect error return due to truncation values on
       hw where sizeof (DWORD) > sizeof (int).
 
-   3. We might consider using Critical Sections instead of Windows32
-      mutexes for better performance, but emulating __gthread_mutex_trylock
-      interface becomes more complicated (Win9x does not support
-      TryEnterCriticalSectioni, while NT does).
+   3. We are currently using a special mutex instead of the Critical
+      Sections, since Win9x does not support TryEnterCriticalSection
+      (while NT does).
 
    The basic framework should work well enough. In the long term, GCC
    needs to use Structured Exception Handling on Windows32.  */
@@ -332,6 +331,11 @@
 extern "C" {
 #endif
 
+#ifndef _WINDOWS_H
+typedef long LONG;
+typedef void *HANDLE;
+#endif
+
 typedef unsigned long __gthread_key_t;
 
 typedef struct {
@@ -339,7 +343,10 @@
   long started;
 } __gthread_once_t;
 
-typedef void* __gthread_mutex_t;
+typedef struct {
+  LONG counter;
+  HANDLE sema;
+} __gthread_mutex_t;
 
 #define __GTHREAD_ONCE_INIT {0, -1}
 #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
@@ -534,8 +541,8 @@
 static inline void
 __gthread_mutex_init_function (__gthread_mutex_t *mutex)
 {
-  /* Create unnamed mutex with default security attr and no initial owner.  */
-  *mutex = CreateMutex (NULL, 0, NULL);
+  mutex->counter = 0;
+  mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
 }
 
 static inline int
@@ -545,10 +552,16 @@
 
   if (__gthread_active_p ())
     {
-      if (WaitForSingleObject (*mutex, INFINITE) == WAIT_OBJECT_0)
+      if (InterlockedIncrement (&mutex->counter) == 1 ||
+	  WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
 	status = 0;
       else
-	status = 1;
+	{
+	  // WaitForSingleObject returns WAIT_FAILED, and we can only do
+	  // some best-effort cleanup here.
+	  InterlockedDecrement (&mutex->counter);
+	  status = 1;
+	}
     }
   return status;
 }
@@ -560,7 +573,7 @@
 
   if (__gthread_active_p ())
     {
-      if (WaitForSingleObject (*mutex, 0) == WAIT_OBJECT_0)
+      if (InterlockedCompareExchange (&mutex->counter, 1, 0 ) == 0)
 	status = 0;
       else
 	status = 1;
@@ -572,7 +585,10 @@
 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
 {
   if (__gthread_active_p ())
-    return (ReleaseMutex (*mutex) != 0) ? 0 : 1;
+    {
+      if (InterlockedDecrement (&mutex->counter))
+	return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
+    }
   else
     return 0;
 }
Index: gcc/config/i386/gthr-win32.c
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/config/i386/gthr-win32.c,v
retrieving revision 1.5
diff -u -r1.5 gthr-win32.c
--- gcc/config/i386/gthr-win32.c	31 Jan 2004 02:06:57 -0000	1.5
+++ gcc/config/i386/gthr-win32.c	14 Mar 2004 13:05:35 -0000
@@ -61,10 +61,9 @@
       This may cause incorrect error return due to truncation values on 
       hw where sizeof (DWORD) > sizeof (int).
    
-   3. We might consider using Critical Sections instead of Windows32 
-      mutexes for better performance, but emulating __gthread_mutex_trylock 
-      interface becomes more complicated (Win9x does not support
-      TryEnterCriticalSectioni, while NT does).
+   3. We are currently using a special mutex instead of the Critical
+      Sections, since Win9x does not support TryEnterCriticalSection
+      (while NT does).
   
    The basic framework should work well enough. In the long term, GCC
    needs to use Structured Exception Handling on Windows32.  */
@@ -145,23 +144,29 @@
 void
 __gthr_win32_mutex_init_function (__gthread_mutex_t *mutex)
 {
-  /* Create unnamed mutex with default security attr and no initial owner.  */ 
-  *mutex = CreateMutex (NULL, 0, NULL);
+  mutex->counter = 0;
+  mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
 }
 
 int
 __gthr_win32_mutex_lock (__gthread_mutex_t *mutex)
 {
-  if (WaitForSingleObject (*mutex, INFINITE) == WAIT_OBJECT_0)
+  if (InterlockedIncrement (&mutex->counter) == 1 ||
+      WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
     return 0;
   else
-    return 1;
+    {
+      // WaitForSingleObject returns WAIT_FAILED, and we can only do
+      // some best-effort cleanup here.
+      InterlockedDecrement (&mutex->counter);
+      return 1;
+    }
 }
 
 int
 __gthr_win32_mutex_trylock (__gthread_mutex_t *mutex)
 {
-  if (WaitForSingleObject (*mutex, 0) == WAIT_OBJECT_0)
+  if (InterlockedCompareExchange (&mutex->counter, 1, 0 ) == 0)
     return 0;
   else
     return 1;
@@ -170,5 +175,6 @@
 int
 __gthr_win32_mutex_unlock (__gthread_mutex_t *mutex)
 {
-    return (ReleaseMutex (*mutex) != 0) ? 0 : 1;
+  if (InterlockedDecrement (&mutex->counter))
+    return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
 }

#ifdef TEST_NEW_GTHR
#include <gthr-win32.h>
#else
#include <bits/gthr-default.h>
#endif
#include <iostream>
#include <windows.h>
#include <process.h>

__gthread_mutex_t mtx;

void mythread(void*)
{
	if (__gthread_mutex_trylock(&mtx) != 0) {
		Sleep(100);
		std::cout << "Cannot lock in mythread" << std::endl;
		__gthread_mutex_lock(&mtx);
	}
	std::cout << "Locked in mythread" << std::endl;
	Sleep(1000);
	__gthread_mutex_unlock(&mtx);
}

int main()
{
	__gthread_mutex_init_function(&mtx);
	_beginthread(mythread, 0, NULL);
//	Sleep(10);
	if (__gthread_mutex_trylock(&mtx) != 0) {
		Sleep(100);
		std::cout << "Cannot lock in main" << std::endl;
		__gthread_mutex_lock(&mtx);
	}
	std::cout << "Locked in main" << std::endl;
	Sleep(1000);
	__gthread_mutex_unlock(&mtx);
	Sleep(1000);
	return 0;
}

#ifdef TEST_NEW_GTHR
#include <gthr-win32.h>
#else
#include <bits/gthr-default.h>
#endif
#include <iostream>
#include <windows.h>
#include <time.h>

#define LOOPS 500000

using namespace std;

int main()
{
	clock_t t1, t2;

	CRITICAL_SECTION cs;
	InitializeCriticalSection(&cs);
	t1 = clock();
	for (int i = 0; i < LOOPS; ++i) {
		EnterCriticalSection(&cs);
		LeaveCriticalSection(&cs);
	}
	t2 = clock();
	DeleteCriticalSection(&cs);
	cout << t2 - t1 << " clocks elapsed" << endl;

	__gthread_mutex_t mtx;
	__GTHREAD_MUTEX_INIT_FUNCTION(&mtx);
	t1 = clock();
	for (int i = 0; i < LOOPS; ++i) {
		__gthread_mutex_lock(&mtx);
		__gthread_mutex_unlock(&mtx);
	}
	t2 = clock();
	cout << t2 - t1 << " clocks elapsed" << endl;
}

Attachment: test.log
Description: Text document