/*
 *  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 <open/hythread_ext.h>
#include <apr_atomic.h>
#include <port_atomic.h>
#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;
}

//@}