/* src/threads/native/threads.c - native threads support
- Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
- R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
- C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
- Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
+ C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
+ E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
+ J. Wenninger, Institut f. Computersprachen - TU Wien
This file is part of CACAO.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA.
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
- Contact: cacao@complang.tuwien.ac.at
+ $Id: threads.c 8321 2007-08-16 11:37:25Z michi $
- Authors: Stefan Ring
-
- Changes: Christian Thalinger
+*/
- $Id: threads.c 4087 2006-01-03 23:46:48Z twisti $
-*/
+#include "config.h"
+/* XXX cleanup these includes */
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
-#include <semaphore.h>
-#include "config.h"
#include "vm/types.h"
-#ifndef USE_MD_THREAD_STUFF
-#include "machine-instr.h"
+#include "arch.h"
+
+#if !defined(USE_FAKE_ATOMIC_INSTRUCTIONS)
+# include "machine-instr.h"
#else
-#include "threads/native/generic-primitives.h"
+# include "threads/native/generic-primitives.h"
#endif
-#include "cacao/cacao.h"
-#include "mm/boehm.h"
+#include "mm/gc-common.h"
#include "mm/memory.h"
+
+#if defined(ENABLE_GC_CACAO)
+# include "mm/cacao-gc/gc.h"
+#endif
+
+#include "native/jni.h"
+#include "native/llni.h"
#include "native/native.h"
#include "native/include/java_lang_Object.h"
+#include "native/include/java_lang_String.h"
#include "native/include/java_lang_Throwable.h"
#include "native/include/java_lang_Thread.h"
-#include "native/include/java_lang_ThreadGroup.h"
-#include "native/include/java_lang_VMThread.h"
+
+#if defined(ENABLE_JAVASE)
+# include "native/include/java_lang_ThreadGroup.h"
+#endif
+
+#if defined(WITH_CLASSPATH_GNU)
+# include "native/include/java_lang_VMThread.h"
+#endif
+
+#include "threads/lock-common.h"
+#include "threads/threads-common.h"
+
#include "threads/native/threads.h"
-#include "toolbox/avl.h"
+
#include "toolbox/logging.h"
+
#include "vm/builtin.h"
#include "vm/exceptions.h"
#include "vm/global.h"
-#include "vm/loader.h"
-#include "vm/options.h"
#include "vm/stringlocal.h"
+#include "vm/vm.h"
+
#include "vm/jit/asmpart.h"
-#if !defined(__DARWIN__)
-#if defined(__LINUX__)
-#define GC_LINUX_THREADS
-#elif defined(__MIPS__)
-#define GC_IRIX_THREADS
+#include "vmcore/options.h"
+
+#if defined(ENABLE_STATISTICS)
+# include "vmcore/statistics.h"
#endif
-#include "boehm-gc/include/gc.h"
+
+#if !defined(__DARWIN__)
+# if defined(__LINUX__)
+# define GC_LINUX_THREADS
+# elif defined(__MIPS__)
+# define GC_IRIX_THREADS
+# endif
+# include <semaphore.h>
+# if defined(ENABLE_GC_BOEHM)
+# include "mm/boehm-gc/include/gc.h"
+# endif
#endif
-#ifdef USE_MD_THREAD_STUFF
-pthread_mutex_t _atomic_add_lock = PTHREAD_MUTEX_INITIALIZER;
-pthread_mutex_t _cas_lock = PTHREAD_MUTEX_INITIALIZER;
-pthread_mutex_t _mb_lock = PTHREAD_MUTEX_INITIALIZER;
+#if defined(ENABLE_JVMTI)
+#include "native/jvmti/cacaodbg.h"
#endif
-#ifdef MUTEXSIM
+#if defined(__DARWIN__)
+/* Darwin has no working semaphore implementation. This one is taken
+ from Boehm-GC. */
-/* We need this for older MacOSX (10.1.x) */
+/*
+ This is a very simple semaphore implementation for darwin. It
+ is implemented in terms of pthreads calls so it isn't async signal
+ safe. This isn't a problem because signals aren't used to
+ suspend threads on darwin.
+*/
+
+static int sem_init(sem_t *sem, int pshared, int value)
+{
+ if (pshared)
+ assert(0);
-typedef struct {
- pthread_mutex_t mutex;
- pthread_t owner;
- int count;
-} pthread_mutex_rec_t;
+ sem->value = value;
+
+ if (pthread_mutex_init(&sem->mutex, NULL) < 0)
+ return -1;
-static void pthread_mutex_init_rec(pthread_mutex_rec_t *m)
-{
- pthread_mutex_init(&m->mutex, NULL);
- m->count = 0;
+ if (pthread_cond_init(&sem->cond, NULL) < 0)
+ return -1;
+
+ return 0;
}
-static void pthread_mutex_destroy_rec(pthread_mutex_rec_t *m)
+static int sem_post(sem_t *sem)
{
- pthread_mutex_destroy(&m->mutex);
+ if (pthread_mutex_lock(&sem->mutex) < 0)
+ return -1;
+
+ sem->value++;
+
+ if (pthread_cond_signal(&sem->cond) < 0) {
+ pthread_mutex_unlock(&sem->mutex);
+ return -1;
+ }
+
+ if (pthread_mutex_unlock(&sem->mutex) < 0)
+ return -1;
+
+ return 0;
}
-static void pthread_mutex_lock_rec(pthread_mutex_rec_t *m)
+static int sem_wait(sem_t *sem)
{
- for (;;)
- if (!m->count)
- {
- pthread_mutex_lock(&m->mutex);
- m->owner = pthread_self();
- m->count++;
- break;
- } else {
- if (m->owner != pthread_self())
- pthread_mutex_lock(&m->mutex);
- else
- {
- m->count++;
- break;
- }
- }
+ if (pthread_mutex_lock(&sem->mutex) < 0)
+ return -1;
+
+ while (sem->value == 0) {
+ pthread_cond_wait(&sem->cond, &sem->mutex);
+ }
+
+ sem->value--;
+
+ if (pthread_mutex_unlock(&sem->mutex) < 0)
+ return -1;
+
+ return 0;
}
-static void pthread_mutex_unlock_rec(pthread_mutex_rec_t *m)
+static int sem_destroy(sem_t *sem)
{
- if (!--m->count)
- pthread_mutex_unlock(&m->mutex);
+ if (pthread_cond_destroy(&sem->cond) < 0)
+ return -1;
+
+ if (pthread_mutex_destroy(&sem->mutex) < 0)
+ return -1;
+
+ return 0;
}
+#endif /* defined(__DARWIN__) */
-#else /* MUTEXSIM */
-#define pthread_mutex_lock_rec pthread_mutex_lock
-#define pthread_mutex_unlock_rec pthread_mutex_unlock
-#define pthread_mutex_rec_t pthread_mutex_t
+/* internally used constants **************************************************/
-#endif /* MUTEXSIM */
+/* CAUTION: Do not change these values. Boehm GC code depends on them. */
+#define STOPWORLD_FROM_GC 1
+#define STOPWORLD_FROM_CLASS_NUMBERING 2
-static void setPriority(pthread_t tid, int priority)
-{
- struct sched_param schedp;
- int policy;
- pthread_getschedparam(tid, &policy, &schedp);
- schedp.sched_priority = priority;
- pthread_setschedparam(tid, policy, &schedp);
-}
+/* startupinfo *****************************************************************
+
+ Struct used to pass info from threads_start_thread to
+ threads_startup_thread.
+
+******************************************************************************/
+
+typedef struct {
+ threadobject *thread; /* threadobject for this thread */
+ functionptr function; /* function to run in the new thread */
+ sem_t *psem; /* signals when thread has been entered */
+ /* in the thread list */
+ sem_t *psem_first; /* signals when pthread_create has returned */
+} startupinfo;
+
+
+/* prototypes *****************************************************************/
+
+static void threads_calc_absolute_time(struct timespec *tm, s8 millis, s4 nanos);
-static avl_tree *criticaltree;
-threadobject *mainthreadobj;
+/******************************************************************************/
+/* GLOBAL VARIABLES */
+/******************************************************************************/
-#ifndef HAVE___THREAD
-pthread_key_t tkey_threadinfo;
+static methodinfo *method_thread_init;
+
+/* the thread object of the current thread */
+/* This is either a thread-local variable defined with __thread, or */
+/* a thread-specific value stored with key threads_current_threadobject_key. */
+#if defined(HAVE___THREAD)
+__thread threadobject *threads_current_threadobject;
#else
-__thread threadobject *threadobj;
+pthread_key_t threads_current_threadobject_key;
#endif
-static pthread_mutex_rec_t compiler_mutex;
-static pthread_mutex_rec_t tablelock;
+/* global mutex for the threads table */
+static pthread_mutex_t mutex_threads_list;
-void compiler_lock()
-{
- pthread_mutex_lock_rec(&compiler_mutex);
-}
+/* global mutex for stop-the-world */
+static pthread_mutex_t stopworldlock;
-void compiler_unlock()
-{
- pthread_mutex_unlock_rec(&compiler_mutex);
-}
+/* global mutex and condition for joining threads on exit */
+static pthread_mutex_t mutex_join;
+static pthread_cond_t cond_join;
-void tables_lock()
-{
- pthread_mutex_lock_rec(&tablelock);
-}
+/* XXX We disable that whole bunch of code until we have the exact-GC
+ running. */
-void tables_unlock()
-{
- pthread_mutex_unlock_rec(&tablelock);
-}
+#if 1
+/* this is one of the STOPWORLD_FROM_ constants, telling why the world is */
+/* being stopped */
+static volatile int stopworldwhere;
-static s4 criticalcompare(const void *pa, const void *pb)
-{
- const threadcritnode *na = pa;
- const threadcritnode *nb = pb;
+/* semaphore used for acknowleding thread suspension */
+static sem_t suspend_ack;
+#if defined(__MIPS__)
+static pthread_mutex_t suspend_ack_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t suspend_cond = PTHREAD_COND_INITIALIZER;
+#endif
- if (na->mcodebegin < nb->mcodebegin)
- return -1;
- if (na->mcodebegin > nb->mcodebegin)
- return 1;
- return 0;
-}
+#endif /* 0 */
+
+/* mutexes used by the fake atomic instructions */
+#if defined(USE_FAKE_ATOMIC_INSTRUCTIONS)
+pthread_mutex_t _atomic_add_lock = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t _cas_lock = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t _mb_lock = PTHREAD_MUTEX_INITIALIZER;
+#endif
-static const threadcritnode *findcritical(u1 *mcodeptr)
-{
- avl_node *n;
- const threadcritnode *m;
-
- n = criticaltree->root;
- m = NULL;
-
- if (!n)
- return NULL;
-
- for (;;) {
- const threadcritnode *d = n->data;
-
- if (mcodeptr == d->mcodebegin)
- return d;
-
- if (mcodeptr < d->mcodebegin) {
- if (n->childs[0])
- n = n->childs[0];
- else
- return m;
-
- } else {
- if (n->childs[1]) {
- m = n->data;
- n = n->childs[1];
- } else
- return n->data;
- }
- }
-}
+/* threads_sem_init ************************************************************
+
+ Initialize a semaphore. Checks against errors and interruptions.
+ IN:
+ sem..............the semaphore to initialize
+ shared...........true if this semaphore will be shared between processes
+ value............the initial value for the semaphore
+
+*******************************************************************************/
-void thread_registercritical(threadcritnode *n)
+void threads_sem_init(sem_t *sem, bool shared, int value)
{
- avl_insert(criticaltree, n);
+ int r;
+
+ assert(sem);
+
+ do {
+ r = sem_init(sem, shared, value);
+ if (r == 0)
+ return;
+ } while (errno == EINTR);
+
+ vm_abort("sem_init failed: %s", strerror(errno));
}
-u1 *thread_checkcritical(u1 *mcodeptr)
+
+/* threads_sem_wait ************************************************************
+
+ Wait for a semaphore, non-interruptible.
+
+ IMPORTANT: Always use this function instead of `sem_wait` directly, as
+ `sem_wait` may be interrupted by signals!
+
+ IN:
+ sem..............the semaphore to wait on
+
+*******************************************************************************/
+
+void threads_sem_wait(sem_t *sem)
{
- const threadcritnode *n = findcritical(mcodeptr);
- return (n && mcodeptr < n->mcodeend && mcodeptr > n->mcodebegin) ? n->mcoderestart : NULL;
+ int r;
+
+ assert(sem);
+
+ do {
+ r = sem_wait(sem);
+ if (r == 0)
+ return;
+ } while (errno == EINTR);
+
+ vm_abort("sem_wait failed: %s", strerror(errno));
}
-static void thread_addstaticcritical()
+
+/* threads_sem_post ************************************************************
+
+ Increase the count of a semaphore. Checks for errors.
+
+ IN:
+ sem..............the semaphore to increase the count of
+
+*******************************************************************************/
+
+void threads_sem_post(sem_t *sem)
{
- threadcritnode *n = &asm_criticalsections;
+ int r;
+
+ assert(sem);
- while (n->mcodebegin)
- thread_registercritical(n++);
+ /* unlike sem_wait, sem_post is not interruptible */
+
+ r = sem_post(sem);
+ if (r == 0)
+ return;
+
+ vm_abort("sem_post failed: %s", strerror(errno));
}
-static pthread_mutex_t threadlistlock;
-static pthread_mutex_t stopworldlock;
-volatile int stopworldwhere;
+/* lock_stopworld **************************************************************
-static sem_t suspend_ack;
-#if defined(__MIPS__)
-static pthread_mutex_t suspend_ack_lock = PTHREAD_MUTEX_INITIALIZER;
-static pthread_cond_t suspend_cond = PTHREAD_COND_INITIALIZER;
-#endif
+ Enter the stopworld lock, specifying why the world shall be stopped.
+
+ IN:
+ where........ STOPWORLD_FROM_GC (1) from within GC
+ STOPWORLD_FROM_CLASS_NUMBERING (2) class numbering
+
+******************************************************************************/
-/*
- * where - 1 from within GC
- 2 class numbering
- */
void lock_stopworld(int where)
{
pthread_mutex_lock(&stopworldlock);
- stopworldwhere = where;
+/* stopworldwhere = where; */
}
-void unlock_stopworld()
+
+/* unlock_stopworld ************************************************************
+
+ Release the stopworld lock.
+
+******************************************************************************/
+
+void unlock_stopworld(void)
{
- stopworldwhere = 0;
+/* stopworldwhere = 0; */
pthread_mutex_unlock(&stopworldlock);
}
+/* XXX We disable that whole bunch of code until we have the exact-GC
+ running. */
+
+#if 0
+
#if !defined(__DARWIN__)
/* Caller must hold threadlistlock */
-static int cast_sendsignals(int sig, int count)
+static s4 threads_cast_sendsignals(s4 sig)
{
- /* Count threads */
- threadobject *tobj = mainthreadobj;
- nativethread *infoself = THREADINFO;
+ threadobject *t;
+ threadobject *self;
+ s4 count;
- if (count == 0)
- do {
- count++;
- tobj = tobj->info.next;
- } while (tobj != mainthreadobj);
+ self = THREADOBJECT;
- do {
- nativethread *info = &tobj->info;
- if (info != infoself)
- pthread_kill(info->tid, sig);
- tobj = tobj->info.next;
- } while (tobj != mainthreadobj);
+ /* iterate over all started threads */
- return count-1;
+ count = 0;
+
+ for (t = threads_list_first(); t != NULL; t = threads_list_next(t)) {
+ /* don't send the signal to ourself */
+
+ if (t == self)
+ continue;
+
+ /* don't send the signal to NEW threads (because they are not
+ completely initialized) */
+
+ if (t->state == THREAD_STATE_NEW)
+ continue;
+
+ /* send the signal */
+
+ pthread_kill(t->tid, sig);
+
+ /* increase threads count */
+
+ count++;
+ }
+
+ return count;
}
#else
-static void cast_darwinstop()
+static void threads_cast_darwinstop(void)
{
threadobject *tobj = mainthreadobj;
- nativethread *infoself = THREADINFO;
+ threadobject *self = THREADOBJECT;
do {
- nativethread *info = &tobj->info;
- if (info != infoself)
+ if (tobj != self)
{
- thread_state_flavor_t flavor = PPC_THREAD_STATE;
- mach_msg_type_number_t thread_state_count = PPC_THREAD_STATE_COUNT;
+ thread_state_flavor_t flavor = MACHINE_THREAD_STATE;
+ mach_msg_type_number_t thread_state_count = MACHINE_THREAD_STATE_COUNT;
+#if defined(__I386__)
+ i386_thread_state_t thread_state;
+#else
ppc_thread_state_t thread_state;
- mach_port_t thread = info->mach_thread;
+#endif
+ mach_port_t thread = tobj->mach_thread;
kern_return_t r;
r = thread_suspend(thread);
- if (r != KERN_SUCCESS) {
- log_text("thread_suspend failed");
- assert(0);
- }
-
- r = thread_get_state(thread, flavor,
- (natural_t*)&thread_state, &thread_state_count);
- if (r != KERN_SUCCESS) {
- log_text("thread_get_state failed");
- assert(0);
- }
-
- thread_restartcriticalsection(&thread_state);
-
- r = thread_set_state(thread, flavor,
- (natural_t*)&thread_state, thread_state_count);
- if (r != KERN_SUCCESS) {
- log_text("thread_set_state failed");
- assert(0);
- }
+
+ if (r != KERN_SUCCESS)
+ vm_abort("thread_suspend failed");
+
+ r = thread_get_state(thread, flavor, (natural_t *) &thread_state,
+ &thread_state_count);
+
+ if (r != KERN_SUCCESS)
+ vm_abort("thread_get_state failed");
+
+ md_critical_section_restart((ucontext_t *) &thread_state);
+
+ r = thread_set_state(thread, flavor, (natural_t *) &thread_state,
+ thread_state_count);
+
+ if (r != KERN_SUCCESS)
+ vm_abort("thread_set_state failed");
}
- tobj = tobj->info.next;
+
+ tobj = tobj->next;
} while (tobj != mainthreadobj);
}
-static void cast_darwinresume()
+static void threads_cast_darwinresume(void)
{
threadobject *tobj = mainthreadobj;
- nativethread *infoself = THREADINFO;
+ threadobject *self = THREADOBJECT;
do {
- nativethread *info = &tobj->info;
- if (info != infoself)
+ if (tobj != self)
{
- mach_port_t thread = info->mach_thread;
+ mach_port_t thread = tobj->mach_thread;
kern_return_t r;
r = thread_resume(thread);
- if (r != KERN_SUCCESS) {
- log_text("thread_resume failed");
- assert(0);
- }
+
+ if (r != KERN_SUCCESS)
+ vm_abort("thread_resume failed");
}
- tobj = tobj->info.next;
+
+ tobj = tobj->next;
} while (tobj != mainthreadobj);
}
#endif
#if defined(__MIPS__)
-static void cast_irixresume()
+static void threads_cast_irixresume(void)
{
pthread_mutex_lock(&suspend_ack_lock);
pthread_cond_broadcast(&suspend_cond);
pthread_mutex_unlock(&suspend_ack_lock);
}
#endif
-
-void cast_stopworld()
-{
- int count, i;
- lock_stopworld(2);
- pthread_mutex_lock(&threadlistlock);
-#if defined(__DARWIN__)
- cast_darwinstop();
-#else
- count = cast_sendsignals(GC_signum1(), 0);
- for (i=0; i<count; i++)
- sem_wait(&suspend_ack);
-#endif
- pthread_mutex_unlock(&threadlistlock);
-}
-
-void cast_startworld()
-{
- pthread_mutex_lock(&threadlistlock);
-#if defined(__DARWIN__)
- cast_darwinresume();
-#elif defined(__MIPS__)
- cast_irixresume();
-#else
- cast_sendsignals(GC_signum2(), -1);
#endif
- pthread_mutex_unlock(&threadlistlock);
- unlock_stopworld();
-}
-#if !defined(__DARWIN__)
-static void sigsuspend_handler(ucontext_t *ctx)
+#if defined(ENABLE_GC_BOEHM) && !defined(__DARWIN__)
+static void threads_sigsuspend_handler(ucontext_t *_uc)
{
int sig;
sigset_t sigs;
-
- thread_restartcriticalsection(ctx);
+
+ /* XXX TWISTI: this is just a quick hack */
+#if defined(ENABLE_JIT)
+ md_critical_section_restart(_uc);
+#endif
/* Do as Boehm does. On IRIX a condition variable is used for wake-up
(not POSIX async-safe). */
#if defined(__IRIX__)
pthread_mutex_lock(&suspend_ack_lock);
- sem_post(&suspend_ack);
+ threads_sem_post(&suspend_ack);
pthread_cond_wait(&suspend_cond, &suspend_ack_lock);
pthread_mutex_unlock(&suspend_ack_lock);
+#elif defined(__CYGWIN__)
+ /* TODO */
+ assert(0);
#else
- sem_post(&suspend_ack);
sig = GC_signum2();
sigfillset(&sigs);
sigsuspend(&sigs);
#endif
}
+#endif
-int cacao_suspendhandler(ucontext_t *ctx)
-{
- if (stopworldwhere != 2)
- return 0;
+/* threads_stopworld ***********************************************************
- sigsuspend_handler(ctx);
- return 1;
-}
-#endif
+ Stops the world from turning. All threads except the calling one
+ are suspended. The function returns as soon as all threads have
+ acknowledged their suspension.
+
+*******************************************************************************/
-static void setthreadobject(threadobject *thread)
+#if !defined(DISABLE_GC)
+void threads_stopworld(void)
{
-#if !defined(HAVE___THREAD)
- pthread_setspecific(tkey_threadinfo, thread);
-#else
- threadobj = thread;
+#if !defined(__DARWIN__) && !defined(__CYGWIN__)
+ threadobject *t;
+ threadobject *self;
+ bool result;
+ s4 count, i;
#endif
-}
+ lock_stopworld(STOPWORLD_FROM_CLASS_NUMBERING);
-/* thread_setself **************************************************************
+ /* lock the threads lists */
- XXX
+ threads_list_lock();
-*******************************************************************************/
+#if defined(__DARWIN__)
+ threads_cast_darwinstop();
+#elif defined(__CYGWIN__)
+ /* TODO */
+ assert(0);
+#else
+ self = THREADOBJECT;
-void *thread_getself(void)
-{
- return pthread_getspecific(tkey_threadinfo);
-}
+ count = 0;
+ /* suspend all running threads */
+ for (t = threads_list_first(); t != NULL; t = threads_list_next(t)) {
+ /* don't send the signal to ourself */
-static monitorLockRecord *dummyLR;
+ if (t == self)
+ continue;
-static void initPools();
+ /* don't send the signal to NEW threads (because they are not
+ completely initialized) */
+ if (t->state == THREAD_STATE_NEW)
+ continue;
-/* thread_preinit **************************************************************
+ /* send the signal */
- Do some early initialization of stuff required.
+ result = threads_suspend_thread(t, SUSPEND_REASON_STOPWORLD);
+ assert(result);
-*******************************************************************************/
+ /* increase threads count */
-void threads_preinit(void)
-{
-#ifndef MUTEXSIM
- pthread_mutexattr_t mutexattr;
- pthread_mutexattr_init(&mutexattr);
- pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE);
- pthread_mutex_init(&compiler_mutex, &mutexattr);
- pthread_mutex_init(&tablelock, &mutexattr);
- pthread_mutexattr_destroy(&mutexattr);
-#else
- pthread_mutex_init_rec(&compiler_mutex);
- pthread_mutex_init_rec(&tablelock);
+ count++;
+ }
+
+ /* wait for all threads signaled to suspend */
+ for (i = 0; i < count; i++)
+ threads_sem_wait(&suspend_ack);
#endif
- pthread_mutex_init(&threadlistlock, NULL);
- pthread_mutex_init(&stopworldlock, NULL);
+ /* ATTENTION: Don't unlock the threads-lists here so that
+ non-signaled NEW threads can't change their state and execute
+ code. */
+}
+#endif /* !defined(DISABLE_GC) */
- /* Allocate something so the garbage collector's signal handlers
- are installed. */
- heap_allocate(1, false, NULL);
- mainthreadobj = NEW(threadobject);
- mainthreadobj->info.tid = pthread_self();
-#if !defined(HAVE___THREAD)
- pthread_key_create(&tkey_threadinfo, NULL);
-#endif
- setthreadobject(mainthreadobj);
- initPools();
+/* threads_startworld **********************************************************
- /* Every newly created object's monitorPtr points here so we save
- a check against NULL */
+ Starts the world again after it has previously been stopped.
- dummyLR = NEW(monitorLockRecord);
- dummyLR->o = NULL;
- dummyLR->ownerThread = NULL;
- dummyLR->waiting = false;
+*******************************************************************************/
- /* we need a working dummyLR before initializing the critical
- section tree */
+#if !defined(DISABLE_GC)
+void threads_startworld(void)
+{
+#if !defined(__DARWIN__) && !defined(__CYGWIN__)
+ threadobject *t;
+ threadobject *self;
+ bool result;
+ s4 count, i;
+#endif
- criticaltree = avl_create(&criticalcompare);
+#if defined(__DARWIN__)
+ threads_cast_darwinresume();
+#elif defined(__MIPS__)
+ threads_cast_irixresume();
+#elif defined(__CYGWIN__)
+ /* TODO */
+ assert(0);
+#else
+ self = THREADOBJECT;
- thread_addstaticcritical();
- sem_init(&suspend_ack, 0, 0);
-}
+ count = 0;
+ /* resume all thread we haltet */
+ for (t = threads_list_first(); t != NULL; t = threads_list_next(t)) {
+ /* don't send the signal to ourself */
-static pthread_attr_t threadattr;
+ if (t == self)
+ continue;
-static void freeLockRecordPools(lockRecordPool *);
+ /* don't send the signal to NEW threads (because they are not
+ completely initialized) */
+ if (t->state == THREAD_STATE_NEW)
+ continue;
-/* threads_init ****************************************************************
+ /* send the signal */
- Initializes the threads required by the JVM: main, finalizer.
+ result = threads_resume_thread(t);
+ assert(result);
-*******************************************************************************/
+ /* increase threads count */
-bool threads_init(u1 *stackbottom)
-{
- java_lang_String *threadname;
- java_lang_Thread *mainthread;
- java_lang_ThreadGroup *threadgroup;
- threadobject *tempthread;
- methodinfo *method;
+ count++;
+ }
- tempthread = mainthreadobj;
+ /* wait for all threads signaled to suspend */
+ for (i = 0; i < count; i++)
+ threads_sem_wait(&suspend_ack);
- freeLockRecordPools(mainthreadobj->ee.lrpool);
+#endif
- /* This is kinda tricky, we grow the java.lang.Thread object so we
- can keep the execution environment there. No Thread object must
- have been created at an earlier time. */
+ /* unlock the threads lists */
- class_java_lang_VMThread->instancesize = sizeof(threadobject);
+ threads_list_unlock();
- /* create a VMThread */
+ unlock_stopworld();
+}
+#endif
- mainthreadobj = (threadobject *) builtin_new(class_java_lang_VMThread);
- if (!mainthreadobj)
- return false;
+/* threads_set_current_threadobject ********************************************
- FREE(tempthread, threadobject);
+ Set the current thread object.
+
+ IN:
+ thread.......the thread object to set
- initThread(&mainthreadobj->o);
+*******************************************************************************/
- setthreadobject(mainthreadobj);
+void threads_set_current_threadobject(threadobject *thread)
+{
+#if !defined(HAVE___THREAD)
+ if (pthread_setspecific(threads_current_threadobject_key, thread) != 0)
+ vm_abort("threads_set_current_threadobject: pthread_setspecific failed: %s", strerror(errno));
+#else
+ threads_current_threadobject = thread;
+#endif
+}
- initLocks();
- mainthreadobj->info.next = mainthreadobj;
- mainthreadobj->info.prev = mainthreadobj;
+/* threads_impl_thread_new *****************************************************
-#if defined(ENABLE_INTRP)
- /* create interpreter stack */
+ Initialize implementation fields of a threadobject.
- if (opt_intrp) {
- MSET(intrp_main_stack, 0, u1, opt_stacksize);
- mainthreadobj->info._global_sp = intrp_main_stack + opt_stacksize;
- }
-#endif
+ IN:
+ t....the threadobject
- threadname = javastring_new(utf_new_char("main"));
+*******************************************************************************/
- /* allocate and init ThreadGroup */
+void threads_impl_thread_new(threadobject *t)
+{
+ /* get the pthread id */
- threadgroup = (java_lang_ThreadGroup *)
- native_new_and_init(class_java_lang_ThreadGroup);
+ t->tid = pthread_self();
- if (!threadgroup)
- throw_exception_exit();
+ /* initialize the mutex and the condition */
- /* create a Thread */
+ pthread_mutex_init(&(t->waitmutex), NULL);
+ pthread_cond_init(&(t->waitcond), NULL);
+ pthread_mutex_init(&(t->suspendmutex), NULL);
+ pthread_cond_init(&(t->suspendcond), NULL);
- mainthread = (java_lang_Thread *) builtin_new(class_java_lang_Thread);
+#if defined(ENABLE_DEBUG_FILTER)
+ /* Initialize filter counters */
+ t->filterverbosecallctr[0] = 0;
+ t->filterverbosecallctr[1] = 0;
+#endif
- if (!mainthread)
- throw_exception_exit();
+#if !defined(NDEBUG)
+ t->tracejavacallindent = 0;
+ t->tracejavacallcount = 0;
+#endif
+}
- mainthreadobj->o.thread = mainthread;
- /* call Thread.<init>(Ljava/lang/VMThread;Ljava/lang/String;IZ)V */
+/* threads_impl_thread_free ****************************************************
- method = class_resolveclassmethod(class_java_lang_Thread,
- utf_init,
- utf_new_char("(Ljava/lang/VMThread;Ljava/lang/String;IZ)V"),
- class_java_lang_Thread,
- true);
+ Cleanup thread stuff.
- if (!method)
- return false;
+ IN:
+ t....the threadobject
- asm_calljavafunction(method, mainthread, mainthreadobj, threadname, (void*) 5);
- if (*exceptionptr)
- return false;
+*******************************************************************************/
- mainthread->group = threadgroup;
- /* XXX This is a hack because the fourth argument was omitted */
- mainthread->daemon = false;
+void threads_impl_thread_free(threadobject *t)
+{
+ /* destroy the mutex and the condition */
- /* add mainthread to ThreadGroup */
+ if (pthread_mutex_destroy(&(t->waitmutex)) != 0)
+ vm_abort("threads_impl_thread_free: pthread_mutex_destroy failed: %s",
+ strerror(errno));
- method = class_resolveclassmethod(class_java_lang_ThreadGroup,
- utf_new_char("addThread"),
- utf_new_char("(Ljava/lang/Thread;)V"),
- class_java_lang_ThreadGroup,
- true);
+ if (pthread_cond_destroy(&(t->waitcond)) != 0)
+ vm_abort("threads_impl_thread_free: pthread_cond_destroy failed: %s",
+ strerror(errno));
- if (!method)
- return false;
+ if (pthread_mutex_destroy(&(t->suspendmutex)) != 0)
+ vm_abort("threads_impl_thread_free: pthread_mutex_destroy failed: %s",
+ strerror(errno));
- asm_calljavafunction(method, threadgroup, mainthread, NULL, NULL);
+ if (pthread_cond_destroy(&(t->suspendcond)) != 0)
+ vm_abort("threads_impl_thread_free: pthread_cond_destroy failed: %s",
+ strerror(errno));
+}
- if (*exceptionptr)
- return false;
- setPriority(pthread_self(), 5);
+/* threads_get_current_threadobject ********************************************
- pthread_attr_init(&threadattr);
- pthread_attr_setdetachstate(&threadattr, PTHREAD_CREATE_DETACHED);
+ Return the threadobject of the current thread.
+
+ RETURN VALUE:
+ the current threadobject *
- /* everything's ok */
+*******************************************************************************/
- return true;
+threadobject *threads_get_current_threadobject(void)
+{
+ return THREADOBJECT;
}
-void initThread(java_lang_VMThread *t)
-{
- threadobject *thread = (threadobject*) t;
- nativethread *info = &thread->info;
- info->tid = pthread_self();
- /* TODO destroy all those things */
- pthread_mutex_init(&info->joinMutex, NULL);
- pthread_cond_init(&info->joinCond, NULL);
-
- pthread_mutex_init(&thread->waitLock, NULL);
- pthread_cond_init(&thread->waitCond, NULL);
- thread->interrupted = false;
- thread->signaled = false;
- thread->isSleeping = false;
+/* threads_impl_preinit ********************************************************
+
+ Do some early initialization of stuff required.
+
+ ATTENTION: Do NOT use any Java heap allocation here, as gc_init()
+ is called AFTER this function!
+
+*******************************************************************************/
+
+void threads_impl_preinit(void)
+{
+ pthread_mutex_init(&stopworldlock, NULL);
+
+ /* initialize exit mutex and condition (on exit we join all
+ threads) */
+
+ pthread_mutex_init(&mutex_join, NULL);
+ pthread_cond_init(&cond_join, NULL);
+
+ /* initialize the threads-list mutex */
+
+ pthread_mutex_init(&mutex_threads_list, NULL);
+
+#if !defined(HAVE___THREAD)
+ pthread_key_create(&threads_current_threadobject_key, NULL);
+#endif
+
+ threads_sem_init(&suspend_ack, 0, 0);
}
-static void initThreadLocks(threadobject *);
+/* threads_list_lock ***********************************************************
-typedef struct {
- threadobject *thread;
- functionptr function;
- sem_t *psem;
- sem_t *psem_first;
-} startupinfo;
+ Enter the threads table mutex.
+
+ NOTE: We need this function as we can't use an internal lock for
+ the threads lists because the thread's lock is initialized in
+ threads_table_add (when we have the thread index), but we
+ already need the lock at the entry of the function.
+
+*******************************************************************************/
+
+void threads_list_lock(void)
+{
+ if (pthread_mutex_lock(&mutex_threads_list) != 0)
+ vm_abort("threads_list_lock: pthread_mutex_lock failed: %s",
+ strerror(errno));
+}
+
+
+/* threads_list_unlock *********************************************************
+ Leave the threads list mutex.
+
+*******************************************************************************/
+
+void threads_list_unlock(void)
+{
+ if (pthread_mutex_unlock(&mutex_threads_list) != 0)
+ vm_abort("threads_list_unlock: pthread_mutex_unlock failed: %s",
+ strerror(errno));
+}
+
+
+/* threads_mutex_join_lock *****************************************************
+
+ Enter the join mutex.
+
+*******************************************************************************/
+
+void threads_mutex_join_lock(void)
+{
+ if (pthread_mutex_lock(&mutex_join) != 0)
+ vm_abort("threads_mutex_join_lock: pthread_mutex_lock failed: %s",
+ strerror(errno));
+}
+
+
+/* threads_mutex_join_unlock ***************************************************
+
+ Leave the join mutex.
+
+*******************************************************************************/
+
+void threads_mutex_join_unlock(void)
+{
+ if (pthread_mutex_unlock(&mutex_join) != 0)
+ vm_abort("threads_mutex_join_unlock: pthread_mutex_unlock failed: %s",
+ strerror(errno));
+}
+
+
+/* threads_init ****************************************************************
+
+ Initializes the threads required by the JVM: main, finalizer.
+
+*******************************************************************************/
+
+bool threads_init(void)
+{
+ threadobject *mainthread;
+ java_handle_t *threadname;
+ java_lang_Thread *t;
+ java_handle_t *o;
+
+#if defined(ENABLE_JAVASE)
+ java_lang_ThreadGroup *threadgroup;
+ methodinfo *m;
+#endif
+
+#if defined(WITH_CLASSPATH_GNU)
+ java_lang_VMThread *vmt;
+#endif
-/* threads_startup *************************************************************
+ pthread_attr_t attr;
+
+ /* get methods we need in this file */
+
+#if defined(WITH_CLASSPATH_GNU)
+ method_thread_init =
+ class_resolveclassmethod(class_java_lang_Thread,
+ utf_init,
+ utf_new_char("(Ljava/lang/VMThread;Ljava/lang/String;IZ)V"),
+ class_java_lang_Thread,
+ true);
+#else
+ method_thread_init =
+ class_resolveclassmethod(class_java_lang_Thread,
+ utf_init,
+ utf_new_char("(Ljava/lang/String;)V"),
+ class_java_lang_Thread,
+ true);
+#endif
+
+ if (method_thread_init == NULL)
+ return false;
+
+ /* Get the main-thread (NOTE: The main threads is always the first
+ thread in the list). */
+
+ mainthread = threads_list_first();
+
+#if defined(ENABLE_GC_CACAO)
+ /* register reference to java.lang.Thread with the GC */
+
+ gc_reference_register((java_objectheader **) &(mainthread->object));
+#endif
+
+ /* create a java.lang.Thread for the main thread */
+
+ t = (java_lang_Thread *) builtin_new(class_java_lang_Thread);
+
+ if (t == NULL)
+ return false;
+
+ /* set the object in the internal data structure */
+
+ mainthread->object = t;
+
+#if defined(ENABLE_INTRP)
+ /* create interpreter stack */
+
+ if (opt_intrp) {
+ MSET(intrp_main_stack, 0, u1, opt_stacksize);
+ mainthread->_global_sp = (Cell*) (intrp_main_stack + opt_stacksize);
+ }
+#endif
+
+ threadname = javastring_new(utf_new_char("main"));
+
+#if defined(ENABLE_JAVASE)
+ /* allocate and init ThreadGroup */
+
+ threadgroup = (java_lang_ThreadGroup *)
+ native_new_and_init(class_java_lang_ThreadGroup);
+
+ if (threadgroup == NULL)
+ return false;
+#endif
+
+#if defined(WITH_CLASSPATH_GNU)
+ /* create a java.lang.VMThread for the main thread */
+
+ vmt = (java_lang_VMThread *) builtin_new(class_java_lang_VMThread);
+
+ if (vmt == NULL)
+ return false;
+
+ /* set the thread */
+
+ LLNI_field_set_ref(vmt, thread, t);
+ LLNI_field_set_val(vmt, vmdata, (java_lang_Object *) mainthread);
+
+ /* call java.lang.Thread.<init>(Ljava/lang/VMThread;Ljava/lang/String;IZ)V */
+ o = (java_handle_t *) t;
+
+ (void) vm_call_method(method_thread_init, o, vmt, threadname, NORM_PRIORITY,
+ false);
+
+#elif defined(WITH_CLASSPATH_SUN)
+
+ /* We trick java.lang.Thread.init, which sets the priority of the
+ current thread to the parent's one. */
+
+ t->priority = NORM_PRIORITY;
+
+#elif defined(WITH_CLASSPATH_CLDC1_1)
+
+ /* set the thread */
+
+ t->vm_thread = (java_lang_Object *) mainthread;
+
+ /* call public Thread(String name) */
+
+ o = (java_handle_t *) t;
+
+ (void) vm_call_method(method_thread_init, o, threadname);
+#else
+# error unknown classpath configuration
+#endif
+
+ if (exceptions_get_exception())
+ return false;
+
+#if defined(ENABLE_JAVASE)
+ LLNI_field_set_ref(t, group, threadgroup);
+
+# if defined(WITH_CLASSPATH_GNU)
+ /* add main thread to java.lang.ThreadGroup */
+
+ m = class_resolveclassmethod(class_java_lang_ThreadGroup,
+ utf_addThread,
+ utf_java_lang_Thread__V,
+ class_java_lang_ThreadGroup,
+ true);
+
+ o = (java_handle_t *) threadgroup;
+
+ (void) vm_call_method(m, o, t);
+
+ if (exceptions_get_exception())
+ return false;
+# else
+# warning Do not know what to do here
+# endif
+#endif
+
+ threads_set_thread_priority(pthread_self(), NORM_PRIORITY);
+
+ /* initialize the thread attribute object */
+
+ if (pthread_attr_init(&attr) != 0)
+ vm_abort("threads_init: pthread_attr_init failed: %s", strerror(errno));
+
+ if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
+ vm_abort("threads_init: pthread_attr_setdetachstate failed: %s",
+ strerror(errno));
+
+#if !defined(NDEBUG)
+ if (opt_verbosethreads) {
+ printf("[Starting thread ");
+ threads_thread_print_info(mainthread);
+ printf("]\n");
+ }
+#endif
+
+ /* everything's ok */
+
+ return true;
+}
+
+
+/* threads_startup_thread ******************************************************
Thread startup function called by pthread_create.
+ Thread which have a startup.function != NULL are marked as internal
+ threads. All other threads are threated as normal Java threads.
+
+ NOTE: This function is not called directly by pthread_create. The Boehm GC
+ inserts its own GC_start_routine in between, which then calls
+ threads_startup.
+
+ IN:
+ arg..........the argument passed to pthread_create, ie. a pointer to
+ a startupinfo struct. CAUTION: When the `psem` semaphore
+ is posted, the startupinfo struct becomes invalid! (It
+ is allocated on the stack of threads_start_thread.)
+
******************************************************************************/
-static void *threads_startup_thread(void *t)
+static void *threads_startup_thread(void *arg)
{
- startupinfo *startup;
- threadobject *thread;
- sem_t *psem;
- nativethread *info;
- threadobject *tnext;
- methodinfo *method;
- functionptr function;
+ startupinfo *startup;
+ threadobject *thread;
+#if defined(WITH_CLASSPATH_GNU)
+ java_lang_VMThread *vmt;
+#endif
+ sem_t *psem;
+ classinfo *c;
+ methodinfo *m;
+ java_handle_t *o;
+ functionptr function;
#if defined(ENABLE_INTRP)
u1 *intrp_thread_stack;
/* create interpreter stack */
if (opt_intrp) {
- intrp_thread_stack = (u1 *) alloca(opt_stacksize);
+ intrp_thread_stack = GCMNEW(u1, opt_stacksize);
MSET(intrp_thread_stack, 0, u1, opt_stacksize);
}
+ else
+ intrp_thread_stack = NULL;
#endif
/* get passed startupinfo structure and the values in there */
- startup = t;
+ startup = arg;
thread = startup->thread;
function = startup->function;
psem = startup->psem;
- info = &thread->info;
+ /* Seems like we've encountered a situation where thread->tid was
+ not set by pthread_create. We alleviate this problem by waiting
+ for pthread_create to return. */
- /* Seems like we've encountered a situation where info->tid was not set by
- * pthread_create. We alleviate this problem by waiting for pthread_create
- * to return. */
- sem_wait(startup->psem_first);
+ threads_sem_wait(startup->psem_first);
- t = NULL;
#if defined(__DARWIN__)
- info->mach_thread = mach_thread_self();
+ thread->mach_thread = mach_thread_self();
#endif
- setthreadobject(thread);
- /* insert the thread into the threadlist */
+ /* store the internal thread data-structure in the TSD */
- pthread_mutex_lock(&threadlistlock);
+ threads_set_current_threadobject(thread);
- info->prev = mainthreadobj;
- info->next = tnext = mainthreadobj->info.next;
- mainthreadobj->info.next = thread;
- tnext->info.prev = thread;
+ /* set our priority */
- pthread_mutex_unlock(&threadlistlock);
+ threads_set_thread_priority(thread->tid, LLNI_field_direct(thread->object, priority));
- initThreadLocks(thread);
+ /* thread is completely initialized */
- startup = NULL;
- sem_post(psem);
+ threads_thread_state_runnable(thread);
- setPriority(info->tid, thread->o.thread->priority);
+ /* tell threads_startup_thread that we registered ourselves */
+ /* CAUTION: *startup becomes invalid with this! */
+
+ startup = NULL;
+ threads_sem_post(psem);
#if defined(ENABLE_INTRP)
/* set interpreter stack */
if (opt_intrp)
- THREADINFO->_global_sp = (void *) (intrp_thread_stack + opt_stacksize);
+ thread->_global_sp = (Cell *) (intrp_thread_stack + opt_stacksize);
+#endif
+
+#if defined(ENABLE_JVMTI)
+ /* fire thread start event */
+
+ if (jvmti)
+ jvmti_ThreadStartEnd(JVMTI_EVENT_THREAD_START);
+#endif
+
+#if !defined(NDEBUG)
+ if (opt_verbosethreads) {
+ printf("[Starting thread ");
+ threads_thread_print_info(thread);
+ printf("]\n");
+ }
#endif
/* find and run the Thread.run()V method if no other function was passed */
if (function == NULL) {
- method = class_resolveclassmethod(thread->o.header.vftbl->class,
- utf_run,
- utf_void__void,
- thread->o.header.vftbl->class,
- true);
+#if defined(WITH_CLASSPATH_GNU)
+ /* We need to start the run method of
+ java.lang.VMThread. Since this is a final class, we can use
+ the class object directly. */
+
+ c = class_java_lang_VMThread;
+#elif defined(WITH_CLASSPATH_SUN) || defined(WITH_CLASSPATH_CLDC1_1)
+ c = thread->object->header.vftbl->class;
+#else
+# error unknown classpath configuration
+#endif
+
+ m = class_resolveclassmethod(c, utf_run, utf_void__void, c, true);
+
+ if (m == NULL)
+ vm_abort("threads_startup_thread: run() method not found in class");
+
+ /* set ThreadMXBean variables */
+
+ _Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount++;
+ _Jv_jvm->java_lang_management_ThreadMXBean_TotalStartedThreadCount++;
+
+ if (_Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount >
+ _Jv_jvm->java_lang_management_ThreadMXBean_PeakThreadCount)
+ _Jv_jvm->java_lang_management_ThreadMXBean_PeakThreadCount =
+ _Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount;
+
+#if defined(WITH_CLASSPATH_GNU)
+ /* we need to start the run method of java.lang.VMThread */
+
+ vmt = (java_lang_VMThread *) LLNI_field_direct(thread->object, vmThread);
+ o = (java_handle_t *) vmt;
+
+#elif defined(WITH_CLASSPATH_SUN) || defined(WITH_CLASSPATH_CLDC1_1)
+ o = (java_handle_t *) thread->object;
+#else
+# error unknown classpath configuration
+#endif
+
+ /* run the thread */
+
+ (void) vm_call_method(m, o);
+ }
+ else {
+ /* set ThreadMXBean variables */
- if (!method)
- throw_exception();
+ _Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount++;
+ _Jv_jvm->java_lang_management_ThreadMXBean_TotalStartedThreadCount++;
- asm_calljavafunction(method, thread, NULL, NULL, NULL);
+ if (_Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount >
+ _Jv_jvm->java_lang_management_ThreadMXBean_PeakThreadCount)
+ _Jv_jvm->java_lang_management_ThreadMXBean_PeakThreadCount =
+ _Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount;
- } else {
/* call passed function, e.g. finalizer_thread */
(function)();
}
- /* Allow lock record pools to be used by other threads. They
- cannot be deleted so we'd better not waste them. */
-
- freeLockRecordPools(thread->ee.lrpool);
+#if !defined(NDEBUG)
+ if (opt_verbosethreads) {
+ printf("[Stopping thread ");
+ threads_thread_print_info(thread);
+ printf("]\n");
+ }
+#endif
- /* remove thread from thread list, do this inside a lock */
+#if defined(ENABLE_JVMTI)
+ /* fire thread end event */
- pthread_mutex_lock(&threadlistlock);
- info->next->info.prev = info->prev;
- info->prev->info.next = info->next;
- pthread_mutex_unlock(&threadlistlock);
+ if (jvmti)
+ jvmti_ThreadStartEnd(JVMTI_EVENT_THREAD_END);
+#endif
- /* reset thread id (lock on joinMutex? TWISTI) */
+ if (!threads_detach_thread(thread))
+ vm_abort("threads_startup_thread: threads_detach_thread failed");
- pthread_mutex_lock(&info->joinMutex);
- info->tid = 0;
- pthread_mutex_unlock(&info->joinMutex);
+ /* set ThreadMXBean variables */
- pthread_cond_broadcast(&info->joinCond);
+ _Jv_jvm->java_lang_management_ThreadMXBean_ThreadCount--;
return NULL;
}
-/* threads_start_thread ********************************************************
+/* threads_impl_thread_start ***************************************************
- Start a thread in the JVM.
+ Start a thread in the JVM. Both (vm internal and java) thread
+ objects exist.
+
+ IN:
+ thread....the thread object
+ f.........function to run in the new thread. NULL means that the
+ "run" method of the object `t` should be called
******************************************************************************/
-void threads_start_thread(thread *t, functionptr function)
+void threads_impl_thread_start(threadobject *thread, functionptr f)
{
- nativethread *info;
- sem_t sem;
- sem_t sem_first;
- startupinfo startup;
-
- info = &((threadobject *) t->vmThread)->info;
+ sem_t sem;
+ sem_t sem_first;
+ pthread_attr_t attr;
+ startupinfo startup;
+ int ret;
- /* fill startupinfo structure passed by pthread_create to XXX */
+ /* fill startupinfo structure passed by pthread_create to
+ * threads_startup_thread */
- startup.thread = (threadobject*) t->vmThread;
- startup.function = function; /* maybe we don't call Thread.run()V */
+ startup.thread = thread;
+ startup.function = f; /* maybe we don't call Thread.run()V */
startup.psem = &sem;
startup.psem_first = &sem_first;
- sem_init(&sem, 0, 0);
- sem_init(&sem_first, 0, 0);
-
- if (pthread_create(&info->tid, &threadattr, threads_startup_thread,
- &startup)) {
- log_text("pthread_create failed");
- assert(0);
- }
+ threads_sem_init(&sem, 0, 0);
+ threads_sem_init(&sem_first, 0, 0);
+
+ /* initialize thread attributes */
+
+ if (pthread_attr_init(&attr) != 0)
+ vm_abort("threads_impl_thread_start: pthread_attr_init failed: %s",
+ strerror(errno));
+
+ if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) != 0)
+ vm_abort("threads_impl_thread_start: pthread_attr_setdetachstate failed: %s",
+ strerror(errno));
+
+ /* initialize thread stacksize */
+
+ if (pthread_attr_setstacksize(&attr, opt_stacksize))
+ vm_abort("threads_impl_thread_start: pthread_attr_setstacksize failed: %s",
+ strerror(errno));
+
+ /* create the thread */
+
+ ret = pthread_create(&(thread->tid), &attr, threads_startup_thread, &startup);
- sem_post(&sem_first);
+ /* destroy the thread attributes */
+
+ if (pthread_attr_destroy(&attr) != 0)
+ vm_abort("threads_impl_thread_start: pthread_attr_destroy failed: %s",
+ strerror(errno));
+
+ /* check for pthread_create error */
+
+ if (ret != 0)
+ vm_abort("threads_impl_thread_start: pthread_create failed: %s",
+ strerror(errno));
+
+ /* signal that pthread_create has returned, so thread->tid is valid */
+
+ threads_sem_post(&sem_first);
/* wait here until the thread has entered itself into the thread list */
- sem_wait(&sem);
+ threads_sem_wait(&sem);
+
+ /* cleanup */
+
sem_destroy(&sem);
sem_destroy(&sem_first);
}
-/* At the end of the program, we wait for all running non-daemon threads to die
- */
+/* threads_set_thread_priority *************************************************
-static threadobject *findNonDaemon(threadobject *thread)
+ Set the priority of the given thread.
+
+ IN:
+ tid..........thread id
+ priority.....priority to set
+
+******************************************************************************/
+
+void threads_set_thread_priority(pthread_t tid, int priority)
{
- while (thread != mainthreadobj) {
- if (!thread->o.thread->daemon)
- return thread;
- thread = thread->info.prev;
- }
+ struct sched_param schedp;
+ int policy;
- return NULL;
+ pthread_getschedparam(tid, &policy, &schedp);
+ schedp.sched_priority = priority;
+ pthread_setschedparam(tid, policy, &schedp);
}
-void joinAllThreads()
+
+/* threads_attach_current_thread ***********************************************
+
+ Attaches the current thread to the VM. Used in JNI.
+
+*******************************************************************************/
+
+bool threads_attach_current_thread(JavaVMAttachArgs *vm_aargs, bool isdaemon)
{
- threadobject *thread;
- pthread_mutex_lock(&threadlistlock);
- while ((thread = findNonDaemon(mainthreadobj->info.prev)) != NULL) {
- nativethread *info = &thread->info;
- pthread_mutex_lock(&info->joinMutex);
- pthread_mutex_unlock(&threadlistlock);
- while (info->tid)
- pthread_cond_wait(&info->joinCond, &info->joinMutex);
- pthread_mutex_unlock(&info->joinMutex);
- pthread_mutex_lock(&threadlistlock);
+ threadobject *thread;
+ utf *u;
+ java_handle_t *s;
+ java_handle_t *o;
+ java_lang_Thread *t;
+
+#if defined(ENABLE_JAVASE)
+ java_lang_ThreadGroup *group;
+ threadobject *mainthread;
+ classinfo *c;
+ methodinfo *m;
+#endif
+
+#if defined(WITH_CLASSPATH_GNU)
+ java_lang_VMThread *vmt;
+#endif
+
+ /* Enter the join-mutex, so if the main-thread is currently
+ waiting to join all threads, the number of non-daemon threads
+ is correct. */
+
+ threads_mutex_join_lock();
+
+ /* create internal thread data-structure */
+
+ thread = threads_thread_new();
+
+ /* thread is a Java thread and running */
+
+ thread->flags = THREAD_FLAG_JAVA;
+
+ if (isdaemon)
+ thread->flags |= THREAD_FLAG_DAEMON;
+
+ /* The thread is flagged and (non-)daemon thread, we can leave the
+ mutex. */
+
+ threads_mutex_join_unlock();
+
+ /* create a java.lang.Thread object */
+
+ t = (java_lang_Thread *) builtin_new(class_java_lang_Thread);
+
+ /* XXX memory leak!!! */
+ if (t == NULL)
+ return false;
+
+ thread->object = t;
+
+ /* thread is completely initialized */
+
+ threads_thread_state_runnable(thread);
+
+#if !defined(NDEBUG)
+ if (opt_verbosethreads) {
+ printf("[Attaching thread ");
+ threads_thread_print_info(thread);
+ printf("]\n");
}
- pthread_mutex_unlock(&threadlistlock);
-}
+#endif
-static void initLockRecord(monitorLockRecord *r, threadobject *t)
-{
- r->lockCount = 1;
- r->ownerThread = t;
- r->queuers = 0;
- r->o = NULL;
- r->waiter = NULL;
- r->incharge = (monitorLockRecord *) &dummyLR;
- r->waiting = false;
- sem_init(&r->queueSem, 0, 0);
- pthread_mutex_init(&r->resolveLock, NULL);
- pthread_cond_init(&r->resolveWait, NULL);
-}
+#if defined(ENABLE_INTRP)
+ /* create interpreter stack */
-/* No lock record must ever be destroyed because there may still be references
- * to it.
+ if (opt_intrp) {
+ MSET(intrp_main_stack, 0, u1, opt_stacksize);
+ thread->_global_sp = (Cell *) (intrp_main_stack + opt_stacksize);
+ }
+#endif
-static void destroyLockRecord(monitorLockRecord *r)
-{
- sem_destroy(&r->queueSem);
- pthread_mutex_destroy(&r->resolveLock);
- pthread_cond_destroy(&r->resolveWait);
-}
-*/
+#if defined(WITH_CLASSPATH_GNU)
-void initLocks()
-{
- initThreadLocks(mainthreadobj);
-}
+ /* create a java.lang.VMThread object */
-static void initThreadLocks(threadobject *thread)
-{
- thread->ee.firstLR = NULL;
- thread->ee.lrpool = NULL;
- thread->ee.numlr = 0;
-}
+ vmt = (java_lang_VMThread *) builtin_new(class_java_lang_VMThread);
-static lockRecordPool *allocNewLockRecordPool(threadobject *thread, int size)
-{
- lockRecordPool *p = mem_alloc(sizeof(lockRecordPoolHeader) + sizeof(monitorLockRecord) * size);
- int i;
+ /* XXX memory leak!!! */
+ if (vmt == NULL)
+ return false;
+
+ /* set the thread */
+
+ LLNI_field_set_ref(vmt, thread, t);
+ LLNI_field_set_val(vmt, vmdata, (java_lang_Object *) thread);
+
+#elif defined(WITH_CLASSPATH_SUN)
+
+ vm_abort("threads_attach_current_thread: IMPLEMENT ME!");
+
+#elif defined(WITH_CLASSPATH_CLDC1_1)
- p->header.size = size;
- for (i=0; i<size; i++) {
- initLockRecord(&p->lr[i], thread);
- p->lr[i].nextFree = &p->lr[i+1];
+ LLNI_field_set_val(t, vm_thread, (java_lang_Object *) thread);
+
+#else
+# error unknown classpath configuration
+#endif
+
+ if (vm_aargs != NULL) {
+ u = utf_new_char(vm_aargs->name);
+#if defined(ENABLE_JAVASE)
+ group = (java_lang_ThreadGroup *) vm_aargs->group;
+#endif
}
- p->lr[i-1].nextFree = NULL;
- return p;
-}
+ else {
+ u = utf_null;
+#if defined(ENABLE_JAVASE)
+ /* get the main thread */
-#define INITIALLOCKRECORDS 8
+ mainthread = threads_list_first();
+ group = LLNI_field_direct(mainthread->object, group);
+#endif
+ }
-pthread_mutex_t pool_lock;
-lockRecordPool *global_pool;
+ /* the the thread name */
-static void initPools()
-{
- pthread_mutex_init(&pool_lock, NULL);
+ s = javastring_new(u);
+
+ /* for convenience */
+
+ o = (java_handle_t *) thread->object;
+
+#if defined(WITH_CLASSPATH_GNU)
+ (void) vm_call_method(method_thread_init, o, vmt, s, NORM_PRIORITY,
+ isdaemon);
+#elif defined(WITH_CLASSPATH_CLDC1_1)
+ (void) vm_call_method(method_thread_init, o, s);
+#endif
+
+ if (exceptions_get_exception())
+ return false;
+
+#if defined(ENABLE_JAVASE)
+ /* store the thread group in the object */
+
+ LLNI_field_direct(thread->object, group) = group;
+
+ /* add thread to given thread-group */
+
+ LLNI_class_get(group, c);
+
+ m = class_resolveclassmethod(c,
+ utf_addThread,
+ utf_java_lang_Thread__V,
+ class_java_lang_ThreadGroup,
+ true);
+
+ o = (java_handle_t *) group;
+
+ (void) vm_call_method(m, o, t);
+
+ if (exceptions_get_exception())
+ return false;
+#endif
+
+ return true;
}
-static lockRecordPool *allocLockRecordPool(threadobject *t, int size)
+
+/* threads_detach_thread *******************************************************
+
+ Detaches the passed thread from the VM. Used in JNI.
+
+*******************************************************************************/
+
+bool threads_detach_thread(threadobject *thread)
{
- pthread_mutex_lock(&pool_lock);
- if (global_pool) {
- int i;
- lockRecordPool *pool = global_pool;
- global_pool = pool->header.next;
- pthread_mutex_unlock(&pool_lock);
-
- for (i=0; i < pool->header.size; i++)
- pool->lr[i].ownerThread = t;
-
- return pool;
+#if defined(ENABLE_JAVASE)
+ java_lang_ThreadGroup *group;
+ classinfo *c;
+ methodinfo *m;
+ java_handle_t *o;
+ java_lang_Thread *t;
+#endif
+
+ /* XXX implement uncaught exception stuff (like JamVM does) */
+
+#if defined(ENABLE_JAVASE)
+ /* remove thread from the thread group */
+
+ group = LLNI_field_direct(thread->object, group);
+
+ /* XXX TWISTI: should all threads be in a ThreadGroup? */
+
+ if (group != NULL) {
+ LLNI_class_get(group, c);
+
+# if defined(WITH_CLASSPATH_GNU)
+ m = class_resolveclassmethod(c,
+ utf_removeThread,
+ utf_java_lang_Thread__V,
+ class_java_lang_ThreadGroup,
+ true);
+# elif defined(WITH_CLASSPATH_SUN)
+ m = class_resolveclassmethod(c,
+ utf_remove,
+ utf_java_lang_Thread__V,
+ class_java_lang_ThreadGroup,
+ true);
+# else
+# error unknown classpath configuration
+# endif
+
+ if (m == NULL)
+ return false;
+
+ o = (java_handle_t *) group;
+ t = thread->object;
+
+ (void) vm_call_method(m, o, t);
+
+ if (exceptions_get_exception())
+ return false;
}
- pthread_mutex_unlock(&pool_lock);
+#endif
- return allocNewLockRecordPool(t, size);
-}
+ /* thread is terminated */
-static void freeLockRecordPools(lockRecordPool *pool)
-{
- lockRecordPoolHeader *last;
- pthread_mutex_lock(&pool_lock);
- last = &pool->header;
- while (last->next)
- last = &last->next->header;
- last->next = global_pool;
- global_pool = pool;
- pthread_mutex_unlock(&pool_lock);
-}
+ threads_thread_state_terminated(thread);
-static monitorLockRecord *allocLockRecordSimple(threadobject *t)
-{
- monitorLockRecord *r = t->ee.firstLR;
-
- if (!r) {
- int poolsize = t->ee.numlr ? t->ee.numlr * 2 : INITIALLOCKRECORDS;
- lockRecordPool *pool = allocLockRecordPool(t, poolsize);
- pool->header.next = t->ee.lrpool;
- t->ee.lrpool = pool;
- r = &pool->lr[0];
- t->ee.numlr += pool->header.size;
+#if !defined(NDEBUG)
+ if (opt_verbosethreads) {
+ printf("[Detaching thread ");
+ threads_thread_print_info(thread);
+ printf("]\n");
}
-
- t->ee.firstLR = r->nextFree;
- return r;
-}
+#endif
-static inline void recycleLockRecord(threadobject *t, monitorLockRecord *r)
-{
- r->nextFree = t->ee.firstLR;
- t->ee.firstLR = r;
-}
+ /* Enter the join-mutex before calling threads_thread_free, so
+ threads_join_all_threads gets the correct number of non-daemon
+ threads. */
-void initObjectLock(java_objectheader *o)
-{
- o->monitorPtr = dummyLR;
+ threads_mutex_join_lock();
+
+ /* free the vm internal thread object */
+
+ threads_thread_free(thread);
+
+ /* Signal that this thread has finished and leave the mutex. */
+
+ pthread_cond_signal(&cond_join);
+ threads_mutex_join_unlock();
+
+ return true;
}
-/* get_dummyLR *****************************************************************
+/* threads_suspend_thread ******************************************************
+
+ Suspend the passed thread. Execution stops until the thread
+ is explicitly resumend again.
- Returns the global dummy monitor lock record. The pointer is
- required in the code generator to set up a virtual
- java_objectheader for code patch locking.
+ IN:
+ reason.....Reason for suspending this thread.
*******************************************************************************/
-monitorLockRecord *get_dummyLR(void)
+bool threads_suspend_thread(threadobject *thread, s4 reason)
{
- return dummyLR;
-}
+ /* acquire the suspendmutex */
+ if (pthread_mutex_lock(&(thread->suspendmutex)) != 0)
+ vm_abort("threads_suspend_thread: pthread_mutex_lock failed: %s",
+ strerror(errno));
+ if (thread->suspended) {
+ pthread_mutex_unlock(&(thread->suspendmutex));
+ return false;
+ }
-static void queueOnLockRecord(monitorLockRecord *lr, java_objectheader *o)
-{
- atomic_add(&lr->queuers, 1);
+ /* set the reason for the suspension */
+ thread->suspend_reason = reason;
- MEMORY_BARRIER_AFTER_ATOMIC();
+ /* send the suspend signal to the thread */
+ assert(thread != THREADOBJECT);
+ if (pthread_kill(thread->tid, SIGUSR1) != 0)
+ vm_abort("threads_suspend_thread: pthread_kill failed: %s",
+ strerror(errno));
- while (lr->o == o)
- sem_wait(&lr->queueSem);
+ /* REMEMBER: do not release the suspendmutex, this is done
+ by the thread itself in threads_suspend_ack(). */
- atomic_add(&lr->queuers, -1);
+ return true;
}
-static void freeLockRecord(monitorLockRecord *lr)
-{
- int q;
- lr->o = NULL;
- MEMORY_BARRIER();
- q = lr->queuers;
- while (q--)
- sem_post(&lr->queueSem);
-}
-static inline void handleWaiter(monitorLockRecord *mlr, monitorLockRecord *lr)
-{
- if (lr->waiting)
- mlr->waiter = lr;
-}
+/* threads_suspend_ack *********************************************************
+
+ Acknowledges the suspension of the current thread.
-monitorLockRecord *monitorEnter(threadobject *t, java_objectheader *o)
+ IN:
+ pc.....The PC where the thread suspended its execution.
+ sp.....The SP before the thread suspended its execution.
+
+*******************************************************************************/
+
+void threads_suspend_ack(u1* pc, u1* sp)
{
- for (;;) {
- monitorLockRecord *lr = o->monitorPtr;
- if (lr->o != o) {
- monitorLockRecord *nlr, *mlr = allocLockRecordSimple(t);
- mlr->o = o;
- if (mlr == lr) {
- MEMORY_BARRIER();
- nlr = o->monitorPtr;
- if (nlr == lr) {
- handleWaiter(mlr, lr);
- return mlr;
- }
- } else {
- if (lr->ownerThread != t)
- mlr->incharge = lr;
- MEMORY_BARRIER_BEFORE_ATOMIC();
- nlr = (void*) compare_and_swap((long*) &o->monitorPtr, (long) lr, (long) mlr);
- }
- if (nlr == lr) {
- if (mlr == lr || lr->o != o) {
- handleWaiter(mlr, lr);
- return mlr;
- }
- while (lr->o == o)
- queueOnLockRecord(lr, o);
- handleWaiter(mlr, lr);
- return mlr;
- }
- freeLockRecord(mlr);
- recycleLockRecord(t, mlr);
- queueOnLockRecord(nlr, o);
- } else {
- if (lr->ownerThread == t) {
- lr->lockCount++;
- return lr;
- }
- queueOnLockRecord(lr, o);
+ threadobject *thread;
+
+ thread = THREADOBJECT;
+
+ assert(thread->suspend_reason != 0);
+
+ /* TODO: remember dump memory size */
+
+#if defined(ENABLE_GC_CACAO)
+ /* inform the GC about the suspension */
+ if (thread->suspend_reason == SUSPEND_REASON_STOPWORLD && gc_pending) {
+
+ /* check if the GC wants to leave the thread running */
+ if (!gc_suspend(thread, pc, sp)) {
+
+ /* REMEMBER: we do not unlock the suspendmutex because the thread
+ will suspend itself again at a later time */
+ return;
+
}
}
-}
+#endif
-static void wakeWaiters(monitorLockRecord *lr)
-{
- monitorLockRecord *tmplr;
- s4 q;
+ /* mark this thread as suspended and remember the PC */
+ thread->pc = pc;
+ thread->suspended = true;
- /* assign lock record to a temporary variable */
+ /* if we are stopping the world, we should send a global ack */
+ if (thread->suspend_reason == SUSPEND_REASON_STOPWORLD) {
+ threads_sem_post(&suspend_ack);
+ }
- tmplr = lr;
+ /* release the suspension mutex and wait till we are resumed */
+ /*printf("thread down %p\n", thread);*/
+ pthread_cond_wait(&(thread->suspendcond), &(thread->suspendmutex));
+ /*printf("thread up %p\n", thread);*/
- do {
- q = tmplr->queuers;
+ /* if we are stopping the world, we should send a global ack */
+ if (thread->suspend_reason == SUSPEND_REASON_STOPWORLD) {
+ threads_sem_post(&suspend_ack);
+ }
- while (q--)
- sem_post(&tmplr->queueSem);
+ /* TODO: free dump memory */
- tmplr = tmplr->waiter;
- } while (tmplr != NULL && tmplr != lr);
+ /* release the suspendmutex */
+ if (pthread_mutex_unlock(&(thread->suspendmutex)) != 0)
+ vm_abort("threads_suspend_ack: pthread_mutex_unlock failed: %s",
+ strerror(errno));
}
-#define GRAB_LR(lr,t) \
- if (lr->ownerThread != t) { \
- lr = lr->incharge; \
- }
-#define CHECK_MONITORSTATE(lr,t,mo,a) \
- if (lr == NULL || lr->o != mo || lr->ownerThread != t) { \
- *exceptionptr = new_illegalmonitorstateexception(); \
- a; \
- }
+/* threads_resume_thread *******************************************************
-bool monitorExit(threadobject *t, java_objectheader *o)
+ Resumes the execution of the passed thread.
+
+*******************************************************************************/
+
+bool threads_resume_thread(threadobject *thread)
{
- monitorLockRecord *lr = o->monitorPtr;
- GRAB_LR(lr, t);
- CHECK_MONITORSTATE(lr, t, o, return false);
- if (lr->lockCount > 1) {
- lr->lockCount--;
- return true;
- }
- if (lr->waiter) {
- monitorLockRecord *wlr = lr->waiter;
- if (o->monitorPtr != lr ||
- (void*) compare_and_swap((long*) &o->monitorPtr, (long) lr, (long) wlr) != lr)
- {
- monitorLockRecord *nlr = o->monitorPtr;
- nlr->waiter = wlr;
- STORE_ORDER_BARRIER();
- } else
- wakeWaiters(wlr);
- lr->waiter = NULL;
+ /* acquire the suspendmutex */
+ if (pthread_mutex_lock(&(thread->suspendmutex)) != 0)
+ vm_abort("threads_resume_ack: pthread_mutex_unlock failed: %s",
+ strerror(errno));
+
+ if (!thread->suspended) {
+ pthread_mutex_unlock(&(thread->suspendmutex));
+ return false;
}
- freeLockRecord(lr);
- recycleLockRecord(t, lr);
+
+ thread->suspended = false;
+
+ /* tell everyone that the thread should resume */
+ assert(thread != THREADOBJECT);
+ pthread_cond_broadcast(&(thread->suspendcond));
+
+ /* release the suspendmutex */
+ pthread_mutex_unlock(&(thread->suspendmutex));
+
return true;
}
-static void removeFromWaiters(monitorLockRecord *lr, monitorLockRecord *wlr)
+
+/* threads_join_all_threads ****************************************************
+
+ Join all non-daemon threads.
+
+*******************************************************************************/
+
+void threads_join_all_threads(void)
{
- do {
- if (lr->waiter == wlr) {
- lr->waiter = wlr->waiter;
- break;
- }
- lr = lr->waiter;
- } while (lr);
+ threadobject *t;
+
+ /* get current thread */
+
+ t = THREADOBJECT;
+
+ /* this thread is waiting for all non-daemon threads to exit */
+
+ threads_thread_state_waiting(t);
+
+ /* enter join mutex */
+
+ threads_mutex_join_lock();
+
+ /* Wait for condition as long as we have non-daemon threads. We
+ compare against 1 because the current (main thread) is also a
+ non-daemon thread. */
+
+ while (threads_list_get_non_daemons() > 1)
+ pthread_cond_wait(&cond_join, &mutex_join);
+
+ /* leave join mutex */
+
+ threads_mutex_join_unlock();
}
-static inline bool timespec_less(const struct timespec *tv1, const struct timespec *tv2)
+
+/* threads_timespec_earlier ****************************************************
+
+ Return true if timespec tv1 is earlier than timespec tv2.
+
+ IN:
+ tv1..........first timespec
+ tv2..........second timespec
+
+ RETURN VALUE:
+ true, if the first timespec is earlier
+
+*******************************************************************************/
+
+static inline bool threads_timespec_earlier(const struct timespec *tv1,
+ const struct timespec *tv2)
{
- return tv1->tv_sec < tv2->tv_sec || (tv1->tv_sec == tv2->tv_sec && tv1->tv_nsec < tv2->tv_nsec);
+ return (tv1->tv_sec < tv2->tv_sec)
+ ||
+ (tv1->tv_sec == tv2->tv_sec && tv1->tv_nsec < tv2->tv_nsec);
}
-static bool timeIsEarlier(const struct timespec *tv)
+
+/* threads_current_time_is_earlier_than ****************************************
+
+ Check if the current time is earlier than the given timespec.
+
+ IN:
+ tv...........the timespec to compare against
+
+ RETURN VALUE:
+ true, if the current time is earlier
+
+*******************************************************************************/
+
+static bool threads_current_time_is_earlier_than(const struct timespec *tv)
{
struct timeval tvnow;
struct timespec tsnow;
- gettimeofday(&tvnow, NULL);
+
+ /* get current time */
+
+ if (gettimeofday(&tvnow, NULL) != 0)
+ vm_abort("gettimeofday failed: %s\n", strerror(errno));
+
+ /* convert it to a timespec */
+
tsnow.tv_sec = tvnow.tv_sec;
tsnow.tv_nsec = tvnow.tv_usec * 1000;
- return timespec_less(&tsnow, tv);
+
+ /* compare current time with the given timespec */
+
+ return threads_timespec_earlier(&tsnow, tv);
}
-/* waitWithTimeout *************************************************************
+/* threads_wait_with_timeout ***************************************************
+
+ Wait until the given point in time on a monitor until either
+ we are notified, we are interrupted, or the time is up.
- XXX
+ IN:
+ t............the current thread
+ wakeupTime...absolute (latest) wakeup time
+ If both tv_sec and tv_nsec are zero, this function
+ waits for an unlimited amount of time.
+
+ RETURN VALUE:
+ true.........if the wait has been interrupted,
+ false........if the wait was ended by notification or timeout
*******************************************************************************/
-static bool waitWithTimeout(threadobject *t, monitorLockRecord *lr, struct timespec *wakeupTime)
+static bool threads_wait_with_timeout(threadobject *thread,
+ struct timespec *wakeupTime)
{
bool wasinterrupted;
- pthread_mutex_lock(&t->waitLock);
+ /* acquire the waitmutex */
- t->isSleeping = true;
+ pthread_mutex_lock(&thread->waitmutex);
- if (wakeupTime->tv_sec || wakeupTime->tv_nsec)
- while (!t->interrupted && !t->signaled && timeIsEarlier(wakeupTime))
- pthread_cond_timedwait(&t->waitCond, &t->waitLock, wakeupTime);
- else
- while (!t->interrupted && !t->signaled)
- pthread_cond_wait(&t->waitCond, &t->waitLock);
+ /* mark us as sleeping */
+
+ thread->sleeping = true;
+
+ /* wait on waitcond */
+
+ if (wakeupTime->tv_sec || wakeupTime->tv_nsec) {
+ /* with timeout */
+ while (!thread->interrupted && !thread->signaled
+ && threads_current_time_is_earlier_than(wakeupTime))
+ {
+ threads_thread_state_timed_waiting(thread);
+
+ pthread_cond_timedwait(&thread->waitcond, &thread->waitmutex,
+ wakeupTime);
+
+ threads_thread_state_runnable(thread);
+ }
+ }
+ else {
+ /* no timeout */
+ while (!thread->interrupted && !thread->signaled) {
+ threads_thread_state_waiting(thread);
+
+ pthread_cond_wait(&thread->waitcond, &thread->waitmutex);
+
+ threads_thread_state_runnable(thread);
+ }
+ }
+
+ /* check if we were interrupted */
+
+ wasinterrupted = thread->interrupted;
+
+ /* reset all flags */
- wasinterrupted = t->interrupted;
- t->interrupted = false;
- t->signaled = false;
- t->isSleeping = false;
+ thread->interrupted = false;
+ thread->signaled = false;
+ thread->sleeping = false;
+
+ /* release the waitmutex */
- pthread_mutex_unlock(&t->waitLock);
+ pthread_mutex_unlock(&thread->waitmutex);
return wasinterrupted;
}
-static void calcAbsoluteTime(struct timespec *tm, s8 millis, s4 nanos)
+/* threads_wait_with_timeout_relative ******************************************
+
+ Wait for the given maximum amount of time on a monitor until either
+ we are notified, we are interrupted, or the time is up.
+
+ IN:
+ t............the current thread
+ millis.......milliseconds to wait
+ nanos........nanoseconds to wait
+
+ RETURN VALUE:
+ true.........if the wait has been interrupted,
+ false........if the wait was ended by notification or timeout
+
+*******************************************************************************/
+
+bool threads_wait_with_timeout_relative(threadobject *thread, s8 millis,
+ s4 nanos)
+{
+ struct timespec wakeupTime;
+
+ /* calculate the the (latest) wakeup time */
+
+ threads_calc_absolute_time(&wakeupTime, millis, nanos);
+
+ /* wait */
+
+ return threads_wait_with_timeout(thread, &wakeupTime);
+}
+
+
+/* threads_calc_absolute_time **************************************************
+
+ Calculate the absolute point in time a given number of ms and ns from now.
+
+ IN:
+ millis............milliseconds from now
+ nanos.............nanoseconds from now
+
+ OUT:
+ *tm...............receives the timespec of the absolute point in time
+
+*******************************************************************************/
+
+static void threads_calc_absolute_time(struct timespec *tm, s8 millis, s4 nanos)
{
- if (millis || nanos) {
+ if ((millis != 0x7fffffffffffffffLLU) && (millis || nanos)) {
struct timeval tv;
long nsec;
gettimeofday(&tv, NULL);
nsec = tv.tv_usec * 1000 + (s4) millis * 1000000 + nanos;
tm->tv_sec = tv.tv_sec + nsec / 1000000000;
tm->tv_nsec = nsec % 1000000000;
- } else {
+ }
+ else {
tm->tv_sec = 0;
tm->tv_nsec = 0;
}
}
-void monitorWait(threadobject *t, java_objectheader *o, s8 millis, s4 nanos)
-{
- bool wasinterrupted;
- struct timespec wakeupTime;
- monitorLockRecord *mlr, *lr = o->monitorPtr;
- GRAB_LR(lr, t);
- CHECK_MONITORSTATE(lr, t, o, return);
-
- calcAbsoluteTime(&wakeupTime, millis, nanos);
-
- if (lr->waiter)
- wakeWaiters(lr->waiter);
- lr->waiting = true;
- STORE_ORDER_BARRIER();
- freeLockRecord(lr);
- wasinterrupted = waitWithTimeout(t, lr, &wakeupTime);
- mlr = monitorEnter(t, o);
- removeFromWaiters(mlr, lr);
- mlr->lockCount = lr->lockCount;
- lr->lockCount = 1;
- lr->waiting = false;
- lr->waiter = NULL;
- recycleLockRecord(t, lr);
- if (wasinterrupted)
- *exceptionptr = new_exception(string_java_lang_InterruptedException);
-}
+/* threads_thread_interrupt ****************************************************
-static void notifyOneOrAll(threadobject *t, java_objectheader *o, bool one)
-{
- monitorLockRecord *lr = o->monitorPtr;
- GRAB_LR(lr, t);
- CHECK_MONITORSTATE(lr, t, o, return);
- do {
- threadobject *wthread;
- monitorLockRecord *wlr = lr->waiter;
- if (!wlr)
- break;
- wthread = wlr->ownerThread;
- pthread_mutex_lock(&wthread->waitLock);
- if (wthread->isSleeping)
- pthread_cond_signal(&wthread->waitCond);
- wthread->signaled = true;
- pthread_mutex_unlock(&wthread->waitLock);
- lr = wlr;
- } while (!one);
-}
+ Interrupt the given thread.
-bool threadHoldsLock(threadobject *t, java_objectheader *o)
-{
- monitorLockRecord *lr = o->monitorPtr;
- GRAB_LR(lr, t);
- /* The reason why we have to check against NULL is that
- * dummyLR->incharge == NULL */
- return lr && lr->o == o && lr->ownerThread == t;
-}
+ The thread gets the "waitcond" signal and
+ its interrupted flag is set to true.
-void interruptThread(java_lang_VMThread *thread)
-{
- threadobject *t = (threadobject*) thread;
+ IN:
+ thread............the thread to interrupt
- t->interrupted = true;
- pthread_mutex_lock(&t->waitLock);
- if (t->isSleeping)
- pthread_cond_signal(&t->waitCond);
- pthread_mutex_unlock(&t->waitLock);
-}
+*******************************************************************************/
-bool interruptedThread()
+void threads_thread_interrupt(threadobject *thread)
{
- threadobject *t = (threadobject*) THREADOBJECT;
- bool intr = t->interrupted;
- t->interrupted = false;
- return intr;
-}
+ /* Signal the thread a "waitcond" and tell it that it has been
+ interrupted. */
-bool isInterruptedThread(java_lang_VMThread *thread)
-{
- threadobject *t = (threadobject*) thread;
- return t->interrupted;
-}
+ pthread_mutex_lock(&thread->waitmutex);
-void sleepThread(s8 millis, s4 nanos)
-{
- bool wasinterrupted;
- threadobject *t = (threadobject*) THREADOBJECT;
- monitorLockRecord *lr;
- struct timespec wakeupTime;
- calcAbsoluteTime(&wakeupTime, millis, nanos);
+ /* Interrupt blocking system call using a signal. */
- lr = allocLockRecordSimple(t);
- wasinterrupted = waitWithTimeout(t, lr, &wakeupTime);
- recycleLockRecord(t, lr);
+ pthread_kill(thread->tid, SIGHUP);
- if (wasinterrupted)
- *exceptionptr = new_exception(string_java_lang_InterruptedException);
-}
+ if (thread->sleeping)
+ pthread_cond_signal(&thread->waitcond);
-void yieldThread()
-{
- sched_yield();
-}
+ thread->interrupted = true;
-void setPriorityThread(thread *t, s4 priority)
-{
- nativethread *info = &((threadobject*) t->vmThread)->info;
- setPriority(info->tid, priority);
+ pthread_mutex_unlock(&thread->waitmutex);
}
-void wait_cond_for_object(java_objectheader *o, s8 time, s4 nanos)
-{
- threadobject *t = (threadobject*) THREADOBJECT;
- monitorWait(t, o, time, nanos);
-}
-void signal_cond_for_object(java_objectheader *o)
-{
- threadobject *t = (threadobject*) THREADOBJECT;
- notifyOneOrAll(t, o, true);
-}
+/* threads_check_if_interrupted_and_reset **************************************
-void broadcast_cond_for_object(java_objectheader *o)
+ Check if the current thread has been interrupted and reset the
+ interruption flag.
+
+ RETURN VALUE:
+ true, if the current thread had been interrupted
+
+*******************************************************************************/
+
+bool threads_check_if_interrupted_and_reset(void)
{
- threadobject *t = (threadobject*) THREADOBJECT;
- notifyOneOrAll(t, o, false);
+ threadobject *thread;
+ bool intr;
+
+ thread = THREADOBJECT;
+
+ /* get interrupted flag */
+
+ intr = thread->interrupted;
+
+ /* reset interrupted flag */
+
+ thread->interrupted = false;
+
+ return intr;
}
-/* threads_dump ****************************************************************
+/* threads_thread_has_been_interrupted *****************************************
- Dumps info for all threads running in the JVM. This function is
- called when SIGQUIT (<ctrl>-\) is sent to CACAO.
+ Check if the given thread has been interrupted
-*******************************************************************************/
+ IN:
+ t............the thread to check
-void threads_dump(void)
-{
- threadobject *tobj;
- java_lang_VMThread *vmt;
- nativethread *nt;
- ExecEnvironment *ee;
- java_lang_Thread *t;
- utf *name;
+ RETURN VALUE:
+ true, if the given thread had been interrupted
- tobj = mainthreadobj;
+*******************************************************************************/
- printf("Full thread dump CACAO "VERSION":\n");
+bool threads_thread_has_been_interrupted(threadobject *thread)
+{
+ return thread->interrupted;
+}
- /* iterate over all started threads */
- do {
- /* get thread objects */
+/* threads_sleep ***************************************************************
- vmt = &tobj->o;
- nt = &tobj->info;
- ee = &tobj->ee;
- t = vmt->thread;
+ Sleep the current thread for the specified amount of time.
- /* the thread may be currently in initalization, don't print it */
+*******************************************************************************/
- if (t) {
- /* get thread name */
+void threads_sleep(s8 millis, s4 nanos)
+{
+ threadobject *thread;
+ struct timespec wakeupTime;
+ bool wasinterrupted;
- name = javastring_toutf(t->name, false);
+ thread = THREADOBJECT;
- printf("\n\"");
- utf_display(name);
- printf("\" ");
+ threads_calc_absolute_time(&wakeupTime, millis, nanos);
- if (t->daemon)
- printf("daemon ");
+ wasinterrupted = threads_wait_with_timeout(thread, &wakeupTime);
-#if SIZEOF_VOID_P == 8
- printf("prio=%d tid=0x%016lx\n", t->priority, nt->tid);
-#else
- printf("prio=%d tid=0x%08lx\n", t->priority, nt->tid);
-#endif
+ if (wasinterrupted)
+ exceptions_throw_interruptedexception();
+}
- /* send SIGUSR1 to thread to print stacktrace */
- pthread_kill(nt->tid, SIGUSR1);
+/* threads_yield ***************************************************************
- /* sleep this thread a bit, so the signal can reach the thread */
+ Yield to the scheduler.
- sleepThread(10, 0);
- }
+*******************************************************************************/
- tobj = tobj->info.next;
- } while (tobj && (tobj != mainthreadobj));
+void threads_yield(void)
+{
+ sched_yield();
}
* c-basic-offset: 4
* tab-width: 4
* End:
+ * vim:noexpandtab:sw=4:ts=4:
*/
projects / cacao.git / blobdiff