rts/posix/OSThreads.c

   1 /* ---------------------------------------------------------------------------
   2  *
   3  * (c) The GHC Team, 2001-2005
   4  *
   5  * Accessing OS threads functionality in a (mostly) OS-independent
   6  * manner.
   7  *
   8  * --------------------------------------------------------------------------*/
   9
  10 #if defined(__linux__)
  11 /* We want GNU extensions in DEBUG mode for mutex error checking */
  12 /* We also want the affinity API, which requires _GNU_SOURCE */
  13 #define _GNU_SOURCE
  14 #endif
  15
  16 #include "PosixSource.h"
  17
  18 #if defined(freebsd_HOST_OS)
  19 /* Inclusion of system headers usually requires __BSD_VISIBLE on FreeBSD,
  20  * because of some specific types, like u_char, u_int, etc. */
  21 #define __BSD_VISIBLE   1
  22 #endif
  23
  24 #include "Rts.h"
  25
  26 #if defined(THREADED_RTS)
  27 #include "RtsUtils.h"
  28 #include "Task.h"
  29
  30 #if HAVE_STRING_H
  31 #include <string.h>
  32 #endif
  33
  34 #if defined(darwin_HOST_OS) || defined(freebsd_HOST_OS)
  35 #include <sys/types.h>
  36 #include <sys/sysctl.h>
  37 #endif
  38
  39 #if !defined(HAVE_PTHREAD_H)
  40 #error pthreads.h is required for the threaded RTS on Posix platforms
  41 #endif
  42
  43 #if defined(HAVE_SCHED_H)
  44 #include <sched.h>
  45 #endif
  46
  47 #if defined(HAVE_SYS_CPUSET_H)
  48 #include <sys/param.h>
  49 #include <sys/cpuset.h>
  50 #endif
  51
  52 #ifdef HAVE_UNISTD_H
  53 #include <unistd.h>
  54 #endif
  55
  56 #if defined(darwin_HOST_OS)
  57 #include <mach/mach.h>
  58 #endif
  59
  60 #ifdef HAVE_SIGNAL_H
  61 # include <signal.h>
  62 #endif
  63
  64 /*
  65  * This (allegedly) OS threads independent layer was initially
  66  * abstracted away from code that used Pthreads, so the functions
  67  * provided here are mostly just wrappers to the Pthreads API.
  68  *
  69  */
  70
  71 void
  72 initCondition( Condition* pCond )
  73 {
  74   pthread_cond_init(pCond, NULL);
  75   return;
  76 }
  77
  78 void
  79 closeCondition( Condition* pCond )
  80 {
  81   pthread_cond_destroy(pCond);
  82   return;
  83 }
  84
  85 rtsBool
  86 broadcastCondition ( Condition* pCond )
  87 {
  88   return (pthread_cond_broadcast(pCond) == 0);
  89 }
  90
  91 rtsBool
  92 signalCondition ( Condition* pCond )
  93 {
  94   return (pthread_cond_signal(pCond) == 0);
  95 }
  96
  97 rtsBool
  98 waitCondition ( Condition* pCond, Mutex* pMut )
  99 {
 100   return (pthread_cond_wait(pCond,pMut) == 0);
 101 }
 102
 103 void
 104 yieldThread()
 105 {
 106   sched_yield();
 107   return;
 108 }
 109
 110 void
 111 shutdownThread()
 112 {
 113   pthread_exit(NULL);
 114 }
 115
 116 int
 117 createOSThread (OSThreadId* pId, OSThreadProc *startProc, void *param)
 118 {
 119   int result = pthread_create(pId, NULL, (void *(*)(void *))startProc, param);
 120   if(!result)
 121     pthread_detach(*pId);
 122   return result;
 123 }
 124
 125 OSThreadId
 126 osThreadId()
 127 {
 128   return pthread_self();
 129 }
 130
 131 rtsBool
 132 osThreadIsAlive(OSThreadId id STG_UNUSED)
 133 {
 134     // no good way to implement this on POSIX, AFAICT.  Returning true
 135     // is safe.
 136     return rtsTrue;
 137 }
 138
 139 void
 140 initMutex(Mutex* pMut)
 141 {
 142 #if defined(DEBUG)
 143     pthread_mutexattr_t attr;
 144     pthread_mutexattr_init(&attr);
 145     pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK);
 146     pthread_mutex_init(pMut,&attr);
 147 #else
 148     pthread_mutex_init(pMut,NULL);
 149 #endif
 150     return;
 151 }
 152 void
 153 closeMutex(Mutex* pMut)
 154 {
 155     pthread_mutex_destroy(pMut);
 156 }
 157
 158 void
 159 newThreadLocalKey (ThreadLocalKey *key)
 160 {
 161     int r;
 162     if ((r = pthread_key_create(key, NULL)) != 0) {
 163         barf("newThreadLocalKey: %s", strerror(r));
 164     }
 165 }
 166
 167 void *
 168 getThreadLocalVar (ThreadLocalKey *key)
 169 {
 170     return pthread_getspecific(*key);
 171     // Note: a return value of NULL can indicate that either the key
 172     // is not valid, or the key is valid and the data value has not
 173     // yet been set.  We need to use the latter case, so we cannot
 174     // detect errors here.
 175 }
 176
 177 void
 178 setThreadLocalVar (ThreadLocalKey *key, void *value)
 179 {
 180     int r;
 181     if ((r = pthread_setspecific(*key,value)) != 0) {
 182         barf("setThreadLocalVar: %s", strerror(r));
 183     }
 184 }
 185
 186 void
 187 freeThreadLocalKey (ThreadLocalKey *key)
 188 {
 189     int r;
 190     if ((r = pthread_key_delete(*key)) != 0) {
 191         barf("freeThreadLocalKey: %s", strerror(r));
 192     }
 193 }
 194
 195 static void *
 196 forkOS_createThreadWrapper ( void * entry )
 197 {
 198     Capability *cap;
 199     cap = rts_lock();
 200     cap = rts_evalStableIO(cap, (HsStablePtr) entry, NULL);
 201     taskTimeStamp(myTask());
 202     rts_unlock(cap);
 203     return NULL;
 204 }
 205
 206 int
 207 forkOS_createThread ( HsStablePtr entry )
 208 {
 209     pthread_t tid;
 210     int result = pthread_create(&tid, NULL,
 211                                 forkOS_createThreadWrapper, (void*)entry);
 212     if(!result)
 213         pthread_detach(tid);
 214     return result;
 215 }
 216
 217 nat
 218 getNumberOfProcessors (void)
 219 {
 220     static nat nproc = 0;
 221
 222     if (nproc == 0) {
 223 #if defined(HAVE_SYSCONF) && defined(_SC_NPROCESSORS_ONLN)
 224         nproc = sysconf(_SC_NPROCESSORS_ONLN);
 225 #elif defined(HAVE_SYSCONF) && defined(_SC_NPROCESSORS_CONF)
 226         nproc = sysconf(_SC_NPROCESSORS_CONF);
 227 #elif defined(darwin_HOST_OS) || defined(freebsd_HOST_OS)
 228         size_t size = sizeof(nat);
 229         if(0 != sysctlbyname("hw.ncpu",&nproc,&size,NULL,0))
 230             nproc = 1;
 231 #else
 232         nproc = 1;
 233 #endif
 234     }
 235
 236     return nproc;
 237 }
 238
 239 #if defined(HAVE_SCHED_H) && defined(HAVE_SCHED_SETAFFINITY)
 240 // Schedules the thread to run on CPU n of m.  m may be less than the
 241 // number of physical CPUs, in which case, the thread will be allowed
 242 // to run on CPU n, n+m, n+2m etc.
 243 void
 244 setThreadAffinity (nat n, nat m)
 245 {
 246     nat nproc;
 247     cpu_set_t cs;
 248     nat i;
 249
 250     nproc = getNumberOfProcessors();
 251     CPU_ZERO(&cs);
 252     for (i = n; i < nproc; i+=m) {
 253         CPU_SET(i, &cs);
 254     }
 255     sched_setaffinity(0, sizeof(cpu_set_t), &cs);
 256 }
 257
 258 #elif defined(darwin_HOST_OS) && defined(THREAD_AFFINITY_POLICY)
 259 // Schedules the current thread in the affinity set identified by tag n.
 260 void
 261 setThreadAffinity (nat n, nat m GNUC3_ATTRIBUTE(__unused__))
 262 {
 263     thread_affinity_policy_data_t policy;
 264
 265     policy.affinity_tag = n;
 266     thread_policy_set(mach_thread_self(),
 267                       THREAD_AFFINITY_POLICY,
 268                       (thread_policy_t) &policy,
 269                       THREAD_AFFINITY_POLICY_COUNT);
 270 }
 271
 272 #elif defined(HAVE_SYS_CPUSET_H) /* FreeBSD 7.1+ */
 273 void
 274 setThreadAffinity(nat n, nat m)
 275 {
 276         nat nproc;
 277         cpuset_t cs;
 278         nat i;
 279
 280         nproc = getNumberOfProcessors();
 281         CPU_ZERO(&cs);
 282
 283         for (i = n; i < nproc; i += m)
 284                 CPU_SET(i, &cs);
 285
 286         cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(cpuset_t), &cs);
 287 }
 288
 289 #else
 290 void
 291 setThreadAffinity (nat n GNUC3_ATTRIBUTE(__unused__),
 292                    nat m GNUC3_ATTRIBUTE(__unused__))
 293 {
 294 }
 295 #endif
 296
 297 void
 298 interruptOSThread (OSThreadId id)
 299 {
 300     pthread_kill(id, SIGPIPE);
 301 }
 302
 303 #else /* !defined(THREADED_RTS) */
 304
 305 int
 306 forkOS_createThread ( HsStablePtr entry STG_UNUSED )
 307 {
 308     return -1;
 309 }
 310
 311 #endif /* !defined(THREADED_RTS) */