X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=includes%2FOSThreads.h;h=f5c434fc28029088fe2d296ff9c6182e68c7d041;hb=2da67673279cf015ccc84270f6fd7935f64261a6;hp=32429b5794ce7de58ca249b291e4293b1c3bc0dc;hpb=16ed3e3cd3ba05ae7222f8da2c80f8294540817d;p=ghc-hetmet.git

diff --git a/includes/OSThreads.h b/includes/OSThreads.h
index 32429b5..f5c434f 100644
--- a/includes/OSThreads.h
+++ b/includes/OSThreads.h
@@ -16,13 +16,14 @@
 
 #if CMINUSMINUS
 
-#define ACQUIRE_LOCK(mutex) pthread_mutex_lock(mutex)
-#define RELEASE_LOCK(mutex) pthread_mutex_unlock(mutex)
+#define ACQUIRE_LOCK(mutex) foreign "C" pthread_mutex_lock(mutex)
+#define RELEASE_LOCK(mutex) foreign "C" pthread_mutex_unlock(mutex)
 #define ASSERT_LOCK_HELD(mutex) /* nothing */
 
 #else
 
 #include <pthread.h>
+#include <errno.h>
 
 typedef pthread_cond_t  Condition;
 typedef pthread_mutex_t Mutex;
@@ -34,51 +35,47 @@ typedef pthread_key_t   ThreadLocalKey;
 #define INIT_COND_VAR       PTHREAD_COND_INITIALIZER
 
 #ifdef LOCK_DEBUG
+#define LOCK_DEBUG_BELCH(what, mutex) \
+  debugBelch("%s(0x%p) %s %d\n", what, mutex, __FILE__, __LINE__)
+#else
+#define LOCK_DEBUG_BELCH(what, mutex) /* nothing */
+#endif
 
+/* Always check the result of lock and unlock. */
 #define ACQUIRE_LOCK(mutex) \
-  debugBelch("ACQUIRE_LOCK(0x%p) %s %d\n", mutex,__FILE__,__LINE__); \
-  pthread_mutex_lock(mutex)
-#define RELEASE_LOCK(mutex) \
-  debugBelch("RELEASE_LOCK(0x%p) %s %d\n", mutex,__FILE__,__LINE__); \
-  pthread_mutex_unlock(mutex)
-#define ASSERT_LOCK_HELD(mutex) /* nothing */
-
-#elif defined(DEBUG) && defined(linux_HOST_OS)
-#include <errno.h>
-/* 
- * On Linux, we can use extensions to determine whether we already
- * hold a lock or not, which is useful for debugging.
- */
-#define ACQUIRE_LOCK(mutex) \
+  LOCK_DEBUG_BELCH("ACQUIRE_LOCK", mutex); \
   if (pthread_mutex_lock(mutex) == EDEADLK) { \
     barf("multiple ACQUIRE_LOCK: %s %d", __FILE__,__LINE__); \
   }
+
 #define RELEASE_LOCK(mutex) \
+  LOCK_DEBUG_BELCH("RELEASE_LOCK", mutex); \
   if (pthread_mutex_unlock(mutex) != 0) { \
     barf("RELEASE_LOCK: I do not own this lock: %s %d", __FILE__,__LINE__); \
   }
 
+// Note: this assertion calls pthread_mutex_lock() on a mutex that
+// is already held by the calling thread.  The mutex should therefore
+// have been created with PTHREAD_MUTEX_ERRORCHECK, otherwise this
+// assertion will hang.  We always initialise mutexes with
+// PTHREAD_MUTEX_ERRORCHECK when DEBUG is on (see rts/posix/OSThreads.h).
 #define ASSERT_LOCK_HELD(mutex) ASSERT(pthread_mutex_lock(mutex) == EDEADLK)
 
-#define ASSERT_LOCK_NOTHELD(mutex)		\
-  if (pthread_mutex_lock(mutex) != EDEADLK) {	\
-     pthread_mutex_unlock(mutex);		\
-  } else {					\
-    ASSERT(0);					\
-  }
+#endif // CMINUSMINUS
 
+# elif defined(HAVE_WINDOWS_H)
 
-#else
+#if CMINUSMINUS
 
-#define ACQUIRE_LOCK(mutex) pthread_mutex_lock(mutex)
-#define RELEASE_LOCK(mutex) pthread_mutex_unlock(mutex)
-#define ASSERT_LOCK_HELD(mutex) /* nothing */
+/* We jump through a hoop here to get a CCall EnterCriticalSection
+   and LeaveCriticalSection, as that's what C-- wants. */
 
-#endif
+#define ACQUIRE_LOCK(mutex) foreign "stdcall" EnterCriticalSection(mutex)
+#define RELEASE_LOCK(mutex) foreign "stdcall" LeaveCriticalSection(mutex)
+#define ASSERT_LOCK_HELD(mutex) /* nothing */
 
-#endif // CMINUSMINUS
+#else
 
-# elif defined(HAVE_WINDOWS_H)
 #include <windows.h>
 
 typedef HANDLE Condition;
@@ -143,6 +140,8 @@ typedef HANDLE Mutex;
 #define ASSERT_LOCK_HELD(mutex) /* nothing */
 #endif
 
+#endif // CMINUSMINUS
+
 # else
 #  error "Threads not supported"
 # endif
@@ -186,6 +185,9 @@ void *getThreadLocalVar (ThreadLocalKey *key);
 void  setThreadLocalVar (ThreadLocalKey *key, void *value);
 void  freeThreadLocalKey (ThreadLocalKey *key);
 
+// Processors and affinity
+nat  getNumberOfProcessors (void);
+void setThreadAffinity     (nat n, nat m);
 #endif // !CMINUSMINUS
 
 #else