X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=libjava%2Fposix-threads.cc;h=6ea724b3be8f51fdc2dd6801ed8f8e19bdf5b2a3;hb=258d332bd2fb1463c12ab74cc33c15ba140b3a31;hp=042370fc37958c87c1fe26870610204d448da5a2;hpb=4798d49714873599cc6135df4e84f74f472dbf41;p=pf3gnuchains%2Fgcc-fork.git diff --git a/libjava/posix-threads.cc b/libjava/posix-threads.cc index 042370fc379..6ea724b3be8 100644 --- a/libjava/posix-threads.cc +++ b/libjava/posix-threads.cc @@ -1,6 +1,6 @@ // 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. @@ -13,6 +13,8 @@ details. */ #include +#include "posix.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 @@ -78,6 +80,34 @@ static int non_daemon_count; +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. @@ -93,19 +123,33 @@ _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, 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) @@ -115,10 +159,8 @@ _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, 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 (); @@ -134,6 +176,9 @@ _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, 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; @@ -294,6 +339,133 @@ _Jv_ThreadInterrupt (_Jv_Thread_t *data) 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)) + { + pthread_mutex_lock (&mutex); + pthread_cond_signal (&cond); + pthread_mutex_unlock (&mutex); + } +} + +/** + * Sets our state to dead. + */ +void +ParkHelper::deactivate () +{ + permit = ::java::lang::Thread::THREAD_PARK_DEAD; +} + +/** + * 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; + jlong millis = 0, nanos = 0; + + if (time) + { + if (isAbsolute) + { + millis = time; + nanos = 0; + } + else + { + millis = java::lang::System::currentTimeMillis(); + nanos = time; + } + + 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 timespec. + + unsigned long long m = (unsigned long long)millis; + unsigned long long seconds = m / 1000; + + 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 + { + m %= 1000; + ts.tv_nsec = m * 1000000 + (unsigned long long)nanos; + } + } + } + + if (compare_and_swap + (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED)) + { + pthread_mutex_lock (&mutex); + if (millis == 0 && nanos == 0) + pthread_cond_wait (&cond, &mutex); + else + pthread_cond_timedwait (&cond, &mutex, &ts); + pthread_mutex_unlock (&mutex); + + /* If we were unparked by some other thread, this will already + be in state THREAD_PARK_RUNNING. If we timed out, we have to + do it ourself. */ + compare_and_swap + (ptr, Thread::THREAD_PARK_PARKED, Thread::THREAD_PARK_RUNNING); + } +} + static void handle_intr (int) { @@ -338,8 +510,10 @@ _Jv_InitThreads (void) // Bigger default on 64-bit systems. min_ss *= 2; +#ifdef PTHREAD_STACK_MIN if (min_ss < PTHREAD_STACK_MIN) min_ss = PTHREAD_STACK_MIN; +#endif if (gcj::stack_size > 0 && gcj::stack_size < min_ss) gcj::stack_size = min_ss;