Initial revision

From-SVN: r26263

libjava/include/posix-threads.h

@@ -0,0 +1,210 @@
+// -*- c++ -*-
+// posix-threads.h - Defines for using POSIX threads.
+
+/* Copyright (C) 1998, 1999  Cygnus Solutions
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+#ifndef __JV_POSIX_THREADS__
+#define __JV_POSIX_THREADS__
+
+// NOTE: This file may only reference those pthread functions which
+// are known not to be overridden by the Boehm GC.  If in doubt, scan
+// boehm-gc/gc.h.  This is yucky but lets us avoid including gc.h
+// everywhere (which would be truly yucky).
+
+#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;
+#ifdef HAVE_RECURSIVE_MUTEX
+typedef pthread_mutex_t _Jv_Mutex_t;
+#else
+// Some systems do not have recursive mutexes, so we must simulate
+// them.  Solaris is one such system.
+typedef struct
+{
+  // Mutex used when locking this structure transiently.
+  pthread_mutex_t mutex;
+  // 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;
+  // Number of times mutex is held.  If 0, the lock is not held.
+  int count;
+} _Jv_Mutex_t;
+#endif /* HAVE_RECURSIVE_MUTEX */
+
+typedef struct
+{
+  // Flag values are defined in implementation.
+  int flags;
+
+  // Actual thread id.
+  pthread_t thread;
+
+  // Exception we want to throw when cancelled.
+  void *exception;
+} _Jv_Thread_t;
+typedef void _Jv_ThreadStartFunc (java::lang::Thread *);
+
+
+//
+// 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);
+
+inline int
+_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *)
+{
+  // FIXME: check to see if mutex is held by current thread.
+  return pthread_cond_signal (cv);
+}
+
+inline int
+_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *)
+{
+  // FIXME: check to see if mutex is held by current thread.
+  return pthread_cond_broadcast (cv);
+}
+
+
+//
+// Mutexes.
+//
+
+#ifdef RECURSIVE_MUTEX_IS_DEFAULT
+inline void
+_Jv_MutexInit (_Jv_Mutex_t *mu)
+{
+  pthread_mutex_init (mu, NULL);
+}
+#else
+void _Jv_MutexInit (_Jv_Mutex_t *mu);
+#endif
+
+#ifndef LINUX_THREADS
+
+// pthread_mutex_destroy does nothing on Linux and it is a win to avoid
+// defining this macro.
+
+#define _Jv_HaveMutexDestroy
+
+#ifdef HAVE_RECURSIVE_MUTEX
+
+inline void
+_Jv_MutexDestroy (_Jv_Mutex_t *mu)
+{
+  pthread_mutex_destroy (mu);
+}
+
+#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)
+{
+  return pthread_mutex_lock (mu);
+}
+
+inline int
+_Jv_MutexUnlock (_Jv_Mutex_t *mu)
+{
+  return pthread_mutex_unlock (mu);
+}
+
+#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.
+//
+
+void _Jv_InitThreads (void);
+
+void _Jv_ThreadInitData (_Jv_Thread_t **data, java::lang::Thread *thread);
+
+inline java::lang::Thread *
+_Jv_ThreadCurrent (void)
+{
+  extern pthread_key_t _Jv_ThreadKey;
+  return (java::lang::Thread *) pthread_getspecific (_Jv_ThreadKey);
+}
+
+inline void
+_Jv_ThreadYield (void)
+{
+#ifdef HAVE_SCHED_YIELD
+  sched_yield ();
+#endif /* HAVE_SCHED_YIELD */
+}
+
+void _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio);
+
+void _Jv_ThreadCancel (_Jv_Thread_t *data, void *error);
+
+// Like Cancel, but doesn't run cleanups.
+inline void
+_Jv_ThreadDestroy (_Jv_Thread_t *)
+{
+  JvFail ("_Jv_ThreadDestroy");
+}
+
+void _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
+		      _Jv_ThreadStartFunc *meth);
+
+void _Jv_ThreadWait (void);
+
+void _Jv_ThreadInterrupt (_Jv_Thread_t *data);
+
+#endif /* __JV_POSIX_THREADS__ */