// posix-threads.cc - interface between libjava and POSIX threads.
-/* Copyright (C) 1998, 1999, 2000, 2001, 2004 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2004, 2006 Free Software Foundation
This file is part of libgcj.
#include <config.h>
+#include "posix.h"
+#include "posix-threads.h"
+
// If we're using the Boehm GC, then we need to override some of the
// thread primitives. This is fairly gross.
#ifdef HAVE_BOEHM_GC
\f
+int
+_Jv_MutexLock (_Jv_Mutex_t *mu)
+{
+ pthread_t self = pthread_self ();
+ if (mu->owner == self)
+ {
+ mu->count++;
+ }
+ else
+ {
+ JvSetThreadState holder (_Jv_ThreadCurrent(), JV_BLOCKED);
+
+# ifdef LOCK_DEBUG
+ int result = pthread_mutex_lock (&mu->mutex);
+ if (0 != result)
+ {
+ fprintf(stderr, "Pthread_mutex_lock returned %d\n", result);
+ for (;;) {}
+ }
+# else
+ pthread_mutex_lock (&mu->mutex);
+# endif
+ mu->count = 1;
+ mu->owner = self;
+ }
+ return 0;
+}
+
// Wait for the condition variable "CV" to be notified.
// Return values:
// 0: the condition was notified, or the timeout expired.
struct timespec ts;
+ JvThreadState new_state = JV_WAITING;
if (millis > 0 || nanos > 0)
{
// Calculate the abstime corresponding to the timeout.
- // Everything is in milliseconds.
- //
- // We use `unsigned long long' rather than jlong because our
- // caller may pass up to Long.MAX_VALUE millis. This would
- // overflow the range of a jlong when added to the current time.
-
- unsigned long long startTime
- = (unsigned long long)java::lang::System::currentTimeMillis();
- unsigned long long m = (unsigned long long)millis + startTime;
- unsigned long long seconds = m / 1000;
+ unsigned long long seconds;
+ unsigned long usec;
+
+ // For better accuracy, should use pthread_condattr_setclock
+ // and clock_gettime.
+#ifdef HAVE_GETTIMEOFDAY
+ timeval tv;
+ gettimeofday (&tv, NULL);
+ usec = tv.tv_usec;
+ seconds = tv.tv_sec;
+#else
+ unsigned long long startTime = java::lang::System::currentTimeMillis();
+ seconds = startTime / 1000;
+ /* Assume we're about half-way through this millisecond. */
+ usec = (startTime % 1000) * 1000 + 500;
+#endif
+ /* These next two statements cannot overflow. */
+ usec += nanos / 1000;
+ usec += (millis % 1000) * 1000;
+ /* These two statements could overflow only if tv.tv_sec was
+ insanely large. */
+ seconds += millis / 1000;
+ seconds += usec / 1000000;
ts.tv_sec = seconds;
if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
millis = nanos = 0;
}
else
- {
- m %= 1000;
- ts.tv_nsec = m * 1000000 + (unsigned long long)nanos;
- }
+ /* This next statement also cannot overflow. */
+ ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
}
_Jv_Thread_t *current = _Jv_ThreadCurrentData ();
return _JV_INTERRUPTED;
}
+ // Set the thread's state.
+ JvSetThreadState holder (current_obj, new_state);
+
// Add this thread to the cv's wait set.
current->next = NULL;
pthread_mutex_unlock (&data->wait_mutex);
}
+/**
+ * Releases the block on a thread created by _Jv_ThreadPark(). This
+ * 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
+ * guaranteed to be live.
+ *
+ * @param thread the thread to unblock.
+ */
+void
+ParkHelper::unpark ()
+{
+ using namespace ::java::lang;
+ volatile obj_addr_t *ptr = &permit;
+
+ /* If this thread is in state RUNNING, give it a permit and return
+ immediately. */
+ if (compare_and_swap
+ (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PERMIT))
+ return;
+
+ /* If this thread is parked, put it into state RUNNING and send it a
+ signal. */
+ if (compare_and_swap
+ (ptr, Thread::THREAD_PARK_PARKED, Thread::THREAD_PARK_RUNNING))
+ {
+ int result;
+ pthread_mutex_lock (&mutex);
+ result = pthread_cond_signal (&cond);
+ pthread_mutex_unlock (&mutex);
+ JvAssert (result == 0);
+ }
+}
+
+/**
+ * Sets our state to dead.
+ */
+void
+ParkHelper::deactivate ()
+{
+ permit = ::java::lang::Thread::THREAD_PARK_DEAD;
+}
+
+void
+ParkHelper::init ()
+{
+ pthread_mutex_init (&mutex, NULL);
+ pthread_cond_init (&cond, NULL);
+ permit = ::java::lang::Thread::THREAD_PARK_RUNNING;
+}
+
+/**
+ * Blocks the thread until a matching _Jv_ThreadUnpark() occurs, the
+ * thread is interrupted or the optional timeout expires. If an
+ * unpark call has already occurred, this also counts. A timeout
+ * value of zero is defined as no timeout. When isAbsolute is true,
+ * the timeout is in milliseconds relative to the epoch. Otherwise,
+ * the value is the number of nanoseconds which must occur before
+ * timeout. This call may also return spuriously (i.e. for no
+ * apparent reason).
+ *
+ * @param isAbsolute true if the timeout is specified in milliseconds from
+ * the epoch.
+ * @param time either the number of nanoseconds to wait, or a time in
+ * milliseconds from the epoch to wait for.
+ */
+void
+ParkHelper::park (jboolean isAbsolute, jlong time)
+{
+ using namespace ::java::lang;
+ volatile obj_addr_t *ptr = &permit;
+
+ /* If we have a permit, return immediately. */
+ if (compare_and_swap
+ (ptr, Thread::THREAD_PARK_PERMIT, Thread::THREAD_PARK_RUNNING))
+ return;
+
+ struct timespec ts;
+
+ if (time)
+ {
+ unsigned long long seconds;
+ unsigned long usec;
+
+ if (isAbsolute)
+ {
+ ts.tv_sec = time / 1000;
+ ts.tv_nsec = (time % 1000) * 1000 * 1000;
+ }
+ else
+ {
+ // Calculate the abstime corresponding to the timeout.
+ jlong nanos = time;
+ jlong millis = 0;
+
+ // For better accuracy, should use pthread_condattr_setclock
+ // and clock_gettime.
+#ifdef HAVE_GETTIMEOFDAY
+ timeval tv;
+ gettimeofday (&tv, NULL);
+ usec = tv.tv_usec;
+ seconds = tv.tv_sec;
+#else
+ unsigned long long startTime
+ = java::lang::System::currentTimeMillis();
+ seconds = startTime / 1000;
+ /* Assume we're about half-way through this millisecond. */
+ usec = (startTime % 1000) * 1000 + 500;
+#endif
+ /* These next two statements cannot overflow. */
+ usec += nanos / 1000;
+ usec += (millis % 1000) * 1000;
+ /* These two statements could overflow only if tv.tv_sec was
+ insanely large. */
+ seconds += millis / 1000;
+ seconds += usec / 1000000;
+
+ 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
+ // as a wait forever.
+ millis = nanos = 0;
+ }
+ else
+ /* This next statement also cannot overflow. */
+ ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
+ }
+ }
+
+ pthread_mutex_lock (&mutex);
+ if (compare_and_swap
+ (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED))
+ {
+ int result = 0;
+
+ if (! time)
+ result = pthread_cond_wait (&cond, &mutex);
+ else
+ result = pthread_cond_timedwait (&cond, &mutex, &ts);
+
+ JvAssert (result == 0 || result == ETIMEDOUT);
+
+ /* If we were unparked by some other thread, this will already
+ be in state THREAD_PARK_RUNNING. If we timed out or were
+ interrupted, we have to do it ourself. */
+ permit = Thread::THREAD_PARK_RUNNING;
+ }
+ pthread_mutex_unlock (&mutex);
+}
+
static void
handle_intr (int)
{
// Do nothing.
}
-static void
-block_sigchld()
+void
+_Jv_BlockSigchld()
{
sigset_t mask;
sigemptyset (&mask);
}
void
+_Jv_UnBlockSigchld()
+{
+ sigset_t mask;
+ sigemptyset (&mask);
+ sigaddset (&mask, SIGCHLD);
+ int c = pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
+ if (c != 0)
+ JvFail (strerror (c));
+}
+
+void
_Jv_InitThreads (void)
{
pthread_key_create (&_Jv_ThreadKey, NULL);
// Block SIGCHLD here to ensure that any non-Java threads inherit the new
// signal mask.
- block_sigchld();
+ _Jv_BlockSigchld();
// Check/set the thread stack size.
size_t min_ss = 32 * 1024;
}
# endif
// Block SIGCHLD which is used in natPosixProcess.cc.
- block_sigchld();
+ _Jv_BlockSigchld();
}
void
// Block SIGCHLD which is used in natPosixProcess.cc.
// The current mask is inherited by the child thread.
- block_sigchld();
+ _Jv_BlockSigchld();
param.sched_priority = thread->getPriority();
OSDN Git Service
