? build ? build_intrp ? config/powerpc/darwin/md.h.new ? kaffe/kaffevm/locks.c.v2 ? libraries/javalib/Klasses.jar.bootstrap.save ? libraries/javalib/l ? po/fr.gmo ? po/zh_TW.gmo ? test/regression/RefTest ? test/regression/l Index: config/alpha/osf/md.c =================================================================== RCS file: /cvs/kaffe/kaffe/config/alpha/osf/md.c,v retrieving revision 1.8 diff -u -B -b -r1.8 md.c --- config/alpha/osf/md.c 8 Jul 2003 07:33:48 -0000 1.8 +++ config/alpha/osf/md.c 7 Mar 2005 19:00:46 -0000 @@ -87,7 +87,6 @@ void __alpha_osf_firstFrame (exceptionFrame *frame) { - int iLockRoot; /* Retreive caller frame as current one will be invalidate after function exit. */ @@ -104,7 +103,6 @@ exceptionFrame * __alpha_osf_nextFrame (exceptionFrame *frame) { - int iLockRoot; DBG(STACKTRACE, dprintf("__alpha_osf_nextFrame(0x%p) pc 0x%p fp 0x%p sp 0x%p\n", frame, @@ -140,7 +138,6 @@ /* Construct JIT Exception information and register it. */ void __alpha_osf_register_jit_exc (void *methblock, void *codebase, void *codeend) { - int iLockRoot; extern int maxLocal, maxStack, maxTemp, maxArgs, maxPush; struct { pdsc_crd crd[2]; @@ -209,7 +206,6 @@ void __alpha_osf_unregister_jit_exc (void *methblock, void *codebase, void *codeend) { - int iLockRoot; int codelen = codeend - codebase; DBG(STACKTRACE, Index: config/i386/jit.h =================================================================== RCS file: /cvs/kaffe/kaffe/config/i386/jit.h,v retrieving revision 1.25 diff -u -B -b -r1.25 jit.h --- config/i386/jit.h 20 Dec 2004 00:55:13 -0000 1.25 +++ config/i386/jit.h 7 Mar 2005 19:00:47 -0000 @@ -112,7 +112,7 @@ #define LABEL_Lframe(P,D,L) \ { \ int framesize = SLOTSIZE * (maxLocal + maxStack + \ - maxTemp - maxArgs); \ + maxTemp - maxArgs + 1); \ *(uint32*)(P) = framesize; \ } #define LABEL_Llong8(P,V,L) *(char*)(P) = (V) Index: config/i386/jit3-icode.h =================================================================== RCS file: /cvs/kaffe/kaffe/config/i386/jit3-icode.h,v retrieving revision 1.9 diff -u -B -b -r1.9 jit3-icode.h --- config/i386/jit3-icode.h 17 Jun 2001 16:39:10 -0000 1.9 +++ config/i386/jit3-icode.h 7 Mar 2005 19:00:47 -0000 @@ -223,8 +223,8 @@ #define HAVE_call_indirect_const call_ind_xCC -#define HAVE_mon_enter monenter_xxRCC -#define HAVE_mon_exit monexit_xxRCC +//#define HAVE_mon_enter monenter_xxRCC +//#define HAVE_mon_exit monexit_xxRCC #define HAVE_get_arg_ptr get_arg_ptr_R Index: include/errors.h =================================================================== RCS file: /cvs/kaffe/kaffe/include/errors.h,v retrieving revision 1.16 diff -u -B -b -r1.16 errors.h --- include/errors.h 19 Dec 2004 22:13:08 -0000 1.16 +++ include/errors.h 7 Mar 2005 19:00:48 -0000 @@ -36,7 +36,7 @@ typedef struct _errorInfo { int type; /* type of error */ const char* classname; /* full dotted name of exception/error class */ - char* mess; /* accompanying msg */ + const char* mess; /* accompanying msg */ struct Hjava_lang_Throwable* throwable; /* a throwable */ } errorInfo; Index: kaffe/kaffevm/classMethod.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/classMethod.c,v retrieving revision 1.135 diff -u -B -b -r1.135 classMethod.c --- kaffe/kaffevm/classMethod.c 16 Feb 2005 13:35:20 -0000 1.135 +++ kaffe/kaffevm/classMethod.c 7 Mar 2005 19:00:49 -0000 @@ -115,7 +115,6 @@ static int depth; #endif /* !(defined(NDEBUG) || !defined(KAFFE_VMDEBUG)) */ static Method *object_fin; - int iLockRoot; /* If this class is initialised to the required point, quit now */ if (class->state >= tostate) { @@ -750,7 +749,6 @@ static bool resolveInterfaces(Hjava_lang_Class *class, errorInfo *einfo) { - int iLockRoot; int i, j, k; int totalilen; Hjava_lang_Class** newifaces; @@ -1539,7 +1537,6 @@ errorInfo info; Utf8Const *utf8; classEntry* centry; - int iLockRoot; bool refAdded; utf8 = utf8ConstNew(name, -1); @@ -1618,7 +1615,6 @@ { Hjava_lang_Class* clas; const char* name; - int iLockRoot; /* Avoid locking if we can */ if (FIELD_RESOLVED(fld)) { @@ -2230,7 +2226,6 @@ int found_i; bool rc = false; Hjava_lang_Class** ifcs; - int iLockRoot; /* find an impl_index for this class * Note that we only find a suitable impl_index with regard to the @@ -2429,7 +2424,6 @@ Utf8Const* utf8; Hjava_lang_String* str = NULL; constants* pool; - int iLockRoot; pool = CLASS_CONSTANTS(clazz); @@ -2768,7 +2762,6 @@ classEntry* centry; Hjava_lang_Class* arr_class; int arr_flags; - int iLockRoot; /* If we couldn't resolve the element type, there's no way we can * construct the array type. Index: kaffe/kaffevm/classPool.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/classPool.c,v retrieving revision 1.33 diff -u -B -b -r1.33 classPool.c --- kaffe/kaffevm/classPool.c 4 Feb 2005 10:36:14 -0000 1.33 +++ kaffe/kaffevm/classPool.c 7 Mar 2005 19:00:49 -0000 @@ -30,7 +30,7 @@ #include "md.h" #define CLASSHASHSZ 256 /* Must be a power of two */ -static iStaticLock classHashLock = KAFFE_STATIC_LOCK_INITIALIZER; +static iStaticLock classHashLock; static classEntry* classEntryPool[CLASSHASHSZ]; #if defined(KAFFE_STATS) statobject classStats; @@ -65,7 +65,6 @@ { classEntry* entry; classEntry** entryp; - int iLockRoot; static int f = 0; if (f == 0) { @@ -194,7 +193,6 @@ classEntry* entry; int ipool; int totalent = 0; - int iLockRoot; lockStaticMutex(&classHashLock); for (ipool = CLASSHASHSZ; --ipool >= 0; ) { @@ -252,7 +250,7 @@ } static nameDependency *dependencies; -static iStaticLock mappingLock = KAFFE_STATIC_LOCK_INITIALIZER; +static iStaticLock mappingLock; static nameDependency *findNameDependency(jthread_t jt) @@ -273,7 +271,6 @@ int addNameDependency(nameDependency *nd) { int retval = 1; - int iLockRoot; assert(nd != 0); @@ -301,7 +298,6 @@ static void remNameDependency(classEntry *ce) { - int iLockRoot; assert(ce != 0); @@ -331,7 +327,6 @@ int done = 0, retval = 1; nameDependency nd; jthread_t jt; - int iLockRoot; jt = KTHREAD(current)(); while( !done ) @@ -403,7 +398,6 @@ int done = 0, retval = 1; nameDependency nd; jthread_t jt; - int iLockRoot; *out_cl = NULL; jt = KTHREAD(current)(); @@ -465,7 +459,6 @@ Hjava_lang_Class *classMappingLoaded(classEntry *ce, Hjava_lang_Class *cl) { Hjava_lang_Class *retval = NULL; - int iLockRoot; assert(ce != 0); assert(cl != 0); @@ -502,7 +495,6 @@ void setClassMappingState(classEntry *ce, name_mapping_state_t nms) { - int iLockRoot; assert(ce != 0); Index: kaffe/kaffevm/exception.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/exception.c,v retrieving revision 1.93 diff -u -B -b -r1.93 exception.c --- kaffe/kaffevm/exception.c 7 Feb 2005 01:27:59 -0000 1.93 +++ kaffe/kaffevm/exception.c 7 Mar 2005 19:00:49 -0000 @@ -85,7 +85,7 @@ { assert(eh != NULL); assert(eh->meth == VMEXCEPTHANDLER_KAFFEJNI_HANDLER); - assert(fp != NULL); + assert(fp != (JNIFrameAddress)0); return (eh->frame.jni.fp == fp); } @@ -94,7 +94,7 @@ vmExcept_setJNIFrame(VmExceptHandler* eh, JNIFrameAddress fp) { assert(eh != NULL); - assert(fp != NULL); + assert(fp != (JNIFrameAddress)0); eh->meth = VMEXCEPTHANDLER_KAFFEJNI_HANDLER; eh->frame.jni.fp = fp; @@ -181,6 +181,8 @@ case KERR_OUT_OF_MEMORY: err = gc_throwOOM(); break; + default: + assert(!!!"Unexpected error info mask"); } discardErrorInfo(einfo); @@ -292,7 +294,7 @@ discardErrorInfo(errorInfo *einfo) { if (einfo->type & KERR_FREE_MESSAGE) { - KFREE(einfo->mess); + KFREE((void *)einfo->mess); einfo->type &= ~KERR_FREE_MESSAGE; } } @@ -461,7 +463,7 @@ /* If not here, exit monitor if synchronised. */ if (frame->meth->accflags & ACC_SYNCHRONISED) { - locks_internal_slowUnlockMutexIfHeld(&obj->lock, (void *)frame->fp, NULL); + locks_internal_slowUnlockMutexIfHeld(&obj->lock); } /* If method found and profiler enable, fix self+children time */ Index: kaffe/kaffevm/external.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/external.c,v retrieving revision 1.78 diff -u -B -b -r1.78 external.c --- kaffe/kaffevm/external.c 10 Jan 2005 12:43:19 -0000 1.78 +++ kaffe/kaffevm/external.c 7 Mar 2005 19:00:49 -0000 @@ -72,7 +72,7 @@ Hjava_lang_ClassLoader* loader; } libHandle[MAXLIBS]; -static iStaticLock libraryLock = KAFFE_STATIC_LOCK_INITIALIZER; /* mutex on all intern operations */ +static iStaticLock libraryLock; /* mutex on all intern operations */ static char *libraryPath = NULL; extern JavaVM Kaffe_JavaVM; @@ -201,7 +201,6 @@ struct _libHandle *lib; int libIndex; void *func; - int iLockRoot; lockStaticMutex(&libraryLock); @@ -311,7 +310,6 @@ unloadNativeLibraries(struct Hjava_lang_ClassLoader* loader) { int libIndex; - int iLockRoot; lockStaticMutex(&libraryLock); @@ -349,7 +347,6 @@ { int i = 0; void* func = NULL; - int iLockRoot; lockStaticMutex(&libraryLock); Index: kaffe/kaffevm/findInJar.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/findInJar.c,v retrieving revision 1.65 diff -u -B -b -r1.65 findInJar.c --- kaffe/kaffevm/findInJar.c 4 Feb 2005 10:36:14 -0000 1.65 +++ kaffe/kaffevm/findInJar.c 7 Mar 2005 19:00:49 -0000 @@ -184,11 +184,10 @@ { char *buf; int fp; - static iStaticLock jarlock = KAFFE_STATIC_LOCK_INITIALIZER; + static iStaticLock jarlock; classpathEntry* ptr; int i; int rc; - int iLockRoot; /* Look for the class */ DBG(CLASSLOOKUP, dprintf("Scanning for element %s\n", cname); ); Index: kaffe/kaffevm/jar.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/jar.c,v retrieving revision 1.36 diff -u -B -b -r1.36 jar.c --- kaffe/kaffevm/jar.c 8 Jan 2005 00:31:46 -0000 1.36 +++ kaffe/kaffevm/jar.c 7 Mar 2005 19:00:50 -0000 @@ -75,12 +75,7 @@ unsigned int count; }; -static struct _jarCache jarCache = { -#if !defined(KAFFEH) - KAFFE_STATIC_LOCK_INITIALIZER, -#endif - NULL, 0 -}; +static struct _jarCache jarCache; /* * Hash a file name, the hash value is stored in what `hash' points to. @@ -105,9 +100,6 @@ static jarFile *findCachedJarFile(char *name) { jarFile *curr, **prev, *retval = NULL; -#if !defined(KAFFEH) - int iLockRoot; -#endif assert(name != NULL); @@ -200,9 +192,6 @@ { jarFile *curr, **prev, **lru = NULL, *dead_jar = NULL, *retval = jf; int already_cached = 0; -#if !defined(KAFFEH) - int iLockRoot; -#endif assert(jf != 0); assert(!(jf->flags & JFF_CACHED)); @@ -330,9 +319,6 @@ static void removeJarFile(jarFile *jf) { jarFile *curr, **prev; -#if !defined(KAFFEH) - int iLockRoot; -#endif assert(jf != NULL); @@ -364,9 +350,6 @@ void flushJarCache(void) { jarFile **prev, *curr, *next; -#if !defined(KAFFEH) - int iLockRoot; -#endif lockStaticMutex(&jarCache.lock); curr = jarCache.files; @@ -951,9 +934,6 @@ { uint8 *buf = NULL, *retval = NULL; jarLocalHeader lh; -#if !defined(KAFFEH) - int iLockRoot; -#endif assert(jf != 0); assert(je != 0); @@ -1018,9 +998,6 @@ if( jar_stat.st_mtime == jf->lastModified ) { #endif /* !defined(STATIC_JAR_FILES) */ -#if !defined(KAFFEH) - int iLockRoot; -#endif /* Only set the fd in the structure here */ lockMutex(jf); @@ -1196,9 +1173,6 @@ { if( jf ) { -#if !defined(KAFFEH) - int iLockRoot; -#endif lockStaticMutex(&jarCache.lock); jf->users--; Index: kaffe/kaffevm/ksem.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/ksem.c,v retrieving revision 1.12 diff -u -B -b -r1.12 ksem.c --- kaffe/kaffevm/ksem.c 30 Jan 2005 18:21:38 -0000 1.12 +++ kaffe/kaffevm/ksem.c 7 Mar 2005 19:00:50 -0000 @@ -63,15 +63,15 @@ } /* Use a stored wakeup if available. */ - if (sem->count == 1) { - sem->count = 0; + if (sem->count > 0) { + sem->count--; r = true; } else { /* Still no stored wakeup means we waited and timedout. */ r = false; } - assert(sem->count == 0); + assert(sem->count >= 0); KMUTEX(unlock)(&sem->mux); return (r); } @@ -85,7 +85,7 @@ { assert(sem != NULL); KMUTEX(lock)(&sem->mux); - sem->count = 1; + sem->count++; KCONDVAR(signal)(&sem->cv, &sem->mux); KMUTEX(unlock)(&sem->mux); } Index: kaffe/kaffevm/ksem.h =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/ksem.h,v retrieving revision 1.10 diff -u -B -b -r1.10 ksem.h Index: kaffe/kaffevm/locks.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/locks.c,v retrieving revision 1.56 diff -u -B -b -r1.56 locks.c --- kaffe/kaffevm/locks.c 6 Feb 2005 15:38:47 -0000 1.56 +++ kaffe/kaffevm/locks.c 7 Mar 2005 19:00:50 -0000 @@ -24,6 +24,7 @@ #include "debug.h" #include "gc.h" #include "jvmpi_kaffe.h" +#include "stats.h" /* * If we don't have an atomic compare and exchange defined then make @@ -50,9 +51,6 @@ #endif #endif -/* Count number of backoffs. XXX move into the STAT infrastructure. */ -int backoffcount = 0; - /* * Initialise the locking system. */ @@ -61,70 +59,89 @@ { } +static timespent heavyLockTime; +static timespent locksTime; + /* * Get a heavy lock for the object and hold it. If the object doesn't * have a heavy lock then we create one. */ -static -iLock* -getHeavyLock(iLock* volatile * lkp, iLock *heavyLock) +static iLock * +getHeavyLock(iLock* volatile * lkp) { - iLock* old; - iLock* lk; - jlong timeout; + volatile iLock lock_in_progress; + int i; + iLock *lk; -DBG(SLOWLOCKS, - dprintf(" getHeavyLock(**lkp=%p, *lk=%p, th=%p)\n", - lkp, *lkp, KTHREAD(current)()); -); + DBG(SLOWLOCKS, + dprintf(" getHeavyLock(lk=%p, th=%p)\n", + *lkp, KTHREAD(current)()); + ); - lk = heavyLock; - timeout = 1; - for (;;) { - /* Get the current lock and replace it with LOCKINPROGRESS to indicate - * changes are in progress. - */ - old = *lkp; - if (old == LOCKINPROGRESS || !COMPARE_AND_EXCHANGE(lkp, old, LOCKINPROGRESS)) { - /* Someone else put the lock in LOCKINPROGRESS state */ - backoffcount++; - KSEM(get)(&THREAD_DATA()->sem, timeout); - /* Back off */ - timeout = (timeout << 1)|timeout; - continue; - } + lk = *lkp; - /* If bottom bit is set, strip off and use pointer as pointer to heavy lock */ - if ((((uintp)old) & 1) == 1) { -DBG(SLOWLOCKS, - dprintf(" got cached lock\n"); -); - if (lk != heavyLock) { - gc_free (lk); - } - - lk = (iLock*)(((uintp)old) & (uintp)-2); - } - else { - if (lk == LOCKFREE) { - /* Release the lock before we go into malloc. - * We have to reclaim the lock afterwards (at beginning - * of loop) + /* Check if it has been allocated, if not acquire the lock by putting our + * temporary structure. */ - *lkp = old; + if (lk == LOCKFREE || !lk->allocated) + { + startTiming(&heavylockTime, "heavylock-handling"); + /* Build a temporary lock */ + lock_in_progress.sem = &THREAD_DATA()->heavy_sem; + lock_in_progress.in_progress = 1; + lock_in_progress.num_wait = 0; + + /* Try to put it if that fails it means another thread has beaten us + * and so we only have wasted a few cpu cycles. + * N.B.: This is done once in the case of a static heavyLock. + */ + if (COMPARE_AND_EXCHANGE(lkp, lk, &lock_in_progress)) + { + /* Build a real lock object. If lk is a static lock it is already allocated. + */ + if (lk == NULL) + { lk = (iLock*)gc_malloc(sizeof(iLock), KGC_ALLOC_LOCK); - /* if that fails we're in trouble!! */ - assert(lk != 0); - continue; + assert(lk != NULL); } -DBG(SLOWLOCKS, - dprintf(" got %s lock\n", - (lk != heavyLock) ? "new" : "special"); -); - lk->holder = (void*)old; + + lk->allocated = 1; + lk->in_progress = 1; lk->mux = NULL; lk->cv = NULL; + lk->num_wait = 0; + KSEM(init)(&lk->real_sem); + lk->sem = &lk->real_sem; + + /* Put the real heavylock structure in place */ + *lkp = lk; + + /* Wake up all threads which are locked on the lock_in_progress. + * That way they will refresh the semaphore pointer. */ + for (i = 0; i < lock_in_progress.num_wait; i++) + KSEM(put)(lock_in_progress.sem); + + /* Now the lock is acquired by this thread and ready to use for the others. + */ + stopTiming(&heavyLockTime); + return lk; + } + stopTiming(&heavyLockTime); } + else assert(lk->allocated == 1); + + /* The lock is allocated and ready to use. */ + for (;;) { + lk = *lkp; + /* Try to acquire the lock. */ + if (!COMPARE_AND_EXCHANGE(&(lk->in_progress), 0, 1)) + { + lk->num_wait++; + KSEM(get)(lk->sem, (jlong)0); + lk->num_wait--; + continue; + } + return (lk); } } @@ -135,21 +152,24 @@ */ static void -putHeavyLock(iLock** lkp, iLock* lk) +putHeavyLock(volatile iLock* lk) { - assert(*lkp == LOCKINPROGRESS); - -DBG(SLOWLOCKS, - dprintf(" putHeavyLock(**lkp=%p, *lk=%p, th=%p)\n", - lkp, lk, KTHREAD(current)()); -); - - if (lk == LOCKFREE) { - *lkp = LOCKFREE; - } - else { - *lkp = (iLock*)(1|(uintp)lk); - } + DBG(SLOWLOCKS, + dprintf(" putHeavyLock(lk=%p, th=%p)\n", + lk, KTHREAD(current)()); + ); + + assert(lk->allocated == 1); + assert(lk->in_progress == 1); + + lk->in_progress = 0; + /* + * This is safe as we have just put in_progress to 0 num_wait cannot grow. + * This prevents us from invoking unnecessarily the thread layer and this is needed + * at the initialization time when the thread system is not yet initialized. + */ + if (lk->num_wait != 0) + KSEM(put)(lk->sem); } /* @@ -157,40 +177,52 @@ * If we can't lock it we suspend until we can. */ static void -slowLockMutex(iLock** lkp, void* where, iLock *heavyLock) +slowLockMutex(iLock** lkp) { - iLock* lk; + volatile iLock* lk; jthread_t cur = KTHREAD(current) (); + threadData *tdata; DBG(SLOWLOCKS, - dprintf("slowLockMutex(**lkp=%p, where=%p, th=%p)\n", - lkp, where, KTHREAD(current)()); -); + dprintf("slowLockMutex(lk=%p, th=%p)\n", + *lkp, KTHREAD(current)()); + ); KTHREAD(disable_stop)(); /* protect the heavy lock, and its queues */ + tdata = KTHREAD(get_data)(cur); for (;;) { - lk = getHeavyLock(lkp, heavyLock); + lk = getHeavyLock(lkp); + startTiming(&lockTime, "slowlocks-time"); /* If I hold the heavy lock then just keep on going */ - if (KTHREAD(on_current_stack)(lk->holder)) { - putHeavyLock(lkp, lk); + if (cur == lk->holder) { + lk->lockCount++; + putHeavyLock(lk); + stopTiming(&lockTime); KTHREAD(enable_stop)(); return; } /* If no one holds the heavy lock then claim it */ - if (lk->holder == 0) { - lk->holder = where; - putHeavyLock(lkp, lk); + if (lk->holder == NULL) { + if (lk->lockCount != 0) { + dprintf("Lockcount should be 0 for %p\n", lk); + abort(); + } + lk->holder = cur; + lk->lockCount++; + stopTiming(&lockTime); + putHeavyLock(lk); KTHREAD(enable_stop)(); return; } /* Otherwise wait for holder to release it */ - KTHREAD(get_data)(cur)->nextlk = lk->mux; + tdata->nextlk = lk->mux; lk->mux = cur; - putHeavyLock(lkp, lk); - KSEM(get)(&KTHREAD(get_data)(cur)->sem, (jlong)0); + putHeavyLock(lk); + stopTiming(&lockTime); + KSEM(get)(&tdata->sem, (jlong)0); } } @@ -200,32 +232,36 @@ * a fast thin lock. */ static void -slowUnlockMutex(iLock** lkp, void* where, iLock *heavyLock) +slowUnlockMutex(iLock** lkp) { - iLock* lk; + volatile iLock* lk; jthread_t tid; + jthread_t cur = KTHREAD(current)(); -DBG(SLOWLOCKS, - dprintf("slowUnlockMutex(**lkp=%p, where=%p, th=%p)\n", - lkp, where, KTHREAD(current)()); -); + DBG(SLOWLOCKS, + dprintf("slowUnlockMutex(lk=%p, th=%p)\n", + *lkp, KTHREAD(current)()); + ); KTHREAD(disable_stop)(); /* protect the heavy lock, and its queues */ - lk = getHeavyLock(lkp, heavyLock); + lk = getHeavyLock(lkp); + + startTiming(&locksTime, "slowlocks-time"); /* Only the lock holder can be doing an unlock */ - if (!KTHREAD(on_current_stack)(lk->holder)) { - putHeavyLock(lkp, lk); + if (cur != lk->holder) { + putHeavyLock(lk); KTHREAD(enable_stop)(); + stopTiming(&locksTime); throwException(IllegalMonitorStateException); } + assert(lk->lockCount > 0); + /* If holder isn't where we are now then this isn't the final unlock */ -#if defined(STACK_GROWS_UP) - if (lk->holder < where) { -#else - if (lk->holder > where) { -#endif - putHeavyLock(lkp, lk); + lk->lockCount--; + if (lk->lockCount != 0) { + putHeavyLock(lk); + stopTiming(&locksTime); KTHREAD(enable_stop)(); return; } @@ -234,182 +270,192 @@ * time to tell them. */ if (lk->mux != NULL) { + threadData *tdata; + tid = lk->mux; - lk->mux = KTHREAD(get_data)(tid)->nextlk; - KTHREAD(get_data)(tid)->nextlk = NULL; + tdata = KTHREAD(get_data)(tid); + lk->mux = tdata->nextlk; + tdata->nextlk = NULL; lk->holder = NULL; - putHeavyLock(lkp, lk); - KSEM(put)(&KTHREAD(get_data)(tid)->sem); + putHeavyLock(lk); + KSEM(put)(&tdata->sem); } /* If someone's waiting to be signaled keep the heavy in place */ else if (lk->cv != NULL) { lk->holder = NULL; - putHeavyLock(lkp, lk); - } - else { - if (lk != heavyLock) { - gc_free(lk); + putHeavyLock(lk); } else { lk->holder = NULL; - } - putHeavyLock(lkp, LOCKFREE); + putHeavyLock(lk); } KTHREAD(enable_stop)(); + stopTiming(&locksTime); } void -locks_internal_slowUnlockMutexIfHeld(iLock** lkp, void* where, iLock *heavyLock) +locks_internal_slowUnlockMutexIfHeld(iLock** lkp) { iLock* lk; void* holder; + jthread_t cur = KTHREAD(current)(); -DBG(SLOWLOCKS, - dprintf("slowUnlockMutexIfHeld(**lkp=%p, where=%p, th=%p)\n", - lkp, where, KTHREAD(current)()); -); - holder = *lkp; + DBG(SLOWLOCKS, + dprintf("slowUnlockMutexIfHeld(lkp=%p, th=%p)\n", + *lkp, KTHREAD(current)()); + ); + lk = *lkp; + /* Even if the lock is not allocated the holder is NULL. */ + holder = (lk == NULL) ? NULL : (*lkp)->holder; /* nothing to do if the lock is free */ - if (holder == LOCKFREE) { + if (holder == NULL) { return; } /* if it's a thin lock and this thread owns it, * try to free it the easy way */ - if (KTHREAD(on_current_stack)(holder) && - COMPARE_AND_EXCHANGE(lkp, holder, LOCKFREE)) { - return; - } + // if (holder == cur && + // COMPARE_AND_EXCHANGE(&(lk->holder), holder, LOCKFREE)) { + // return; + //} /* ok, it is a heavy lock */ - lk = getHeavyLock(lkp, heavyLock); + lk = getHeavyLock(lkp); holder = lk->holder; - putHeavyLock(lkp, lk); + putHeavyLock(lk); - if (KTHREAD(on_current_stack)(holder)) { - slowUnlockMutex(lkp, where, heavyLock); + if (holder == cur) { + slowUnlockMutex(lkp); } } jboolean -locks_internal_waitCond(iLock** lkp, jlong timeout, iLock *heavyLock) +locks_internal_waitCond(iLock** lkp, jlong timeout) { - iLock* lk; + volatile iLock* lk; void* holder; jthread_t cur = KTHREAD(current)(); jthread_t *ptr; jboolean r; + threadData *tdata; -DBG(SLOWLOCKS, - dprintf("_waitCond(**lkp=%p, timeout=%ld, th=%p)\n", - lkp, (long)timeout, KTHREAD(current)()); -); + DBG(SLOWLOCKS, + dprintf("_waitCond(lk=%p, timeout=%ld, th=%p)\n", + *lkp, (long)timeout, KTHREAD(current)()); + ); - lk = getHeavyLock(lkp, heavyLock); + lk = getHeavyLock(lkp); holder = lk->holder; /* I must be holding the damn thing */ - if (!KTHREAD(on_current_stack)(holder)) { - putHeavyLock(lkp, holder); + if (holder != cur) { + putHeavyLock(lk); throwException(IllegalMonitorStateException); } - KTHREAD(get_data)(cur)->nextlk = lk->cv; + tdata = KTHREAD(get_data)(cur); + tdata->nextlk = lk->cv; lk->cv = cur; - putHeavyLock(lkp, lk); - slowUnlockMutex(lkp, holder, heavyLock); - r = KSEM(get)(&KTHREAD(get_data)(cur)->sem, timeout); + + putHeavyLock(lk); + slowUnlockMutex(lkp); + r = KSEM(get)(&tdata->sem, timeout); /* Timeout */ if (r == false) { - lk = getHeavyLock(lkp, heavyLock); + lk = getHeavyLock(lkp); /* Remove myself from CV or MUX queue - if I'm * not on either * then I should wait on myself to remove any pending signal. */ for (ptr = &lk->cv; *ptr != 0; ptr = &KTHREAD(get_data)(*ptr)->nextlk) { if ((*ptr) == cur) { - *ptr = KTHREAD(get_data)(cur)->nextlk; + *ptr = tdata->nextlk; goto found; } } for (ptr = &lk->mux; *ptr != 0; ptr = &KTHREAD(get_data)(*ptr)->nextlk) { if ((*ptr) == cur) { - *ptr = KTHREAD(get_data)(cur)->nextlk; + *ptr = tdata->nextlk; goto found; } } /* Not on list - so must have been signalled after all - * decrease the semaphore to avoid problems. */ - KSEM(get)(&KTHREAD(get_data)(cur)->sem, (jlong)0); + KSEM(get)(&tdata->sem, (jlong)0); found:; - putHeavyLock(lkp, lk); + putHeavyLock(lk); } - slowLockMutex(lkp, holder, heavyLock); + slowLockMutex(lkp); return (r); } void -locks_internal_signalCond(iLock** lkp, iLock *heavyLock) +locks_internal_signalCond(iLock** lkp) { - iLock* lk; + volatile iLock* lk; jthread_t tid; -DBG(SLOWLOCKS, - dprintf("_signalCond(**lkp=%p, th=%p)\n", - lkp, KTHREAD(current)()); -); + DBG(SLOWLOCKS, + dprintf("_signalCond(lk=%p, th=%p)\n", + *lkp, KTHREAD(current)()); + ); - lk = getHeavyLock(lkp, heavyLock); + lk = getHeavyLock(lkp); - if (!KTHREAD(on_current_stack)(lk->holder)) { - putHeavyLock(lkp, lk); + if (lk->holder != KTHREAD(current)()) { + putHeavyLock(lk); throwException(IllegalMonitorStateException); } /* Move one CV's onto the MUX */ tid = lk->cv; if (tid != 0) { - lk->cv = KTHREAD(get_data)(tid)->nextlk; - KTHREAD(get_data)(tid)->nextlk = lk->mux; + threadData *tdata = KTHREAD(get_data)(tid); + + lk->cv = tdata->nextlk; + tdata->nextlk = lk->mux; lk->mux = tid; } - putHeavyLock(lkp, lk); + putHeavyLock(lk); } void -locks_internal_broadcastCond(iLock** lkp, iLock *heavyLock) +locks_internal_broadcastCond(iLock** lkp) { iLock* lk; jthread_t tid; -DBG(SLOWLOCKS, - dprintf("_broadcastCond(**lkp=%p, th=%p)\n", - lkp, KTHREAD(current)()); -); + DBG(SLOWLOCKS, + dprintf("_broadcastCond(lk=%p, th=%p)\n", + *lkp, KTHREAD(current)()); + ); - lk = getHeavyLock(lkp, heavyLock); + lk = getHeavyLock(lkp); - if (!KTHREAD(on_current_stack)(lk->holder)) { - putHeavyLock(lkp, lk); + if (lk->holder != KTHREAD(current)()) { + putHeavyLock(lk); throwException(IllegalMonitorStateException); } /* Move all the CV's onto the MUX */ while (lk->cv != 0) { + threadData *tdata; + tid = lk->cv; - lk->cv = KTHREAD(get_data)(tid)->nextlk; - KTHREAD(get_data)(tid)->nextlk = lk->mux; + tdata = KTHREAD(get_data)(tid); + lk->cv = tdata->nextlk; + tdata->nextlk = lk->mux; lk->mux = tid; } - putHeavyLock(lkp, lk); + putHeavyLock(lk); } /* @@ -418,21 +464,27 @@ * contention then fall back on a slow lock. */ void -locks_internal_lockMutex(iLock** lkp, void* where, iLock *heavyLock) +locks_internal_lockMutex(iLock** lkp, iLock *heavyLock) { - uintp val; - - val = (uintp)*lkp; + COMPARE_AND_EXCHANGE(lkp, LOCKFREE, heavyLock); + /* This small checking may speed up things on most locks */ +#if 0 + if (*lkp != NULL && (*lkp)->allocated && COMPARE_AND_EXCHANGE(&(*lkp)->in_progress, 0, 1)) + { + iLock *lk = *lkp; + /* If the thread system is not yet initialized, this call will return NULL. + * so no harm is done. + * TODO: Avoid the call to KTHREAD(current). + */ + jthread_t cur = KTHREAD(current)(); - if (val == 0) { - if (!COMPARE_AND_EXCHANGE(lkp, 0, (iLock*)where)) { - slowLockMutex(lkp, where, heavyLock); - } - } - else if (!KTHREAD(on_current_stack)((void *)val)) { - /* XXX count this in the stats area */ - slowLockMutex(lkp, where, heavyLock); + lk->holder = cur; + lk->lockCount++; + putHeavyLock(lk); } + else +#endif + slowLockMutex(lkp); } /* @@ -440,35 +492,26 @@ * we've got contention so fall back on a slow lock. */ void -locks_internal_unlockMutex(iLock** lkp, void* where, iLock *heavyLock) +locks_internal_unlockMutex(iLock** lkp) { - uintp val; - - val = (uintp)*lkp; - - if ((val & 1) != 0) { - slowUnlockMutex(lkp, where, heavyLock); - } - else if ((val == (uintp)where) /* XXX squirrely bit */ - && !COMPARE_AND_EXCHANGE(lkp, (iLock*)where, LOCKFREE)) { - slowUnlockMutex(lkp, where, heavyLock); - } + /* slowUnlockMutex should be fast enough. */ + slowUnlockMutex(lkp); } void lockObject(Hjava_lang_Object* obj) { - locks_internal_lockMutex(&obj->lock, &obj, NULL); + locks_internal_lockMutex(&obj->lock, NULL); } void unlockObject(Hjava_lang_Object* obj) { - locks_internal_unlockMutex(&obj->lock, &obj, NULL); + locks_internal_unlockMutex(&obj->lock); } void -slowLockObject(Hjava_lang_Object* obj, void* where) +slowLockObject(Hjava_lang_Object* obj) { #if defined(ENABLE_JVMPI) if( JVMPI_EVENT_ISENABLED(JVMPI_EVENT_MONITOR_CONTENDED_ENTER) ) @@ -480,7 +523,7 @@ jvmpiPostEvent(&ev); } #endif - slowLockMutex(&obj->lock, where, NULL); + slowLockMutex(&obj->lock); #if defined(ENABLE_JVMPI) if( JVMPI_EVENT_ISENABLED(JVMPI_EVENT_MONITOR_CONTENDED_ENTERED) ) { @@ -494,7 +537,7 @@ } void -slowUnlockObject(Hjava_lang_Object* obj, void* where) +slowUnlockObject(Hjava_lang_Object* obj) { #if defined(ENABLE_JVMPI) if( JVMPI_EVENT_ISENABLED(JVMPI_EVENT_MONITOR_CONTENDED_EXIT) ) @@ -506,7 +549,7 @@ jvmpiPostEvent(&ev); } #endif - slowUnlockMutex(&obj->lock, where, NULL); + slowUnlockMutex(&obj->lock); } void Index: kaffe/kaffevm/locks.h =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/locks.h,v retrieving revision 1.27 diff -u -B -b -r1.27 locks.h --- kaffe/kaffevm/locks.h 17 Dec 2004 17:47:35 -0000 1.27 +++ kaffe/kaffevm/locks.h 7 Mar 2005 19:00:50 -0000 @@ -17,25 +17,26 @@ #include "md.h" #include "support.h" +#include "ksem.h" struct _iLock; #define LOCKOBJECT struct _iLock** -#define lockMutex(O) (KTHREAD(disable_stop)(), locks_internal_lockMutex(&(O)->lock, &iLockRoot, NULL)) -#define unlockMutex(O) do { locks_internal_unlockMutex(&(O)->lock, &iLockRoot, NULL); KTHREAD(enable_stop)(); } while (0) -#define waitCond(O,T) locks_internal_waitCond(&(O)->lock, (T), NULL) -#define signalCond(O) locks_internal_signalCond(&(O)->lock, NULL) -#define broadcastCond(O) locks_internal_broadcastCond(&(O)->lock, NULL) - -#define lockStaticMutex(THING) (KTHREAD(disable_stop)(), locks_internal_lockMutex(&(THING)->lock, &iLockRoot, &(THING)->heavyLock)) -#define unlockStaticMutex(THING) do { locks_internal_unlockMutex(&(THING)->lock, &iLockRoot, &(THING)->heavyLock); KTHREAD(enable_stop)(); } while(0) -#define waitStaticCond(THING, TIME) locks_internal_waitCond(&(THING)->lock, (TIME), &(THING)->heavyLock) -#define signalStaticCond(THING) locks_internal_signalCond(&(THING)->lock, &(THING)->heavyLock) -#define broadcastStaticCond(THING) locks_internal_broadcastCond(&(THING)->lock, &(THING)->heavyLock) +#define lockMutex(O) (KTHREAD(disable_stop)(), locks_internal_lockMutex(&(O)->lock, NULL)) +#define unlockMutex(O) do { locks_internal_unlockMutex(&(O)->lock); KTHREAD(enable_stop)(); } while (0) +#define waitCond(O,T) locks_internal_waitCond(&(O)->lock, (T)) +#define signalCond(O) locks_internal_signalCond(&(O)->lock) +#define broadcastCond(O) locks_internal_broadcastCond(&(O)->lock) + +#define lockStaticMutex(THING) (KTHREAD(disable_stop)(), locks_internal_lockMutex(&(THING)->lock, &(THING)->heavyLock)) +#define unlockStaticMutex(THING) do { locks_internal_unlockMutex(&(THING)->lock); KTHREAD(enable_stop)(); } while(0) +#define waitStaticCond(THING, TIME) locks_internal_waitCond(&(THING)->lock, (TIME)) +#define signalStaticCond(THING) locks_internal_signalCond(&(THING)->lock) +#define broadcastStaticCond(THING) locks_internal_broadcastCond(&(THING)->lock) struct Hjava_lang_Object; -/* +/** * The "heavy" alternative when fast-locking encounters true * contention, and for some of the global locks. The _iLock * works like a monitor (i.e. Java locks). The "holder" field @@ -44,9 +45,16 @@ * unlock and for distinguishing recursive invocations). */ typedef struct _iLock { + /* It is important this one to be the first */ + uintp allocated; + uint8 in_progress; + uint16 num_wait; + uint8 lockCount; void* holder; jthread_t mux; jthread_t cv; + Ksem *sem; + Ksem real_sem; } iLock; typedef struct _iStaticLock { @@ -54,10 +62,8 @@ iLock heavyLock; } iStaticLock; -#define KAFFE_STATIC_LOCK_INITIALIZER { NULL, { NULL, (jthread_t)0, (jthread_t)0 } } - -#define LOCKINPROGRESS ((iLock*)-1) #define LOCKFREE ((iLock*)0) +#define INIT_LOCKVAR extern void initLocking(void); @@ -66,15 +72,15 @@ */ extern void lockObject(struct Hjava_lang_Object*); extern void unlockObject(struct Hjava_lang_Object*); -extern void slowLockObject(struct Hjava_lang_Object*, void*); -extern void slowUnlockObject(struct Hjava_lang_Object*, void*); +extern void slowLockObject(struct Hjava_lang_Object*); +extern void slowUnlockObject(struct Hjava_lang_Object*); -extern void locks_internal_lockMutex(LOCKOBJECT, void*, iLock *heavyLock); -extern void locks_internal_unlockMutex(LOCKOBJECT, void*, iLock *heavyLock); -extern jboolean locks_internal_waitCond(LOCKOBJECT, jlong, iLock *heavyLock); -extern void locks_internal_signalCond(LOCKOBJECT, iLock *heavyLock); -extern void locks_internal_broadcastCond(LOCKOBJECT, iLock *heavyLock); -extern void locks_internal_slowUnlockMutexIfHeld(LOCKOBJECT, void*, iLock *heavyLock); +extern void locks_internal_lockMutex(LOCKOBJECT, iLock *heavyLock); +extern void locks_internal_unlockMutex(LOCKOBJECT); +extern jboolean locks_internal_waitCond(LOCKOBJECT, jlong); +extern void locks_internal_signalCond(LOCKOBJECT); +extern void locks_internal_broadcastCond(LOCKOBJECT); +extern void locks_internal_slowUnlockMutexIfHeld(LOCKOBJECT); extern void dumpLocks(void); Index: kaffe/kaffevm/lookup.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/lookup.c,v retrieving revision 1.42 diff -u -B -b -r1.42 lookup.c --- kaffe/kaffevm/lookup.c 20 Dec 2004 02:12:53 -0000 1.42 +++ kaffe/kaffevm/lookup.c 7 Mar 2005 19:00:50 -0000 @@ -155,7 +155,6 @@ Utf8Const *name; Hjava_lang_Class* class; int tag; - int iLockRoot; pool = CLASS_CONSTANTS(this); Index: kaffe/kaffevm/reference.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/reference.c,v retrieving revision 1.2 diff -u -B -b -r1.2 reference.c --- kaffe/kaffevm/reference.c 30 Jan 2005 18:21:38 -0000 1.2 +++ kaffe/kaffevm/reference.c 7 Mar 2005 19:00:50 -0000 @@ -33,7 +33,7 @@ referenceLinkList *references; } referenceLinkListHead; -static iStaticLock referencesLock = KAFFE_STATIC_LOCK_INITIALIZER; +static iStaticLock referencesLock; static hashtab_t referencesHashTable; static uint32 referentOffset = ~((uint32)0); @@ -69,7 +69,6 @@ void KaffeVM_registerObjectReference(jobject reference, jobject obj, kgc_reference_type reftype) { - int iLockRoot; referenceLinkList *ll; referenceLinkListHead *head, *temp; @@ -123,7 +122,6 @@ bool KaffeVM_isReferenced(jobject obj) { - int iLockRoot; referenceLinkListHead *ref; lockStaticMutex(&referencesLock); @@ -154,7 +152,6 @@ static void referenceObjectFinalizer(jobject ob) { - int iLockRoot; referenceLinkListHead *head; referenceLinkList *ll; referenceLinkListHead search_ref; @@ -200,7 +197,6 @@ static void referenceFinalizer(jobject ref) { - int iLockRoot; void *referent; referenceLinkList **ll; referenceLinkListHead *head; Index: kaffe/kaffevm/string.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/string.c,v retrieving revision 1.39 diff -u -B -b -r1.39 string.c --- kaffe/kaffevm/string.c 21 Dec 2004 08:06:37 -0000 1.39 +++ kaffe/kaffevm/string.c 7 Mar 2005 19:00:51 -0000 @@ -23,8 +23,7 @@ /* Internal variables */ static hashtab_t hashTable; /* intern hash table */ -static iStaticLock stringLock = KAFFE_STATIC_LOCK_INITIALIZER; /* mutex on all intern operations */ -static int * stringLockRoot = NULL; /* the string lock is not a monitor */ +static iStaticLock stringLock; /* mutex on all intern operations */ /* Internal functions */ static int stringHashValue(void *ptr); @@ -278,26 +277,21 @@ stringAlloc(size_t sz) { void* p; - int *myRoot = stringLockRoot; /* XXX assumes stringLock isn't acquired recursively (which it isn't) */ - locks_internal_unlockMutex(&stringLock.lock, myRoot, &stringLock.heavyLock); + unlockStaticMutex(&stringLock); p = gc_malloc(sz, KGC_ALLOC_FIXED); - locks_internal_lockMutex(&stringLock.lock, myRoot, &stringLock.heavyLock); - stringLockRoot = myRoot; - return (p); + lockStaticMutex(&stringLock); + return p; } static void stringFree(const void *ptr) { - int *myRoot = stringLockRoot; - /* XXX assumes stringLock isn't acquired recursively (which it isn't) */ - locks_internal_unlockMutex(&stringLock.lock, myRoot, &stringLock.heavyLock); + unlockStaticMutex(&stringLock); KFREE(ptr); - locks_internal_lockMutex(&stringLock.lock, myRoot, &stringLock.heavyLock); - stringLockRoot = myRoot; + lockStaticMutex(&stringLock); } /* @@ -307,12 +301,10 @@ const Hjava_lang_String * stringInternString(Hjava_lang_String *string) { - int iLockRoot; const Hjava_lang_String *temp; /* Lock intern table */ lockStaticMutex(&stringLock); - stringLockRoot = &iLockRoot; /* See if string is already in the table */ if (hashTable != NULL) { @@ -348,7 +340,6 @@ void stringUninternString(Hjava_lang_String* string) { - int iLockRoot; lockStaticMutex(&stringLock); if (!unhand(string)->interned) @@ -356,7 +347,6 @@ unlockStaticMutex(&stringLock); return; } - stringLockRoot = &iLockRoot; hashRemove(hashTable, string); unhand(string)->interned = false; unlockStaticMutex(&stringLock); @@ -426,7 +416,6 @@ Hjava_lang_String *string; HArrayOfChar *ary; errorInfo info; - int iLockRoot; /* Lock intern table * NB: we must not hold stringLock when we call KMALLOC/KFREE! @@ -458,7 +447,6 @@ /* Return existing copy of this string, if any */ lockStaticMutex(&stringLock); - stringLockRoot = &iLockRoot; string = hashFind(hashTable, &fakeString); unlockStaticMutex(&stringLock); Index: kaffe/kaffevm/thread.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/thread.c,v retrieving revision 1.92 diff -u -B -b -r1.92 thread.c --- kaffe/kaffevm/thread.c 30 Jan 2005 18:21:38 -0000 1.92 +++ kaffe/kaffevm/thread.c 7 Mar 2005 19:00:51 -0000 @@ -282,8 +282,10 @@ void **pointer_args = (void **)arg; void *argument; jthread_t calling_thread; + threadData *thread_data = THREAD_DATA(); - KSEM(init)(&THREAD_DATA()->sem); + KSEM(init)(&thread_data->sem); + KSEM(init)(&thread_data->heavy_sem); /* We save the value before the lock so we are sure * pointer_args is still a valid pointer on the stack. @@ -297,9 +299,9 @@ /* We have now to wait the parent to synchronize the data * and link the thread to the Java VM. */ - KSEM(get)(&THREAD_DATA()->sem, (jlong)0); + KSEM(get)(&thread_data->sem, (jlong)0); - THREAD_DATA()->exceptObj = NULL; + thread_data->exceptObj = NULL; func(argument); } @@ -388,18 +390,21 @@ JNIEnv *env; jmethodID runmethod; jthread_t calling_thread = (jthread_t) arg; + threadData *thread_data; cur = KTHREAD(current)(); + thread_data = KTHREAD(get_data)(cur); - KSEM(init)(&KTHREAD(get_data)(cur)->sem); + KSEM(init)(&thread_data->sem); + KSEM(init)(&thread_data->heavy_sem); /* We acknowledge the parent thread that this thread has been started. */ KSEM(put)(&KTHREAD(get_data)(calling_thread)->sem); /* Now we must wait the parent to link the thread to the Java VM. */ - KSEM(get)(&KTHREAD(get_data)(cur)->sem, (jlong)0); + KSEM(get)(&thread_data->sem, (jlong)0); - tid = (Hjava_lang_VMThread *)(KTHREAD(get_data)(cur)->jlThread); - env = &KTHREAD(get_data)(cur)->jniEnv; + tid = (Hjava_lang_VMThread *)(thread_data->jlThread); + env = &thread_data->jniEnv; #if defined(ENABLE_JVMPI) if( JVMPI_EVENT_ISENABLED(JVMPI_EVENT_THREAD_START) ) @@ -552,7 +557,6 @@ { Hjava_lang_VMThread *vmtid = (Hjava_lang_VMThread *)jlThread; Hjava_lang_Thread *tid = unhand(vmtid)->thread; - int iLockRoot; /* Notify on the object just in case anyone is waiting */ lockMutex(&tid->base); @@ -723,6 +727,7 @@ thread_data = THREAD_DATA(); KSEM(init)(&thread_data->sem); + KSEM(init)(&thread_data->heavy_sem); thread_data->jnireferences = NULL; thread_data->jniEnv = &Kaffe_JNINativeInterface; Index: kaffe/kaffevm/threadData.h =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/threadData.h,v retrieving revision 1.6 diff -u -B -b -r1.6 threadData.h --- kaffe/kaffevm/threadData.h 30 Jan 2005 12:42:41 -0000 1.6 +++ kaffe/kaffevm/threadData.h 7 Mar 2005 19:00:51 -0000 @@ -27,6 +27,7 @@ /* things required by the locking subsystem */ struct Ksem sem; + struct Ksem heavy_sem; struct _jthread *nextlk; Index: kaffe/kaffevm/utf8const.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/utf8const.c,v retrieving revision 1.45 diff -u -B -b -r1.45 utf8const.c --- kaffe/kaffevm/utf8const.c 30 Jan 2005 12:42:41 -0000 1.45 +++ kaffe/kaffevm/utf8const.c 7 Mar 2005 19:00:51 -0000 @@ -38,7 +38,7 @@ /* Internal variables */ #ifndef KAFFEH /* Yuk! */ static hashtab_t hashTable; -static iStaticLock utf8Lock = KAFFE_STATIC_LOCK_INITIALIZER; /* mutex on all intern operations */ +static iStaticLock utf8Lock; /* mutex on all intern operations */ /* * Used to keep track of the current utf8Lock holder's stack @@ -49,61 +49,26 @@ * Also used by debugging code to assert that the utf8Lock is never * recursively acquired. */ -static int *utfLockRoot = NULL; -static inline void do_lockUTF(int *where) -{ - KTHREAD(disable_stop)(); - locks_internal_lockMutex(&utf8Lock.lock, where, &utf8Lock.heavyLock); - DBGIF(assert(utfLockRoot == NULL)); - utfLockRoot = where; -} - -static inline void do_unlockUTF(int *where) -{ - DBGIF(assert(utfLockRoot != NULL)); - DBGIF(utfLockRoot = NULL); - locks_internal_unlockMutex(&utf8Lock.lock, where, &utf8Lock.heavyLock); - KTHREAD(enable_stop)(); -} - -/* convenience macros which assume the iLockRoot local variable */ -#define lockUTF() do_lockUTF(&iLockRoot) -#define unlockUTF() do_unlockUTF(&iLockRoot) +#define lockUTF() lockStaticMutex(&utf8Lock) +#define unlockUTF() unlockStaticMutex(&utf8Lock) static inline void *UTFmalloc(size_t size) { void *ret; - int *myRoot; - - DBGIF(assert(utfLockRoot != NULL)); - myRoot = utfLockRoot; - DBGIF(utfLockRoot = NULL); - locks_internal_unlockMutex(&utf8Lock.lock, myRoot, &utf8Lock.heavyLock); + unlockStaticMutex(&utf8Lock); ret = gc_malloc(size, KGC_ALLOC_UTF8CONST); - - locks_internal_lockMutex(&utf8Lock.lock, myRoot, &utf8Lock.heavyLock); - DBGIF(assert(utfLockRoot == NULL)); - utfLockRoot = myRoot; + lockStaticMutex(&utf8Lock); return ret; } static inline void UTFfree(const void *mem) { - int *myRoot; - - DBGIF(assert(utfLockRoot != NULL)); - myRoot = utfLockRoot; - DBGIF(utfLockRoot = NULL); - locks_internal_unlockMutex(&utf8Lock.lock, myRoot, &utf8Lock.heavyLock); - + unlockStaticMutex(&utf8Lock); gc_free((void *)mem); - - locks_internal_lockMutex(&utf8Lock.lock, myRoot, &utf8Lock.heavyLock); - DBGIF(assert(utfLockRoot == NULL)); - utfLockRoot = myRoot; + lockStaticMutex(&utf8Lock); } #else /* KAFFEH replacements: */ static hashtab_t hashTable = (hashtab_t)1; @@ -131,7 +96,6 @@ Utf8Const *fake; char buf[200]; #if !defined(KAFFEH) - int iLockRoot; #endif /* Automatic length finder */ @@ -235,7 +199,6 @@ utf8ConstAddRef(Utf8Const *utf8) { #if !defined(KAFFEH) - int iLockRoot; #endif lockUTF(); assert(utf8->nrefs >= 1); @@ -250,7 +213,6 @@ utf8ConstRelease(Utf8Const *utf8) { #if !defined(KAFFEH) - int iLockRoot; #endif /* NB: we ignore zero utf8s here in order to not having to do it at * the call sites, such as when destroying half-processed class @@ -406,7 +368,6 @@ utf8ConstInit(void) { #if !defined(KAFFEH) - int iLockRoot; #endif DBG(INIT, dprintf("utf8ConstInit()\n"); ); Index: kaffe/kaffevm/boehm-gc/gc2.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/boehm-gc/gc2.c,v retrieving revision 1.8 diff -u -B -b -r1.8 gc2.c --- kaffe/kaffevm/boehm-gc/gc2.c 25 Dec 2004 19:09:14 -0000 1.8 +++ kaffe/kaffevm/boehm-gc/gc2.c 7 Mar 2005 19:00:51 -0000 @@ -44,9 +44,9 @@ int mem; /* only used ifdef STATS */ } gcFuncs; -static iStaticLock gcman_lock = KAFFE_STATIC_LOCK_INITIALIZER; -static iStaticLock gcmanend_lock = KAFFE_STATIC_LOCK_INITIALIZER; -static iStaticLock finman_lock = KAFFE_STATIC_LOCK_INITIALIZER; +static iStaticLock gcman_lock; +static iStaticLock gcmanend_lock; +static iStaticLock finman_lock; static volatile int finalRunning = -1; static volatile int gcRunning = -1; static volatile int gcDisabled = 0; @@ -154,7 +154,6 @@ static void NONRETURNING finaliserMan(void* arg UNUSED) { - int iLockRoot; lockStaticMutex(&finman_lock); for (;;) { @@ -178,7 +177,6 @@ void KaffeGC_SignalFinalizer(void) { - int iLockRoot; lockStaticMutex(&finman_lock); if (finalRunning == 0) { @@ -207,7 +205,6 @@ void KaffeGC_InvokeGC(Collector* gcif UNUSED, int mustgc) { - int iLockRoot; while (gcRunning < 0) KTHREAD(yield)(); @@ -231,7 +228,6 @@ static void NONRETURNING gcMan(UNUSED void* arg) { - int iLockRoot; lockStaticMutex(&gcman_lock); gcRunning = 0; @@ -253,7 +249,6 @@ static void KaffeGC_EnableGC(Collector* gcif UNUSED) { - int iLockRoot; lockStaticMutex(&gcman_lock); gcDisabled -= 1; @@ -265,7 +260,6 @@ static void KaffeGC_DisableGC(Collector* gcif UNUSED) { - int iLockRoot; lockStaticMutex(&gcman_lock); gcDisabled += 1; Index: kaffe/kaffevm/intrp/machine.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/intrp/machine.c,v retrieving revision 1.48 diff -u -B -b -r1.48 machine.c --- kaffe/kaffevm/intrp/machine.c 6 Feb 2005 13:51:30 -0000 1.48 +++ kaffe/kaffevm/intrp/machine.c 7 Mar 2005 19:00:55 -0000 @@ -220,7 +220,7 @@ mobj = (Hjava_lang_Object*)lcl[0].v.taddr; } /* this lock is safe for Thread.stop() */ - locks_internal_lockMutex(&mobj->lock, &mjbuf, 0); + locks_internal_lockMutex(&mobj->lock, 0); /* * We must store the object on which we synchronized @@ -237,7 +237,7 @@ end: /* Unsync. if required */ if (mobj != 0) { - locks_internal_unlockMutex(&mobj->lock, &mjbuf, 0); + locks_internal_unlockMutex(&mobj->lock); } cleanupExceptionHandling(&mjbuf, thread_data); Index: kaffe/kaffevm/jit/machine.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/jit/machine.c,v retrieving revision 1.75 diff -u -B -b -r1.75 machine.c --- kaffe/kaffevm/jit/machine.c 10 Jan 2005 10:30:19 -0000 1.75 +++ kaffe/kaffevm/jit/machine.c 7 Mar 2005 19:00:55 -0000 @@ -202,7 +202,6 @@ int64 tms = 0; int64 tme; - int iLockRoot; static Method* jitting = NULL; /* DEBUG */ Index: kaffe/kaffevm/jit/native-wrapper.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/jit/native-wrapper.c,v retrieving revision 1.7 diff -u -B -b -r1.7 native-wrapper.c --- kaffe/kaffevm/jit/native-wrapper.c 30 Jan 2005 12:42:42 -0000 1.7 +++ kaffe/kaffevm/jit/native-wrapper.c 7 Mar 2005 19:00:55 -0000 @@ -89,7 +89,6 @@ bool success = true; int j; int an; - int iLockRoot; isStatic = METHOD_IS_STATIC(xmeth) ? 1 : 0; count = sizeofSigMethod(xmeth, false); Index: kaffe/kaffevm/jit3/machine.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/jit3/machine.c,v retrieving revision 1.71 diff -u -B -b -r1.71 machine.c --- kaffe/kaffevm/jit3/machine.c 14 Jan 2005 16:52:00 -0000 1.71 +++ kaffe/kaffevm/jit3/machine.c 7 Mar 2005 19:00:56 -0000 @@ -180,7 +180,6 @@ static bool reinvoke = false; jboolean success = true; - int iLockRoot; lockClass(xmeth->class); Index: kaffe/kaffevm/kaffe-gc/gc-incremental.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/kaffe-gc/gc-incremental.c,v retrieving revision 1.19 diff -u -B -b -r1.19 gc-incremental.c --- kaffe/kaffevm/kaffe-gc/gc-incremental.c 13 Feb 2005 16:51:37 -0000 1.19 +++ kaffe/kaffevm/kaffe-gc/gc-incremental.c 7 Mar 2005 19:00:56 -0000 @@ -168,11 +168,11 @@ gcStats.markedmem += size; } -static iStaticLock gcman = KAFFE_STATIC_LOCK_INITIALIZER; -static iStaticLock finman = KAFFE_STATIC_LOCK_INITIALIZER; -static iStaticLock gcmanend = KAFFE_STATIC_LOCK_INITIALIZER; -static iStaticLock finmanend = KAFFE_STATIC_LOCK_INITIALIZER; -static iStaticLock gc_lock = KAFFE_STATIC_LOCK_INITIALIZER; /* allocator mutex */ +static iStaticLock gcman; +static iStaticLock finman; +static iStaticLock gcmanend; +static iStaticLock finmanend; +static iStaticLock gc_lock; /* allocator mutex */ static void gcFree(Collector* gcif, void* mem); @@ -386,7 +386,6 @@ { int idx; gc_block* info; - int iLockRoot; /* quickly reject pointers that are not part of this heap */ if (!IS_A_HEAP_POINTER(mem)) { @@ -504,7 +503,6 @@ gc_block* info; uintp idx; Collector *gcif = (Collector*)arg; - int iLockRoot; lockStaticMutex(&gcman); gcRunning = 0; @@ -840,7 +838,6 @@ void startFinalizer(void) { - int iLockRoot; int start; start = 0; @@ -867,7 +864,7 @@ * the objects in turn. An object is only finalised once after which * it is deleted. */ -static void finaliserJob(Collector *gcif, int *where) +static void finaliserJob(Collector *gcif) { gc_block* info = NULL; gc_unit* unit = NULL; @@ -939,7 +936,6 @@ finaliserMan(void* arg) { Collector *gcif = (Collector*)arg; - int iLockRoot; lockStaticMutex(&finman); for (;;) { @@ -949,7 +945,7 @@ } assert(finalRunning == true); - finaliserJob(gcif, &iLockRoot); + finaliserJob(gcif); /* Wake up anyone waiting for the finalizer to finish */ lockStaticMutex(&finmanend); @@ -963,7 +959,6 @@ void gcEnableGC(Collector* gcif UNUSED) { - int iLockRoot; lockStaticMutex(&gcman); gcDisabled -= 1; @@ -976,7 +971,6 @@ void gcDisableGC(Collector* gcif UNUSED) { - int iLockRoot; lockStaticMutex(&gcman); gcDisabled += 1; @@ -990,7 +984,6 @@ void gcInvokeGC(Collector* gcif UNUSED, int mustgc) { - int iLockRoot; while (gcRunning < 0) KTHREAD(yield)(); @@ -1018,7 +1011,6 @@ void gcInvokeFinalizer(Collector* gcif) { - int iLockRoot; /* First invoke the GC */ KGC_invoke(gcif, 1); @@ -1055,7 +1047,6 @@ void * volatile mem; /* needed on SGI, see comment below */ int i; size_t bsz; - int iLockRoot; int times = 0; assert(gc_init != 0); @@ -1189,7 +1180,6 @@ { Hjava_lang_Throwable *ret = NULL; int reffed; - int iLockRoot; /* * Make sure we are the only thread to use this exception @@ -1236,7 +1226,6 @@ void* newmem; gc_unit* unit; size_t osize; - int iLockRoot; assert(gcFunctions[fidx].final == KGC_OBJECT_FIXED); @@ -1281,7 +1270,6 @@ gc_block* info; int idx; gc_unit* unit; - int iLockRoot; if (mem != NULL) { lockStaticMutex(&gc_lock); Index: kaffe/kaffevm/kaffe-gc/gc-mem.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/kaffe-gc/gc-mem.c,v retrieving revision 1.24 diff -u -B -b -r1.24 gc-mem.c --- kaffe/kaffevm/kaffe-gc/gc-mem.c 16 Jan 2005 09:09:01 -0000 1.24 +++ kaffe/kaffevm/kaffe-gc/gc-mem.c 7 Mar 2005 19:00:56 -0000 @@ -354,7 +354,6 @@ gc_block** mptr; gc_block* blk; size_t nsz; - int iLockRoot; lockStaticMutex(&gc_heap_lock); @@ -453,7 +452,6 @@ int lnr; int msz; int idx; - int iLockRoot; info = gc_mem2block(mem); idx = GCMEM2IDX(info, mem); @@ -1183,7 +1181,6 @@ gc_heap_grow(size_t sz) { gc_block* blk; - int iLockRoot; if (KGC_SMALL_OBJECT(sz)) { sz = gc_pgsize; Index: kaffe/kaffevm/kaffe-gc/gc-refs.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/kaffevm/kaffe-gc/gc-refs.c,v retrieving revision 1.11 diff -u -B -b -r1.11 gc-refs.c --- kaffe/kaffevm/kaffe-gc/gc-refs.c 30 Jan 2005 12:42:44 -0000 1.11 +++ kaffe/kaffevm/kaffe-gc/gc-refs.c 7 Mar 2005 19:00:56 -0000 @@ -52,8 +52,8 @@ static strongRefTable strongRefObjects; static weakRefTable weakRefObjects; -static iStaticLock strongRefLock = KAFFE_STATIC_LOCK_INITIALIZER; -static iStaticLock weakRefLock = KAFFE_STATIC_LOCK_INITIALIZER; +static iStaticLock strongRefLock; +static iStaticLock weakRefLock; /* This is a bit homemade. We need a 7-bit hash from the address here */ #define REFOBJHASH(V) ((((uintp)(V) >> 2) ^ ((uintp)(V) >> 9))%REFOBJHASHSZ) @@ -64,7 +64,6 @@ bool KaffeGC_addRef(Collector *collector, const void* mem) { - int iLockRoot; uint32 idx; strongRefObject* obj; @@ -99,7 +98,6 @@ bool KaffeGC_rmRef(Collector *collector, void* mem) { - int iLockRoot; uint32 idx; strongRefObject** objp; strongRefObject* obj; @@ -128,7 +126,6 @@ bool KaffeGC_addWeakRef(Collector *collector, void* mem, void** refobj) { - int iLockRoot; int idx; weakRefObject* obj; @@ -173,7 +170,6 @@ bool KaffeGC_rmWeakRef(Collector *collector, void* mem, void** refobj) { - int iLockRoot; uint32 idx; weakRefObject** objp; weakRefObject* obj; @@ -314,7 +310,6 @@ { int i; strongRefObject* robj; - int iLockRoot; DBG(GCWALK, dprintf("Walking gc roots...\n"); @@ -359,7 +354,6 @@ weakRefObject** objp; weakRefObject* obj; unsigned int i; - int iLockRoot; idx = REFOBJHASH(mem); Index: kaffe/xprof/debugFile.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/xprof/debugFile.c,v retrieving revision 1.7 diff -u -B -b -r1.7 debugFile.c --- kaffe/xprof/debugFile.c 14 Dec 2004 08:23:00 -0000 1.7 +++ kaffe/xprof/debugFile.c 7 Mar 2005 19:00:58 -0000 @@ -412,7 +412,7 @@ int addDebugInfo(struct debug_file *df, df_tag_t tag, ...) { int retval = 1; - int iLockRoot; + INIT_LOCKVAR; va_list args; #if defined(KAFFE_XPROFILER) Index: kaffe/xprof/feedback.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/xprof/feedback.c,v retrieving revision 1.4 diff -u -B -b -r1.4 feedback.c --- kaffe/xprof/feedback.c 18 Sep 2004 20:48:17 -0000 1.4 +++ kaffe/xprof/feedback.c 7 Mar 2005 19:00:58 -0000 @@ -238,7 +238,8 @@ { struct section_file_data *sfd; struct jit_section_data *jsd; - int retval = 0, iLockRoot; + int retval = 0; + INIT_LOCKVAR; if( !kaffe_feedback_file ) return( 0 ); @@ -274,7 +275,8 @@ int feedbackLibrary(char *name, int preload) { struct section_file_data *sfd; - int retval = 0, iLockRoot; + int retval = 0; + INIT_LOCKVAR; if( !kaffe_feedback_file ) return( 0 ); Index: kaffe/xprof/sectionFile.c =================================================================== RCS file: /cvs/kaffe/kaffe/kaffe/xprof/sectionFile.c,v retrieving revision 1.6 diff -u -B -b -r1.6 sectionFile.c --- kaffe/xprof/sectionFile.c 18 Sep 2004 20:48:17 -0000 1.6 +++ kaffe/xprof/sectionFile.c 7 Mar 2005 19:00:58 -0000 @@ -1082,7 +1082,7 @@ int syncSectionFile(struct section_file *sf) { - int iLockRoot, retval; + INIT_LOCKVAR, retval; lockMutex(sf); retval = syncFile(0, sf, sf->sf_filename); @@ -1119,7 +1119,7 @@ void addSectionToFile(struct section_file *sf, struct section_file_data *sfd) { - int iLockRoot, hash; + INIT_LOCKVAR, hash; hash = hashName(sfd->sfd_name, SECTION_FILE_HASH_SIZE); lockMutex(sf); @@ -1143,7 +1143,7 @@ char *name) { struct section_file_data *retval = 0, *sfd; - int iLockRoot, hash; + INIT_LOCKVAR, hash; lockMutex(sf); hash = hashName(name, SECTION_FILE_HASH_SIZE); @@ -1166,7 +1166,7 @@ void *arg) { struct section_file_data *sfd; - int iLockRoot, retval = 1; + INIT_LOCKVAR, retval = 1; if( !sf ) return( 0 ); Index: libraries/clib/net/InetAddressImpl.c =================================================================== RCS file: /cvs/kaffe/kaffe/libraries/clib/net/InetAddressImpl.c,v retrieving revision 1.28 diff -u -B -b -r1.28 InetAddressImpl.c --- libraries/clib/net/InetAddressImpl.c 20 Dec 2004 03:40:03 -0000 1.28 +++ libraries/clib/net/InetAddressImpl.c 7 Mar 2005 19:01:02 -0000 @@ -103,7 +103,6 @@ static iStaticLock hostLock; struct Hjava_lang_String *retval = NULL; - int iLockRoot; lockStaticMutex(&hostLock); if( gethostname(hostname, HOSTNMSZ - 1) < 0 ) @@ -131,7 +130,6 @@ jsize count = 0; struct addrinfo hints, *ai = NULL, *curr; HArrayOfArray *retval = NULL; - int iLockRoot; errorInfo einfo; char *name; @@ -369,7 +367,6 @@ #endif struct sockaddr_in *sain = (struct sockaddr_in *)&sa_buf; int rc, retryCount = 5; - int iLockRoot; errorInfo einfo; char *hostname; unsigned int sin_len; @@ -501,7 +498,6 @@ int family, rc = 0; const char *msg; errorInfo einfo; - int iLockRoot; switch( obj_length(addr) ) {