ghc/includes/OSThreads.h

   1 /* ---------------------------------------------------------------------------
   2  *
   3  * (c) The GHC Team, 2001
   4  *
   5  * Accessing OS threads functionality in a (mostly) OS-independent
   6  * manner.
   7  *
   8  * --------------------------------------------------------------------------*/
   9
  10 #ifndef __OSTHREADS_H__
  11 #define __OSTHREADS_H__
  12
  13 #if defined(THREADED_RTS) /* to the end */
  14
  15 # if defined(HAVE_PTHREAD_H) && !defined(WANT_NATIVE_WIN32_THREADS)
  16
  17 #include <pthread.h>
  18
  19 typedef pthread_cond_t  Condition;
  20 typedef pthread_mutex_t Mutex;
  21 typedef pthread_t       OSThreadId;
  22 typedef pthread_key_t   ThreadLocalKey;
  23
  24 #define OSThreadProcAttr /* nothing */
  25
  26 #define INIT_MUTEX_VAR      PTHREAD_MUTEX_INITIALIZER
  27 #define INIT_COND_VAR       PTHREAD_COND_INITIALIZER
  28
  29 #ifdef LOCK_DEBUG
  30
  31 #define ACQUIRE_LOCK(mutex) \
  32   debugBelch("ACQUIRE_LOCK(0x%p) %s %d\n", mutex,__FILE__,__LINE__); \
  33   pthread_mutex_lock(mutex)
  34 #define RELEASE_LOCK(mutex) \
  35   debugBelch("RELEASE_LOCK(0x%p) %s %d\n", mutex,__FILE__,__LINE__); \
  36   pthread_mutex_unlock(mutex)
  37 #define ASSERT_LOCK_HELD(mutex) /* nothing */
  38
  39 #elif defined(DEBUG) && defined(linux_HOST_OS)
  40 #include <errno.h>
  41 /*
  42  * On Linux, we can use extensions to determine whether we already
  43  * hold a lock or not, which is useful for debugging.
  44  */
  45 #define ACQUIRE_LOCK(mutex) \
  46   if (pthread_mutex_lock(mutex) == EDEADLK) { \
  47     barf("multiple ACQUIRE_LOCK: %s %d", __FILE__,__LINE__); \
  48   }
  49 #define RELEASE_LOCK(mutex) \
  50   if (pthread_mutex_unlock(mutex) != 0) { \
  51     barf("RELEASE_LOCK: I do not own this lock: %s %d", __FILE__,__LINE__); \
  52   }
  53
  54 #define ASSERT_LOCK_HELD(mutex) ASSERT(pthread_mutex_lock(mutex) == EDEADLK)
  55
  56 #define ASSERT_LOCK_NOTHELD(mutex)              \
  57   if (pthread_mutex_lock(mutex) != EDEADLK) {   \
  58      pthread_mutex_unlock(mutex);               \
  59   } else {                                      \
  60     ASSERT(0);                                  \
  61   }
  62
  63
  64 #else
  65
  66 #define ACQUIRE_LOCK(mutex) pthread_mutex_lock(mutex)
  67 #define RELEASE_LOCK(mutex) pthread_mutex_unlock(mutex)
  68 #define ASSERT_LOCK_HELD(mutex) /* nothing */
  69
  70 #endif
  71
  72 # elif defined(HAVE_WINDOWS_H)
  73 #include <windows.h>
  74
  75 typedef HANDLE Condition;
  76 typedef HANDLE Mutex;
  77 typedef DWORD OSThreadId;
  78 typedef DWORD ThreadLocalKey;
  79
  80 #define OSThreadProcAttr __stdcall
  81
  82 #define INIT_MUTEX_VAR 0
  83 #define INIT_COND_VAR  0
  84
  85 INLINE_HEADER void
  86 ACQUIRE_LOCK(Mutex *mutex)
  87 {
  88     if (WaitForSingleObject(*mutex,INFINITE) == WAIT_FAILED) {
  89         barf("WaitForSingleObject: %d", GetLastError());
  90     }
  91 }
  92
  93 INLINE_HEADER void
  94 RELEASE_LOCK(Mutex *mutex)
  95 {
  96     if (ReleaseMutex(*mutex) == 0) {
  97         barf("ReleaseMutex: %d", GetLastError());
  98     }
  99 }
 100
 101 #define ASSERT_LOCK_HELD(mutex) /* nothing */
 102
 103 # else
 104 #  error "Threads not supported"
 105 # endif
 106
 107 //
 108 // General thread operations
 109 //
 110 extern OSThreadId osThreadId      ( void );
 111 extern void shutdownThread        ( void );
 112 extern void yieldThread           ( void );
 113
 114 typedef void OSThreadProcAttr OSThreadProc(void *);
 115
 116 extern int  createOSThread        ( OSThreadId* tid,
 117                                     OSThreadProc *startProc, void *param);
 118
 119 //
 120 // Condition Variables
 121 //
 122 extern void initCondition         ( Condition* pCond );
 123 extern void closeCondition        ( Condition* pCond );
 124 extern rtsBool broadcastCondition ( Condition* pCond );
 125 extern rtsBool signalCondition    ( Condition* pCond );
 126 extern rtsBool waitCondition      ( Condition* pCond,
 127                                     Mutex* pMut );
 128
 129 //
 130 // Mutexes
 131 //
 132 extern void initMutex             ( Mutex* pMut );
 133
 134 //
 135 // Thread-local storage
 136 //
 137 void  newThreadLocalKey (ThreadLocalKey *key);
 138 void *getThreadLocalVar (ThreadLocalKey *key);
 139 void  setThreadLocalVar (ThreadLocalKey *key, void *value);
 140
 141 #else
 142
 143 #define ACQUIRE_LOCK(l)
 144 #define RELEASE_LOCK(l)
 145 #define ASSERT_LOCK_HELD(l)
 146
 147 #endif /* defined(RTS_SUPPORTS_THREADS) */
 148
 149 #endif /* __OSTHREADS_H__ */