| // natObject.cc - Implementation of the Object class. |
| |
| /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation |
| |
| This file is part of libgcj. |
| |
| This software is copyrighted work licensed under the terms of the |
| Libgcj License. Please consult the file "LIBGCJ_LICENSE" for |
| details. */ |
| |
| #include <config.h> |
| #include <platform.h> |
| |
| #include <string.h> |
| |
| #pragma implementation "Object.h" |
| |
| #include <gcj/cni.h> |
| #include <jvm.h> |
| #include <java/lang/Object.h> |
| #include <java-threads.h> |
| #include <java-signal.h> |
| #include <java/lang/CloneNotSupportedException.h> |
| #include <java/lang/IllegalArgumentException.h> |
| #include <java/lang/IllegalMonitorStateException.h> |
| #include <java/lang/InterruptedException.h> |
| #include <java/lang/NullPointerException.h> |
| #include <java/lang/Class.h> |
| #include <java/lang/Cloneable.h> |
| #include <java/lang/Thread.h> |
| |
| #ifdef LOCK_DEBUG |
| # include <stdio.h> |
| #endif |
| |
| |
| |
| using namespace java::lang; |
| |
| // This is used to represent synchronization information. |
| struct _Jv_SyncInfo |
| { |
| #if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) |
| // We only need to keep track of initialization state if we can |
| // possibly finalize this object. |
| bool init; |
| #endif |
| _Jv_ConditionVariable_t condition; |
| _Jv_Mutex_t mutex; |
| }; |
| |
| |
| |
| jclass |
| java::lang::Object::getClass (void) |
| { |
| _Jv_VTable **dt = (_Jv_VTable **) this; |
| return (*dt)->clas; |
| } |
| |
| jint |
| java::lang::Object::hashCode (void) |
| { |
| return _Jv_HashCode (this); |
| } |
| |
| jobject |
| java::lang::Object::clone (void) |
| { |
| jclass klass = getClass (); |
| jobject r; |
| jint size; |
| |
| // We also clone arrays here. If we put the array code into |
| // __JArray, then we'd have to figure out a way to find the array |
| // vtbl when creating a new array class. This is easier, if uglier. |
| if (klass->isArray()) |
| { |
| __JArray *array = (__JArray *) this; |
| jclass comp = getClass()->getComponentType(); |
| jint eltsize; |
| if (comp->isPrimitive()) |
| { |
| r = _Jv_NewPrimArray (comp, array->length); |
| eltsize = comp->size(); |
| } |
| else |
| { |
| r = _Jv_NewObjectArray (array->length, comp, NULL); |
| eltsize = sizeof (jobject); |
| } |
| // We can't use sizeof on __JArray because we must account for |
| // alignment of the element type. |
| size = (_Jv_GetArrayElementFromElementType (array, comp) - (char *) array |
| + array->length * eltsize); |
| } |
| else |
| { |
| if (! java::lang::Cloneable::class$.isAssignableFrom(klass)) |
| throw new CloneNotSupportedException; |
| |
| size = klass->size(); |
| r = _Jv_AllocObject (klass); |
| } |
| |
| memcpy ((void *) r, (void *) this, size); |
| return r; |
| } |
| |
| void |
| _Jv_FinalizeObject (jobject obj) |
| { |
| // Ignore exceptions. From section 12.6 of the Java Language Spec. |
| try |
| { |
| obj->finalize (); |
| } |
| catch (java::lang::Throwable *t) |
| { |
| // Ignore. |
| } |
| } |
| |
| |
| // |
| // Synchronization code. |
| // |
| |
| #ifndef JV_HASH_SYNCHRONIZATION |
| // This global is used to make sure that only one thread sets an |
| // object's `sync_info' field. |
| static _Jv_Mutex_t sync_mutex; |
| |
| // This macro is used to see if synchronization initialization is |
| // needed. |
| #if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) |
| # define INIT_NEEDED(Obj) (! (Obj)->sync_info \ |
| || ! ((_Jv_SyncInfo *) ((Obj)->sync_info))->init) |
| #else |
| # define INIT_NEEDED(Obj) (! (Obj)->sync_info) |
| #endif |
| |
| #if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) |
| // If we have to run a destructor for a sync_info member, then this |
| // function is registered as a finalizer for the sync_info. |
| static void |
| finalize_sync_info (jobject obj) |
| { |
| _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj; |
| #if defined (_Jv_HaveCondDestroy) |
| _Jv_CondDestroy (&si->condition); |
| #endif |
| #if defined (_Jv_HaveMutexDestroy) |
| _Jv_MutexDestroy (&si->mutex); |
| #endif |
| si->init = false; |
| } |
| #endif |
| |
| // This is called to initialize the sync_info element of an object. |
| void |
| java::lang::Object::sync_init (void) |
| { |
| _Jv_MutexLock (&sync_mutex); |
| // Check again to see if initialization is needed now that we have |
| // the lock. |
| if (INIT_NEEDED (this)) |
| { |
| // We assume there are no pointers in the sync_info |
| // representation. |
| _Jv_SyncInfo *si; |
| // We always create a new sync_info, even if there is already |
| // one available. Any given object can only be finalized once. |
| // If we get here and sync_info is not null, then it has already |
| // been finalized. So if we just reinitialize the old one, |
| // we'll never be able to (re-)destroy the mutex and/or |
| // condition variable. |
| si = (_Jv_SyncInfo *) _Jv_AllocBytes (sizeof (_Jv_SyncInfo)); |
| _Jv_MutexInit (&si->mutex); |
| _Jv_CondInit (&si->condition); |
| #if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) |
| // Register a finalizer. |
| si->init = true; |
| _Jv_RegisterFinalizer (si, finalize_sync_info); |
| #endif |
| sync_info = (jobject) si; |
| } |
| _Jv_MutexUnlock (&sync_mutex); |
| } |
| |
| void |
| java::lang::Object::notify (void) |
| { |
| if (__builtin_expect (INIT_NEEDED (this), false)) |
| sync_init (); |
| _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info; |
| if (__builtin_expect (_Jv_CondNotify (&si->condition, &si->mutex), false)) |
| throw new IllegalMonitorStateException(JvNewStringLatin1 |
| ("current thread not owner")); |
| } |
| |
| void |
| java::lang::Object::notifyAll (void) |
| { |
| if (__builtin_expect (INIT_NEEDED (this), false)) |
| sync_init (); |
| _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info; |
| if (__builtin_expect (_Jv_CondNotifyAll (&si->condition, &si->mutex), false)) |
| throw new IllegalMonitorStateException(JvNewStringLatin1 |
| ("current thread not owner")); |
| } |
| |
| void |
| java::lang::Object::wait (jlong timeout, jint nanos) |
| { |
| if (__builtin_expect (INIT_NEEDED (this), false)) |
| sync_init (); |
| if (__builtin_expect (timeout < 0 || nanos < 0 || nanos > 999999, false)) |
| throw new IllegalArgumentException; |
| _Jv_SyncInfo *si = (_Jv_SyncInfo *) sync_info; |
| switch (_Jv_CondWait (&si->condition, &si->mutex, timeout, nanos)) |
| { |
| case _JV_NOT_OWNER: |
| throw new IllegalMonitorStateException (JvNewStringLatin1 |
| ("current thread not owner")); |
| case _JV_INTERRUPTED: |
| if (Thread::interrupted ()) |
| throw new InterruptedException; |
| } |
| } |
| |
| // |
| // Some runtime code. |
| // |
| |
| // This function is called at system startup to initialize the |
| // `sync_mutex'. |
| void |
| _Jv_InitializeSyncMutex (void) |
| { |
| _Jv_MutexInit (&sync_mutex); |
| } |
| |
| void |
| _Jv_MonitorEnter (jobject obj) |
| { |
| #ifndef HANDLE_SEGV |
| if (__builtin_expect (! obj, false)) |
| throw new java::lang::NullPointerException; |
| #endif |
| if (__builtin_expect (INIT_NEEDED (obj), false)) |
| obj->sync_init (); |
| _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj->sync_info; |
| _Jv_MutexLock (&si->mutex); |
| // FIXME: In the Windows case, this can return a nonzero error code. |
| // We should turn that into some exception ... |
| } |
| |
| void |
| _Jv_MonitorExit (jobject obj) |
| { |
| JvAssert (obj); |
| JvAssert (! INIT_NEEDED (obj)); |
| _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj->sync_info; |
| if (__builtin_expect (_Jv_MutexUnlock (&si->mutex), false)) |
| throw new java::lang::IllegalMonitorStateException; |
| } |
| |
| bool |
| _Jv_ObjectCheckMonitor (jobject obj) |
| { |
| if (__builtin_expect (INIT_NEEDED (obj), false)) |
| obj->sync_init (); |
| _Jv_SyncInfo *si = (_Jv_SyncInfo *) obj->sync_info; |
| return _Jv_MutexCheckMonitor (&si->mutex); |
| } |
| |
| #else /* JV_HASH_SYNCHRONIZATION */ |
| |
| // FIXME: We shouldn't be calling GC_register_finalizer directly. |
| #ifndef HAVE_BOEHM_GC |
| # error Hash synchronization currently requires boehm-gc |
| // That's actually a bit of a lie: It should also work with the null GC, |
| // probably even better than the alternative. |
| // To really support alternate GCs here, we would need to widen the |
| // interface to finalization, since we sometimes have to register a |
| // second finalizer for an object that already has one. |
| // We might also want to move the GC interface to a .h file, since |
| // the number of procedure call levels involved in some of these |
| // operations is already ridiculous, and would become worse if we |
| // went through the proper intermediaries. |
| #else |
| # ifdef LIBGCJ_GC_DEBUG |
| # define GC_DEBUG |
| # endif |
| # include "gc.h" |
| #endif |
| |
| // What follows currenly assumes a Linux-like platform. |
| // Some of it specifically assumes X86 or IA64 Linux, though that |
| // should be easily fixable. |
| |
| // A Java monitor implemention based on a table of locks. |
| // Each entry in the table describes |
| // locks held for objects that hash to that location. |
| // This started out as a reimplementation of the technique used in SGIs JVM, |
| // for which we obtained permission from SGI. |
| // But in fact, this ended up quite different, though some ideas are |
| // still shared with the original. |
| // It was also influenced by some of the published IBM work, |
| // though it also differs in many ways from that. |
| // We could speed this up if we had a way to atomically update |
| // an entire cache entry, i.e. 2 contiguous words of memory. |
| // That would usually be the case with a 32 bit ABI on a 64 bit processor. |
| // But we don't currently go out of our way to target those. |
| // I don't know how to do much better with a N bit ABI on a processor |
| // that can atomically update only N bits at a time. |
| // Author: Hans-J. Boehm (Hans_Boehm@hp.com, boehm@acm.org) |
| |
| #include <limits.h> |
| #include <unistd.h> // for usleep, sysconf. |
| #include <gcj/javaprims.h> |
| #include <sysdep/locks.h> |
| #include <java/lang/Thread.h> |
| |
| // Try to determine whether we are on a multiprocessor, i.e. whether |
| // spinning may be profitable. |
| // This should really use a suitable autoconf macro. |
| // False is the conservative answer, though the right one is much better. |
| static bool |
| is_mp() |
| { |
| #ifdef _SC_NPROCESSORS_ONLN |
| long nprocs = sysconf(_SC_NPROCESSORS_ONLN); |
| return (nprocs > 1); |
| #else |
| return false; |
| #endif |
| } |
| |
| // A call to keep_live(p) forces p to be accessible to the GC |
| // at this point. |
| inline static void |
| keep_live(obj_addr_t p) |
| { |
| __asm__ __volatile__("" : : "rm"(p) : "memory"); |
| } |
| |
| // Each hash table entry holds a single preallocated "lightweight" lock. |
| // In addition, it holds a chain of "heavyweight" locks. Lightweight |
| // locks do not support Object.wait(), and are converted to heavyweight |
| // status in response to contention. Unlike the SGI scheme, both |
| // ligtweight and heavyweight locks in one hash entry can be simultaneously |
| // in use. (The SGI scheme requires that we be able to acquire a heavyweight |
| // lock on behalf of another thread, and can thus convert a lock we don't |
| // hold to heavyweight status. Here we don't insist on that, and thus |
| // let the original holder of the lighweight lock keep it.) |
| |
| struct heavy_lock { |
| void * reserved_for_gc; |
| struct heavy_lock *next; // Hash chain link. |
| // Traced by GC. |
| void * old_client_data; // The only other field traced by GC. |
| GC_finalization_proc old_finalization_proc; |
| obj_addr_t address; // Object to which this lock corresponds. |
| // Should not be traced by GC. |
| // Cleared as heavy_lock is destroyed. |
| // Together with the rest of the heavy lock |
| // chain, this is protected by the lock |
| // bit in the hash table entry to which |
| // the chain is attached. |
| _Jv_SyncInfo si; |
| // The remaining fields save prior finalization info for |
| // the object, which we needed to replace in order to arrange |
| // for cleanup of the lock structure. |
| }; |
| |
| #ifdef LOCK_DEBUG |
| void |
| print_hl_list(heavy_lock *hl) |
| { |
| heavy_lock *p = hl; |
| for (; 0 != p; p = p->next) |
| fprintf (stderr, "(hl = %p, addr = %p)", p, (void *)(p -> address)); |
| } |
| #endif /* LOCK_DEBUG */ |
| |
| #if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) |
| // If we have to run a destructor for a sync_info member, then this |
| // function could be registered as a finalizer for the sync_info. |
| // In fact, we now only invoke it explicitly. |
| static inline void |
| heavy_lock_finalization_proc (heavy_lock *hl) |
| { |
| #if defined (_Jv_HaveCondDestroy) |
| _Jv_CondDestroy (&hl->si.condition); |
| #endif |
| #if defined (_Jv_HaveMutexDestroy) |
| _Jv_MutexDestroy (&hl->si.mutex); |
| #endif |
| hl->si.init = false; |
| } |
| #endif /* defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) */ |
| |
| // We convert the lock back to lightweight status when |
| // we exit, so that a single contention episode doesn't doom the lock |
| // forever. But we also need to make sure that lock structures for dead |
| // objects are eventually reclaimed. We do that in a an additional |
| // finalizer on the underlying object. |
| // Note that if the corresponding object is dead, it is safe to drop |
| // the heavy_lock structure from its list. It is not necessarily |
| // safe to deallocate it, since the unlock code could still be running. |
| |
| struct hash_entry { |
| volatile obj_addr_t address; // Address of object for which lightweight |
| // k is held. |
| // We assume the 3 low order bits are zero. |
| // With the Boehm collector and bitmap |
| // allocation, objects of size 4 bytes are |
| // broken anyway. Thus this is primarily |
| // a constraint on statically allocated |
| // objects used for synchronization. |
| // This allows us to use the low order |
| // bits as follows: |
| # define LOCKED 1 // This hash entry is locked, and its |
| // state may be invalid. |
| // The lock protects both the hash_entry |
| // itself (except for the light_count |
| // and light_thr_id fields, which |
| // are protected by the lightweight |
| // lock itself), and any heavy_monitor |
| // structures attached to it. |
| # define HEAVY 2 // Heavyweight locks associated with this |
| // hash entry may be held. |
| // The lightweight entry is still valid, |
| // if the leading bits of the address |
| // field are nonzero. |
| // If the LOCKED bit is clear, then this is |
| // set exactly when heavy_count is > 0 . |
| // Stored redundantly so a single |
| // compare-and-swap works in the easy case. |
| // If HEAVY is not set, it is safe to use |
| // an available lightweight lock entry |
| // without checking if there is an existing |
| // heavyweight lock for the same object. |
| // (There may be one, but it won't be held |
| // or waited for.) |
| # define REQUEST_CONVERSION 4 // The lightweight lock is held. But |
| // one or more other threads have tried |
| // to acquire the lock, and hence request |
| // conversion to heavyweight status. |
| // The heavyweight lock is already allocated. |
| // Threads requesting conversion are |
| // waiting on the condition variable associated |
| // with the heavyweight lock. |
| // Not used for conversion due to |
| // Object.wait() calls. |
| # define FLAGS (LOCKED | HEAVY | REQUEST_CONVERSION) |
| volatile _Jv_ThreadId_t light_thr_id; |
| // Thr_id of holder of lightweight lock. |
| // Only updated by lightweight lock holder. |
| // Must be recognizably invalid if the |
| // lightweight lock is not held. |
| # define INVALID_THREAD_ID 0 // Works for Linux? |
| // If zero doesn't work, we have to |
| // initialize lock table. |
| volatile unsigned short light_count; |
| // Number of times the lightweight lock |
| // is held minus one. Zero if lightweight |
| // lock is not held. Only updated by |
| // lightweight lock holder or, in one |
| // case, while holding the LOCKED bit in |
| // a state in which there can be no |
| // lightweight lock holder. |
| unsigned short heavy_count; // Total number of times heavyweight locks |
| // associated with this hash entry are held |
| // or waiting to be acquired. |
| // Threads in wait() are included eventhough |
| // they have temporarily released the lock. |
| // Protected by LOCKED bit. |
| // Threads requesting conversion to heavyweight |
| // status are also included. |
| struct heavy_lock * heavy_locks; |
| // Chain of heavy locks. Protected |
| // by lockbit for he. Locks may |
| // remain allocated here even if HEAVY |
| // is not set and heavy_count is 0. |
| // If a lightweight and heavyweight lock |
| // correspond to the same address, the |
| // lightweight lock is the right one. |
| }; |
| |
| #ifndef JV_SYNC_TABLE_SZ |
| # define JV_SYNC_TABLE_SZ 2048 // Must be power of 2. |
| #endif |
| |
| hash_entry light_locks[JV_SYNC_TABLE_SZ]; |
| |
| #define JV_SYNC_HASH(p) (((long)p ^ ((long)p >> 10)) & (JV_SYNC_TABLE_SZ-1)) |
| |
| // Note that the light_locks table is scanned conservatively by the |
| // collector. It is essential the the heavy_locks field is scanned. |
| // Currently the address field may or may not cause the associated object |
| // to be retained, depending on whether flag bits are set. |
| // This means that we can conceivable get an unexpected deadlock if |
| // 1) Object at address A is locked. |
| // 2) The client drops A without unlocking it. |
| // 3) Flag bits in the address entry are set, so the collector reclaims |
| // the object at A. |
| // 4) A is reallocated, and an attempt is made to lock the result. |
| // This could be fixed by scanning light_locks in a more customized |
| // manner that ignores the flag bits. But it can only happen with hand |
| // generated semi-illegal .class files, and then it doesn't present a |
| // security hole. |
| |
| #ifdef LOCK_DEBUG |
| void print_he(hash_entry *he) |
| { |
| fprintf(stderr, "lock hash entry = %p, index = %d, address = 0x%lx\n" |
| "\tlight_thr_id = 0x%lx, light_count = %d, " |
| "heavy_count = %d\n\theavy_locks:", he, |
| he - light_locks, (unsigned long)(he -> address), |
| (unsigned long)(he -> light_thr_id), |
| he -> light_count, he -> heavy_count); |
| print_hl_list(he -> heavy_locks); |
| fprintf(stderr, "\n"); |
| } |
| #endif /* LOCK_DEBUG */ |
| |
| #ifdef LOCK_LOG |
| // Log locking operations. For debugging only. |
| // Logging is intended to be as unintrusive as possible. |
| // Log calls are made after an operation completes, and hence |
| // may not completely reflect actual synchronization ordering. |
| // The choice of events to log is currently a bit haphazard. |
| // The intent is that if we have to track down any other bugs |
| // inthis code, we extend the logging as appropriate. |
| typedef enum |
| { |
| ACQ_LIGHT, ACQ_LIGHT2, ACQ_HEAVY, ACQ_HEAVY2, PROMOTE, REL_LIGHT, |
| REL_HEAVY, REQ_CONV, PROMOTE2, WAIT_START, WAIT_END, NOTIFY, NOTIFY_ALL |
| } event_type; |
| |
| struct lock_history |
| { |
| event_type tp; |
| obj_addr_t addr; // Often includes flags. |
| _Jv_ThreadId_t thr; |
| }; |
| |
| const int LOG_SIZE = 128; // Power of 2. |
| |
| lock_history lock_log[LOG_SIZE]; |
| |
| volatile obj_addr_t log_next = 0; |
| // Next location in lock_log. |
| // Really an int, but we need compare_and_swap. |
| |
| static void add_log_entry(event_type t, obj_addr_t a, _Jv_ThreadId_t th) |
| { |
| obj_addr_t my_entry; |
| obj_addr_t next_entry; |
| do |
| { |
| my_entry = log_next; |
| next_entry = ((my_entry + 1) & (LOG_SIZE - 1)); |
| } |
| while (!compare_and_swap(&log_next, my_entry, next_entry)); |
| lock_log[my_entry].tp = t; |
| lock_log[my_entry].addr = a; |
| lock_log[my_entry].thr = th; |
| } |
| |
| # define LOG(t, a, th) add_log_entry(t, a, th) |
| #else /* !LOCK_LOG */ |
| # define LOG(t, a, th) |
| #endif |
| |
| static bool mp = false; // Known multiprocesssor. |
| |
| // Wait for roughly 2^n units, touching as little memory as possible. |
| static void |
| spin(unsigned n) |
| { |
| const unsigned MP_SPINS = 10; |
| const unsigned YIELDS = 4; |
| const unsigned SPINS_PER_UNIT = 30; |
| const unsigned MIN_SLEEP_USECS = 2001; // Shorter times spin under Linux. |
| const unsigned MAX_SLEEP_USECS = 200000; |
| static unsigned spin_limit = 0; |
| static unsigned yield_limit = YIELDS; |
| static bool spin_initialized = false; |
| |
| if (!spin_initialized) |
| { |
| mp = is_mp(); |
| if (mp) |
| { |
| spin_limit = MP_SPINS; |
| yield_limit = MP_SPINS + YIELDS; |
| } |
| spin_initialized = true; |
| } |
| if (n < spin_limit) |
| { |
| unsigned i = SPINS_PER_UNIT << n; |
| for (; i > 0; --i) |
| __asm__ __volatile__(""); |
| } |
| else if (n < yield_limit) |
| { |
| _Jv_ThreadYield(); |
| } |
| else |
| { |
| unsigned duration = MIN_SLEEP_USECS << (n - yield_limit); |
| if (n >= 15 + yield_limit || duration > MAX_SLEEP_USECS) |
| duration = MAX_SLEEP_USECS; |
| _Jv_platform_usleep(duration); |
| } |
| } |
| |
| // Wait for a hash entry to become unlocked. |
| static void |
| wait_unlocked (hash_entry *he) |
| { |
| unsigned i = 0; |
| while (he -> address & LOCKED) |
| spin (i++); |
| } |
| |
| // Return the heavy lock for addr if it was already allocated. |
| // The client passes in the appropriate hash_entry. |
| // We hold the lock for he. |
| static inline heavy_lock * |
| find_heavy (obj_addr_t addr, hash_entry *he) |
| { |
| heavy_lock *hl = he -> heavy_locks; |
| while (hl != 0 && hl -> address != addr) hl = hl -> next; |
| return hl; |
| } |
| |
| // Unlink the heavy lock for the given address from its hash table chain. |
| // Dies miserably and conspicuously if it's not there, since that should |
| // be impossible. |
| static inline void |
| unlink_heavy (obj_addr_t addr, hash_entry *he) |
| { |
| heavy_lock **currentp = &(he -> heavy_locks); |
| while ((*currentp) -> address != addr) |
| currentp = &((*currentp) -> next); |
| *currentp = (*currentp) -> next; |
| } |
| |
| // Finalization procedure for objects that have associated heavy-weight |
| // locks. This may replace the real finalization procedure. |
| static void |
| heavy_lock_obj_finalization_proc (void *obj, void *cd) |
| { |
| heavy_lock *hl = (heavy_lock *)cd; |
| |
| // This only addresses misalignment of statics, not heap objects. It |
| // works only because registering statics for finalization is a noop, |
| // no matter what the least significant bits are. |
| #ifdef JV_LINKER_CANNOT_8BYTE_ALIGN_STATICS |
| obj_addr_t addr = (obj_addr_t)obj & ~((obj_addr_t)0x7); |
| #else |
| obj_addr_t addr = (obj_addr_t)obj; |
| #endif |
| hash_entry *he = light_locks + JV_SYNC_HASH(addr); |
| obj_addr_t he_address = (he -> address & ~LOCKED); |
| |
| // Acquire lock bit immediately. It's possible that the hl was already |
| // destroyed while we were waiting for the finalizer to run. If it |
| // was, the address field was set to zero. The address filed access is |
| // protected by the lock bit to ensure that we do this exactly once. |
| // The lock bit also protects updates to the objects finalizer. |
| while (!compare_and_swap(&(he -> address), he_address, he_address|LOCKED )) |
| { |
| // Hash table entry is currently locked. We can't safely |
| // touch the list of heavy locks. |
| wait_unlocked(he); |
| he_address = (he -> address & ~LOCKED); |
| } |
| if (0 == hl -> address) |
| { |
| // remove_all_heavy destroyed hl, and took care of the real finalizer. |
| release_set(&(he -> address), he_address); |
| return; |
| } |
| JvAssert(hl -> address == addr); |
| GC_finalization_proc old_finalization_proc = hl -> old_finalization_proc; |
| if (old_finalization_proc != 0) |
| { |
| // We still need to run a real finalizer. In an idealized |
| // world, in which people write thread-safe finalizers, that is |
| // likely to require synchronization. Thus we reregister |
| // ourselves as the only finalizer, and simply run the real one. |
| // Thus we don't clean up the lock yet, but we're likely to do so |
| // on the next GC cycle. |
| // It's OK if remove_all_heavy actually destroys the heavy lock, |
| // since we've updated old_finalization_proc, and thus the user's |
| // finalizer won't be rerun. |
| void * old_client_data = hl -> old_client_data; |
| hl -> old_finalization_proc = 0; |
| hl -> old_client_data = 0; |
| # ifdef HAVE_BOEHM_GC |
| GC_REGISTER_FINALIZER_NO_ORDER(obj, heavy_lock_obj_finalization_proc, cd, 0, 0); |
| # endif |
| release_set(&(he -> address), he_address); |
| old_finalization_proc(obj, old_client_data); |
| } |
| else |
| { |
| // The object is really dead, although it's conceivable that |
| // some thread may still be in the process of releasing the |
| // heavy lock. Unlink it and, if necessary, register a finalizer |
| // to destroy sync_info. |
| unlink_heavy(addr, he); |
| hl -> address = 0; // Don't destroy it again. |
| release_set(&(he -> address), he_address); |
| # if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) |
| // Make sure lock is not held and then destroy condvar and mutex. |
| _Jv_MutexLock(&(hl->si.mutex)); |
| _Jv_MutexUnlock(&(hl->si.mutex)); |
| heavy_lock_finalization_proc (hl); |
| # endif |
| } |
| } |
| |
| // We hold the lock on he, and heavy_count is 0. |
| // Release the lock by replacing the address with new_address_val. |
| // Remove all heavy locks on the list. Note that the only possible way |
| // in which a lock may still be in use is if it's in the process of |
| // being unlocked. |
| // FIXME: Why does this unlock the hash entry? I think that |
| // could now be done more cleanly in MonitorExit. |
| static void |
| remove_all_heavy (hash_entry *he, obj_addr_t new_address_val) |
| { |
| JvAssert(he -> heavy_count == 0); |
| JvAssert(he -> address & LOCKED); |
| heavy_lock *hl = he -> heavy_locks; |
| he -> heavy_locks = 0; |
| // We would really like to release the lock bit here. Unfortunately, that |
| // Creates a race between or finalizer removal, and the potential |
| // reinstallation of a new finalizer as a new heavy lock is created. |
| // This may need to be revisited. |
| for(; 0 != hl; hl = hl->next) |
| { |
| obj_addr_t obj = hl -> address; |
| JvAssert(0 != obj); // If this was previously finalized, it should no |
| // longer appear on our list. |
| hl -> address = 0; // Finalization proc might still see it after we |
| // finish. |
| GC_finalization_proc old_finalization_proc = hl -> old_finalization_proc; |
| void * old_client_data = hl -> old_client_data; |
| # ifdef HAVE_BOEHM_GC |
| // Remove our finalization procedure. |
| // Reregister the clients if applicable. |
| GC_REGISTER_FINALIZER_NO_ORDER((GC_PTR)obj, old_finalization_proc, |
| old_client_data, 0, 0); |
| // Note that our old finalization procedure may have been |
| // previously determined to be runnable, and may still run. |
| // FIXME - direct dependency on boehm GC. |
| # endif |
| # if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) |
| // Wait for a possible lock holder to finish unlocking it. |
| // This is only an issue if we have to explicitly destroy the mutex |
| // or possibly if we have to destroy a condition variable that is |
| // still being notified. |
| _Jv_MutexLock(&(hl->si.mutex)); |
| _Jv_MutexUnlock(&(hl->si.mutex)); |
| heavy_lock_finalization_proc (hl); |
| # endif |
| } |
| release_set(&(he -> address), new_address_val); |
| } |
| |
| // We hold the lock on he and heavy_count is 0. |
| // We release it by replacing the address field with new_address_val. |
| // Remove all heavy locks on the list if the list is sufficiently long. |
| // This is called periodically to avoid very long lists of heavy locks. |
| // This seems to otherwise become an issue with SPECjbb, for example. |
| static inline void |
| maybe_remove_all_heavy (hash_entry *he, obj_addr_t new_address_val) |
| { |
| static const int max_len = 5; |
| heavy_lock *hl = he -> heavy_locks; |
| |
| for (int i = 0; i < max_len; ++i) |
| { |
| if (0 == hl) |
| { |
| release_set(&(he -> address), new_address_val); |
| return; |
| } |
| hl = hl -> next; |
| } |
| remove_all_heavy(he, new_address_val); |
| } |
| |
| // Allocate a new heavy lock for addr, returning its address. |
| // Assumes we already have the hash_entry locked, and there |
| // is currently no lightweight or allocated lock for addr. |
| // We register a finalizer for addr, which is responsible for |
| // removing the heavy lock when addr goes away, in addition |
| // to the responsibilities of any prior finalizer. |
| // This unfortunately holds the lock bit for the hash entry while it |
| // allocates two objects (on for the finalizer). |
| // It would be nice to avoid that somehow ... |
| static heavy_lock * |
| alloc_heavy(obj_addr_t addr, hash_entry *he) |
| { |
| heavy_lock * hl = (heavy_lock *) _Jv_AllocTraceTwo(sizeof (heavy_lock)); |
| |
| hl -> address = addr; |
| _Jv_MutexInit (&(hl -> si.mutex)); |
| _Jv_CondInit (&(hl -> si.condition)); |
| # if defined (_Jv_HaveCondDestroy) || defined (_Jv_HaveMutexDestroy) |
| hl->si.init = true; // needed ? |
| # endif |
| hl -> next = he -> heavy_locks; |
| he -> heavy_locks = hl; |
| // FIXME: The only call that cheats and goes directly to the GC interface. |
| # ifdef HAVE_BOEHM_GC |
| GC_REGISTER_FINALIZER_NO_ORDER( |
| (void *)addr, heavy_lock_obj_finalization_proc, |
| hl, &hl->old_finalization_proc, |
| &hl->old_client_data); |
| # endif /* HAVE_BOEHM_GC */ |
| return hl; |
| } |
| |
| // Return the heavy lock for addr, allocating if necessary. |
| // Assumes we have the cache entry locked, and there is no lightweight |
| // lock for addr. |
| static heavy_lock * |
| get_heavy(obj_addr_t addr, hash_entry *he) |
| { |
| heavy_lock *hl = find_heavy(addr, he); |
| if (0 == hl) |
| hl = alloc_heavy(addr, he); |
| return hl; |
| } |
| |
| void |
| _Jv_MonitorEnter (jobject obj) |
| { |
| #ifdef JV_LINKER_CANNOT_8BYTE_ALIGN_STATICS |
| obj_addr_t addr = (obj_addr_t)obj & ~((obj_addr_t)FLAGS); |
| #else |
| obj_addr_t addr = (obj_addr_t)obj; |
| #endif |
| obj_addr_t address; |
| unsigned hash = JV_SYNC_HASH(addr); |
| hash_entry * he = light_locks + hash; |
| _Jv_ThreadId_t self = _Jv_ThreadSelf(); |
| unsigned count; |
| const unsigned N_SPINS = 18; |
| |
| // We need to somehow check that addr is not NULL on the fast path. |
| // A very predictable |
| // branch on a register value is probably cheaper than dereferencing addr. |
| // We could also permanently lock the NULL entry in the hash table. |
| // But it's not clear that's cheaper either. |
| if (__builtin_expect(!addr, false)) |
| throw new java::lang::NullPointerException; |
| |
| JvAssert(!(addr & FLAGS)); |
| retry: |
| if (__builtin_expect(compare_and_swap(&(he -> address), |
| 0, addr),true)) |
| { |
| JvAssert(he -> light_thr_id == INVALID_THREAD_ID); |
| JvAssert(he -> light_count == 0); |
| he -> light_thr_id = self; |
| // Count fields are set correctly. Heavy_count was also zero, |
| // but can change asynchronously. |
| // This path is hopefully both fast and the most common. |
| LOG(ACQ_LIGHT, addr, self); |
| return; |
| } |
| address = he -> address; |
| if ((address & ~(HEAVY | REQUEST_CONVERSION)) == addr) |
| { |
| if (he -> light_thr_id == self) |
| { |
| // We hold the lightweight lock, and it's for the right |
| // address. |
| count = he -> light_count; |
| if (count == USHRT_MAX) |
| { |
| // I think most JVMs don't check for this. |
| // But I'm not convinced I couldn't turn this into a security |
| // hole, even with a 32 bit counter. |
| throw new java::lang::IllegalMonitorStateException( |
| JvNewStringLatin1("maximum monitor nesting level exceeded")); |
| } |
| he -> light_count = count + 1; |
| return; |
| } |
| else |
| { |
| JvAssert(!(address & LOCKED)); |
| // Lightweight lock is held, but by somone else. |
| // Spin a few times. This avoids turning this into a heavyweight |
| // lock if the current holder is about to release it. |
| // FIXME: Does this make sense on a uniprocessor, where |
| // it actually yields? It's probably cheaper to convert. |
| for (unsigned int i = 0; i < N_SPINS; ++i) |
| { |
| if ((he -> address & ~LOCKED) != address) goto retry; |
| spin(i); |
| } |
| if (!compare_and_swap(&(he -> address), address, address | LOCKED )) |
| { |
| wait_unlocked(he); |
| goto retry; |
| } |
| heavy_lock *hl = get_heavy(addr, he); |
| ++ (he -> heavy_count); |
| // The hl lock acquisition can't block for long, since it can |
| // only be held by other threads waiting for conversion, and |
| // they, like us, drop it quickly without blocking. |
| _Jv_MutexLock(&(hl->si.mutex)); |
| JvAssert(he -> address == address | LOCKED ); |
| release_set(&(he -> address), (address | REQUEST_CONVERSION | HEAVY)); |
| // release lock on he |
| LOG(REQ_CONV, (address | REQUEST_CONVERSION | HEAVY), self); |
| // If _Jv_CondWait is interrupted, we ignore the interrupt, but |
| // restore the thread's interrupt status flag when done. |
| jboolean interrupt_flag = false; |
| while ((he -> address & ~FLAGS) == (address & ~FLAGS)) |
| { |
| // Once converted, the lock has to retain heavyweight |
| // status, since heavy_count > 0. |
| int r = _Jv_CondWait (&(hl->si.condition), &(hl->si.mutex), 0, 0); |
| if (r == _JV_INTERRUPTED) |
| { |
| interrupt_flag = true; |
| Thread::currentThread()->interrupt_flag = false; |
| } |
| } |
| if (interrupt_flag) |
| Thread::currentThread()->interrupt_flag = interrupt_flag; |
| keep_live(addr); |
| // Guarantee that hl doesn't get unlinked by finalizer. |
| // This is only an issue if the client fails to release |
| // the lock, which is unlikely. |
| JvAssert(he -> address & HEAVY); |
| // Lock has been converted, we hold the heavyweight lock, |
| // heavy_count has been incremented. |
| return; |
| } |
| } |
| obj_addr_t was_heavy = (address & HEAVY); |
| if ((address & LOCKED) || |
| !compare_and_swap(&(he -> address), address, (address | LOCKED ))) |
| { |
| wait_unlocked(he); |
| goto retry; |
| } |
| if ((address & ~(HEAVY | REQUEST_CONVERSION)) == 0) |
| { |
| // Either was_heavy is true, or something changed out from under us, |
| // since the initial test for 0 failed. |
| JvAssert(!(address & REQUEST_CONVERSION)); |
| // Can't convert a nonexistent lightweight lock. |
| heavy_lock *hl; |
| hl = (was_heavy? find_heavy(addr, he) : 0); |
| // The CAS succeeded, so was_heavy is still accurate. |
| if (0 == hl) |
| { |
| // It is OK to use the lighweight lock, since either the |
| // heavyweight lock does not exist, or none of the |
| // heavyweight locks are currently in use. Future threads |
| // trying to acquire the lock will see the lightweight |
| // one first and use that. |
| he -> light_thr_id = self; // OK, since nobody else can hold |
| // light lock or do this at the same time. |
| JvAssert(he -> light_count == 0); |
| JvAssert(was_heavy == (he -> address & HEAVY)); |
| release_set(&(he -> address), (addr | was_heavy)); |
| LOG(ACQ_LIGHT2, addr | was_heavy, self); |
| } |
| else |
| { |
| // Must use heavy lock. |
| ++ (he -> heavy_count); |
| JvAssert(0 == (address & ~HEAVY)); |
| release_set(&(he -> address), HEAVY); |
| LOG(ACQ_HEAVY, addr | was_heavy, self); |
| _Jv_MutexLock(&(hl->si.mutex)); |
| keep_live(addr); |
| } |
| return; |
| } |
| // Lightweight lock is held, but does not correspond to this object. |
| // We hold the lock on the hash entry, and he -> address can't |
| // change from under us. Neither can the chain of heavy locks. |
| { |
| JvAssert(0 == he -> heavy_count || (address & HEAVY)); |
| heavy_lock *hl = get_heavy(addr, he); |
| ++ (he -> heavy_count); |
| release_set(&(he -> address), address | HEAVY); |
| LOG(ACQ_HEAVY2, address | HEAVY, self); |
| _Jv_MutexLock(&(hl->si.mutex)); |
| keep_live(addr); |
| } |
| } |
| |
| |
| void |
| _Jv_MonitorExit (jobject obj) |
| { |
| #ifdef JV_LINKER_CANNOT_8BYTE_ALIGN_STATICS |
| obj_addr_t addr = (obj_addr_t)obj & ~((obj_addr_t)FLAGS); |
| #else |
| obj_addr_t addr = (obj_addr_t)obj; |
| #endif |
| _Jv_ThreadId_t self = _Jv_ThreadSelf(); |
| unsigned hash = JV_SYNC_HASH(addr); |
| hash_entry * he = light_locks + hash; |
| _Jv_ThreadId_t light_thr_id; |
| unsigned count; |
| obj_addr_t address; |
| |
| retry: |
| light_thr_id = he -> light_thr_id; |
| // Unfortunately, it turns out we always need to read the address |
| // first. Even if we are going to update it with compare_and_swap, |
| // we need to reset light_thr_id, and that's not safe unless we know |
| // that we hold the lock. |
| address = he -> address; |
| // First the (relatively) fast cases: |
| if (__builtin_expect(light_thr_id == self, true)) |
| // Above must fail if addr == 0 . |
| { |
| count = he -> light_count; |
| if (__builtin_expect((address & ~HEAVY) == addr, true)) |
| { |
| if (count != 0) |
| { |
| // We held the lightweight lock all along. Thus the values |
| // we saw for light_thr_id and light_count must have been valid. |
| he -> light_count = count - 1; |
| return; |
| } |
| else |
| { |
| // We hold the lightweight lock once. |
| he -> light_thr_id = INVALID_THREAD_ID; |
| if (compare_and_swap_release(&(he -> address), address, |
| address & HEAVY)) |
| { |
| LOG(REL_LIGHT, address & HEAVY, self); |
| return; |
| } |
| else |
| { |
| he -> light_thr_id = light_thr_id; // Undo prior damage. |
| goto retry; |
| } |
| } |
| } |
| // else lock is not for this address, conversion is requested, |
| // or the lock bit in the address field is set. |
| } |
| else |
| { |
| if (__builtin_expect(!addr, false)) |
| throw new java::lang::NullPointerException; |
| if ((address & ~(HEAVY | REQUEST_CONVERSION)) == addr) |
| { |
| # ifdef LOCK_DEBUG |
| fprintf(stderr, "Lightweight lock held by other thread\n\t" |
| "light_thr_id = 0x%lx, self = 0x%lx, " |
| "address = 0x%lx, heavy_count = %d, pid = %d\n", |
| light_thr_id, self, (unsigned long)address, |
| he -> heavy_count, getpid()); |
| print_he(he); |
| for(;;) {} |
| # endif |
| // Someone holds the lightweight lock for this object, and |
| // it can't be us. |
| throw new java::lang::IllegalMonitorStateException( |
| JvNewStringLatin1("current thread not owner")); |
| } |
| else |
| count = he -> light_count; |
| } |
| if (address & LOCKED) |
| { |
| wait_unlocked(he); |
| goto retry; |
| } |
| // Now the unlikely cases. |
| // We do know that: |
| // - Address is set, and doesn't contain the LOCKED bit. |
| // - If address refers to the same object as addr, then he -> light_thr_id |
| // refers to this thread, and count is valid. |
| // - The case in which we held the lightweight lock has been |
| // completely handled, except for the REQUEST_CONVERSION case. |
| // |
| if ((address & ~FLAGS) == addr) |
| { |
| // The lightweight lock is assigned to this object. |
| // Thus we must be in the REQUEST_CONVERSION case. |
| if (0 != count) |
| { |
| // Defer conversion until we exit completely. |
| he -> light_count = count - 1; |
| return; |
| } |
| JvAssert(he -> light_thr_id == self); |
| JvAssert(address & REQUEST_CONVERSION); |
| // Conversion requested |
| // Convert now. |
| if (!compare_and_swap(&(he -> address), address, address | LOCKED)) |
| goto retry; |
| heavy_lock *hl = find_heavy(addr, he); |
| JvAssert (0 != hl); |
| // Requestor created it. |
| he -> light_count = 0; |
| JvAssert(he -> heavy_count > 0); |
| // was incremented by requestor. |
| _Jv_MutexLock(&(hl->si.mutex)); |
| // Release the he lock after acquiring the mutex. |
| // Otherwise we can accidentally |
| // notify a thread that has already seen a heavyweight |
| // lock. |
| he -> light_thr_id = INVALID_THREAD_ID; |
| release_set(&(he -> address), HEAVY); |
| LOG(PROMOTE, address, self); |
| // lightweight lock now unused. |
| _Jv_CondNotifyAll(&(hl->si.condition), &(hl->si.mutex)); |
| _Jv_MutexUnlock(&(hl->si.mutex)); |
| // heavy_count was already incremented by original requestor. |
| keep_live(addr); |
| return; |
| } |
| // lightweight lock not for this object. |
| JvAssert(!(address & LOCKED)); |
| JvAssert((address & ~FLAGS) != addr); |
| if (!compare_and_swap(&(he -> address), address, address | LOCKED)) |
| goto retry; |
| heavy_lock *hl = find_heavy(addr, he); |
| if (NULL == hl) |
| { |
| # ifdef LOCK_DEBUG |
| fprintf(stderr, "Failed to find heavyweight lock for addr 0x%lx" |
| " pid = %d\n", addr, getpid()); |
| print_he(he); |
| for(;;) {} |
| # endif |
| release_set(&(he -> address), address); |
| throw new java::lang::IllegalMonitorStateException( |
| JvNewStringLatin1("current thread not owner")); |
| } |
| JvAssert(address & HEAVY); |
| count = he -> heavy_count; |
| JvAssert(count > 0); |
| --count; |
| he -> heavy_count = count; |
| if (0 == count) |
| { |
| const unsigned test_freq = 16; // Power of 2 |
| static volatile unsigned counter = 0; |
| unsigned my_counter = counter; |
| |
| counter = my_counter + 1; |
| if (my_counter%test_freq == 0) |
| { |
| // Randomize the interval length a bit. |
| counter = my_counter + (my_counter >> 4) % (test_freq/2); |
| // Unlock mutex first, to avoid self-deadlock, or worse. |
| _Jv_MutexUnlock(&(hl->si.mutex)); |
| maybe_remove_all_heavy(he, address &~HEAVY); |
| // release lock bit, preserving |
| // REQUEST_CONVERSION |
| // and object address. |
| } |
| else |
| { |
| release_set(&(he -> address), address &~HEAVY); |
| _Jv_MutexUnlock(&(hl->si.mutex)); |
| // Unlock after releasing the lock bit, so that |
| // we don't switch to another thread prematurely. |
| } |
| } |
| else |
| { |
| release_set(&(he -> address), address); |
| _Jv_MutexUnlock(&(hl->si.mutex)); |
| } |
| LOG(REL_HEAVY, addr, self); |
| keep_live(addr); |
| } |
| |
| // Return false if obj's monitor is held by the current thread |
| bool |
| _Jv_ObjectCheckMonitor (jobject obj) |
| { |
| #ifdef JV_LINKER_CANNOT_8BYTE_ALIGN_STATICS |
| obj_addr_t addr = (obj_addr_t)obj & ~((obj_addr_t)FLAGS); |
| #else |
| obj_addr_t addr = (obj_addr_t)obj; |
| #endif |
| obj_addr_t address; |
| unsigned hash = JV_SYNC_HASH(addr); |
| hash_entry * he = light_locks + hash; |
| |
| JvAssert(!(addr & FLAGS)); |
| address = he -> address; |
| // Try it the easy way first: |
| if (address == 0) return true; |
| _Jv_ThreadId_t self = _Jv_ThreadSelf(); |
| if ((address & ~(HEAVY | REQUEST_CONVERSION)) == addr) |
| // Fails if entry is LOCKED. |
| // I can't asynchronously become or stop being the holder. |
| return he -> light_thr_id != self; |
| retry: |
| // Acquire the hash table entry lock |
| address &= ~LOCKED; |
| if (!compare_and_swap(&(he -> address), address, address | LOCKED)) |
| { |
| wait_unlocked(he); |
| goto retry; |
| } |
| |
| bool not_mine; |
| |
| if ((address & ~FLAGS) == addr) |
| not_mine = (he -> light_thr_id != self); |
| else |
| { |
| heavy_lock* hl = find_heavy(addr, he); |
| not_mine = hl ? _Jv_MutexCheckMonitor(&hl->si.mutex) : true; |
| } |
| |
| release_set(&(he -> address), address); // unlock hash entry |
| return not_mine; |
| } |
| |
| // The rest of these are moderately thin veneers on _Jv_Cond ops. |
| // The current version of Notify might be able to make the pthread |
| // call AFTER releasing the lock, thus saving some context switches?? |
| |
| void |
| java::lang::Object::wait (jlong timeout, jint nanos) |
| { |
| #ifdef JV_LINKER_CANNOT_8BYTE_ALIGN_STATICS |
| obj_addr_t addr = (obj_addr_t)this & ~((obj_addr_t)FLAGS); |
| #else |
| obj_addr_t addr = (obj_addr_t)this; |
| #endif |
| _Jv_ThreadId_t self = _Jv_ThreadSelf(); |
| unsigned hash = JV_SYNC_HASH(addr); |
| hash_entry * he = light_locks + hash; |
| unsigned count; |
| obj_addr_t address; |
| heavy_lock *hl; |
| |
| if (__builtin_expect (timeout < 0 || nanos < 0 || nanos > 999999, false)) |
| throw new IllegalArgumentException; |
| retry: |
| address = he -> address; |
| address &= ~LOCKED; |
| if (!compare_and_swap(&(he -> address), address, address | LOCKED)) |
| { |
| wait_unlocked(he); |
| goto retry; |
| } |
| // address did not have the lock bit set. We now hold the lock on he. |
| if ((address & ~FLAGS) == addr) |
| { |
| // Convert to heavyweight. |
| if (he -> light_thr_id != self) |
| { |
| # ifdef LOCK_DEBUG |
| fprintf(stderr, "Found wrong lightweight lock owner in wait " |
| "address = 0x%lx pid = %d\n", address, getpid()); |
| print_he(he); |
| for(;;) {} |
| # endif |
| release_set(&(he -> address), address); |
| throw new IllegalMonitorStateException (JvNewStringLatin1 |
| ("current thread not owner")); |
| } |
| count = he -> light_count; |
| hl = get_heavy(addr, he); |
| he -> light_count = 0; |
| he -> heavy_count += count + 1; |
| for (unsigned i = 0; i <= count; ++i) |
| _Jv_MutexLock(&(hl->si.mutex)); |
| // Again release the he lock after acquiring the mutex. |
| he -> light_thr_id = INVALID_THREAD_ID; |
| release_set(&(he -> address), HEAVY); // lightweight lock now unused. |
| LOG(PROMOTE2, addr, self); |
| if (address & REQUEST_CONVERSION) |
| _Jv_CondNotifyAll (&(hl->si.condition), &(hl->si.mutex)); |
| // Since we do this before we do a CondWait, we guarantee that |
| // threads waiting on requested conversion are awoken before |
| // a real wait on the same condition variable. |
| // No other notification can occur in the interim, since |
| // we hold the heavy lock, and notifications are made |
| // without acquiring it. |
| } |
| else /* We should hold the heavyweight lock. */ |
| { |
| hl = find_heavy(addr, he); |
| release_set(&(he -> address), address); |
| if (0 == hl) |
| { |
| # ifdef LOCK_DEBUG |
| fprintf(stderr, "Couldn't find heavy lock in wait " |
| "addr = 0x%lx pid = %d\n", addr, getpid()); |
| print_he(he); |
| for(;;) {} |
| # endif |
| throw new IllegalMonitorStateException (JvNewStringLatin1 |
| ("current thread not owner")); |
| } |
| JvAssert(address & HEAVY); |
| } |
| LOG(WAIT_START, addr, self); |
| switch (_Jv_CondWait (&(hl->si.condition), &(hl->si.mutex), timeout, nanos)) |
| { |
| case _JV_NOT_OWNER: |
| throw new IllegalMonitorStateException (JvNewStringLatin1 |
| ("current thread not owner")); |
| case _JV_INTERRUPTED: |
| if (Thread::interrupted ()) |
| throw new InterruptedException; |
| } |
| LOG(WAIT_END, addr, self); |
| } |
| |
| void |
| java::lang::Object::notify (void) |
| { |
| #ifdef JV_LINKER_CANNOT_8BYTE_ALIGN_STATICS |
| obj_addr_t addr = (obj_addr_t)this & ~((obj_addr_t)FLAGS); |
| #else |
| obj_addr_t addr = (obj_addr_t)this; |
| #endif |
| _Jv_ThreadId_t self = _Jv_ThreadSelf(); |
| unsigned hash = JV_SYNC_HASH(addr); |
| hash_entry * he = light_locks + hash; |
| heavy_lock *hl; |
| obj_addr_t address; |
| int result; |
| |
| retry: |
| address = ((he -> address) & ~LOCKED); |
| if (!compare_and_swap(&(he -> address), address, address | LOCKED)) |
| { |
| wait_unlocked(he); |
| goto retry; |
| } |
| if ((address & ~FLAGS) == addr && he -> light_thr_id == self) |
| { |
| // We hold lightweight lock. Since it has not |
| // been inflated, there are no waiters. |
| release_set(&(he -> address), address); // unlock |
| return; |
| } |
| hl = find_heavy(addr, he); |
| // Hl can't disappear since we point to the underlying object. |
| // It's important that we release the lock bit before the notify, since |
| // otherwise we will try to wake up the target while we still hold the |
| // bit. This results in lock bit contention, which we don't handle |
| // terribly well. |
| release_set(&(he -> address), address); // unlock |
| if (0 == hl) |
| { |
| throw new IllegalMonitorStateException(JvNewStringLatin1 |
| ("current thread not owner")); |
| return; |
| } |
| // We know that we hold the heavyweight lock at this point, |
| // and the lightweight lock is not in use. |
| result = _Jv_CondNotify(&(hl->si.condition), &(hl->si.mutex)); |
| LOG(NOTIFY, addr, self); |
| keep_live(addr); |
| if (__builtin_expect (result, 0)) |
| throw new IllegalMonitorStateException(JvNewStringLatin1 |
| ("current thread not owner")); |
| } |
| |
| void |
| java::lang::Object::notifyAll (void) |
| { |
| #ifdef JV_LINKER_CANNOT_8BYTE_ALIGN_STATICS |
| obj_addr_t addr = (obj_addr_t)this & ~((obj_addr_t)FLAGS); |
| #else |
| obj_addr_t addr = (obj_addr_t)this; |
| #endif |
| _Jv_ThreadId_t self = _Jv_ThreadSelf(); |
| unsigned hash = JV_SYNC_HASH(addr); |
| hash_entry * he = light_locks + hash; |
| heavy_lock *hl; |
| obj_addr_t address; |
| int result; |
| |
| retry: |
| address = (he -> address) & ~LOCKED; |
| if (!compare_and_swap(&(he -> address), address, address | LOCKED)) |
| { |
| wait_unlocked(he); |
| goto retry; |
| } |
| hl = find_heavy(addr, he); |
| if ((address & ~FLAGS) == addr && he -> light_thr_id == self) |
| { |
| // We hold lightweight lock. Since it has not |
| // been inflated, there are no waiters. |
| release_set(&(he -> address), address); // unlock |
| return; |
| } |
| release_set(&(he -> address), address); // unlock |
| if (0 == hl) |
| { |
| throw new IllegalMonitorStateException(JvNewStringLatin1 |
| ("current thread not owner")); |
| } |
| result = _Jv_CondNotifyAll(&(hl->si.condition), &(hl->si.mutex)); |
| LOG(NOTIFY_ALL, addr, self); |
| if (__builtin_expect (result, 0)) |
| throw new IllegalMonitorStateException(JvNewStringLatin1 |
| ("current thread not owner")); |
| } |
| |
| // This is declared in Java code and in Object.h. |
| // It should never be called with JV_HASH_SYNCHRONIZATION |
| void |
| java::lang::Object::sync_init (void) |
| { |
| throw new IllegalMonitorStateException(JvNewStringLatin1 |
| ("internal error: sync_init")); |
| } |
| |
| // This is called on startup and declared in Object.h. |
| // For now we just make it a no-op. |
| void |
| _Jv_InitializeSyncMutex (void) |
| { |
| } |
| |
| #endif /* JV_HASH_SYNCHRONIZATION */ |
| |