* src/threads/native/lock.c (lock_init_thread_lock_record_pool):

Renamed to lock_init_execution_env. Cleanup and Comments.

* src/threads/native/lock.h (lock_init_thread_lock_record_pool):
Renamed to lock_init_execution_env.

* src/threads/native/threads.c (lock_init_thread_lock_record_pool):
Renamed to lock_init_execution_env.

diff --git a/src/threads/native/lock.c b/src/threads/native/lock.c
index 1cf54330e38047b1ac9f29b1ca6cb3789aa7a3f4..61c323844832c2df449eefb525f13d00dc8b892b 100644 (file)
--- a/src/threads/native/lock.c
+++ b/src/threads/native/lock.c
@@ -126,6 +126,12 @@ pthread_mutex_t lock_global_pool_lock;
 lock_record_pool_t *lock_global_pool;
 
 
+
+/*============================================================================*/
+/* INITIALIZATION OF DATA STRUCTURES                                          */
+/*============================================================================*/
+
+
 /* lock_init *******************************************************************
 
    Initialize global data for locking.
@@ -172,16 +178,16 @@ static void lock_record_init(lock_record_t *r, threadobject *t)
 }
 
 
-/* lock_init_thread_lock_record_pool *******************************************
+/* lock_init_execution_env *****************************************************
 
-   Initialize the lock record pool(s) for a thread.
+   Initialize the execution environment for a thread.
 
    IN:
       thread.......the thread
 
 *******************************************************************************/
 
-void lock_init_thread_lock_record_pool(threadobject *thread)
+void lock_init_execution_env(threadobject *thread)
 {
        thread->ee.firstLR = NULL;
        thread->ee.lrpool = NULL;
@@ -189,6 +195,12 @@ void lock_init_thread_lock_record_pool(threadobject *thread)
 }
 
 
+
+/*============================================================================*/
+/* LOCK RECORD MANAGEMENT                                                     */
+/*============================================================================*/
+
+
 /* lock_record_alloc_new_pool **************************************************
 
    Get a new lock record pool from the memory allocator.
@@ -204,7 +216,7 @@ void lock_init_thread_lock_record_pool(threadobject *thread)
 
 static lock_record_pool_t *lock_record_alloc_new_pool(threadobject *thread, int size)
 {
-       lock_record_pool_t *p = mem_alloc(sizeof(lock_record_pool_header_t) 
+       lock_record_pool_t *p = mem_alloc(sizeof(lock_record_pool_header_t)
                                                                                + sizeof(lock_record_t) * size);
        int i;
 
@@ -235,10 +247,12 @@ static lock_record_pool_t *lock_record_alloc_new_pool(threadobject *thread, int
 static lock_record_pool_t *lock_record_alloc_pool(threadobject *t, int size)
 {
        pthread_mutex_lock(&lock_global_pool_lock);
+
        if (lock_global_pool) {
                int i;
                lock_record_pool_t *pool = lock_global_pool;
                lock_global_pool = pool->header.next;
+
                pthread_mutex_unlock(&lock_global_pool_lock);
 
                for (i=0; i < pool->header.size; i++) {
@@ -249,6 +263,7 @@ static lock_record_pool_t *lock_record_alloc_pool(threadobject *t, int size)
 
                return pool;
        }
+
        pthread_mutex_unlock(&lock_global_pool_lock);
 
        return lock_record_alloc_new_pool(t, size);
@@ -267,12 +282,15 @@ static lock_record_pool_t *lock_record_alloc_pool(threadobject *t, int size)
 void lock_record_free_pools(lock_record_pool_t *pool)
 {
        lock_record_pool_header_t *last;
+
        pthread_mutex_lock(&lock_global_pool_lock);
+
        last = &pool->header;
        while (last->next)
                last = &last->next->header;
        last->next = lock_global_pool;
        lock_global_pool = pool;
+
        pthread_mutex_unlock(&lock_global_pool_lock);
 }
 
@@ -333,6 +351,12 @@ static inline void lock_record_recycle(threadobject *t, lock_record_t *r)
 }
 
 
+
+/*============================================================================*/
+/* OBJECT LOCK INITIALIZATION                                                 */
+/*============================================================================*/
+
+
 /* lock_init_object_lock *******************************************************
 
    Initialize the monitor pointer of the given object. The monitor gets
@@ -362,6 +386,12 @@ lock_record_t *lock_get_initial_lock_word(void)
 }
 
 
+
+/*============================================================================*/
+/* LOCKING ALGORITHM                                                          */
+/*============================================================================*/
+
+
 /* lock_queue_on_lock_record ***************************************************
 
    Suspend the current thread and queue it on the given lock record.
@@ -434,7 +464,7 @@ lock_record_t *lock_monitor_enter(threadobject *t, java_objectheader *o)
                        /* the lock record does not lock this object */
                        lock_record_t *nlr;
                        lock_record_t *mlr;
