2 // posix-threads.h - Defines for using POSIX threads.
4 /* Copyright (C) 1998, 1999, 2001 Free Software Foundation
6 This file is part of libgcj.
8 This software is copyrighted work licensed under the terms of the
9 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
12 #ifndef __JV_POSIX_THREADS__
13 #define __JV_POSIX_THREADS__
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).
27 typedef struct _Jv_Thread_t
29 // Flag values are defined in implementation.
35 // Java Thread object.
36 java::lang::Thread *thread_obj;
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;
43 // Next thread for Condition Variable wait-list chain.
48 typedef void _Jv_ThreadStartFunc (java::lang::Thread *);
51 // Condition Variables used to implement wait/notify/sleep/interrupt.
54 // Linked list of Threads that are waiting to be notified.
57 } _Jv_ConditionVariable_t;
61 // For compatibility, simplicity, and correctness, we do not use the native
62 // pthreads recursive mutex implementation, but simulate them instead.
64 // Mutex the thread holds the entire time this mutex is held.
65 pthread_mutex_t mutex;
67 // Thread holding this mutex.
70 // Number of times mutex is held (lock depth). If 0, the lock is not held.
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
80 _Jv_PthreadCheckMonitor (_Jv_Mutex_t *mu)
82 pthread_t self = pthread_self();
83 if (mu->owner == self)
89 // Condition variables.
92 int _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
93 jlong millis, jint nanos);
95 int _Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu);
97 int _Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu);
100 _Jv_CondInit (_Jv_ConditionVariable_t *cv)
114 _Jv_MutexInit (_Jv_Mutex_t *mu)
116 # ifdef LOCK_DEBUG /* Assumes Linuxthreads */
117 pthread_mutexattr_t attr;
118 pthread_mutexattr_init(&attr);
119 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
120 pthread_mutex_init (&mu->mutex, &attr);
122 pthread_mutex_init (&mu->mutex, 0);
130 _Jv_MutexLock (_Jv_Mutex_t *mu)
132 pthread_t self = pthread_self ();
133 if (mu->owner == self)
140 int result = pthread_mutex_lock (&mu->mutex);
143 fprintf(stderr, "Pthread_mutex_lock returned %d\n", result);
147 pthread_mutex_lock (&mu->mutex);
156 _Jv_MutexUnlock (_Jv_Mutex_t *mu)
158 if (_Jv_PthreadCheckMonitor (mu))
161 fprintf(stderr, "_Jv_MutexUnlock: Not owner\n");
173 int result = pthread_mutex_unlock (&mu->mutex);
176 fprintf(stderr, "Pthread_mutex_unlock returned %d\n", result);
180 pthread_mutex_unlock (&mu->mutex);
186 #ifndef LINUX_THREADS
188 // pthread_mutex_destroy does nothing on Linux and it is a win to avoid
189 // defining this macro.
191 #define _Jv_HaveMutexDestroy
194 _Jv_MutexDestroy (_Jv_Mutex_t *mu)
196 pthread_mutex_destroy (&mu->mutex);
199 #endif /* LINUX_THREADS */
202 // Thread creation and manipulation.
205 void _Jv_InitThreads (void);
207 _Jv_Thread_t *_Jv_ThreadInitData (java::lang::Thread *thread);
208 void _Jv_ThreadDestroyData (_Jv_Thread_t *data);
210 inline java::lang::Thread *
211 _Jv_ThreadCurrent (void)
213 extern pthread_key_t _Jv_ThreadKey;
214 return (java::lang::Thread *) pthread_getspecific (_Jv_ThreadKey);
217 #ifdef JV_HASH_SYNCHRONIZATION
218 // Should be specialized to just load the "current thread" register
219 // on platforms that support it. Speed is of the essence. The value
220 // of the descriptor is not, so long as there is a one-to-one correspondence
226 #define SLOW_PTHREAD_SELF
227 // Add a cache for pthread_self() if we don't have the thread
228 // pointer in a register.
230 #endif /* __i386__ */
234 typedef size_t _Jv_ThreadId_t;
236 register size_t _Jv_self __asm__("r13");
237 // For linux_threads this is really a pointer to its thread data
238 // structure. We treat it as opaque. That should also work
239 // on other operating systems that follow the ABI standard.
241 // This should become the prototype for machines that maintain a thread
242 // pointer in a register.
243 inline _Jv_ThreadId_t
244 _Jv_ThreadSelf (void)
249 #define JV_SELF_DEFINED
251 #endif /* __ia64__ */
257 typedef unsigned long _Jv_ThreadId_t;
259 inline _Jv_ThreadId_t
260 _Jv_ThreadSelf (void)
263 __asm__ ("call_pal %1\n\tmov $0, %0" : "=r"(id) : "i"(PAL_rduniq) : "$0");
267 #define JV_SELF_DEFINED
269 #endif /* __alpha__ */
271 #if defined(SLOW_PTHREAD_SELF)
273 typedef pthread_t _Jv_ThreadId_t;
275 // E.g. on X86 Linux, pthread_self() is too slow for our purpose.
276 // Instead we maintain a cache based on the current sp value.
277 // This is similar to what's done for thread local allocation in the
278 // GC, only far simpler.
279 // This code should probably go away when Linux/X86 starts using a
280 // segment register to hold the thread id.
281 # define LOG_THREAD_SPACING 12
282 // If two thread pointer values are closer than
283 // 1 << LOG_THREAD_SPACING, we assume they belong
284 // to the same thread.
285 # define SELF_CACHE_SIZE 1024
286 # define SC_INDEX(sp) (((unsigned long)(sp) >> 19) & (SELF_CACHE_SIZE-1))
287 // Mapping from sp value to cache index.
288 // Note that this is not in any real sense a hash
289 // function, since we need to be able to clear
290 // all possibly matching slots on thread startup.
291 // Thus all entries that might correspond to
292 // a given thread are intentionally contiguous.
293 // Works well with anything that allocates at least
295 # define SC_CLEAR_MIN (-16) // When starting a new thread, we clear
296 # define SC_CLEAR_MAX 0 // all self cache entries between
297 // SC_INDEX(sp)+SC_CLEAR_MIN and
298 // SC_INDEX(sp)+SC_CLEAR_MAX to ensure
299 // we never see stale values. The
300 // current values assume a downward
301 // growing stack of size <= 7.5 MB.
302 # define BAD_HIGH_SP_VALUE ((size_t)(-1))
305 struct self_cache_entry {
306 size_t high_sp_bits; // sp value >> LOG_THREAD_SPACING
307 pthread_t self; // Corresponding thread
310 void _Jv_Self_Cache_Init();
313 _Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce,
314 size_t high_sp_bits);
316 inline _Jv_ThreadId_t
317 _Jv_ThreadSelf (void)
320 size_t sp = (size_t)(&dummy);
321 unsigned h = SC_INDEX(sp);
322 volatile self_cache_entry *sce = _Jv_self_cache + h;
323 pthread_t candidate_self = sce -> self; // Read must precede following one.
324 // Read barrier goes here, if needed.
325 if (sce -> high_sp_bits == sp >> LOG_THREAD_SPACING)
327 // The sce -> self value we read must be valid. An intervening
328 // cache replacement by another thread would have first replaced
329 // high_sp_bits by something else, and it can't possibly change
330 // back without our intervention.
331 return candidate_self;
334 return _Jv_ThreadSelf_out_of_line(sce, sp >> LOG_THREAD_SPACING);
337 #define JV_SELF_DEFINED
339 #endif /* SLOW_PTHREAD_SELF */
341 #ifndef JV_SELF_DEFINED /* If all else fails, call pthread_self directly */
343 typedef pthread_t _Jv_ThreadId_t;
345 inline _Jv_ThreadId_t
346 _Jv_ThreadSelf (void)
348 return pthread_self();
351 #endif /* !JV_SELF_DEFINED */
353 #endif /* JV_HASH_SYNCHRONIZATION */
355 inline _Jv_Thread_t *
356 _Jv_ThreadCurrentData (void)
358 extern pthread_key_t _Jv_ThreadDataKey;
359 return (_Jv_Thread_t *) pthread_getspecific (_Jv_ThreadDataKey);
363 _Jv_ThreadYield (void)
365 #ifdef HAVE_SCHED_YIELD
367 #endif /* HAVE_SCHED_YIELD */
370 void _Jv_ThreadRegister (_Jv_Thread_t *data);
371 void _Jv_ThreadUnRegister ();
373 void _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio);
375 void _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
376 _Jv_ThreadStartFunc *meth);
378 void _Jv_ThreadWait (void);
380 void _Jv_ThreadInterrupt (_Jv_Thread_t *data);
382 #endif /* __JV_POSIX_THREADS__ */