2 // posix-threads.h - Defines for using POSIX threads.
4 /* Copyright (C) 1998, 1999, 2001, 2003, 2006 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).
22 #include <sysdep/locks.h>
28 typedef struct _Jv_Thread_t
30 // Flag values are defined in implementation.
36 // Java Thread object.
37 java::lang::Thread
*thread_obj
;
39 // Condition variable and corresponding mutex, used to implement the
40 // interruptable wait/notify mechanism.
41 pthread_cond_t wait_cond
;
42 pthread_mutex_t wait_mutex
;
44 // Next thread for Condition Variable wait-list chain.
49 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_MutexCheckMonitor (_Jv_Mutex_t
*mu
)
82 return (pthread_equal(mu
->owner
, pthread_self()) == 0);
85 // Type identifying a POSIX thread.
86 typedef pthread_t _Jv_ThreadDesc_t
;
88 inline _Jv_ThreadDesc_t
89 _Jv_GetPlatformThreadID(_Jv_Thread_t
*t
)
98 void _Jv_BlockSigchld();
99 void _Jv_UnBlockSigchld();
103 // Condition variables.
106 int _Jv_CondWait (_Jv_ConditionVariable_t
*cv
, _Jv_Mutex_t
*mu
,
107 jlong millis
, jint nanos
);
109 int _Jv_CondNotify (_Jv_ConditionVariable_t
*cv
, _Jv_Mutex_t
*mu
);
111 int _Jv_CondNotifyAll (_Jv_ConditionVariable_t
*cv
, _Jv_Mutex_t
*mu
);
114 _Jv_CondInit (_Jv_ConditionVariable_t
*cv
)
128 _Jv_MutexInit (_Jv_Mutex_t
*mu
)
130 # ifdef LOCK_DEBUG /* Assumes Linuxthreads */
131 pthread_mutexattr_t attr
;
132 pthread_mutexattr_init(&attr
);
133 pthread_mutexattr_settype(&attr
, PTHREAD_MUTEX_ERRORCHECK
);
134 pthread_mutex_init (&mu
->mutex
, &attr
);
136 pthread_mutex_init (&mu
->mutex
, 0);
143 extern int _Jv_MutexLock (_Jv_Mutex_t
*);
146 _Jv_MutexUnlock (_Jv_Mutex_t
*mu
)
148 if (_Jv_MutexCheckMonitor (mu
))
151 fprintf(stderr
, "_Jv_MutexUnlock: Not owner\n");
163 int result
= pthread_mutex_unlock (&mu
->mutex
);
166 fprintf(stderr
, "Pthread_mutex_unlock returned %d\n", result
);
170 pthread_mutex_unlock (&mu
->mutex
);
176 #ifndef LINUX_THREADS
178 // pthread_mutex_destroy does nothing on Linux and it is a win to avoid
179 // defining this macro.
181 #define _Jv_HaveMutexDestroy
184 _Jv_MutexDestroy (_Jv_Mutex_t
*mu
)
186 pthread_mutex_destroy (&mu
->mutex
);
189 #endif /* LINUX_THREADS */
192 // Thread creation and manipulation.
195 void _Jv_InitThreads (void);
197 _Jv_Thread_t
*_Jv_ThreadInitData (java::lang::Thread
*thread
);
198 void _Jv_ThreadDestroyData (_Jv_Thread_t
*data
);
200 inline java::lang::Thread
*
201 _Jv_ThreadCurrent (void)
203 extern pthread_key_t _Jv_ThreadKey
;
204 return (java::lang::Thread
*) pthread_getspecific (_Jv_ThreadKey
);
207 #ifdef JV_HASH_SYNCHRONIZATION
208 // Should be specialized to just load the "current thread" register
209 // on platforms that support it. Speed is of the essence. The value
210 // of the descriptor is not, so long as there is a one-to-one correspondence
216 typedef size_t _Jv_ThreadId_t
;
218 register size_t _Jv_self
__asm__("r13");
219 // For linux_threads this is really a pointer to its thread data
220 // structure. We treat it as opaque. That should also work
221 // on other operating systems that follow the ABI standard.
223 // This should become the prototype for machines that maintain a thread
224 // pointer in a register.
225 inline _Jv_ThreadId_t
226 _Jv_ThreadSelf (void)
231 #define JV_SELF_DEFINED
233 #endif /* __ia64__ */
237 typedef void *_Jv_ThreadId_t
;
239 inline _Jv_ThreadId_t
240 _Jv_ThreadSelf (void)
242 return __builtin_thread_pointer ();
245 #define JV_SELF_DEFINED
247 #endif /* __alpha__ */
249 #if defined(SLOW_PTHREAD_SELF)
251 #include "sysdep/locks.h"
253 typedef pthread_t _Jv_ThreadId_t
;
255 // E.g. on X86 Linux, pthread_self() is too slow for our purpose.
256 // Instead we maintain a cache based on the current sp value.
257 // This is similar to what's done for thread local allocation in the
258 // GC, only far simpler.
259 // This code should probably go away when Linux/X86 starts using a
260 // segment register to hold the thread id.
261 # define LOG_THREAD_SPACING 12
262 // If two thread pointer values are closer than
263 // 1 << LOG_THREAD_SPACING, we assume they belong
264 // to the same thread.
265 # define SELF_CACHE_SIZE 1024
266 # define SC_INDEX(sp) (((unsigned long)(sp) >> 19) & (SELF_CACHE_SIZE-1))
267 // Mapping from sp value to cache index.
268 // Note that this is not in any real sense a hash
269 // function, since we need to be able to clear
270 // all possibly matching slots on thread startup.
271 // Thus all entries that might correspond to
272 // a given thread are intentionally contiguous.
273 // Works well with anything that allocates at least
275 # define SC_CLEAR_MIN (-16) // When starting a new thread, we clear
276 # define SC_CLEAR_MAX 0 // all self cache entries between
277 // SC_INDEX(sp)+SC_CLEAR_MIN and
278 // SC_INDEX(sp)+SC_CLEAR_MAX to ensure
279 // we never see stale values. The
280 // current values assume a downward
281 // growing stack of size <= 7.5 MB.
282 # define BAD_HIGH_SP_VALUE ((size_t)(-1))
285 struct self_cache_entry
{
286 size_t high_sp_bits
; // sp value >> LOG_THREAD_SPACING
287 pthread_t self
; // Corresponding thread
290 void _Jv_Self_Cache_Init();
293 _Jv_ThreadSelf_out_of_line(volatile self_cache_entry
*sce
,
294 size_t high_sp_bits
);
296 inline _Jv_ThreadId_t
297 _Jv_ThreadSelf (void)
300 size_t sp
= (size_t)(&dummy
);
301 unsigned h
= SC_INDEX(sp
);
302 volatile self_cache_entry
*sce
= _Jv_self_cache
+ h
;
303 pthread_t candidate_self
= sce
-> self
; // Read must precede following one.
305 if (sce
-> high_sp_bits
== sp
>> LOG_THREAD_SPACING
)
307 // The sce -> self value we read must be valid. An intervening
308 // cache replacement by another thread would have first replaced
309 // high_sp_bits by something else, and it can't possibly change
310 // back without our intervention.
311 return candidate_self
;
314 return _Jv_ThreadSelf_out_of_line(sce
, sp
>> LOG_THREAD_SPACING
);
317 #define JV_SELF_DEFINED
319 #endif /* SLOW_PTHREAD_SELF */
321 #ifndef JV_SELF_DEFINED /* If all else fails, call pthread_self directly */
323 typedef pthread_t _Jv_ThreadId_t
;
325 inline _Jv_ThreadId_t
326 _Jv_ThreadSelf (void)
328 return pthread_self();
331 #endif /* !JV_SELF_DEFINED */
333 #endif /* JV_HASH_SYNCHRONIZATION */
335 inline _Jv_Thread_t
*
336 _Jv_ThreadCurrentData (void)
338 extern pthread_key_t _Jv_ThreadDataKey
;
339 return (_Jv_Thread_t
*) pthread_getspecific (_Jv_ThreadDataKey
);
343 _Jv_ThreadYield (void)
345 #ifdef HAVE_SCHED_YIELD
347 #endif /* HAVE_SCHED_YIELD */
350 void _Jv_ThreadRegister (_Jv_Thread_t
*data
);
351 void _Jv_ThreadUnRegister ();
353 void _Jv_ThreadSetPriority (_Jv_Thread_t
*data
, jint prio
);
355 void _Jv_ThreadStart (java::lang::Thread
*thread
, _Jv_Thread_t
*data
,
356 _Jv_ThreadStartFunc
*meth
);
358 void _Jv_ThreadWait (void);
360 void _Jv_ThreadInterrupt (_Jv_Thread_t
*data
);
362 // park() / unpark() support
366 volatile obj_addr_t permit
;
367 pthread_mutex_t mutex
;
373 void park (jboolean isAbsolute
, jlong time
);
378 ParkHelper::destroy ()
380 pthread_mutex_destroy (&mutex
);
381 pthread_cond_destroy (&cond
);
384 #endif /* __JV_POSIX_THREADS__ */