toolchain/gcc/libjava/include/posix-threads.h

   1 // -*- c++ -*-
   2 // posix-threads.h - Defines for using POSIX threads.
   3
   4 /* Copyright (C) 1998, 1999, 2001, 2003  Free Software Foundation
   5
   6    This file is part of libgcj.
   7
   8 This software is copyrighted work licensed under the terms of the
   9 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
  10 details.  */
  11
  12 #ifndef __JV_POSIX_THREADS__
  13 #define __JV_POSIX_THREADS__
  14
  15 // NOTE: This file may only reference those pthread functions which
  16 // are known not to be overridden by the Boehm GC.  If in doubt, scan
  17 // boehm-gc/gc.h.  This is yucky but lets us avoid including gc.h
  18 // everywhere (which would be truly yucky).
  19
  20 #include <pthread.h>
  21 #include <sched.h>
  22
  23 //
  24 // Typedefs.
  25 //
  26
  27 typedef struct _Jv_Thread_t
  28 {
  29   // Flag values are defined in implementation.
  30   int flags;
  31
  32   // Actual thread id.
  33   pthread_t thread;
  34
  35   // Java Thread object.
  36   java::lang::Thread *thread_obj;
  37
  38   // Condition variable and corresponding mutex, used to implement the
  39   // interruptable wait/notify mechanism.
  40   pthread_cond_t wait_cond;
  41   pthread_mutex_t wait_mutex;
  42
  43   // Next thread for Condition Variable wait-list chain.
  44   _Jv_Thread_t *next;
  45
  46 } _Jv_Thread_t;
  47
  48 typedef void _Jv_ThreadStartFunc (java::lang::Thread *);
  49
  50
  51 // Condition Variables used to implement wait/notify/sleep/interrupt.
  52 typedef struct
  53 {
  54   // Linked list of Threads that are waiting to be notified.
  55   _Jv_Thread_t *first;
  56
  57 } _Jv_ConditionVariable_t;
  58
  59 typedef struct
  60 {
  61   // For compatibility, simplicity, and correctness, we do not use the native
  62   // pthreads recursive mutex implementation, but simulate them instead.
  63
  64   // Mutex the thread holds the entire time this mutex is held.
  65   pthread_mutex_t mutex;
  66
  67   // Thread holding this mutex.
  68   pthread_t owner;
  69
  70   // Number of times mutex is held (lock depth).  If 0, the lock is not held.
  71   int count;
  72 } _Jv_Mutex_t;
  73
  74 // This is a convenience function used only by the pthreads thread
  75 // implementation.  This is slow, but that's too bad -- we need to do
  76 // the checks for correctness.  It might be nice to be able to compile
  77 // this out.  Returns 0 if the lock is held by the current thread, and
  78 // 1 otherwise.
  79 inline int
  80 _Jv_MutexCheckMonitor (_Jv_Mutex_t *mu)
  81 {
  82   return (mu->owner != pthread_self());
  83 }
  84
  85 //
  86 // Condition variables.
  87 //
  88
  89 int _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
  90                   jlong millis, jint nanos);
  91
  92 int _Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu);
  93
  94 int _Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu);
  95
  96 inline void
  97 _Jv_CondInit (_Jv_ConditionVariable_t *cv)
  98 {
  99   cv->first = 0;
 100 }
 101
 102 //
 103 // Mutexes.
 104 //
 105
 106 #ifdef LOCK_DEBUG
 107 # include <stdio.h>
 108 #endif
 109
 110 inline void
 111 _Jv_MutexInit (_Jv_Mutex_t *mu)
 112 {
 113 # ifdef LOCK_DEBUG /* Assumes Linuxthreads */
 114   pthread_mutexattr_t attr;
 115   pthread_mutexattr_init(&attr);
 116   pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
 117   pthread_mutex_init (&mu->mutex, &attr);
 118 # else
 119   pthread_mutex_init (&mu->mutex, 0);
 120 # endif
 121
 122   mu->count = 0;
 123   mu->owner = 0;
 124 }
 125
 126 inline int
 127 _Jv_MutexLock (_Jv_Mutex_t *mu)
 128 {
 129   pthread_t self = pthread_self ();
 130   if (mu->owner == self)
 131     {
 132       mu->count++;
 133     }
 134   else
 135     {
 136 #     ifdef LOCK_DEBUG
 137         int result = pthread_mutex_lock (&mu->mutex);
 138         if (0 != result)
 139           {
 140             fprintf(stderr, "Pthread_mutex_lock returned %d\n", result);
 141             for (;;) {}
 142           }
 143 #     else
 144         pthread_mutex_lock (&mu->mutex);
 145 #     endif
 146       mu->count = 1;
 147       mu->owner = self;
 148     }
 149   return 0;
 150 }
 151
 152 inline int
 153 _Jv_MutexUnlock (_Jv_Mutex_t *mu)
 154 {
 155   if (_Jv_MutexCheckMonitor (mu))
 156     {
 157 #     ifdef LOCK_DEBUG
 158         fprintf(stderr, "_Jv_MutexUnlock: Not owner\n");
 159         for (;;) {}
 160 #     endif
 161       return 1;
 162     }
 163
 164   mu->count--;
 165
 166   if (mu->count == 0)
 167     {
 168       mu->owner = 0;
 169 #     ifdef LOCK_DEBUG
 170         int result = pthread_mutex_unlock (&mu->mutex);
 171         if (0 != result)
 172           {
 173             fprintf(stderr, "Pthread_mutex_unlock returned %d\n", result);
 174             for (;;) {}
 175           }
 176 #     else
 177         pthread_mutex_unlock (&mu->mutex);
 178 #     endif
 179     }
 180   return 0;
 181 }
 182
 183 #ifndef LINUX_THREADS
 184
 185 // pthread_mutex_destroy does nothing on Linux and it is a win to avoid
 186 // defining this macro.
 187
 188 #define _Jv_HaveMutexDestroy
 189
 190 inline void
 191 _Jv_MutexDestroy (_Jv_Mutex_t *mu)
 192 {
 193   pthread_mutex_destroy (&mu->mutex);
 194 }
 195
 196 #endif /* LINUX_THREADS */
 197
 198 //
 199 // Thread creation and manipulation.
 200 //
 201
 202 void _Jv_InitThreads (void);
 203
 204 _Jv_Thread_t *_Jv_ThreadInitData (java::lang::Thread *thread);
 205 void _Jv_ThreadDestroyData (_Jv_Thread_t *data);
 206
 207 inline java::lang::Thread *
 208 _Jv_ThreadCurrent (void)
 209 {
 210   extern pthread_key_t _Jv_ThreadKey;
 211   return (java::lang::Thread *) pthread_getspecific (_Jv_ThreadKey);
 212 }
 213
 214 #ifdef JV_HASH_SYNCHRONIZATION
 215 // Should be specialized to just load the "current thread" register
 216 // on platforms that support it.   Speed is of the essence.  The value
 217 // of the descriptor is not, so long as there is a one-to-one correspondence
 218 // to threads.
 219
 220
 221 #ifdef __ia64__
 222
 223 typedef size_t _Jv_ThreadId_t;
 224
 225 register size_t _Jv_self __asm__("r13");
 226         // For linux_threads this is really a pointer to its thread data
 227         // structure.  We treat it as opaque.  That should also work
 228         // on other operating systems that follow the ABI standard.
 229
 230 // This should become the prototype for machines that maintain a thread
 231 // pointer in a register.
 232 inline _Jv_ThreadId_t
 233 _Jv_ThreadSelf (void)
 234 {
 235   return _Jv_self;
 236 }
 237
 238 #define JV_SELF_DEFINED
 239
 240 #endif /* __ia64__ */
 241
 242 #ifdef __alpha__
 243
 244 #ifdef __FreeBSD__
 245 #include <machine/pal.h>
 246 #define PAL_rduniq PAL_rdunique
 247 #elif defined (__osf__)
 248 #include <machine/pal.h>
 249 #else
 250 #include <asm/pal.h>
 251 #endif
 252
 253 typedef unsigned long _Jv_ThreadId_t;
 254
 255 inline _Jv_ThreadId_t
 256 _Jv_ThreadSelf (void)
 257 {
 258   register unsigned long id __asm__("$0");
 259   __asm__ ("call_pal %1" : "=r"(id) : "i"(PAL_rduniq));
 260   return id;
 261 }
 262
 263 #define JV_SELF_DEFINED
 264
 265 #endif /* __alpha__ */
 266
 267 #if defined(SLOW_PTHREAD_SELF)
 268
 269 #include "sysdep/locks.h"
 270
 271 typedef pthread_t _Jv_ThreadId_t;
 272
 273 // E.g. on X86 Linux, pthread_self() is too slow for our purpose.
 274 // Instead we maintain a cache based on the current sp value.
 275 // This is similar to what's done for thread local allocation in the
 276 // GC, only far simpler.
 277 // This code should probably go away when Linux/X86 starts using a
 278 // segment register to hold the thread id.
 279 # define LOG_THREAD_SPACING 12
 280                         // If two thread pointer values are closer than
 281                         // 1 << LOG_THREAD_SPACING, we assume they belong
 282                         // to the same thread.
 283 # define SELF_CACHE_SIZE 1024
 284 # define SC_INDEX(sp) (((unsigned long)(sp) >> 19) & (SELF_CACHE_SIZE-1))
 285                         // Mapping from sp value to cache index.
 286                         // Note that this is not in any real sense a hash
 287                         // function, since we need to be able to clear
 288                         // all possibly matching slots on thread startup.
 289                         // Thus all entries that might correspond to
 290                         // a given thread are intentionally contiguous.
 291                         // Works well with anything that allocates at least
 292                         // 512KB stacks.
 293 # define SC_CLEAR_MIN (-16)     // When starting a new thread, we clear
 294 # define SC_CLEAR_MAX 0         // all self cache entries between
 295                                 // SC_INDEX(sp)+SC_CLEAR_MIN and
 296                                 // SC_INDEX(sp)+SC_CLEAR_MAX to ensure
 297                                 // we never see stale values.  The
 298                                 // current values assume a downward
 299                                 // growing stack of size <= 7.5 MB.
 300 # define BAD_HIGH_SP_VALUE ((size_t)(-1))
 301
 302 extern volatile
 303 struct self_cache_entry {
 304   size_t high_sp_bits;  // sp value >> LOG_THREAD_SPACING
 305   pthread_t self;       // Corresponding thread
 306 } _Jv_self_cache[];
 307
 308 void _Jv_Self_Cache_Init();
 309
 310 _Jv_ThreadId_t
 311 _Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce,
 312                            size_t high_sp_bits);
 313
 314 inline _Jv_ThreadId_t
 315 _Jv_ThreadSelf (void)
 316 {
 317   int dummy;
 318   size_t sp = (size_t)(&dummy);
 319   unsigned h = SC_INDEX(sp);
 320   volatile self_cache_entry *sce = _Jv_self_cache + h;
 321   pthread_t candidate_self = sce -> self;  // Read must precede following one.
 322   read_barrier();
 323   if (sce -> high_sp_bits == sp >> LOG_THREAD_SPACING)
 324     {
 325       // The sce -> self value we read must be valid.  An intervening
 326       // cache replacement by another thread would have first replaced
 327       // high_sp_bits by something else, and it can't possibly change
 328       // back without our intervention.
 329       return candidate_self;
 330     }
 331   else
 332     return _Jv_ThreadSelf_out_of_line(sce, sp >> LOG_THREAD_SPACING);
 333 }
 334
 335 #define JV_SELF_DEFINED
 336
 337 #endif /* SLOW_PTHREAD_SELF */
 338
 339 #ifndef JV_SELF_DEFINED /* If all else fails, call pthread_self directly */
 340
 341 typedef pthread_t _Jv_ThreadId_t;
 342
 343 inline _Jv_ThreadId_t
 344 _Jv_ThreadSelf (void)
 345 {
 346   return pthread_self();
 347 }
 348
 349 #endif /* !JV_SELF_DEFINED */
 350
 351 #endif /* JV_HASH_SYNCHRONIZATION */
 352
 353 inline _Jv_Thread_t *
 354 _Jv_ThreadCurrentData (void)
 355 {
 356   extern pthread_key_t _Jv_ThreadDataKey;
 357   return (_Jv_Thread_t *) pthread_getspecific (_Jv_ThreadDataKey);
 358 }
 359
 360 inline void
 361 _Jv_ThreadYield (void)
 362 {
 363 #ifdef HAVE_SCHED_YIELD
 364   sched_yield ();
 365 #endif /* HAVE_SCHED_YIELD */
 366 }
 367
 368 void _Jv_ThreadRegister (_Jv_Thread_t *data);
 369 void _Jv_ThreadUnRegister ();
 370
 371 void _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio);
 372
 373 void _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
 374                       _Jv_ThreadStartFunc *meth);
 375
 376 void _Jv_ThreadWait (void);
 377
 378 void _Jv_ThreadInterrupt (_Jv_Thread_t *data);
 379
 380 #endif /* __JV_POSIX_THREADS__ */