/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * @file thread_native_thin_monitor.c * @brief Hythread thin monitors related functions */ #undef LOG_DOMAIN #define LOG_DOMAIN "tm.locks" #include #include #include #include "port_barriers.h" #include "port_thread.h" #include "port_mutex.h" #include "thread_private.h" /** @name Thin monitors support. Implement thin-fat scheme. */ //@{ #if !defined (_IPF_) // spin with try_lock SPIN_COUNT times #define SPIN_COUNT 5 #endif // !defined (_IPF_) /* * 32bit lock word * |0|------15bit-------|--5bit--|1bit|--10bit------| * thin lock -^ threadID (owner) recursion ^ hashcode * | * reservation bit (0 - reserved) * inflated lock: * |1|------------- 20bit -------|----11bit-----| * fat lock -^ fat lock id */ // lockword operations #define THREAD_ID(lockword) (lockword >> 16) #define IS_FAT_LOCK(lockword) (lockword >> 31) #define FAT_LOCK_ID(lockword) \ ((lockword >> HY_FAT_LOCK_ID_OFFSET) & HY_FAT_LOCK_ID_MASK) // lock reservation support #define RESERVED_BITMASK ((1<<10)) #define IS_RESERVED(lockword) (0==(lockword & RESERVED_BITMASK)) #define RECURSION(lockword) ((lockword >> 11) & 31) #define RECURSION_INC(lockword_ptr, lockword) (*lockword_ptr= lockword + (1<<11)) #define RECURSION_DEC(lockword_ptr, lockword) (*lockword_ptr=lockword - (1<<11)) #define MAX_RECURSION 31 #define FAT_LOCK(_x_) \ lock_table->tables[((U_32)(_x_))/HY_FAT_TABLE_ENTRIES]\ [((U_32)(_x_))%HY_FAT_TABLE_ENTRIES] tm_props *tm_properties = NULL; /* * Lock table which holds the omapping between LockID and fat lock (OS fat_monitor) pointer. */ HyFatLockTable *lock_table = NULL; IDATA VMCALL hythread_owns_thin_lock(hythread_t thread, hythread_thin_monitor_t lockword) { IDATA this_id = thread->thread_id; assert(!IS_FAT_LOCK(lockword)); #ifdef LOCK_RESERVATION return THREAD_ID(lockword) == this_id && (!IS_RESERVED(lockword) || RECURSION(lockword) !=0); #else return THREAD_ID(lockword) == this_id; #endif } void set_fat_lock_id(hythread_thin_monitor_t *lockword_ptr, IDATA monitor_id) { U_32 lockword = *lockword_ptr; #ifdef LOCK_RESERVATION assert(!IS_RESERVED(lockword)); #endif assert((U_32)monitor_id < lock_table->size); lockword&=0x7FF; lockword|=(monitor_id << 11) | 0x80000000; *lockword_ptr=lockword; port_rw_barrier(); } IDATA get_fat_lock_id(hythread_thin_monitor_t *lockword_ptr) { // this method steals the bit mask from set_fat_lock_id above // get_fat_lock() and set_fat_lock need cleaning up // the bit masks should be replaced with "#define ..." U_32 lockword = *lockword_ptr; assert(lockword & 0x80000000); //fat lock bit better be set lockword &= 0x7fFFffFF; // throw away the fat lock bit lockword = lockword >> 11; assert(lockword < lock_table->size); return lockword; } int VMCALL hythread_is_fat_lock(hythread_thin_monitor_t lockword) { return (int)IS_FAT_LOCK(lockword); } //forward declaration hythread_monitor_t locktable_get_fat_monitor(IDATA lock_id); IDATA locktable_put_fat_monitor(hythread_monitor_t fat_monitor); hythread_monitor_t locktable_delete_entry(int lock_id); //DEBUG INFO BLOCK //char *vm_get_object_class_name(void* ptr); int unreserve_count=0; int inflate_contended=0; int inflate_waited=0; int unreserve_count_self=0; int fat_lock2_count = 0; int init_reserve_cout = 0; int cas_cout = 0; int res_lock_count = 0; #ifdef LOCK_RESERVATION extern osmutex_t TM_LOCK; /* * Unreserves the lock already owned by this thread */ void unreserve_self_lock(hythread_thin_monitor_t *lockword_ptr) { U_32 lockword = *lockword_ptr; U_32 lockword_new; CTRACE(("unreserve self_id %d lock owner %d", hythread_get_self_id(), THREAD_ID(lockword))); assert(hythread_get_self_id() == THREAD_ID(lockword)); assert (!IS_FAT_LOCK(*lockword_ptr)); assert (IS_RESERVED(lockword)); CTRACE(("Unreserved self %d \n", ++unreserve_count_self/*, vm_get_object_class_name(lockword_ptr-1)*/)); // Set reservation bit to 1 and reduce recursion count lockword_new = (lockword | RESERVED_BITMASK); if (RECURSION(lockword_new) != 0) { RECURSION_DEC(lockword_ptr, lockword_new); } else { lockword_new = lockword_new & 0x0000ffff; *lockword_ptr = lockword_new; } assert(!IS_RESERVED(*lockword_ptr)); CTRACE(("unreserved self")); } /** * Used lockword * Thin monitor functions used java monitor. */ IDATA VMCALL hythread_unreserve_lock(hythread_thin_monitor_t *lockword_ptr) { U_32 lockword = *lockword_ptr; U_32 lockword_new; uint16 lock_id; hythread_t owner; IDATA status; I_32 append; // trylock used to prevent cyclic suspend deadlock // the java_monitor_enter calls safe_point between attempts. /*status = port_mutex_trylock(&TM_LOCK); if (status !=TM_ERROR_NONE) { return status; }*/ if (IS_FAT_LOCK(lockword)) { return TM_ERROR_NONE; } lock_id = THREAD_ID(lockword); owner = hythread_get_thread(lock_id); CTRACE(("Unreserved other %d \n", ++unreserve_count/*, vm_get_object_class_name(lockword_ptr-1)*/)); if (!IS_RESERVED(lockword) || IS_FAT_LOCK(lockword)) { // port_mutex_unlock(&TM_LOCK); return TM_ERROR_NONE; } // suspend owner if (owner) { assert(owner); assert(hythread_get_id(owner) == lock_id); assert(owner != hythread_self()); if(owner->state & (TM_THREAD_STATE_TERMINATED | TM_THREAD_STATE_WAITING | TM_THREAD_STATE_WAITING_INDEFINITELY | TM_THREAD_STATE_WAITING_WITH_TIMEOUT | TM_THREAD_STATE_SLEEPING | TM_THREAD_STATE_PARKED | TM_THREAD_STATE_SUSPENDED | TM_THREAD_STATE_IN_MONITOR_WAIT)) { append = 0; } else { append = RESERVED_BITMASK; } status=hythread_suspend_other(owner); if (status !=TM_ERROR_NONE) { return status; } } else { append = 0; } if(!tm_properties || !tm_properties->use_soft_unreservation) { append = RESERVED_BITMASK; } // prepare new unreserved lockword and try to CAS it with old one. while (IS_RESERVED(lockword)) { assert(!IS_FAT_LOCK(lockword)); CTRACE(("unreserving lock")); if (RECURSION(lockword) != 0) { lockword_new = (lockword | RESERVED_BITMASK); assert(RECURSION(lockword) > 0); assert(RECURSION(lockword_new) > 0); RECURSION_DEC(&lockword_new, lockword_new); } else { lockword_new = (lockword | append); lockword_new = lockword_new & 0x0000ffff; } if (lockword == apr_atomic_cas32 (((volatile apr_uint32_t*) lockword_ptr), (apr_uint32_t) lockword_new, lockword)) { CTRACE(("unreserved lock")); break; } lockword = *lockword_ptr; } // resume owner if (owner) { hythread_yield_other(owner); hythread_resume(owner); } /* status = port_mutex_unlock(&TM_LOCK);*/ // Gregory - This lock, right after it was unreserved, may be // inflated by another thread and therefore instead of recursion // count and reserved flag it will have the fat monitor ID. The // assertion !IS_RESERVED(lockword) fails in this case. So it is // necessary to check first that monitor is not fat. // To avoid race condition between checking two different // conditions inside of assert, the lockword contents has to be // loaded before checking. // lockword = *lockword_ptr; // assert(IS_FAT_LOCK(lockword) || !IS_RESERVED(lockword)); return TM_ERROR_NONE; } #else IDATA VMCALL hythread_unreserve_lock(hythread_thin_monitor_t* lockword_ptr) { return TM_ERROR_NONE; } #endif /** * Initializes a thin monitor at the given address. * Thin monitor is a version of monitor which is optimized for space and * single-threaded usage. * * @param[in] lockword_ptr monitor addr */ IDATA hythread_thin_monitor_create(hythread_thin_monitor_t *lockword_ptr) { //clear anything but hashcode // 000000000000000000011111111111 *lockword_ptr = *lockword_ptr & 0x3FF; return TM_ERROR_NONE; } /** * Attempts to lock thin monitor. * If the monitor is already locked, this call returns immediately with TM_BUSY. * * @param[in] lockword_ptr monitor addr */ IDATA hythread_thin_monitor_try_enter(hythread_thin_monitor_t *lockword_ptr) { U_32 lockword; // warkaround strange intel compiler bug #if defined (__INTEL_COMPILER) && defined (LINUX) volatile #endif IDATA this_id = tm_self_tls->thread_id; IDATA lock_id; IDATA status; hythread_monitor_t fat_monitor; int UNUSED i; assert(!hythread_is_suspend_enabled()); assert((UDATA)lockword_ptr > 4); assert(tm_self_tls); // By DRLVM design rules lockword (see description in thin locks paper) // is only modified without compare-and-exchange by owner thread. If tools // like Intel Thread Checker find a bug about this line, it may actually be a // false-positive. lockword = *lockword_ptr; lock_id = THREAD_ID(lockword); //CTRACE(("try lock %x %d", this_id, RECURSION(lockword))); // Check if the lock is already reserved or owned by this thread if (lock_id == this_id) { if (RECURSION(lockword) == MAX_RECURSION) { //inflate lock in case of recursion overflow fat_monitor = hythread_inflate_lock(lockword_ptr); if (fat_monitor == NULL) { return TM_ERROR_OUT_OF_MEMORY; } return hythread_monitor_try_enter(fat_monitor); //break FAT_LOCK; } else { CTRACE(("try lock %x count:%d", this_id, res_lock_count++)); // increase recursion RECURSION_INC(lockword_ptr, lockword); return TM_ERROR_NONE; } } // Fast path didn't work, someoneelse is holding the monitor (or it isn't reserved yet): // DO SPIN FOR A WHILE, this will decrease the number of fat locks. #ifdef SPIN_COUNT for (i = SPIN_COUNT; i >=0; i--, lockword = *lockword_ptr, lock_id = THREAD_ID(lockword)) { #endif // Check if monitor is free and thin if (lock_id == 0) { // Monitor is free assert( RECURSION(lockword) < 1); assert(this_id > 0 && this_id < 0x8000); // Acquire monitor if (0 != port_atomic_cas16 (((volatile apr_uint16_t*) lockword_ptr)+1, (apr_uint16_t) this_id, 0)) { #ifdef SPIN_COUNT continue; #else return TM_ERROR_EBUSY; #endif } #ifdef LOCK_RESERVATION //lockword = *lockword_ptr; // this reloading of lockword may be odd, need to investigate; if (IS_RESERVED(lockword)) { CTRACE(("initially reserve lock %x count: %d ", *lockword_ptr, init_reserve_cout++)); RECURSION_INC(lockword_ptr, *lockword_ptr); } #endif CTRACE(("CAS lock %x count: %d ", *lockword_ptr, cas_cout++)); return TM_ERROR_NONE; } else // Fat monitor if (IS_FAT_LOCK(lockword)) { CTRACE(("FAT MONITOR %d \n", ++fat_lock2_count/*, vm_get_object_class_name(lockword_ptr-1)*/)); fat_monitor = locktable_get_fat_monitor(FAT_LOCK_ID(lockword)); // find fat_monitor in lock table status = hythread_monitor_try_enter(fat_monitor); #ifdef SPIN_COUNT if (status == TM_ERROR_EBUSY) { continue; } #endif return status; } #ifdef LOCK_RESERVATION // unreserved busy lock else if (IS_RESERVED(lockword)) { status = hythread_unreserve_lock(lockword_ptr); if (status != TM_ERROR_NONE) { #ifdef SPIN_COUNT if (status == TM_ERROR_EBUSY) { continue; } #endif //SPIN_COUNT return status; } return hythread_thin_monitor_try_enter(lockword_ptr); } #endif #ifdef SPIN_COUNT hythread_yield(); } #endif return TM_ERROR_EBUSY; } /** * Locks thin monitor. * * @param[in] lockword_ptr monitor addr */ IDATA hythread_thin_monitor_enter(hythread_thin_monitor_t *lockword_ptr) { hythread_monitor_t fat_monitor; IDATA status; int saved_disable_count; assert(lockword_ptr); if (hythread_thin_monitor_try_enter(lockword_ptr) == TM_ERROR_NONE) { return TM_ERROR_NONE; } while (hythread_thin_monitor_try_enter(lockword_ptr) == TM_ERROR_EBUSY) { if (IS_FAT_LOCK(*lockword_ptr)) { fat_monitor = locktable_get_fat_monitor(FAT_LOCK_ID(*lockword_ptr)); // find fat_monitor in lock table CTRACE((" lock %d\n", FAT_LOCK_ID(*lockword_ptr))); saved_disable_count = hythread_reset_suspend_disable(); status = hythread_monitor_enter(fat_monitor); hythread_set_suspend_disable(saved_disable_count); return status; // lock fat_monitor } //hythread_safe_point(); hythread_yield(); } if (IS_FAT_LOCK(*lockword_ptr)) { // lock already inflated return TM_ERROR_NONE; } CTRACE(("inflate_contended thin_lcok%d\n", ++inflate_contended)); fat_monitor = hythread_inflate_lock(lockword_ptr); if (fat_monitor == NULL) { return TM_ERROR_OUT_OF_MEMORY; } return TM_ERROR_NONE; } /** * Unlocks thin monitor. * * @param[in] lockword_ptr monitor addr */ IDATA VMCALL hythread_thin_monitor_exit(hythread_thin_monitor_t *lockword_ptr) { U_32 lockword = *lockword_ptr; hythread_monitor_t fat_monitor; IDATA this_id = tm_self_tls->thread_id; // obtain current thread id assert(this_id > 0 && this_id < 0xffff); assert(!hythread_is_suspend_enabled()); if (THREAD_ID(lockword) == this_id) { if (RECURSION(lockword)==0) { #ifdef LOCK_RESERVATION if (IS_RESERVED(lockword)) { CTRACE(("ILLEGAL_STATE %x\n", lockword)); return TM_ERROR_ILLEGAL_STATE; } #endif *lockword_ptr = lockword & 0xffff; } else { RECURSION_DEC(lockword_ptr, lockword); //CTRACE(("recursion_dec: 0x%x", *lockword_ptr)); } //CTRACE(("unlocked: 0x%x id: %d\n", *lockword_ptr, THREAD_ID(*lockword_ptr))); //hythread_safe_point(); return TM_ERROR_NONE; } else if (IS_FAT_LOCK(lockword)) { CTRACE(("exit fat monitor %d thread: %d\n", FAT_LOCK_ID(lockword), tm_self_tls->thread_id)); fat_monitor = locktable_get_fat_monitor(FAT_LOCK_ID(lockword)); // find fat_monitor return hythread_monitor_exit(fat_monitor); // unlock fat_monitor } CTRACE(("ILLEGAL_STATE %d\n", FAT_LOCK_ID(lockword))); return TM_ERROR_ILLEGAL_STATE; } /** * Completely releases the ownership over monitor. */ IDATA VMCALL hythread_thin_monitor_release(hythread_thin_monitor_t *lockword_ptr) { IDATA status; U_32 lockword = *lockword_ptr; hythread_t self = hythread_self(); if (self != hythread_thin_monitor_get_owner(lockword_ptr)) { // nothing to do, thread is not an owner of monitor return TM_ERROR_NONE; } if (IS_FAT_LOCK(lockword)) { // this is fat monitor hythread_monitor_t monitor = locktable_get_fat_monitor(FAT_LOCK_ID(lockword)); monitor->recursion_count = 0; status = port_mutex_unlock(&monitor->mutex); assert(status == TM_ERROR_NONE); } else { // this is thin monitor while (RECURSION(lockword)) { RECURSION_DEC(lockword_ptr, lockword); lockword = *lockword_ptr; } *lockword_ptr = lockword & 0xffff; } return TM_ERROR_NONE; } IDATA thin_monitor_wait_impl(hythread_thin_monitor_t *lockword_ptr, I_64 ms, IDATA nano, IDATA interruptable) { // get this thread hythread_t this_thread = tm_self_tls; U_32 lockword = *lockword_ptr; hythread_monitor_t fat_monitor; if (!IS_FAT_LOCK(lockword)) { // check if the current thread owns lock if (!hythread_owns_thin_lock(this_thread, lockword)) { CTRACE(("ILLEGAL_STATE %wait d\n", FAT_LOCK_ID(lockword))); return TM_ERROR_ILLEGAL_STATE; } CTRACE(("inflate_wait%d\n", ++inflate_waited)); // if it is not a thin lock, inflate it fat_monitor = hythread_inflate_lock(lockword_ptr); if (fat_monitor == NULL) { return TM_ERROR_OUT_OF_MEMORY; } } else { // otherwise, get the appropriate fat lock fat_monitor = locktable_get_fat_monitor(FAT_LOCK_ID(lockword)); } assert(fat_monitor == locktable_get_fat_monitor(FAT_LOCK_ID(*lockword_ptr))); return monitor_wait_impl(fat_monitor,ms,nano, interruptable); } /** * Atomically releases a thin monitor and causes the calling * thread to wait on the given condition variable. * * Calling thread must own the monitor. After notification is received, the monitor * is locked again, restoring the original recursion. * * @param[in] lockword_ptr monitor addr * @return * TM_NO_ERROR on success */ IDATA VMCALL hythread_thin_monitor_wait(hythread_thin_monitor_t *lockword_ptr) { return thin_monitor_wait_impl(lockword_ptr, 0, 0, WAIT_NONINTERRUPTABLE); } /** * Atomically releases a thin monitor and causes the calling * thread to wait for signal. * * Calling thread must own the monitor. After notification is received or time out, the monitor * is locked again, restoring the original recursion. * * @param[in] lockword_ptr monitor addr * @param[in] ms timeout millis * @param[in] nano timeout nanos * @return * TM_NO_ERROR on success * TM_ERROR_TIMEOUT in case of time out. */ IDATA VMCALL hythread_thin_monitor_wait_timed(hythread_thin_monitor_t *lockword_ptr, I_64 ms, IDATA nano) { return thin_monitor_wait_impl(lockword_ptr, ms, nano, WAIT_NONINTERRUPTABLE); } /** * Atomically releases a thin monitor and causes the calling * thread to wait for signal. * * Calling thread must own the monitor. After notification is received or time out, the monitor * is locked again, restoring the original recursion. * * @param[in] lockword_ptr monitor addr * @param[in] ms timeout millis * @param[in] nano timeout nanos * @return * TM_NO_ERROR on success * TM_THREAD_INTERRUPTED in case thread was interrupted during wait. * TM_ERROR_TIMEOUT in case of time out. */ IDATA VMCALL hythread_thin_monitor_wait_interruptable(hythread_thin_monitor_t *lockword_ptr, I_64 ms, IDATA nano) { return thin_monitor_wait_impl(lockword_ptr, ms, nano, WAIT_INTERRUPTABLE); } /** * Signals a single thread that is blocking on the given monitor to wake up. * * @param[in] lockword_ptr monitor addr */ IDATA hythread_thin_monitor_notify(hythread_thin_monitor_t *lockword_ptr) { hythread_monitor_t fat_monitor; hythread_thin_monitor_t lockword = *lockword_ptr; if (IS_FAT_LOCK(lockword)) { fat_monitor = locktable_get_fat_monitor(FAT_LOCK_ID(lockword)); assert(fat_monitor); return hythread_monitor_notify(fat_monitor); } // check if the current thread owns lock if (!hythread_owns_thin_lock(tm_self_tls, lockword)) { return TM_ERROR_ILLEGAL_STATE; } return TM_ERROR_NONE; } /** * Signals all threads blocking on the given thin monitor. * * @param[in] lockword_ptr monitor addr */ IDATA hythread_thin_monitor_notify_all(hythread_thin_monitor_t *lockword_ptr) { hythread_monitor_t fat_monitor; hythread_thin_monitor_t lockword = *lockword_ptr; if (IS_FAT_LOCK(lockword)) { fat_monitor = locktable_get_fat_monitor(FAT_LOCK_ID(lockword)); assert(fat_monitor); return hythread_monitor_notify_all(fat_monitor); } // check if the current thread owns lock if (!hythread_owns_thin_lock(tm_self_tls, lockword)) { return TM_ERROR_ILLEGAL_STATE; } return TM_ERROR_NONE; } /** * Destroys the thin monitor and releases any associated resources. * * @param[in] lockword_ptr monitor addr */ IDATA hythread_thin_monitor_destroy(hythread_thin_monitor_t *lockword_ptr) { hythread_monitor_t fat_monitor; hythread_thin_monitor_t lockword = *lockword_ptr; if (IS_FAT_LOCK(lockword)) { fat_monitor = locktable_delete_entry(FAT_LOCK_ID(lockword)); assert(fat_monitor); return hythread_monitor_destroy(fat_monitor); } return TM_ERROR_NONE; } /* * Inflates the compressed lockword into fat fat_monitor */ hythread_monitor_t VMCALL hythread_inflate_lock(hythread_thin_monitor_t *lockword_ptr) { hythread_monitor_t fat_monitor; IDATA status; IDATA fat_monitor_id; U_32 lockword; int i; // we don't need to write lock on lock_table during all this function because // the only invariant we need is 'fat lock is not in the fat lock table before we put it' // however this invariant is true because we hold monitor->mutex during this function // so it cannot be called twice for the signle monitor concurrently lockword = *lockword_ptr; if (IS_FAT_LOCK (lockword)) { return locktable_get_fat_monitor(FAT_LOCK_ID(lockword)); } #ifdef LOCK_RESERVATION // unreserve lock first if (IS_RESERVED(lockword)) { unreserve_self_lock(lockword_ptr); lockword = *lockword_ptr; } assert(!IS_RESERVED(lockword)); #endif assert(hythread_owns_thin_lock(tm_self_tls, lockword)); assert(!hythread_is_suspend_enabled()); CTRACE(("inflation begin for %x thread: %d", lockword, tm_self_tls->thread_id)); status = hythread_monitor_init(&fat_monitor, 0); // allocate fat fat_monitor //assert(status == TM_ERROR_NONE); if (status != TM_ERROR_NONE) { return NULL; } status = hythread_monitor_enter(fat_monitor); if (status != TM_ERROR_NONE) { return NULL; } for (i = RECURSION(lockword); i > 0; i--) { CTRACE(("inflate recursion monitor")); status = hythread_monitor_enter(fat_monitor); // transfer recursion count to fat fat_monitor assert(status == TM_ERROR_NONE); } fat_monitor_id = locktable_put_fat_monitor(fat_monitor); // put fat_monitor into lock table set_fat_lock_id(lockword_ptr, fat_monitor_id); CTRACE(("hythread_inflate_lock %d thread: %d\n", FAT_LOCK_ID(*lockword_ptr), tm_self_tls->thread_id)); //assert(FAT_LOCK_ID(*lockword_ptr) != 2); CTRACE(("FAT ID : 0x%x", *lockword_ptr)); #ifdef LOCK_RESERVATION assert(!IS_RESERVED(*lockword_ptr)); #endif return fat_monitor; } /* * Deflates the fat lock back into compressed lock word. * Not yet implemented. */ void deflate_lock(hythread_monitor_t fat_monitor, hythread_thin_monitor_t *lockword) { /* ;;// put thread_id into lockword //... TODO RECURSION_COUNT(lockword) = fat_monitor->recursion_count; // Transfer recursion count from fat lock back to thin lock IS_FAT_LOCK(lockword) = 0; // Set contention bit indicating that the lock is now thin hythread_monitor_destroy(fat_monitor); // Deallocate fat_monitor locktable_delete_entry(lock_id); // delete entry in lock able */ } // Lock table implementation /* * Enter locktable read section */ static void locktable_reader_enter() { IDATA status = port_mutex_lock(&lock_table->mutex); assert(status == TM_ERROR_NONE); if (lock_table->state == HYTHREAD_LOCKTABLE_IDLE || (lock_table->state == HYTHREAD_LOCKTABLE_READING && lock_table->writers_waiting == 0)) { lock_table->state = HYTHREAD_LOCKTABLE_READING; lock_table->readers_reading++; } else { lock_table->readers_waiting++; hycond_wait_timed_raw(&lock_table->read, &lock_table->mutex, 0, 0); // We are asserting here that we exited wait with the correct state assert(lock_table->state == HYTHREAD_LOCKTABLE_READING); } status = port_mutex_unlock(&lock_table->mutex); assert(status == TM_ERROR_NONE); } /* * Exit locktable read section */ static void locktable_reader_exit() { IDATA status = port_mutex_lock(&lock_table->mutex); assert(status == TM_ERROR_NONE); lock_table->readers_reading--; if (lock_table->readers_reading == 0) { if (lock_table->writers_waiting > 0) { lock_table->state = HYTHREAD_LOCKTABLE_WRITING; hycond_notify(&lock_table->write); } else { lock_table->state = HYTHREAD_LOCKTABLE_IDLE; } } status = port_mutex_unlock(&lock_table->mutex); assert(status == TM_ERROR_NONE); } /* * Enter locktable write section */ static void locktable_writer_enter() { IDATA status = port_mutex_lock(&lock_table->mutex); assert(status == TM_ERROR_NONE); if (lock_table->state != HYTHREAD_LOCKTABLE_IDLE) { lock_table->writers_waiting++; hycond_wait_timed_raw(&lock_table->write, &lock_table->mutex, 0, 0); // We are asserting here that we exited wait with the correct state assert(lock_table->state == HYTHREAD_LOCKTABLE_WRITING); lock_table->writers_waiting--; } else { lock_table->state = HYTHREAD_LOCKTABLE_WRITING; } status = port_mutex_unlock(&lock_table->mutex); assert(status == TM_ERROR_NONE); } /* * Exit locktable write section */ static void locktable_writer_exit() { IDATA status = port_mutex_lock(&lock_table->mutex); assert(status == TM_ERROR_NONE); if (lock_table->readers_reading > 0) { lock_table->readers_reading = lock_table->readers_waiting; lock_table->readers_waiting = 0; lock_table->state = HYTHREAD_LOCKTABLE_READING; hycond_notify_all(&lock_table->read); } else if (lock_table->writers_waiting > 0) { hycond_notify(&lock_table->write); } else { lock_table->state = HYTHREAD_LOCKTABLE_IDLE; } status = port_mutex_unlock(&lock_table->mutex); assert(status == TM_ERROR_NONE); } /* * Returns the OS fat_monitor associated with the given lock id. */ hythread_monitor_t locktable_get_fat_monitor(IDATA lock_id) { hythread_monitor_t fat_monitor; CTRACE(("LOCK ID in table %x\n", lock_id)); assert(lock_id >=0 && (U_32)lock_id < lock_table->size); // we don't need to protect this read, because monitor can't vanish or // be moved in lock table while we are doing get_fat_monitor fat_monitor = FAT_LOCK(lock_id); return fat_monitor; } /* * Sets the value of the specific entry in the lock table */ IDATA locktable_put_fat_monitor(hythread_monitor_t fat_monitor) { U_32 i = 0; U_32 mon_index; short free_slot_found = 0; if (lock_table == 0) { DIE (("Lock table not initialized!")); } locktable_writer_enter(); mon_index = lock_table->array_cursor; for(i =0; i < lock_table->size; i++) { hythread_monitor_t* table; if (mon_index == lock_table->size) mon_index = 0; table = lock_table->tables[mon_index / HY_FAT_TABLE_ENTRIES]; if (table[mon_index % HY_FAT_TABLE_ENTRIES] == 0) { assert(lock_table->live_objs[mon_index] == 0); table[mon_index % HY_FAT_TABLE_ENTRIES] = fat_monitor; free_slot_found = 1; break; } ++mon_index; } if(!free_slot_found) { U_32 old_size; hythread_monitor_t* table; if (lock_table->size >= HY_MAX_FAT_LOCKS) { DIE (("Fat monitor table is exceeded!")); } old_size = lock_table->size; lock_table->size += HY_FAT_TABLE_ENTRIES; table = (hythread_monitor_t *)calloc(HY_FAT_TABLE_ENTRIES, sizeof(hythread_monitor_t)); assert(table); lock_table->tables[old_size / HY_FAT_TABLE_ENTRIES] = table; lock_table->live_objs = realloc(lock_table->live_objs, lock_table->size * sizeof(unsigned char)); assert(lock_table->live_objs); memset(lock_table->live_objs + old_size, 0, HY_FAT_TABLE_ENTRIES * sizeof(unsigned char)); table[0] = fat_monitor; mon_index = old_size; } lock_table->array_cursor = mon_index + 1; locktable_writer_exit(); return mon_index; } // flag that is set when major collection happens static unsigned char live_objs_were_reported = 0; void VMCALL hythread_native_resource_is_live(U_32 lockword) { IDATA index = 0; index = get_fat_lock_id( (hythread_thin_monitor_t *) &lockword); locktable_writer_enter(); lock_table->live_objs[index] = 1; // mark the fat lock entry as still alive live_objs_were_reported = 1; locktable_writer_exit(); } void VMCALL hythread_reclaim_resources() { U_32 i = 0; #ifdef DEBUG_NATIVE_RESOURCE_COLLECTION int old_slots_occupied = 0; int new_slots_occupied = 0; for (;i < lock_table->size; i++) { if (FAT_LOCK(i)) old_slots_occupied++; } #endif locktable_reader_enter(); // If major collection didn't happen, do nothing // reset the flag (major collection happened) if (!live_objs_were_reported) { locktable_reader_exit(); return; } locktable_reader_exit(); locktable_writer_enter(); live_objs_were_reported = 0; for(i = 0; i < lock_table->size; i++) { if (lock_table->live_objs[i]) { assert(FAT_LOCK(i)); #ifdef DEBUG_NATIVE_RESOURCE_COLLECTION new_slots_occupied++; #endif // reset the live array for the next major GC cycle lock_table->live_objs[i] = 0; } else { if (FAT_LOCK(i)) { hythread_monitor_destroy(FAT_LOCK(i)); FAT_LOCK(i) = 0; } } } locktable_writer_exit(); #ifdef DEBUG_NATIVE_RESOURCE_COLLECTION CTRACE(("hythread_reclaim_resources(): old = %d, new = %d\n", old_slots_occupied, new_slots_occupied)); #endif } /* * Deletes the entry in the lock table with the given lock_id */ hythread_monitor_t locktable_delete_entry(int lock_id) { hythread_monitor_t m; DIE(("shouldn't get here")); assert(lock_id >=0 && (U_32)lock_id < lock_table->size); m = FAT_LOCK(lock_id); FAT_LOCK(lock_id) = NULL; return m; } /** * Returns the owner of the given thin monitor. * * @param[in] lockword_ptr monitor addr */ hythread_t VMCALL hythread_thin_monitor_get_owner(hythread_thin_monitor_t *lockword_ptr) { U_32 lockword; hythread_monitor_t fat_monitor; assert(lockword_ptr); lockword = *lockword_ptr; if (IS_FAT_LOCK(lockword)) { // find fat_monitor in lock table fat_monitor = locktable_get_fat_monitor(FAT_LOCK_ID(lockword)); return fat_monitor->owner; } if (THREAD_ID(lockword)== 0) { return NULL; } #ifdef LOCK_RESERVATION if (RECURSION(lockword)==0 && IS_RESERVED(lockword)) { return NULL; } #endif return hythread_get_thread(THREAD_ID(lockword)); } /** * Returns the recursion count of the given monitor. * * @param[in] lockword_ptr monitor addr */ IDATA VMCALL hythread_thin_monitor_get_recursion(hythread_thin_monitor_t *lockword_ptr) { U_32 lockword; hythread_monitor_t fat_monitor; assert(lockword_ptr); lockword = *lockword_ptr; if (IS_FAT_LOCK(lockword)) { // find fat_monitor in lock table fat_monitor = locktable_get_fat_monitor(FAT_LOCK_ID(lockword)); return fat_monitor->recursion_count+1; } if (THREAD_ID(lockword) == 0) { return 0; } #ifdef LOCK_RESERVATION if (IS_RESERVED(lockword)) { return RECURSION(lockword); } #endif return RECURSION(lockword)+1; } //@}