* 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.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@32773 138bc75d-0d04-0410-961f-82ee72b054a4

2 files changed, 55 insertions, 168 deletions

diff --git a/libjava/include/posix-threads.h b/libjava/include/posix-threads.h
index ac74ebe9309..22f6717e82d 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 d87fea07d2a..4938d5faf57 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?
 }
 
 //