diff options
author | Bryce McKinlay <bryce@albatross.co.nz> | 2000-03-28 02:22:24 +0000 |
---|---|---|
committer | Bryce McKinlay <bryce@gcc.gnu.org> | 2000-03-28 03:22:24 +0100 |
commit | b834f1fa0659d66d4c2d033cdb3d0f2a1f1ce390 (patch) | |
tree | 1644e34b97bb6d57435386decdbf6dbeadd31a58 /libjava/include | |
parent | 73780b74b37175aa1c9afd20bfb81b66e6a96c1a (diff) | |
download | gcc-b834f1fa0659d66d4c2d033cdb3d0f2a1f1ce390.zip gcc-b834f1fa0659d66d4c2d033cdb3d0f2a1f1ce390.tar.gz gcc-b834f1fa0659d66d4c2d033cdb3d0f2a1f1ce390.tar.bz2 |
Makefile.in: New #defines and friends for Thread.h.
* Makefile.in: New #defines and friends for Thread.h.
* posix-threads.cc: (struct starter): Remove `object'.
(_Jv_CondWait): Use interruptable condition variables and new
recursive mutexes. New return codes on interrupt or non-ownership
of mutex.
(_Jv_CondNotify): Ditto.
(_Jv_CondNotifyAll): Ditto.
(_Jv_ThreadInterrupt): Set thread interrupt flag directly. Interrupt
the target thread by signaling its wait condition.
(_Jv_ThreadInitData): Set `thread_obj' in the thread data struct,
not the starter struct. Initialize wait_mutex and wait_cond.
(_Jv_MutexLock): New recursive mutex implementation. Moved from
posix-threads.h.
(_Jv_MutexUnlock): Ditto.
(really_start): Set info->data->thread from pthread_self() to work
around a race condition. Destroy wait_mutex and wait_cond when run()
returns.
* java/lang/Thread.java: (isInterrupted_): Renamed to overloaded
`isInterrupted(boolean)'. Clear interrupted flag if clear_flag is
set.
startable_flag: New private field.
(Thread): Initialize `startable_flag'.
(toString): Check for null thread group.
* java/lang/natThread.cc: (struct natThread): New fields
`join_mutex', `join_cond'. Removed fields `joiner', `next'.
(class locker): Removed.
(initialize_native): Initialize `join_cond' and `join_mutex'.
(interrupt): Now just calls _Jv_ThreadInterrupt().
(join): Simplified. Just wait on the target thread's join condition.
(finish_): Remove join list code. Unset thread group. Signal
potential joiners by notifying the dying threads join_cond.
(start): Check for illegal restarts.
* java/lang/natObject.cc: Check for return value of _Jv_CondWait and
act appropriatly.
* include/posix-threads.h: Remove all HAVE_RECURSIVE_MUTEX related
#defines and #ifdefs.
(struct _Jv_Thread_t): New fields `thread_obj', `wait_cond',
`wait_mutex', `next'.
(struct _Jv_ConditionVariable_t): Define as a struct instead of
directly mapping to pthread_cond_t.
(struct _Jv_Mutex_t): New recursive implementation.
(_Jv_PthreadCheckMonitor): Reimplemented. Simple `owner' check.
_Jv_HaveCondDestroy: Never define this for posix-threads.
(_Jv_CondNotify): Remove inline implementation(s), prototype instead.
(_Jv_CondNotifyAll): Ditto.
(_Jv_MutexLock): Ditto.
(_Jv_MutexUnlock): Ditto.
(_Jv_MutexInit): Changed to reflect new mutex implementation.
(_Jv_MutexDestroy): Ditto.
(_Jv_CondDestroy): Removed.
(_Jv_PthreadGetMutex): Removed.
* include/win32-threads.h: (_Jv_CondNotify): Guess _JV_NOT_OWNER on an
error. Add a FIXME about this.
(_Jv_CondNotifyAll): Ditto.
* win32-threads.cc: (_Jv_CondWait): Return 0 on a timeout. Guess
_JV_NOT_OWNER on other errors. Add FIXME.
From-SVN: r32773
Diffstat (limited to 'libjava/include')
-rw-r--r-- | libjava/include/posix-threads.h | 217 | ||||
-rw-r--r-- | libjava/include/win32-threads.h | 6 |
2 files changed, 55 insertions, 168 deletions
diff --git a/libjava/include/posix-threads.h b/libjava/include/posix-threads.h index ac74ebe..22f6717 100644 --- a/libjava/include/posix-threads.h +++ b/libjava/include/posix-threads.h @@ -20,81 +20,56 @@ details. */ #include <pthread.h> #include <sched.h> -#if defined (HAVE_PTHREAD_MUTEXATTR_SETTYPE) || defined (HAVE_PTHREAD_MUTEXATTR_SETKIND_NP) -# define HAVE_RECURSIVE_MUTEX 1 -#endif - - // // Typedefs. // -typedef pthread_cond_t _Jv_ConditionVariable_t; - -#if defined (PTHREAD_MUTEX_HAVE_M_COUNT) || defined (PTHREAD_MUTEX_HAVE___M_COUNT) +typedef struct _Jv_Thread_t +{ + // Flag values are defined in implementation. + int flags; -// On Linux we use implementation details of mutexes in order to get -// faster results. -typedef pthread_mutex_t _Jv_Mutex_t; + // Actual thread id. + pthread_t thread; + + // Java Thread object. + java::lang::Thread *thread_obj; + + // Condition variable and corresponding mutex, used to implement the + // interruptable wait/notify mechanism. + pthread_cond_t wait_cond; + pthread_mutex_t wait_mutex; + + // Next thread for Condition Variable wait-list chain. + _Jv_Thread_t *next; + +} _Jv_Thread_t; -#else /* LINUX_THREADS */ +typedef void _Jv_ThreadStartFunc (java::lang::Thread *); -#define PTHREAD_MUTEX_IS_STRUCT +// Condition Variables used to implement wait/notify/sleep/interrupt. typedef struct { - // Mutex used when locking this structure transiently. - pthread_mutex_t mutex; -#ifndef HAVE_RECURSIVE_MUTEX - // Some systems do not have recursive mutexes, so we must simulate - // them. Solaris is one such system. - - // Mutex the thread holds the entire time this mutex is held. This - // is used to make condition variables work properly. - pthread_mutex_t mutex2; - // Condition variable used when waiting for this lock. - pthread_cond_t cond; - // Thread holding this mutex. If COUNT is 0, no thread is holding. - pthread_t thread; -#endif /* HAVE_RECURSIVE_MUTEX */ - - // Number of times mutex is held. If 0, the lock is not held. We - // do this even if we have a native recursive mutex so that we can - // keep track of whether the lock is held; this lets us do error - // checking. FIXME it would be nice to optimize this; on some - // systems we could do so by relying on implementation details of - // recursive mutexes. - int count; -} _Jv_Mutex_t; + // Linked list of Threads that are waiting to be notified. + _Jv_Thread_t *first; -#endif +} _Jv_ConditionVariable_t; typedef struct { - // Flag values are defined in implementation. - int flags; - - // Actual thread id. - pthread_t thread; -} _Jv_Thread_t; -typedef void _Jv_ThreadStartFunc (java::lang::Thread *); + // For compatibility, simplicity, and correctness, we do not use the native + // pthreads recursive mutex implementation, but simulate them instead. + // Mutex the thread holds the entire time this mutex is held. + pthread_mutex_t mutex; -// This convenience function is used to return the POSIX mutex -// corresponding to our mutex. -inline pthread_mutex_t * -_Jv_PthreadGetMutex (_Jv_Mutex_t *mu) -{ -#if ! defined (PTHREAD_MUTEX_IS_STRUCT) - return mu; -#elif defined (HAVE_RECURSIVE_MUTEX) - return &mu->mutex; -#else - return &mu->mutex2; -#endif -} + // Thread holding this mutex. + pthread_t owner; -#include <stdio.h> + // Number of times mutex is held (lock depth). If 0, the lock is not held. + int count; +} _Jv_Mutex_t; // This is a convenience function used only by the pthreads thread // implementation. This is slow, but that's too bad -- we need to do @@ -104,95 +79,44 @@ _Jv_PthreadGetMutex (_Jv_Mutex_t *mu) inline int _Jv_PthreadCheckMonitor (_Jv_Mutex_t *mu) { - pthread_mutex_t *pmu; -#ifdef HAVE_RECURSIVE_MUTEX - pmu = _Jv_PthreadGetMutex (mu); - // See if the mutex is locked by this thread. - if (pthread_mutex_trylock (pmu)) - return 1; - -#if defined (PTHREAD_MUTEX_HAVE_M_COUNT) - // On Linux we exploit knowledge of the implementation. - int r = pmu->m_count == 1; -#elif defined (PTHREAD_MUTEX_HAVE___M_COUNT) - // In glibc 2.1, the first time the mutex is grabbed __m_count is - // set to 0 and __m_owner is set to pthread_self(). - int r = ! pmu->__m_count; -#else - int r = mu->count == 0; -#endif - -#else /* HAVE_RECURSIVE_MUTEX */ - // In this case we must lock our structure and then see if this - // thread owns the mutex. - pmu = &mu->mutex; - if (pthread_mutex_lock (pmu)) - return 1; - - int r = mu->thread != pthread_self () || mu->count == 0; -#endif /* HAVE_RECURSIVE_MUTEX */ - - pthread_mutex_unlock (pmu); - return r; + pthread_t self = pthread_self(); + if (mu->owner == self) + return 0; + else return 1; } // // Condition variables. // -inline void -_Jv_CondInit (_Jv_ConditionVariable_t *cv) -{ - pthread_cond_init (cv, 0); -} - -#ifndef LINUX_THREADS - -// pthread_cond_destroy does nothing on Linux and it is a win to avoid -// defining this macro. - -#define _Jv_HaveCondDestroy - -inline void -_Jv_CondDestroy (_Jv_ConditionVariable_t *cv) -{ - pthread_cond_destroy (cv); -} - -#endif /* LINUX_THREADS */ - int _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint nanos); + +int _Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu); -inline int -_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu) -{ - return _Jv_PthreadCheckMonitor (mu) || pthread_cond_signal (cv); -} +int _Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu); -inline int -_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu) +inline void +_Jv_CondInit (_Jv_ConditionVariable_t *cv) { - return _Jv_PthreadCheckMonitor (mu) || pthread_cond_broadcast (cv); + cv->first = NULL; } - // // Mutexes. // -#ifdef RECURSIVE_MUTEX_IS_DEFAULT inline void _Jv_MutexInit (_Jv_Mutex_t *mu) { - pthread_mutex_init (_Jv_PthreadGetMutex (mu), NULL); -#ifdef PTHREAD_MUTEX_IS_STRUCT + pthread_mutex_init (&mu->mutex, NULL); + mu->count = 0; -#endif + mu->owner = 0; } -#else -void _Jv_MutexInit (_Jv_Mutex_t *mu); -#endif + +int _Jv_MutexLock (_Jv_Mutex_t *mu); +int _Jv_MutexUnlock (_Jv_Mutex_t *mu); #ifndef LINUX_THREADS @@ -201,53 +125,14 @@ void _Jv_MutexInit (_Jv_Mutex_t *mu); #define _Jv_HaveMutexDestroy -#ifdef HAVE_RECURSIVE_MUTEX - -inline void +inline void _Jv_MutexDestroy (_Jv_Mutex_t *mu) { - pthread_mutex_destroy (_Jv_PthreadGetMutex (mu)); + pthread_mutex_destroy (&mu->mutex); } -#else /* HAVE_RECURSIVE_MUTEX */ - -extern void _Jv_MutexDestroy (_Jv_Mutex_t *mu); - -#endif /* HAVE_RECURSIVE_MUTEX */ #endif /* LINUX_THREADS */ -#ifdef HAVE_RECURSIVE_MUTEX - -inline int -_Jv_MutexLock (_Jv_Mutex_t *mu) -{ - int r = pthread_mutex_lock (_Jv_PthreadGetMutex (mu)); -#ifdef PTHREAD_MUTEX_IS_STRUCT - if (! r) - ++mu->count; -#endif - return r; -} - -inline int -_Jv_MutexUnlock (_Jv_Mutex_t *mu) -{ - int r = pthread_mutex_unlock (_Jv_PthreadGetMutex (mu)); -#ifdef PTHREAD_MUTEX_IS_STRUCT - if (! r) - --mu->count; -#endif - return r; -} - -#else /* HAVE_RECURSIVE_MUTEX */ - -extern int _Jv_MutexLock (_Jv_Mutex_t *mu); -extern int _Jv_MutexUnlock (_Jv_Mutex_t *mu); - -#endif /* HAVE_RECURSIVE_MUTEX */ - - // // Thread creation and manipulation. // diff --git a/libjava/include/win32-threads.h b/libjava/include/win32-threads.h index d87fea0..4938d5f 100644 --- a/libjava/include/win32-threads.h +++ b/libjava/include/win32-threads.h @@ -54,13 +54,15 @@ int _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, inline int _Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *) { - return PulseEvent (*cv) ? 0 : GetLastError (); // FIXME: Map error code? + // FIXME: check for mutex ownership? + return PulseEvent (*cv) ? 0 : _JV_NOT_OWNER; // FIXME? } inline int _Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *) { - return PulseEvent (*cv) ? 0 : GetLastError (); // FIXME: Map error code? + // FIXME: check for mutex ownership? + return PulseEvent (*cv) ? 0 : _JV_NOT_OWNER; // FIXME? } // |