gcc/libjava/include/posix-threads.h

211 lines
4.4 KiB
C
Raw Normal View History

1999-04-07 16:42:40 +02:00
// -*- 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__ */