// posix-threads.cc - interface between libjava and POSIX threads.
|
// posix-threads.cc - interface between libjava and POSIX threads.
|
|
|
/* Copyright (C) 1998, 1999, 2000, 2001, 2004, 2006 Free Software Foundation
|
/* Copyright (C) 1998, 1999, 2000, 2001, 2004, 2006 Free Software Foundation
|
|
|
This file is part of libgcj.
|
This file is part of libgcj.
|
|
|
This software is copyrighted work licensed under the terms of the
|
This software is copyrighted work licensed under the terms of the
|
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
details. */
|
details. */
|
|
|
// TO DO:
|
// TO DO:
|
// * Document signal handling limitations
|
// * Document signal handling limitations
|
|
|
#include <config.h>
|
#include <config.h>
|
|
|
#include "posix.h"
|
#include "posix.h"
|
#include "posix-threads.h"
|
#include "posix-threads.h"
|
|
|
// If we're using the Boehm GC, then we need to override some of the
|
// If we're using the Boehm GC, then we need to override some of the
|
// thread primitives. This is fairly gross.
|
// thread primitives. This is fairly gross.
|
#ifdef HAVE_BOEHM_GC
|
#ifdef HAVE_BOEHM_GC
|
#include <gc.h>
|
#include <gc.h>
|
#endif /* HAVE_BOEHM_GC */
|
#endif /* HAVE_BOEHM_GC */
|
|
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#include <time.h>
|
#include <time.h>
|
#include <signal.h>
|
#include <signal.h>
|
#include <errno.h>
|
#include <errno.h>
|
#include <limits.h>
|
#include <limits.h>
|
#ifdef HAVE_UNISTD_H
|
#ifdef HAVE_UNISTD_H
|
#include <unistd.h> // To test for _POSIX_THREAD_PRIORITY_SCHEDULING
|
#include <unistd.h> // To test for _POSIX_THREAD_PRIORITY_SCHEDULING
|
#endif
|
#endif
|
|
|
#include <gcj/cni.h>
|
#include <gcj/cni.h>
|
#include <jvm.h>
|
#include <jvm.h>
|
#include <java/lang/Thread.h>
|
#include <java/lang/Thread.h>
|
#include <java/lang/System.h>
|
#include <java/lang/System.h>
|
#include <java/lang/Long.h>
|
#include <java/lang/Long.h>
|
#include <java/lang/OutOfMemoryError.h>
|
#include <java/lang/OutOfMemoryError.h>
|
#include <java/lang/InternalError.h>
|
#include <java/lang/InternalError.h>
|
|
|
// This is used to implement thread startup.
|
// This is used to implement thread startup.
|
struct starter
|
struct starter
|
{
|
{
|
_Jv_ThreadStartFunc *method;
|
_Jv_ThreadStartFunc *method;
|
_Jv_Thread_t *data;
|
_Jv_Thread_t *data;
|
};
|
};
|
|
|
// This is the key used to map from the POSIX thread value back to the
|
// This is the key used to map from the POSIX thread value back to the
|
// Java object representing the thread. The key is global to all
|
// Java object representing the thread. The key is global to all
|
// threads, so it is ok to make it a global here.
|
// threads, so it is ok to make it a global here.
|
pthread_key_t _Jv_ThreadKey;
|
pthread_key_t _Jv_ThreadKey;
|
|
|
// This is the key used to map from the POSIX thread value back to the
|
// This is the key used to map from the POSIX thread value back to the
|
// _Jv_Thread_t* representing the thread.
|
// _Jv_Thread_t* representing the thread.
|
pthread_key_t _Jv_ThreadDataKey;
|
pthread_key_t _Jv_ThreadDataKey;
|
|
|
// We keep a count of all non-daemon threads which are running. When
|
// We keep a count of all non-daemon threads which are running. When
|
// this reaches zero, _Jv_ThreadWait returns.
|
// this reaches zero, _Jv_ThreadWait returns.
|
static pthread_mutex_t daemon_mutex;
|
static pthread_mutex_t daemon_mutex;
|
static pthread_cond_t daemon_cond;
|
static pthread_cond_t daemon_cond;
|
static int non_daemon_count;
|
static int non_daemon_count;
|
|
|
// The signal to use when interrupting a thread.
|
// The signal to use when interrupting a thread.
|
#if defined(LINUX_THREADS) || defined(FREEBSD_THREADS)
|
#if defined(LINUX_THREADS) || defined(FREEBSD_THREADS)
|
// LinuxThreads (prior to glibc 2.1) usurps both SIGUSR1 and SIGUSR2.
|
// LinuxThreads (prior to glibc 2.1) usurps both SIGUSR1 and SIGUSR2.
|
// GC on FreeBSD uses both SIGUSR1 and SIGUSR2.
|
// GC on FreeBSD uses both SIGUSR1 and SIGUSR2.
|
# define INTR SIGHUP
|
# define INTR SIGHUP
|
#else /* LINUX_THREADS */
|
#else /* LINUX_THREADS */
|
# define INTR SIGUSR2
|
# define INTR SIGUSR2
|
#endif /* LINUX_THREADS */
|
#endif /* LINUX_THREADS */
|
|
|
//
|
//
|
// These are the flags that can appear in _Jv_Thread_t.
|
// These are the flags that can appear in _Jv_Thread_t.
|
//
|
//
|
|
|
// Thread started.
|
// Thread started.
|
#define FLAG_START 0x01
|
#define FLAG_START 0x01
|
// Thread is daemon.
|
// Thread is daemon.
|
#define FLAG_DAEMON 0x02
|
#define FLAG_DAEMON 0x02
|
|
|
|
|
|
|
int
|
int
|
_Jv_MutexLock (_Jv_Mutex_t *mu)
|
_Jv_MutexLock (_Jv_Mutex_t *mu)
|
{
|
{
|
pthread_t self = pthread_self ();
|
pthread_t self = pthread_self ();
|
if (mu->owner == self)
|
if (mu->owner == self)
|
{
|
{
|
mu->count++;
|
mu->count++;
|
}
|
}
|
else
|
else
|
{
|
{
|
JvSetThreadState holder (_Jv_ThreadCurrent(), JV_BLOCKED);
|
JvSetThreadState holder (_Jv_ThreadCurrent(), JV_BLOCKED);
|
|
|
# ifdef LOCK_DEBUG
|
# ifdef LOCK_DEBUG
|
int result = pthread_mutex_lock (&mu->mutex);
|
int result = pthread_mutex_lock (&mu->mutex);
|
if (0 != result)
|
if (0 != result)
|
{
|
{
|
fprintf(stderr, "Pthread_mutex_lock returned %d\n", result);
|
fprintf(stderr, "Pthread_mutex_lock returned %d\n", result);
|
for (;;) {}
|
for (;;) {}
|
}
|
}
|
# else
|
# else
|
pthread_mutex_lock (&mu->mutex);
|
pthread_mutex_lock (&mu->mutex);
|
# endif
|
# endif
|
mu->count = 1;
|
mu->count = 1;
|
mu->owner = self;
|
mu->owner = self;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
// Wait for the condition variable "CV" to be notified.
|
// Wait for the condition variable "CV" to be notified.
|
// Return values:
|
// Return values:
|
// 0: the condition was notified, or the timeout expired.
|
// 0: the condition was notified, or the timeout expired.
|
// _JV_NOT_OWNER: the thread does not own the mutex "MU".
|
// _JV_NOT_OWNER: the thread does not own the mutex "MU".
|
// _JV_INTERRUPTED: the thread was interrupted. Its interrupted flag is set.
|
// _JV_INTERRUPTED: the thread was interrupted. Its interrupted flag is set.
|
int
|
int
|
_Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
|
_Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
|
jlong millis, jint nanos)
|
jlong millis, jint nanos)
|
{
|
{
|
pthread_t self = pthread_self();
|
pthread_t self = pthread_self();
|
if (mu->owner != self)
|
if (mu->owner != self)
|
return _JV_NOT_OWNER;
|
return _JV_NOT_OWNER;
|
|
|
struct timespec ts;
|
struct timespec ts;
|
|
|
JvThreadState new_state = JV_WAITING;
|
JvThreadState new_state = JV_WAITING;
|
if (millis > 0 || nanos > 0)
|
if (millis > 0 || nanos > 0)
|
{
|
{
|
// Calculate the abstime corresponding to the timeout.
|
// Calculate the abstime corresponding to the timeout.
|
unsigned long long seconds;
|
unsigned long long seconds;
|
unsigned long usec;
|
unsigned long usec;
|
|
|
// For better accuracy, should use pthread_condattr_setclock
|
// For better accuracy, should use pthread_condattr_setclock
|
// and clock_gettime.
|
// and clock_gettime.
|
#ifdef HAVE_GETTIMEOFDAY
|
#ifdef HAVE_GETTIMEOFDAY
|
timeval tv;
|
timeval tv;
|
gettimeofday (&tv, NULL);
|
gettimeofday (&tv, NULL);
|
usec = tv.tv_usec;
|
usec = tv.tv_usec;
|
seconds = tv.tv_sec;
|
seconds = tv.tv_sec;
|
#else
|
#else
|
unsigned long long startTime = java::lang::System::currentTimeMillis();
|
unsigned long long startTime = java::lang::System::currentTimeMillis();
|
seconds = startTime / 1000;
|
seconds = startTime / 1000;
|
/* Assume we're about half-way through this millisecond. */
|
/* Assume we're about half-way through this millisecond. */
|
usec = (startTime % 1000) * 1000 + 500;
|
usec = (startTime % 1000) * 1000 + 500;
|
#endif
|
#endif
|
/* These next two statements cannot overflow. */
|
/* These next two statements cannot overflow. */
|
usec += nanos / 1000;
|
usec += nanos / 1000;
|
usec += (millis % 1000) * 1000;
|
usec += (millis % 1000) * 1000;
|
/* These two statements could overflow only if tv.tv_sec was
|
/* These two statements could overflow only if tv.tv_sec was
|
insanely large. */
|
insanely large. */
|
seconds += millis / 1000;
|
seconds += millis / 1000;
|
seconds += usec / 1000000;
|
seconds += usec / 1000000;
|
|
|
ts.tv_sec = seconds;
|
ts.tv_sec = seconds;
|
if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
|
if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
|
{
|
{
|
// We treat a timeout that won't fit into a struct timespec
|
// We treat a timeout that won't fit into a struct timespec
|
// as a wait forever.
|
// as a wait forever.
|
millis = nanos = 0;
|
millis = nanos = 0;
|
}
|
}
|
else
|
else
|
/* This next statement also cannot overflow. */
|
/* This next statement also cannot overflow. */
|
ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
|
ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
|
}
|
}
|
|
|
_Jv_Thread_t *current = _Jv_ThreadCurrentData ();
|
_Jv_Thread_t *current = _Jv_ThreadCurrentData ();
|
java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
|
java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
|
|
|
pthread_mutex_lock (¤t->wait_mutex);
|
pthread_mutex_lock (¤t->wait_mutex);
|
|
|
// Now that we hold the wait mutex, check if this thread has been
|
// Now that we hold the wait mutex, check if this thread has been
|
// interrupted already.
|
// interrupted already.
|
if (current_obj->interrupt_flag)
|
if (current_obj->interrupt_flag)
|
{
|
{
|
pthread_mutex_unlock (¤t->wait_mutex);
|
pthread_mutex_unlock (¤t->wait_mutex);
|
return _JV_INTERRUPTED;
|
return _JV_INTERRUPTED;
|
}
|
}
|
|
|
// Set the thread's state.
|
// Set the thread's state.
|
JvSetThreadState holder (current_obj, new_state);
|
JvSetThreadState holder (current_obj, new_state);
|
|
|
// Add this thread to the cv's wait set.
|
// Add this thread to the cv's wait set.
|
current->next = NULL;
|
current->next = NULL;
|
|
|
if (cv->first == NULL)
|
if (cv->first == NULL)
|
cv->first = current;
|
cv->first = current;
|
else
|
else
|
for (_Jv_Thread_t *t = cv->first;; t = t->next)
|
for (_Jv_Thread_t *t = cv->first;; t = t->next)
|
{
|
{
|
if (t->next == NULL)
|
if (t->next == NULL)
|
{
|
{
|
t->next = current;
|
t->next = current;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
// Record the current lock depth, so it can be restored when we re-aquire it.
|
// Record the current lock depth, so it can be restored when we re-aquire it.
|
int count = mu->count;
|
int count = mu->count;
|
|
|
// Release the monitor mutex.
|
// Release the monitor mutex.
|
mu->count = 0;
|
mu->count = 0;
|
mu->owner = 0;
|
mu->owner = 0;
|
pthread_mutex_unlock (&mu->mutex);
|
pthread_mutex_unlock (&mu->mutex);
|
|
|
int r = 0;
|
int r = 0;
|
bool done_sleeping = false;
|
bool done_sleeping = false;
|
|
|
while (! done_sleeping)
|
while (! done_sleeping)
|
{
|
{
|
if (millis == 0 && nanos == 0)
|
if (millis == 0 && nanos == 0)
|
r = pthread_cond_wait (¤t->wait_cond, ¤t->wait_mutex);
|
r = pthread_cond_wait (¤t->wait_cond, ¤t->wait_mutex);
|
else
|
else
|
r = pthread_cond_timedwait (¤t->wait_cond, ¤t->wait_mutex,
|
r = pthread_cond_timedwait (¤t->wait_cond, ¤t->wait_mutex,
|
&ts);
|
&ts);
|
|
|
// In older glibc's (prior to 2.1.3), the cond_wait functions may
|
// In older glibc's (prior to 2.1.3), the cond_wait functions may
|
// spuriously wake up on a signal. Catch that here.
|
// spuriously wake up on a signal. Catch that here.
|
if (r != EINTR)
|
if (r != EINTR)
|
done_sleeping = true;
|
done_sleeping = true;
|
}
|
}
|
|
|
// Check for an interrupt *before* releasing the wait mutex.
|
// Check for an interrupt *before* releasing the wait mutex.
|
jboolean interrupted = current_obj->interrupt_flag;
|
jboolean interrupted = current_obj->interrupt_flag;
|
|
|
pthread_mutex_unlock (¤t->wait_mutex);
|
pthread_mutex_unlock (¤t->wait_mutex);
|
|
|
// Reaquire the monitor mutex, and restore the lock count.
|
// Reaquire the monitor mutex, and restore the lock count.
|
pthread_mutex_lock (&mu->mutex);
|
pthread_mutex_lock (&mu->mutex);
|
mu->owner = self;
|
mu->owner = self;
|
mu->count = count;
|
mu->count = count;
|
|
|
// If we were interrupted, or if a timeout occurred, remove ourself from
|
// If we were interrupted, or if a timeout occurred, remove ourself from
|
// the cv wait list now. (If we were notified normally, notify() will have
|
// the cv wait list now. (If we were notified normally, notify() will have
|
// already taken care of this)
|
// already taken care of this)
|
if (r == ETIMEDOUT || interrupted)
|
if (r == ETIMEDOUT || interrupted)
|
{
|
{
|
_Jv_Thread_t *prev = NULL;
|
_Jv_Thread_t *prev = NULL;
|
for (_Jv_Thread_t *t = cv->first; t != NULL; t = t->next)
|
for (_Jv_Thread_t *t = cv->first; t != NULL; t = t->next)
|
{
|
{
|
if (t == current)
|
if (t == current)
|
{
|
{
|
if (prev != NULL)
|
if (prev != NULL)
|
prev->next = t->next;
|
prev->next = t->next;
|
else
|
else
|
cv->first = t->next;
|
cv->first = t->next;
|
t->next = NULL;
|
t->next = NULL;
|
break;
|
break;
|
}
|
}
|
prev = t;
|
prev = t;
|
}
|
}
|
if (interrupted)
|
if (interrupted)
|
return _JV_INTERRUPTED;
|
return _JV_INTERRUPTED;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
{
|
{
|
if (_Jv_MutexCheckMonitor (mu))
|
if (_Jv_MutexCheckMonitor (mu))
|
return _JV_NOT_OWNER;
|
return _JV_NOT_OWNER;
|
|
|
_Jv_Thread_t *target;
|
_Jv_Thread_t *target;
|
_Jv_Thread_t *prev = NULL;
|
_Jv_Thread_t *prev = NULL;
|
|
|
for (target = cv->first; target != NULL; target = target->next)
|
for (target = cv->first; target != NULL; target = target->next)
|
{
|
{
|
pthread_mutex_lock (&target->wait_mutex);
|
pthread_mutex_lock (&target->wait_mutex);
|
|
|
if (target->thread_obj->interrupt_flag)
|
if (target->thread_obj->interrupt_flag)
|
{
|
{
|
// Don't notify a thread that has already been interrupted.
|
// Don't notify a thread that has already been interrupted.
|
pthread_mutex_unlock (&target->wait_mutex);
|
pthread_mutex_unlock (&target->wait_mutex);
|
prev = target;
|
prev = target;
|
continue;
|
continue;
|
}
|
}
|
|
|
pthread_cond_signal (&target->wait_cond);
|
pthread_cond_signal (&target->wait_cond);
|
pthread_mutex_unlock (&target->wait_mutex);
|
pthread_mutex_unlock (&target->wait_mutex);
|
|
|
// Two concurrent notify() calls must not be delivered to the same
|
// Two concurrent notify() calls must not be delivered to the same
|
// thread, so remove the target thread from the cv wait list now.
|
// thread, so remove the target thread from the cv wait list now.
|
if (prev == NULL)
|
if (prev == NULL)
|
cv->first = target->next;
|
cv->first = target->next;
|
else
|
else
|
prev->next = target->next;
|
prev->next = target->next;
|
|
|
target->next = NULL;
|
target->next = NULL;
|
|
|
break;
|
break;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
|
{
|
{
|
if (_Jv_MutexCheckMonitor (mu))
|
if (_Jv_MutexCheckMonitor (mu))
|
return _JV_NOT_OWNER;
|
return _JV_NOT_OWNER;
|
|
|
_Jv_Thread_t *target;
|
_Jv_Thread_t *target;
|
_Jv_Thread_t *prev = NULL;
|
_Jv_Thread_t *prev = NULL;
|
|
|
for (target = cv->first; target != NULL; target = target->next)
|
for (target = cv->first; target != NULL; target = target->next)
|
{
|
{
|
pthread_mutex_lock (&target->wait_mutex);
|
pthread_mutex_lock (&target->wait_mutex);
|
pthread_cond_signal (&target->wait_cond);
|
pthread_cond_signal (&target->wait_cond);
|
pthread_mutex_unlock (&target->wait_mutex);
|
pthread_mutex_unlock (&target->wait_mutex);
|
|
|
if (prev != NULL)
|
if (prev != NULL)
|
prev->next = NULL;
|
prev->next = NULL;
|
prev = target;
|
prev = target;
|
}
|
}
|
if (prev != NULL)
|
if (prev != NULL)
|
prev->next = NULL;
|
prev->next = NULL;
|
|
|
cv->first = NULL;
|
cv->first = NULL;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
void
|
void
|
_Jv_ThreadInterrupt (_Jv_Thread_t *data)
|
_Jv_ThreadInterrupt (_Jv_Thread_t *data)
|
{
|
{
|
pthread_mutex_lock (&data->wait_mutex);
|
pthread_mutex_lock (&data->wait_mutex);
|
|
|
// Set the thread's interrupted flag *after* aquiring its wait_mutex. This
|
// Set the thread's interrupted flag *after* aquiring its wait_mutex. This
|
// ensures that there are no races with the interrupt flag being set after
|
// ensures that there are no races with the interrupt flag being set after
|
// the waiting thread checks it and before pthread_cond_wait is entered.
|
// the waiting thread checks it and before pthread_cond_wait is entered.
|
data->thread_obj->interrupt_flag = true;
|
data->thread_obj->interrupt_flag = true;
|
|
|
// Interrupt blocking system calls using a signal.
|
// Interrupt blocking system calls using a signal.
|
pthread_kill (data->thread, INTR);
|
pthread_kill (data->thread, INTR);
|
|
|
pthread_cond_signal (&data->wait_cond);
|
pthread_cond_signal (&data->wait_cond);
|
|
|
pthread_mutex_unlock (&data->wait_mutex);
|
pthread_mutex_unlock (&data->wait_mutex);
|
}
|
}
|
|
|
/**
|
/**
|
* Releases the block on a thread created by _Jv_ThreadPark(). This
|
* Releases the block on a thread created by _Jv_ThreadPark(). This
|
* method can also be used to terminate a blockage caused by a prior
|
* method can also be used to terminate a blockage caused by a prior
|
* call to park. This operation is unsafe, as the thread must be
|
* call to park. This operation is unsafe, as the thread must be
|
* guaranteed to be live.
|
* guaranteed to be live.
|
*
|
*
|
* @param thread the thread to unblock.
|
* @param thread the thread to unblock.
|
*/
|
*/
|
void
|
void
|
ParkHelper::unpark ()
|
ParkHelper::unpark ()
|
{
|
{
|
using namespace ::java::lang;
|
using namespace ::java::lang;
|
volatile obj_addr_t *ptr = &permit;
|
volatile obj_addr_t *ptr = &permit;
|
|
|
/* If this thread is in state RUNNING, give it a permit and return
|
/* If this thread is in state RUNNING, give it a permit and return
|
immediately. */
|
immediately. */
|
if (compare_and_swap
|
if (compare_and_swap
|
(ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PERMIT))
|
(ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PERMIT))
|
return;
|
return;
|
|
|
/* If this thread is parked, put it into state RUNNING and send it a
|
/* If this thread is parked, put it into state RUNNING and send it a
|
signal. */
|
signal. */
|
if (compare_and_swap
|
if (compare_and_swap
|
(ptr, Thread::THREAD_PARK_PARKED, Thread::THREAD_PARK_RUNNING))
|
(ptr, Thread::THREAD_PARK_PARKED, Thread::THREAD_PARK_RUNNING))
|
{
|
{
|
int result;
|
int result;
|
pthread_mutex_lock (&mutex);
|
pthread_mutex_lock (&mutex);
|
result = pthread_cond_signal (&cond);
|
result = pthread_cond_signal (&cond);
|
pthread_mutex_unlock (&mutex);
|
pthread_mutex_unlock (&mutex);
|
JvAssert (result == 0);
|
JvAssert (result == 0);
|
}
|
}
|
}
|
}
|
|
|
/**
|
/**
|
* Sets our state to dead.
|
* Sets our state to dead.
|
*/
|
*/
|
void
|
void
|
ParkHelper::deactivate ()
|
ParkHelper::deactivate ()
|
{
|
{
|
permit = ::java::lang::Thread::THREAD_PARK_DEAD;
|
permit = ::java::lang::Thread::THREAD_PARK_DEAD;
|
}
|
}
|
|
|
void
|
void
|
ParkHelper::init ()
|
ParkHelper::init ()
|
{
|
{
|
pthread_mutex_init (&mutex, NULL);
|
pthread_mutex_init (&mutex, NULL);
|
pthread_cond_init (&cond, NULL);
|
pthread_cond_init (&cond, NULL);
|
permit = ::java::lang::Thread::THREAD_PARK_RUNNING;
|
permit = ::java::lang::Thread::THREAD_PARK_RUNNING;
|
}
|
}
|
|
|
/**
|
/**
|
* Blocks the thread until a matching _Jv_ThreadUnpark() occurs, the
|
* Blocks the thread until a matching _Jv_ThreadUnpark() occurs, the
|
* thread is interrupted or the optional timeout expires. If an
|
* thread is interrupted or the optional timeout expires. If an
|
* unpark call has already occurred, this also counts. A timeout
|
* unpark call has already occurred, this also counts. A timeout
|
* value of zero is defined as no timeout. When isAbsolute is true,
|
* value of zero is defined as no timeout. When isAbsolute is true,
|
* the timeout is in milliseconds relative to the epoch. Otherwise,
|
* the timeout is in milliseconds relative to the epoch. Otherwise,
|
* the value is the number of nanoseconds which must occur before
|
* the value is the number of nanoseconds which must occur before
|
* timeout. This call may also return spuriously (i.e. for no
|
* timeout. This call may also return spuriously (i.e. for no
|
* apparent reason).
|
* apparent reason).
|
*
|
*
|
* @param isAbsolute true if the timeout is specified in milliseconds from
|
* @param isAbsolute true if the timeout is specified in milliseconds from
|
* the epoch.
|
* the epoch.
|
* @param time either the number of nanoseconds to wait, or a time in
|
* @param time either the number of nanoseconds to wait, or a time in
|
* milliseconds from the epoch to wait for.
|
* milliseconds from the epoch to wait for.
|
*/
|
*/
|
void
|
void
|
ParkHelper::park (jboolean isAbsolute, jlong time)
|
ParkHelper::park (jboolean isAbsolute, jlong time)
|
{
|
{
|
using namespace ::java::lang;
|
using namespace ::java::lang;
|
volatile obj_addr_t *ptr = &permit;
|
volatile obj_addr_t *ptr = &permit;
|
|
|
/* If we have a permit, return immediately. */
|
/* If we have a permit, return immediately. */
|
if (compare_and_swap
|
if (compare_and_swap
|
(ptr, Thread::THREAD_PARK_PERMIT, Thread::THREAD_PARK_RUNNING))
|
(ptr, Thread::THREAD_PARK_PERMIT, Thread::THREAD_PARK_RUNNING))
|
return;
|
return;
|
|
|
struct timespec ts;
|
struct timespec ts;
|
|
|
if (time)
|
if (time)
|
{
|
{
|
unsigned long long seconds;
|
unsigned long long seconds;
|
unsigned long usec;
|
unsigned long usec;
|
|
|
if (isAbsolute)
|
if (isAbsolute)
|
{
|
{
|
ts.tv_sec = time / 1000;
|
ts.tv_sec = time / 1000;
|
ts.tv_nsec = (time % 1000) * 1000 * 1000;
|
ts.tv_nsec = (time % 1000) * 1000 * 1000;
|
}
|
}
|
else
|
else
|
{
|
{
|
// Calculate the abstime corresponding to the timeout.
|
// Calculate the abstime corresponding to the timeout.
|
jlong nanos = time;
|
jlong nanos = time;
|
jlong millis = 0;
|
jlong millis = 0;
|
|
|
// For better accuracy, should use pthread_condattr_setclock
|
// For better accuracy, should use pthread_condattr_setclock
|
// and clock_gettime.
|
// and clock_gettime.
|
#ifdef HAVE_GETTIMEOFDAY
|
#ifdef HAVE_GETTIMEOFDAY
|
timeval tv;
|
timeval tv;
|
gettimeofday (&tv, NULL);
|
gettimeofday (&tv, NULL);
|
usec = tv.tv_usec;
|
usec = tv.tv_usec;
|
seconds = tv.tv_sec;
|
seconds = tv.tv_sec;
|
#else
|
#else
|
unsigned long long startTime
|
unsigned long long startTime
|
= java::lang::System::currentTimeMillis();
|
= java::lang::System::currentTimeMillis();
|
seconds = startTime / 1000;
|
seconds = startTime / 1000;
|
/* Assume we're about half-way through this millisecond. */
|
/* Assume we're about half-way through this millisecond. */
|
usec = (startTime % 1000) * 1000 + 500;
|
usec = (startTime % 1000) * 1000 + 500;
|
#endif
|
#endif
|
/* These next two statements cannot overflow. */
|
/* These next two statements cannot overflow. */
|
usec += nanos / 1000;
|
usec += nanos / 1000;
|
usec += (millis % 1000) * 1000;
|
usec += (millis % 1000) * 1000;
|
/* These two statements could overflow only if tv.tv_sec was
|
/* These two statements could overflow only if tv.tv_sec was
|
insanely large. */
|
insanely large. */
|
seconds += millis / 1000;
|
seconds += millis / 1000;
|
seconds += usec / 1000000;
|
seconds += usec / 1000000;
|
|
|
ts.tv_sec = seconds;
|
ts.tv_sec = seconds;
|
if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
|
if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
|
{
|
{
|
// We treat a timeout that won't fit into a struct timespec
|
// We treat a timeout that won't fit into a struct timespec
|
// as a wait forever.
|
// as a wait forever.
|
millis = nanos = 0;
|
millis = nanos = 0;
|
}
|
}
|
else
|
else
|
/* This next statement also cannot overflow. */
|
/* This next statement also cannot overflow. */
|
ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
|
ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
|
}
|
}
|
}
|
}
|
|
|
pthread_mutex_lock (&mutex);
|
pthread_mutex_lock (&mutex);
|
if (compare_and_swap
|
if (compare_and_swap
|
(ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED))
|
(ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED))
|
{
|
{
|
int result = 0;
|
int result = 0;
|
|
|
if (! time)
|
if (! time)
|
result = pthread_cond_wait (&cond, &mutex);
|
result = pthread_cond_wait (&cond, &mutex);
|
else
|
else
|
result = pthread_cond_timedwait (&cond, &mutex, &ts);
|
result = pthread_cond_timedwait (&cond, &mutex, &ts);
|
|
|
JvAssert (result == 0 || result == ETIMEDOUT);
|
JvAssert (result == 0 || result == ETIMEDOUT);
|
|
|
/* If we were unparked by some other thread, this will already
|
/* If we were unparked by some other thread, this will already
|
be in state THREAD_PARK_RUNNING. If we timed out or were
|
be in state THREAD_PARK_RUNNING. If we timed out or were
|
interrupted, we have to do it ourself. */
|
interrupted, we have to do it ourself. */
|
permit = Thread::THREAD_PARK_RUNNING;
|
permit = Thread::THREAD_PARK_RUNNING;
|
}
|
}
|
pthread_mutex_unlock (&mutex);
|
pthread_mutex_unlock (&mutex);
|
}
|
}
|
|
|
static void
|
static void
|
handle_intr (int)
|
handle_intr (int)
|
{
|
{
|
// Do nothing.
|
// Do nothing.
|
}
|
}
|
|
|
void
|
void
|
_Jv_BlockSigchld()
|
_Jv_BlockSigchld()
|
{
|
{
|
sigset_t mask;
|
sigset_t mask;
|
sigemptyset (&mask);
|
sigemptyset (&mask);
|
sigaddset (&mask, SIGCHLD);
|
sigaddset (&mask, SIGCHLD);
|
int c = pthread_sigmask (SIG_BLOCK, &mask, NULL);
|
int c = pthread_sigmask (SIG_BLOCK, &mask, NULL);
|
if (c != 0)
|
if (c != 0)
|
JvFail (strerror (c));
|
JvFail (strerror (c));
|
}
|
}
|
|
|
void
|
void
|
_Jv_UnBlockSigchld()
|
_Jv_UnBlockSigchld()
|
{
|
{
|
sigset_t mask;
|
sigset_t mask;
|
sigemptyset (&mask);
|
sigemptyset (&mask);
|
sigaddset (&mask, SIGCHLD);
|
sigaddset (&mask, SIGCHLD);
|
int c = pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
|
int c = pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
|
if (c != 0)
|
if (c != 0)
|
JvFail (strerror (c));
|
JvFail (strerror (c));
|
}
|
}
|
|
|
void
|
void
|
_Jv_InitThreads (void)
|
_Jv_InitThreads (void)
|
{
|
{
|
pthread_key_create (&_Jv_ThreadKey, NULL);
|
pthread_key_create (&_Jv_ThreadKey, NULL);
|
pthread_key_create (&_Jv_ThreadDataKey, NULL);
|
pthread_key_create (&_Jv_ThreadDataKey, NULL);
|
pthread_mutex_init (&daemon_mutex, NULL);
|
pthread_mutex_init (&daemon_mutex, NULL);
|
pthread_cond_init (&daemon_cond, 0);
|
pthread_cond_init (&daemon_cond, 0);
|
non_daemon_count = 0;
|
non_daemon_count = 0;
|
|
|
// Arrange for the interrupt signal to interrupt system calls.
|
// Arrange for the interrupt signal to interrupt system calls.
|
struct sigaction act;
|
struct sigaction act;
|
act.sa_handler = handle_intr;
|
act.sa_handler = handle_intr;
|
sigemptyset (&act.sa_mask);
|
sigemptyset (&act.sa_mask);
|
act.sa_flags = 0;
|
act.sa_flags = 0;
|
sigaction (INTR, &act, NULL);
|
sigaction (INTR, &act, NULL);
|
|
|
// Block SIGCHLD here to ensure that any non-Java threads inherit the new
|
// Block SIGCHLD here to ensure that any non-Java threads inherit the new
|
// signal mask.
|
// signal mask.
|
_Jv_BlockSigchld();
|
_Jv_BlockSigchld();
|
|
|
// Check/set the thread stack size.
|
// Check/set the thread stack size.
|
size_t min_ss = 32 * 1024;
|
size_t min_ss = 32 * 1024;
|
|
|
if (sizeof (void *) == 8)
|
if (sizeof (void *) == 8)
|
// Bigger default on 64-bit systems.
|
// Bigger default on 64-bit systems.
|
min_ss *= 2;
|
min_ss *= 2;
|
|
|
#ifdef PTHREAD_STACK_MIN
|
#ifdef PTHREAD_STACK_MIN
|
if (min_ss < PTHREAD_STACK_MIN)
|
if (min_ss < PTHREAD_STACK_MIN)
|
min_ss = PTHREAD_STACK_MIN;
|
min_ss = PTHREAD_STACK_MIN;
|
#endif
|
#endif
|
|
|
if (gcj::stack_size > 0 && gcj::stack_size < min_ss)
|
if (gcj::stack_size > 0 && gcj::stack_size < min_ss)
|
gcj::stack_size = min_ss;
|
gcj::stack_size = min_ss;
|
}
|
}
|
|
|
_Jv_Thread_t *
|
_Jv_Thread_t *
|
_Jv_ThreadInitData (java::lang::Thread *obj)
|
_Jv_ThreadInitData (java::lang::Thread *obj)
|
{
|
{
|
_Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_Jv_Thread_t));
|
_Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_Jv_Thread_t));
|
data->flags = 0;
|
data->flags = 0;
|
data->thread_obj = obj;
|
data->thread_obj = obj;
|
|
|
pthread_mutex_init (&data->wait_mutex, NULL);
|
pthread_mutex_init (&data->wait_mutex, NULL);
|
pthread_cond_init (&data->wait_cond, NULL);
|
pthread_cond_init (&data->wait_cond, NULL);
|
|
|
return data;
|
return data;
|
}
|
}
|
|
|
void
|
void
|
_Jv_ThreadDestroyData (_Jv_Thread_t *data)
|
_Jv_ThreadDestroyData (_Jv_Thread_t *data)
|
{
|
{
|
pthread_mutex_destroy (&data->wait_mutex);
|
pthread_mutex_destroy (&data->wait_mutex);
|
pthread_cond_destroy (&data->wait_cond);
|
pthread_cond_destroy (&data->wait_cond);
|
_Jv_Free ((void *)data);
|
_Jv_Free ((void *)data);
|
}
|
}
|
|
|
void
|
void
|
_Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
|
_Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
|
{
|
{
|
#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
|
#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
|
if (data->flags & FLAG_START)
|
if (data->flags & FLAG_START)
|
{
|
{
|
struct sched_param param;
|
struct sched_param param;
|
|
|
param.sched_priority = prio;
|
param.sched_priority = prio;
|
pthread_setschedparam (data->thread, SCHED_OTHER, ¶m);
|
pthread_setschedparam (data->thread, SCHED_OTHER, ¶m);
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
void
|
void
|
_Jv_ThreadRegister (_Jv_Thread_t *data)
|
_Jv_ThreadRegister (_Jv_Thread_t *data)
|
{
|
{
|
pthread_setspecific (_Jv_ThreadKey, data->thread_obj);
|
pthread_setspecific (_Jv_ThreadKey, data->thread_obj);
|
pthread_setspecific (_Jv_ThreadDataKey, data);
|
pthread_setspecific (_Jv_ThreadDataKey, data);
|
|
|
// glibc 2.1.3 doesn't set the value of `thread' until after start_routine
|
// glibc 2.1.3 doesn't set the value of `thread' until after start_routine
|
// is called. Since it may need to be accessed from the new thread, work
|
// is called. Since it may need to be accessed from the new thread, work
|
// around the potential race here by explicitly setting it again.
|
// around the potential race here by explicitly setting it again.
|
data->thread = pthread_self ();
|
data->thread = pthread_self ();
|
|
|
# ifdef SLOW_PTHREAD_SELF
|
# ifdef SLOW_PTHREAD_SELF
|
// Clear all self cache slots that might be needed by this thread.
|
// Clear all self cache slots that might be needed by this thread.
|
int dummy;
|
int dummy;
|
int low_index = SC_INDEX(&dummy) + SC_CLEAR_MIN;
|
int low_index = SC_INDEX(&dummy) + SC_CLEAR_MIN;
|
int high_index = SC_INDEX(&dummy) + SC_CLEAR_MAX;
|
int high_index = SC_INDEX(&dummy) + SC_CLEAR_MAX;
|
for (int i = low_index; i <= high_index; ++i)
|
for (int i = low_index; i <= high_index; ++i)
|
{
|
{
|
int current_index = i;
|
int current_index = i;
|
if (current_index < 0)
|
if (current_index < 0)
|
current_index += SELF_CACHE_SIZE;
|
current_index += SELF_CACHE_SIZE;
|
if (current_index >= SELF_CACHE_SIZE)
|
if (current_index >= SELF_CACHE_SIZE)
|
current_index -= SELF_CACHE_SIZE;
|
current_index -= SELF_CACHE_SIZE;
|
_Jv_self_cache[current_index].high_sp_bits = BAD_HIGH_SP_VALUE;
|
_Jv_self_cache[current_index].high_sp_bits = BAD_HIGH_SP_VALUE;
|
}
|
}
|
# endif
|
# endif
|
// Block SIGCHLD which is used in natPosixProcess.cc.
|
// Block SIGCHLD which is used in natPosixProcess.cc.
|
_Jv_BlockSigchld();
|
_Jv_BlockSigchld();
|
}
|
}
|
|
|
void
|
void
|
_Jv_ThreadUnRegister ()
|
_Jv_ThreadUnRegister ()
|
{
|
{
|
pthread_setspecific (_Jv_ThreadKey, NULL);
|
pthread_setspecific (_Jv_ThreadKey, NULL);
|
pthread_setspecific (_Jv_ThreadDataKey, NULL);
|
pthread_setspecific (_Jv_ThreadDataKey, NULL);
|
}
|
}
|
|
|
// This function is called when a thread is started. We don't arrange
|
// This function is called when a thread is started. We don't arrange
|
// to call the `run' method directly, because this function must
|
// to call the `run' method directly, because this function must
|
// return a value.
|
// return a value.
|
static void *
|
static void *
|
really_start (void *x)
|
really_start (void *x)
|
{
|
{
|
struct starter *info = (struct starter *) x;
|
struct starter *info = (struct starter *) x;
|
|
|
_Jv_ThreadRegister (info->data);
|
_Jv_ThreadRegister (info->data);
|
|
|
info->method (info->data->thread_obj);
|
info->method (info->data->thread_obj);
|
|
|
if (! (info->data->flags & FLAG_DAEMON))
|
if (! (info->data->flags & FLAG_DAEMON))
|
{
|
{
|
pthread_mutex_lock (&daemon_mutex);
|
pthread_mutex_lock (&daemon_mutex);
|
--non_daemon_count;
|
--non_daemon_count;
|
if (! non_daemon_count)
|
if (! non_daemon_count)
|
pthread_cond_signal (&daemon_cond);
|
pthread_cond_signal (&daemon_cond);
|
pthread_mutex_unlock (&daemon_mutex);
|
pthread_mutex_unlock (&daemon_mutex);
|
}
|
}
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
void
|
void
|
_Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
|
_Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
|
_Jv_ThreadStartFunc *meth)
|
_Jv_ThreadStartFunc *meth)
|
{
|
{
|
struct sched_param param;
|
struct sched_param param;
|
pthread_attr_t attr;
|
pthread_attr_t attr;
|
struct starter *info;
|
struct starter *info;
|
|
|
if (data->flags & FLAG_START)
|
if (data->flags & FLAG_START)
|
return;
|
return;
|
data->flags |= FLAG_START;
|
data->flags |= FLAG_START;
|
|
|
// Block SIGCHLD which is used in natPosixProcess.cc.
|
// Block SIGCHLD which is used in natPosixProcess.cc.
|
// The current mask is inherited by the child thread.
|
// The current mask is inherited by the child thread.
|
_Jv_BlockSigchld();
|
_Jv_BlockSigchld();
|
|
|
param.sched_priority = thread->getPriority();
|
param.sched_priority = thread->getPriority();
|
|
|
pthread_attr_init (&attr);
|
pthread_attr_init (&attr);
|
pthread_attr_setschedparam (&attr, ¶m);
|
pthread_attr_setschedparam (&attr, ¶m);
|
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
|
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
|
|
|
// Set stack size if -Xss option was given.
|
// Set stack size if -Xss option was given.
|
if (gcj::stack_size > 0)
|
if (gcj::stack_size > 0)
|
{
|
{
|
int e = pthread_attr_setstacksize (&attr, gcj::stack_size);
|
int e = pthread_attr_setstacksize (&attr, gcj::stack_size);
|
if (e != 0)
|
if (e != 0)
|
JvFail (strerror (e));
|
JvFail (strerror (e));
|
}
|
}
|
|
|
info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
|
info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
|
info->method = meth;
|
info->method = meth;
|
info->data = data;
|
info->data = data;
|
|
|
if (! thread->isDaemon())
|
if (! thread->isDaemon())
|
{
|
{
|
pthread_mutex_lock (&daemon_mutex);
|
pthread_mutex_lock (&daemon_mutex);
|
++non_daemon_count;
|
++non_daemon_count;
|
pthread_mutex_unlock (&daemon_mutex);
|
pthread_mutex_unlock (&daemon_mutex);
|
}
|
}
|
else
|
else
|
data->flags |= FLAG_DAEMON;
|
data->flags |= FLAG_DAEMON;
|
int r = pthread_create (&data->thread, &attr, really_start, (void *) info);
|
int r = pthread_create (&data->thread, &attr, really_start, (void *) info);
|
|
|
pthread_attr_destroy (&attr);
|
pthread_attr_destroy (&attr);
|
|
|
if (r)
|
if (r)
|
{
|
{
|
const char* msg = "Cannot create additional threads";
|
const char* msg = "Cannot create additional threads";
|
throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
|
throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
_Jv_ThreadWait (void)
|
_Jv_ThreadWait (void)
|
{
|
{
|
pthread_mutex_lock (&daemon_mutex);
|
pthread_mutex_lock (&daemon_mutex);
|
if (non_daemon_count)
|
if (non_daemon_count)
|
pthread_cond_wait (&daemon_cond, &daemon_mutex);
|
pthread_cond_wait (&daemon_cond, &daemon_mutex);
|
pthread_mutex_unlock (&daemon_mutex);
|
pthread_mutex_unlock (&daemon_mutex);
|
}
|
}
|
|
|
#if defined(SLOW_PTHREAD_SELF)
|
#if defined(SLOW_PTHREAD_SELF)
|
|
|
#include "sysdep/locks.h"
|
#include "sysdep/locks.h"
|
|
|
// Support for pthread_self() lookup cache.
|
// Support for pthread_self() lookup cache.
|
volatile self_cache_entry _Jv_self_cache[SELF_CACHE_SIZE];
|
volatile self_cache_entry _Jv_self_cache[SELF_CACHE_SIZE];
|
|
|
_Jv_ThreadId_t
|
_Jv_ThreadId_t
|
_Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce, size_t high_sp_bits)
|
_Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce, size_t high_sp_bits)
|
{
|
{
|
pthread_t self = pthread_self();
|
pthread_t self = pthread_self();
|
sce -> high_sp_bits = high_sp_bits;
|
sce -> high_sp_bits = high_sp_bits;
|
write_barrier();
|
write_barrier();
|
sce -> self = self;
|
sce -> self = self;
|
return self;
|
return self;
|
}
|
}
|
|
|
#endif /* SLOW_PTHREAD_SELF */
|
#endif /* SLOW_PTHREAD_SELF */
|
|
|
