// -*- 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;

#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
{
  // 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 *);


// 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
}

#include <stdio.h>

// This is a convenience function used only by the pthreads thread
// implementation.  This is slow, but that's too bad -- we need to do
// the checks for correctness.  It might be nice to be able to compile
// this out.
inline int
_Jv_PthreadCheckMonitor (_Jv_Mutex_t *mu)
{
  pthread_mutex_t *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
  pthread_mutex_unlock (pmu);
  return r;
}

//
// 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 *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
  mu->count = 0;
#endif
}
#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 (_Jv_PthreadGetMutex (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)
{
  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.
//

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 _Jv_Thread_t *
_Jv_ThreadCurrentData (void)
{
  extern pthread_key_t _Jv_ThreadDataKey;
  return (_Jv_Thread_t *) pthread_getspecific (_Jv_ThreadDataKey);
}

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__ */