211 lines
4.4 KiB
C++
211 lines
4.4 KiB
C++
// -*- 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__ */
|