-                  
+
                        /* allocate a new lock record for this object */
                        mlr     = lock_record_alloc(t);
                        mlr->o = o;
@@ -449,7 +479,7 @@ lock_record_t *lock_monitor_enter(threadobject *t, java_objectheader *o)
                                        lock_handle_waiter(mlr, lr, o);
                                        return mlr;
                                }
-                       } 
+                       }
                        else {
                                /* no, it's another lock record */
                                /* if we don't own the old record, set incharge XXX */
@@ -483,7 +513,7 @@ lock_record_t *lock_monitor_enter(threadobject *t, java_objectheader *o)
                        lock_record_release(mlr);
                        lock_record_recycle(t, mlr);
                        lock_queue_on_lock_record(nlr, o);
-               } 
+               }
                else {
                        /* the lock record is for the object we want */
 
@@ -602,7 +632,7 @@ bool lock_monitor_exit(threadobject *t, java_objectheader *o)
 *******************************************************************************/
 
 static void lock_record_remove_waiter(lock_record_t *lr,
-                                                                         lock_record_t *toremove)
+                                                                         lock_record_t *toremove)
 {
        do {
                if (lr->waiter == toremove) {
@@ -729,6 +759,12 @@ static void lock_monitor_notify(threadobject *t, java_objectheader *o, bool one)
 }
 
 
+
+/*============================================================================*/
+/* INQUIRY FUNCIONS                                                           */
+/*============================================================================*/
+
+
 /* lock_does_thread_hold_lock **************************************************
 
    Return true if the given thread owns the monitor of the given object.
@@ -753,6 +789,12 @@ bool lock_does_thread_hold_lock(threadobject *t, java_objectheader *o)
 }
 
 
+
+/*============================================================================*/
+/* WRAPPERS FOR OPERATIONS ON THE CURRENT THREAD                              */
+/*============================================================================*/
+
+
 /* lock_wait_for_object ********************************************************
 
    Wait for the given object.

diff --git a/src/threads/native/lock.h b/src/threads/native/lock.h
index 378a6b9b40ee6465333070cd4828919399df68f5..e38d26663c88416e1fcbe2ee16692bc53bcaa48f 100644 (file)
--- a/src/threads/native/lock.h
+++ b/src/threads/native/lock.h
@@ -126,7 +126,7 @@ void lock_notify_all_object(java_objectheader *o);
 void lock_init_object_lock(java_objectheader *);
 lock_record_t *lock_get_initial_lock_word(void);
 
-void lock_init_thread_lock_record_pool(struct threadobject *thread);
+void lock_init_execution_env(struct threadobject *thread);
 void lock_record_free_pools(lock_record_pool_t *pool);
 
 #endif /* _LOCK_H */

diff --git a/src/threads/native/threads.c b/src/threads/native/threads.c
index 094099a5ccdd9f7e9009bfc6ccd4f412db3b46d9..69088d5694054f1079799d72e5af383fac5418e1 100644 (file)
--- a/src/threads/native/threads.c
+++ b/src/threads/native/threads.c
@@ -29,7 +29,7 @@
    Changes: Christian Thalinger
                        Edwin Steiner
 
-   $Id: threads.c 4909 2006-05-13 23:10:21Z edwin $
+   $Id: threads.c 4910 2006-05-13 23:25:20Z edwin $
 
 */
 
@@ -664,7 +664,7 @@ bool threads_init(u1 *stackbottom)
 
        threads_set_current_threadobject(mainthreadobj);
 
-       lock_init_thread_lock_record_pool(mainthreadobj);
+       lock_init_execution_env(mainthreadobj);
 
        mainthreadobj->info.next = mainthreadobj;
        mainthreadobj->info.prev = mainthreadobj;
@@ -845,7 +845,7 @@ static void *threads_startup_thread(void *t)
 
        /* init data structures of this thread */
 
-       lock_init_thread_lock_record_pool(thread);
+       lock_init_execution_env(thread);
 
        /* tell threads_startup_thread that we registered ourselves */
        /* CAUTION: *startup becomes invalid with this!             */