Changeset cc7f4b1 for src/libcfa

Timestamp:

Feb 28, 2017, 12:40:47 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

2781e65, fd061ed3

Parents:

4868be4

Message:

• renamed monitor to monitor_t since the type should not be exposed to users
• added support for recursion in monitors

Location:

src/libcfa/concurrency

Files:

• invoke.h (modified) (2 diffs)
• monitor (modified) (1 diff)
• monitor.c (modified) (3 diffs)

src/libcfa/concurrency/invoke.h

@@ -60 +60 @@
 
       struct coStack_t {
-            unsigned int size;          // size of stack
-            void *storage;                      // pointer to stack
-            void *limit;                        // stack grows towards stack limit
-            void *base;                         // base of stack
-            void *context;                      // address of cfa_context_t
-            void *top;                          // address of top of storage
+            unsigned int size;                // size of stack
+            void *storage;                            // pointer to stack
+            void *limit;                              // stack grows towards stack limit
+            void *base;                               // base of stack
+            void *context;                            // address of cfa_context_t
+            void *top;                                // address of top of storage
             bool userStack;     
       };
@@ -73 +73 @@
       struct coroutine {
             struct coStack_t stack;
-            const char *name;                   // textual name for coroutine/task, initialized by uC++ generated code
-            int errno_;                         // copy of global UNIX variable errno
-            enum coroutine_state state; // current execution status for coroutine
-            struct coroutine *starter;  // first coroutine to resume this one
-            struct coroutine *last;             // last coroutine to resume this one
+            const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
+            int errno_;                               // copy of global UNIX variable errno
+            enum coroutine_state state;       // current execution status for coroutine
+            struct coroutine *starter;        // first coroutine to resume this one
+            struct coroutine *last;                   // last coroutine to resume this one
       };
 
       struct thread {
-            struct coroutine c;           // coroutine body used to store context
-            struct signal_once terminated;// indicate if execuation state is not halted
-            struct thread * next;         // instrusive link field for threads
+            struct coroutine c;                 // coroutine body used to store context
+            struct signal_once terminated;      // indicate if execuation state is not halted
+            struct thread * next;               // instrusive link field for threads
       };
 

src/libcfa/concurrency/monitor

@@ -21 +21 @@
 #include "invoke.h"
 
-struct monitor {
+struct __monitor_t {
         spinlock lock;
-        thread * holder;
+        thread * owner;
         simple_thread_list entry_queue;
+        unsigned int recursion;
 };
 
-void enter(monitor *);
-void leave(monitor *);
+static inline void ?{}(__monitor_t * this) {
+        this->owner = 0;
+        this->recursion = 0;
+}
 
-struct monitor_guard {
-        monitor * m;
+void enter(__monitor_t *);
+void leave(__monitor_t *);
+
+struct monitor_guard_t {
+        __monitor_t * m;
 };
 
-static inline void ?{}( monitor_guard * this, monitor * m ) {
+static inline void ?{}( monitor_guard_t * this, __monitor_t * m ) {
         this->m = m;
         enter( this->m );
 }
 
-static inline void ^?{}( monitor_guard * this ) {
+static inline void ^?{}( monitor_guard_t * this ) {
         leave( this->m );
 }

src/libcfa/concurrency/monitor.c

@@ -6 +6 @@
 // file "LICENCE" distributed with Cforall.
 //
-// monitor.c --
+// __monitor_t.c --
 //
 // Author           : Thierry Delisle
@@ -19 +19 @@
 #include "kernel_private.h"
 
-void enter(monitor * this) {
+void enter(__monitor_t * this) {
         lock( &this->lock );
         thread * thrd = this_thread();
 
-        if( this->holder ) {
+        if( !this->owner ) {
+                //No one has the monitor, just take it
+                this->owner = thrd;
+                this->recursion = 1;
+        }
+        else if( this->owner == thrd) {
+                //We already have the monitor, just not how many times we took it
+                assert( this->recursion > 0 );
+                this->recursion += 1;
+        }
+        else {
+                //Some one else has the monitor, wait in line for it
                 append( &this->entry_queue, thrd );
                 ScheduleInternal( &this->lock );
-                return;
-        }
-        else {
-                this->holder = thrd;
+
+                //ScheduleInternal will unlock spinlock, no need to unlock ourselves
+                return; 
         }
 
@@ -35 +45 @@
 }
 
-void leave(monitor * this) {
+void leave(__monitor_t * this) {
         lock( &this->lock );
 
         thread * thrd = this_thread();
-        assert( thrd == this->holder );
+        assert( thrd == this->owner );
 
-        this->holder = pop_head( &this->entry_queue );
+        //Leaving a recursion level, decrement the counter
+        this->recursion -= 1;
+
+        //If we left the last level of recursion it means we are changing who owns the monitor
+        thread * new_owner = 0;
+        if( this->recursion == 0) {
+                //Get the next thread in the list
+                new_owner = this->owner = pop_head( &this->entry_queue );
+
+                //We are passing the monitor to someone else, which means recursion level is not 0
+                this->recursion = new_owner ? 1 : 0;
+        }       
 
         unlock( &this->lock );
 
-        if( this->holder ) ScheduleThread( this->holder );
+        //If we have a new owner, we need to wake-up the thread
+        if( new_owner ) {
+                ScheduleThread( new_owner );
+        }
 }