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
This commit is contained in:
Bryce McKinlay
Bryce McKinlay
parent
73780b74b3
commit
b834f1fa06
8 changed files with 394 additions and 494 deletions
|
|
@ -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)
|
||||
|
||||
// On Linux we use implementation details of mutexes in order to get
|
||||
// faster results.
|
||||
typedef pthread_mutex_t _Jv_Mutex_t;
|
||||
|
||||
#else /* LINUX_THREADS */
|
||||
|
||||
#define PTHREAD_MUTEX_IS_STRUCT
|
||||
|
||||
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;
|
||||
|
||||
#endif
|
||||
|
||||
typedef struct
|
||||
typedef struct _Jv_Thread_t
|
||||
{
|
||||
// Flag values are defined in implementation.
|
||||
int flags;
|
||||
|
||||
// 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;
|
||||
|
||||
typedef void _Jv_ThreadStartFunc (java::lang::Thread *);
|
||||
|
||||
|
||||
// This convenience function is used to return the POSIX mutex
|
||||
// corresponding to our mutex.
|
||||
inline pthread_mutex_t *
|
||||
_Jv_PthreadGetMutex (_Jv_Mutex_t *mu)
|
||||
// Condition Variables used to implement wait/notify/sleep/interrupt.
|
||||
typedef struct
|
||||
{
|
||||
#if ! defined (PTHREAD_MUTEX_IS_STRUCT)
|
||||
return mu;
|
||||
#elif defined (HAVE_RECURSIVE_MUTEX)
|
||||
return &mu->mutex;
|
||||
#else
|
||||
return &mu->mutex2;
|
||||
#endif
|
||||
}
|
||||
// Linked list of Threads that are waiting to be notified.
|
||||
_Jv_Thread_t *first;
|
||||
|
||||
#include <stdio.h>
|
||||
} _Jv_ConditionVariable_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
// 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;
|
||||
|
||||
// Thread holding this mutex.
|
||||
pthread_t owner;
|
||||
|
||||
// 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.
|
||||
//
|
||||
|
||||
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);
|
||||
|
||||
int _Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu);
|
||||
|
||||
inline void
|
||||
_Jv_CondInit (_Jv_ConditionVariable_t *cv)
|
||||
{
|
||||
pthread_cond_init (cv, 0);
|
||||
cv->first = NULL;
|
||||
}
|
||||
|
||||
#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);
|
||||
|
||||
inline int
|
||||
_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
||||
{
|
||||
return _Jv_PthreadCheckMonitor (mu) || pthread_cond_signal (cv);
|
||||
}
|
||||
|
||||
inline int
|
||||
_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
||||
{
|
||||
return _Jv_PthreadCheckMonitor (mu) || pthread_cond_broadcast (cv);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue