PatchSet 5389 Date: 2004/10/31 14:35:33 Author: hkraemer Branch: HEAD Tag: (none) Log: moved handling of thread interruption to jthread layer, some minor fixes
Members: ChangeLog:1.2940->1.2941 include/errors.h:1.13->1.14 kaffe/kaffevm/stackTrace.c:1.38->1.39 kaffe/kaffevm/thread.c:1.79->1.80 kaffe/kaffevm/jni/jni.c:1.7->1.8 kaffe/kaffevm/systems/unix-jthreads/jthread.c:1.123->1.124 kaffe/kaffevm/systems/unix-jthreads/jthread.h:1.63->1.64 kaffe/kaffevm/systems/unix-pthreads/lock-impl.c:1.10->1.11 kaffe/kaffevm/systems/unix-pthreads/thread-impl.c:1.50->1.51 libraries/clib/native/Object.c:1.9->1.10 libraries/clib/native/Thread.c:1.18->1.19 libraries/javalib/java/lang/VMObject.java:1.1->1.2 libraries/javalib/java/lang/VMThread.java:1.1->1.2 libraries/javalib/kaffe/lang/ThreadStack.java:1.2->1.3 Index: kaffe/ChangeLog diff -u kaffe/ChangeLog:1.2940 kaffe/ChangeLog:1.2941 --- kaffe/ChangeLog:1.2940 Sun Oct 31 13:36:22 2004 +++ kaffe/ChangeLog Sun Oct 31 14:35:33 2004 @@ -1,3 +1,53 @@ +2004-10-31 Helmer Kraemer <[EMAIL PROTECTED]> + + Moved complete handling of thread interruption down to jthread layer: + + * kaffe/kaffevm/systems/unix-jthreads/jthread.h + (THREAD_FLAGS_INTERRUPTED_READ) removed + * kaffe/kaffevm/systems/unix-jthreads/jthread.c + (suspendOnQThread): don't clear interrupted flag + (jthread_interrupt): set interrupted flag if a thread interrupts + itself; only resume threads not waiting for a mutex + + * kaffe/kaffevm/systems/unix-pthreads/lock-impl.c + (jcondvar_wait): don't mess around with interrupted flag, it's + set correctly by the interrupting thread + * kaffe/kaffevm/systems/unix-pthreads/thread-impl.c + (jthread_interrupt): if thread is waiting for its semaphore, signal that + one instead of sending a signal + (jthread_is_interrupted, jthread_interrupted): add comments + (jthread_suspendall): lock thread's suspendLock before reading its + suspendState + + * include/errors.h: added define for java.lang.InterruptedException + + * libraries/clib/native/Object.c, libraries/javalib/java/lang/VMObject.java + (nativeWait): removed + (wait): moved to native code + + * libraries/clib/native/Thread.c, libraries/javalib/java/lang/VMThread.java + (nativeInterrupt, nativeIsInterrupted, nativeInterrupted): removed + (interrupt, isInterrupted, interrupted, sleep): moved to native code + + Some other minor fixes: + + * libraries/javalib/kaffe/lang/ThreadStack.java + (getCallersClassLoader): return AppClassLoader if there're no java methods + on the stack + + * kaffe/kaffevm/jni/jni.c (tryClassForName): removed + (Kaffe_FindClass): simply call Class.forName and let ThreadStack find the + correct ClassLoader + + * libraries/javalib/Klasses.jar.bootstrap: regenerated + + * kaffe/kaffevm/stackTrace.c (getStackTraceElements): adapted to + changes of field names of java.lang.StackTraceElement + + * kaffe/kaffevm/thread.c (thread_malloc, thread_free, + thread_realloc): removed + Added debug messages and removed unused variables + 2004-10-30 Dalibor Topic <[EMAIL PROTECTED]> * libraries/javalib/gnu/xml/xpath/VariableReference.java, Index: kaffe/include/errors.h diff -u kaffe/include/errors.h:1.13 kaffe/include/errors.h:1.14 --- kaffe/include/errors.h:1.13 Tue Oct 12 17:00:10 2004 +++ kaffe/include/errors.h Sun Oct 31 14:35:32 2004 @@ -107,6 +107,7 @@ #define ThreadDeath NEW_LANG_EXCEPTION(ThreadDeath) #define StackOverflowError NEW_LANG_EXCEPTION(StackOverflowError) #define IllegalThreadStateException NEW_LANG_EXCEPTION(IllegalThreadStateException) +#define InterruptedException NEW_LANG_EXCEPTION(InterruptedException) #define InstantiationException(M) NEW_LANG_EXCEPTION_MESSAGE(InstantiationException, M) #if !defined(KAFFEH) Index: kaffe/kaffe/kaffevm/stackTrace.c diff -u kaffe/kaffe/kaffevm/stackTrace.c:1.38 kaffe/kaffe/kaffevm/stackTrace.c:1.39 --- kaffe/kaffe/kaffevm/stackTrace.c:1.38 Fri Oct 22 22:32:41 2004 +++ kaffe/kaffe/kaffevm/stackTrace.c Sun Oct 31 14:35:32 2004 @@ -184,7 +184,7 @@ (CLASS_SOURCEFILE(meth->class)); unhand(element)->lineNumber = getLineNumber(meth, stack[i].pc); - unhand(element)->className + unhand(element)->declaringClass = utf8Const2JavaReplace (meth->class->name, '/', '.'); unhand(element)->methodName Index: kaffe/kaffe/kaffevm/thread.c diff -u kaffe/kaffe/kaffevm/thread.c:1.79 kaffe/kaffe/kaffevm/thread.c:1.80 --- kaffe/kaffe/kaffevm/thread.c:1.79 Wed Oct 27 16:12:03 2004 +++ kaffe/kaffe/kaffevm/thread.c Sun Oct 31 14:35:32 2004 @@ -61,30 +61,6 @@ static void firstStartThread(void*); static void runfinalizer(void); -/* - * How do I get memory? - */ -static -void * -thread_malloc(size_t s) -{ - return gc_malloc(s, KGC_ALLOC_THREADCTX); -} - -static -void -thread_free(void *p) -{ - gc_free(p); -} - -static -void * -thread_realloc(void *p, size_t s) -{ - return gc_realloc(p, s, KGC_ALLOC_THREADCTX); -} - static void linkNativeAndJavaThread(jthread_t thread, Hjava_lang_VMThread *jlThread) { @@ -169,7 +145,8 @@ { jthread_t nativeTid; struct _errorInfo info; - int iLockRoot; + +DBG(VMTHREAD, dprintf ("%p starting thread %p (vmthread %p)\n\n", jthread_current(), unhand(tid)->thread, tid); ) /* Hold the start lock while the thread is created. * This lock prevents the new thread from running until we're @@ -195,9 +172,11 @@ void interruptThread(Hjava_lang_VMThread* tid) { - if ((jthread_t)unhand(tid)->jthreadID) { - jthread_interrupt((jthread_t)unhand(tid)->jthreadID); - } +DBG(VMTHREAD, dprintf ("%p (%p) interrupting %p (%p)\n", jthread_current(), + THREAD_DATA()->jlThread, unhand(tid)->jthreadID, tid); ) + assert(unhand(tid)->jthreadID != NULL); + + jthread_interrupt((jthread_t)unhand(tid)->jthreadID); } /* @@ -293,7 +272,6 @@ void (*func)(void *); void **pointer_args = (void **)arg; void *argument; - int iLockRoot; jthread_t calling_thread; ksemInit(&THREAD_DATA()->sem); @@ -333,7 +311,6 @@ Hjava_lang_Thread* tid; Hjava_lang_VMThread *vmtid; jthread_t nativeTid; - int iLockRoot; Hjava_lang_String* name; void *specialArgument[3]; @@ -400,7 +377,6 @@ jthread_t cur; JNIEnv *env; jmethodID runmethod; - int iLockRoot; jthread_t calling_thread = (jthread_t) arg; cur = jthread_current(); @@ -429,7 +405,7 @@ #endif DBG(VMTHREAD, - dprintf("firstStartThread %p\n", tid); + dprintf("%p (%p) firstStartThread\n", cur, tid); ) /* @@ -483,7 +459,7 @@ exitThread(void) { DBG(VMTHREAD, - dprintf("exitThread %p\n", getCurrentThread()); + dprintf("%p (%p) exitThread\n", jthread_current(), THREAD_DATA()->jlThread); ) #if defined(ENABLE_JVMPI) Index: kaffe/kaffe/kaffevm/jni/jni.c diff -u kaffe/kaffe/kaffevm/jni/jni.c:1.7 kaffe/kaffe/kaffevm/jni/jni.c:1.8 --- kaffe/kaffe/kaffevm/jni/jni.c:1.7 Thu Aug 19 19:29:06 2004 +++ kaffe/kaffe/kaffevm/jni/jni.c Sun Oct 31 14:35:37 2004 @@ -217,28 +217,11 @@ */ static jclass -tryClassForName(jstring nameString) -{ - jvalue retval; - - BEGIN_EXCEPTION_HANDLING(0); - - /* Call Class.forName() */ - retval = do_execute_java_class_method("java.lang.Class", NULL, - "forName", "(Ljava/lang/String;)Ljava/lang/Class;", nameString); - - END_EXCEPTION_HANDLING(); - - return retval.l; -} - -static jclass Kaffe_FindClass(JNIEnv* env, const char* name) { jstring nameString; Utf8Const* utf8; jobject retval; - jobject exc; BEGIN_EXCEPTION_HANDLING(0); @@ -248,42 +231,9 @@ utf8ConstRelease(utf8); checkPtr(nameString); - retval = tryClassForName(nameString); - - exc = thread_data->exceptObj; - if (exc != NULL) - { - if (soft_instanceof(javaLangClassNotFoundException, exc)) - { - int iLockRoot; - static iStaticLock appLock = KAFFE_STATIC_LOCK_INITIALIZER; - - thread_data->exceptObj = NULL; - if (appClassLoader == NULL) - { - lockStaticMutex(&appLock); - if (appClassLoader == NULL) - appClassLoader = do_execute_java_method(kaffeLangAppClassLoaderClass, "getSingleton", "()Ljava/lang/ClassLoader;", NULL, true).l; - unlockStaticMutex(&appLock); - - if (thread_data->exceptObj != NULL) - { - fprintf(stderr, - "ERROR: The default user class loader " - APPCLASSLOADERCLASS " can not be loaded.\n" - "Aborting...\n"); - ABORT(); - } - } - - - retval = do_execute_java_class_method("java.lang.Class", NULL, - "forName", "(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;", nameString, true, appClassLoader).l; - ADD_REF(retval); - } - } else { - ADD_REF(retval); - } + retval = do_execute_java_class_method("java.lang.Class", NULL, + "forName", "(Ljava/lang/String;)Ljava/lang/Class;", nameString).l; + ADD_REF(retval); END_EXCEPTION_HANDLING(); return (retval); @@ -1040,7 +990,7 @@ MIN_HEAPSIZE, /* Min heap size */ MAX_HEAPSIZE, /* Max heap size */ /* 2, */ /* Verify mode ... verify remote by default */ - 0, /* Verify mode ... noverify by default */ + 0, /* Verify mode ... noverify by default */ ".", /* Classpath */ 0, /* Bootclasspath */ (void*)&vfprintf,/* Vprintf */ Index: kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.c diff -u kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.c:1.123 kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.c:1.124 --- kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.c:1.123 Wed Oct 20 16:47:14 2004 +++ kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.c Sun Oct 31 14:35:37 2004 @@ -941,7 +941,6 @@ if (jtid == currentJThread) { reschedule(); if (jtid->flags & THREAD_FLAGS_INTERRUPTED) { - jtid->flags &= ~(THREAD_FLAGS_INTERRUPTED|THREAD_FLAGS_INTERRUPTED_READ); rc = true; } } @@ -1470,11 +1469,14 @@ { intsDisable(); + /* mark thread as interrupted */ + jtid->flags |= THREAD_FLAGS_INTERRUPTED; + /* make sure we only resume suspended threads - * (and neither dead nor runnable threads) + * (and neither dead nor runnable threads) that + * are not trying to acquire a mutex. */ - if (jtid != currentJThread && jtid->status == THREAD_SUSPENDED) { - jtid->flags |= THREAD_FLAGS_INTERRUPTED; + if ((jtid->status == THREAD_SUSPENDED) && !jthread_on_mutex(jtid)) { resumeThread(jtid); } intsRestore(); @@ -2695,11 +2697,13 @@ int jthread_interrupted(jthread_t jt) { - if (jt->flags & THREAD_FLAGS_INTERRUPTED_READ || !(jt->flags & THREAD_FLAGS_INTERRUPTED)) - return 0; + if (jt->flags & THREAD_FLAGS_INTERRUPTED) + { + jt->flags &= ~THREAD_FLAGS_INTERRUPTED; + return 1; + } - jt->flags |= THREAD_FLAGS_INTERRUPTED_READ; - return 1; + return 0; } int jthread_on_mutex(jthread_t jt) Index: kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.h diff -u kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.h:1.63 kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.h:1.64 --- kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.h:1.63 Wed Oct 20 16:47:14 2004 +++ kaffe/kaffe/kaffevm/systems/unix-jthreads/jthread.h Sun Oct 31 14:35:37 2004 @@ -86,7 +86,6 @@ #define THREAD_FLAGS_INTERRUPTED 128 #define THREAD_FLAGS_WAIT_MUTEX 256 #define THREAD_FLAGS_WAIT_CONDVAR 512 -#define THREAD_FLAGS_INTERRUPTED_READ 1024 /* * This is our internal structure representing the "native" threads. Index: kaffe/kaffe/kaffevm/systems/unix-pthreads/lock-impl.c diff -u kaffe/kaffe/kaffevm/systems/unix-pthreads/lock-impl.c:1.10 kaffe/kaffe/kaffevm/systems/unix-pthreads/lock-impl.c:1.11 --- kaffe/kaffe/kaffevm/systems/unix-pthreads/lock-impl.c:1.10 Mon Sep 20 15:48:45 2004 +++ kaffe/kaffe/kaffevm/systems/unix-pthreads/lock-impl.c Sun Oct 31 14:35:38 2004 @@ -81,13 +81,17 @@ int status; struct timespec abst; struct timeval now; - //CHECK_LOCK( cur,lk); - cur->interrupting = 0; + /* + * If a thread trying to get a heavy lock is interrupted, we may get here + * with the interrupted flag set (because the thread didn't get the heavy + * lock and has to wait again). Therefore, we must not clear the interrupted + * flag here. + */ if ( timeout == NOTIMEOUT ) { - /* we handle this as "wait forever" */ + /* we handle this as "wait forever" */ status = ThreadCondWait(cur, cv, mux); } else @@ -116,7 +120,12 @@ } } - cur->interrupting = (status == EINTR); - + /* + * Since we interrupt a thread blocked on a condition variable by signaling that + * condition variable, we cannot set the interrupted flag based on the value of + * 'signal'. Therefore, we have to rely on the interrupting thread to set the + * flag. + */ + return (status == 0); } Index: kaffe/kaffe/kaffevm/systems/unix-pthreads/thread-impl.c diff -u kaffe/kaffe/kaffevm/systems/unix-pthreads/thread-impl.c:1.50 kaffe/kaffe/kaffevm/systems/unix-pthreads/thread-impl.c:1.51 --- kaffe/kaffe/kaffevm/systems/unix-pthreads/thread-impl.c:1.50 Fri Oct 22 21:51:36 2004 +++ kaffe/kaffe/kaffevm/systems/unix-pthreads/thread-impl.c Sun Oct 31 14:35:38 2004 @@ -588,18 +588,46 @@ return (nt); } +/** + * Interrupt a thread. + * + * If tid is currently blocked its interrupted flag is set + * and the blocking operation is canceled. + */ void jthread_interrupt(jthread_t tid) { + pthread_mutex_lock(&tid->suspendLock); + tid->interrupting = 1; - /* We need to send some signal to interrupt syscalls. */ - pthread_kill(tid->tid, sigInterrupt); + + if ((tid->blockState & (BS_CV|BS_CV_TO)) != 0) + { + pthread_cond_signal (&tid->data.sem.cv); + } + else if(tid->blockState == 0) + { + /* We need to send some signal to interrupt syscalls. */ + pthread_kill(tid->tid, sigInterrupt); + } + + pthread_mutex_unlock(&tid->suspendLock); } +/** + * Peek at the interrupted flag of a thread. + * + * @return true iff jt was interrupted. + */ int jthread_is_interrupted(jthread_t jt) { return jt->interrupting; } +/** + * Read and clear the interrupted flag of a thread. + * + * @return true iff jt was interrupted. + */ int jthread_interrupted(jthread_t jt) { int i = jt->interrupting; @@ -1192,11 +1220,11 @@ * signals handled by threads which are blocked on someting else * than the thread lock (which we soon release) */ + pthread_mutex_lock(&t->suspendLock); if ( (t != cur) && (t->suspendState == 0) && (t->active != 0) ) { DBG( JTHREAD, dprintf("signal suspend: %p (susp: %d blk: %d)\n", t, t->suspendState, t->blockState)) - pthread_mutex_lock(&t->suspendLock); t->suspendState = SS_PENDING_SUSPEND; if ((t->blockState & (BS_CV|BS_MUTEX|BS_CV_TO)) != 0) @@ -1221,8 +1249,8 @@ sem_wait( &critSem); } } - pthread_mutex_unlock(&t->suspendLock); } + pthread_mutex_unlock(&t->suspendLock); } #else Index: kaffe/libraries/clib/native/Object.c diff -u kaffe/libraries/clib/native/Object.c:1.9 kaffe/libraries/clib/native/Object.c:1.10 --- kaffe/libraries/clib/native/Object.c:1.9 Thu Jul 29 14:24:54 2004 +++ kaffe/libraries/clib/native/Object.c Sun Oct 31 14:35:32 2004 @@ -24,6 +24,7 @@ #include "java_lang_VMObject.h" #include "thread.h" #include "jvmpi_kaffe.h" +#include "debug.h" /* * Return class object for this object. @@ -89,8 +90,19 @@ * Wait for this object to be notified. */ void -java_lang_VMObject_nativeWait(struct Hjava_lang_Object* o, jlong timeout, UNUSED jint ns) +java_lang_VMObject_wait(struct Hjava_lang_Object* o, jlong timeout, UNUSED jint ns) { + jthread_t cur = jthread_current(); + + if(jthread_interrupted(cur)) + { + throwException(InterruptedException); + } + +DBG(VMTHREAD, dprintf ("%p (%p) waiting for %p, %d\n", + cur, jthread_get_data(cur)->jlThread, + o, timeout); ) + #if defined(ENABLE_JVMPI) if( JVMPI_EVENT_ISENABLED(JVMPI_EVENT_MONITOR_WAIT) ) { @@ -128,4 +140,9 @@ jvmpiPostEvent(&ev); } #endif + + if(jthread_interrupted(cur)) + { + throwException(InterruptedException); + } } Index: kaffe/libraries/clib/native/Thread.c diff -u kaffe/libraries/clib/native/Thread.c:1.18 kaffe/libraries/clib/native/Thread.c:1.19 --- kaffe/libraries/clib/native/Thread.c:1.18 Thu Jul 29 14:24:54 2004 +++ kaffe/libraries/clib/native/Thread.c Sun Oct 31 14:35:32 2004 @@ -20,6 +20,7 @@ #include "locks.h" #include "support.h" #include "jthread.h" +#include "debug.h" struct Hjava_lang_Thread* java_lang_VMThread_currentThread(void) @@ -55,7 +56,7 @@ } void -java_lang_VMThread_nativeInterrupt(struct Hjava_lang_VMThread* this) +java_lang_VMThread_interrupt(struct Hjava_lang_VMThread* this) { interruptThread(this); } @@ -66,12 +67,46 @@ finalizeThread(this); } -jboolean java_lang_VMThread_nativeInterrupted(void) +jboolean java_lang_VMThread_interrupted(void) { return jthread_interrupted(jthread_current()); } -jboolean java_lang_VMThread_nativeIsInterrupted(Hjava_lang_VMThread *this) +jboolean java_lang_VMThread_isInterrupted(Hjava_lang_VMThread *this) { return jthread_is_interrupted((jthread_t)unhand(this)->jthreadID); +} + + +void java_lang_VMThread_sleep(jlong timeout, UNUSED jint ns) +{ + jthread_t cur = jthread_current(); + + if(jthread_interrupted(cur)) + { + throwException(InterruptedException); + } + +DBG(VMTHREAD, dprintf ("%p (%p) sleeping for %d\n", cur, + jthread_get_data(cur)->jlThread, timeout); ) + + /* + * Using the semaphore of this thread for sleeping is safe, since + * there are only two reasons for another thread to invoke ksemPut + * on this semaphore: + * + * - it releases a lock this thread is waiting for, or + * - it has to signal this thread that it has been started. + * + * None of these apply here (we're neither waiting for a lock nor + * starting a new thread). Since the jthread implementation has to + * be able to interrupt a thread waiting for its semaphore anyway, + * this thread can still be interrupted. + */ + ksemGet(&jthread_get_data(cur)->sem, timeout); + + if(jthread_interrupted(cur)) + { + throwException(InterruptedException); + } } Index: kaffe/libraries/javalib/java/lang/VMObject.java diff -u kaffe/libraries/javalib/java/lang/VMObject.java:1.1 kaffe/libraries/javalib/java/lang/VMObject.java:1.2 --- kaffe/libraries/javalib/java/lang/VMObject.java:1.1 Thu Jul 29 14:42:28 2004 +++ kaffe/libraries/javalib/java/lang/VMObject.java Sun Oct 31 14:35:37 2004 @@ -91,23 +91,6 @@ * lock on the Object * @throws InterruptedException if some other Thread interrupts this Thread */ - static void wait(Object o, long ms, int ns) - throws IllegalMonitorStateException, InterruptedException - { - Thread current = Thread.currentThread(); - VMThread vmt = current.vmThread; - - if (current.interrupted()) - throw new InterruptedException(); - - vmt.holder = o; - nativeWait(o, ms, ns); - vmt.holder = null; - - if (current.interrupted()) - throw new InterruptedException(); - } - - static native void nativeWait(Object o, long ms, int ns) - throws IllegalMonitorStateException, InterruptedException; + static native void wait(Object o, long ms, int ns) + throws IllegalMonitorStateException, InterruptedException; } Index: kaffe/libraries/javalib/java/lang/VMThread.java diff -u kaffe/libraries/javalib/java/lang/VMThread.java:1.1 kaffe/libraries/javalib/java/lang/VMThread.java:1.2 --- kaffe/libraries/javalib/java/lang/VMThread.java:1.1 Thu Jul 29 14:42:28 2004 +++ kaffe/libraries/javalib/java/lang/VMThread.java Sun Oct 31 14:35:37 2004 @@ -91,21 +91,6 @@ private Ptr jthreadID; /** - * Kaffe Specific: Object instance to fall asleep. - */ - private Object sleeper; - - /** - * Kaffe Specific: Object which is holding the thread. - */ - Object holder; - - /** - * Kaffe Specific: Thread is being interrupted. - */ - private boolean interrupting; - - /** * Private constructor, create VMThreads with the static create method. * * @param thread The Thread object that was just created. @@ -325,23 +310,7 @@ /** * Interrupt this thread. */ - void interrupt() - { - interrupting = true; - Object h = holder; - if (h != null) - { - holder = null; - synchronized(h) - { - h.notify(); - } - } - else - nativeInterrupt(); - } - - private native void nativeInterrupt(); + native void interrupt(); /** * Determine whether this Thread has been interrupted, but leave @@ -349,12 +318,7 @@ * * @return whether the Thread has been interrupted */ - boolean isInterrupted() - { - return interrupting || nativeIsInterrupted(); - } - - private native boolean nativeIsInterrupted(); + native boolean isInterrupted(); /** * Suspend this Thread. It will not come back, ever, unless it is resumed. @@ -396,7 +360,7 @@ * * @return the currently executing Thread */ - native static Thread currentThread(); + static native Thread currentThread(); /** * Yield to another thread. The Thread will not lose any locks it holds @@ -424,18 +388,7 @@ * <i>interrupted status</i> will be cleared * @throws IllegalArgumentException if ns is invalid */ - static void sleep(long ms, int ns) throws InterruptedException - { - VMThread curr = currentThread().vmThread; - - if (curr.sleeper == null) - curr.sleeper = new Object(); - - synchronized (curr.sleeper) - { - curr.sleeper.wait(ms, ns); - } - } + static native void sleep(long ms, int ns) throws InterruptedException; /** * Determine whether the current Thread has been interrupted, and clear @@ -443,16 +396,7 @@ * * @return whether the current Thread has been interrupted */ - static boolean interrupted() - { - VMThread vmt = Thread.currentThread().vmThread; - boolean i = nativeInterrupted() || vmt.interrupting; - - vmt.interrupting = false; - return i; - } - - static native boolean nativeInterrupted(); + static native boolean interrupted(); /** * Kaffe Specific: finalize thread Index: kaffe/libraries/javalib/kaffe/lang/ThreadStack.java diff -u kaffe/libraries/javalib/kaffe/lang/ThreadStack.java:1.2 kaffe/libraries/javalib/kaffe/lang/ThreadStack.java:1.3 --- kaffe/libraries/javalib/kaffe/lang/ThreadStack.java:1.2 Sat Jun 28 18:06:41 2003 +++ kaffe/libraries/javalib/kaffe/lang/ThreadStack.java Sun Oct 31 14:35:31 2004 @@ -80,10 +80,11 @@ /* * if this is already the last class on the stack, we're done * this should only happen in the very beginning when main.c - * calls FindClass and thus forName outside a java class. + * calls FindClass and thus forName outside a java class, so + * we return the AppClassLoader in this case. */ if (frameIdx == classStack.length) { - return javaPrimordial ? PrimordialClassLoader.getSingleton() : null; + return AppClassLoader.getSingleton(); } /* _______________________________________________ kaffe mailing list [EMAIL PROTECTED] http://kaffe.org/cgi-bin/mailman/listinfo/kaffe