Changes in / [72dc82a:936a287]

Files:

• doc/proposals/concurrency/thePlan.md (modified) (1 diff)
• src/libcfa/concurrency/invoke.h (modified) (3 diffs)
• src/libcfa/concurrency/kernel.c (modified) (2 diffs)
• src/libcfa/concurrency/monitor (modified) (2 diffs)
• src/libcfa/concurrency/monitor.c (modified) (3 diffs)

doc/proposals/concurrency/thePlan.md

@@ -10 +10 @@
 done - Multi monitors calls,
 done - Monitors as a language feature (not calling enter/leave by hand)
+Internal scheduling
 
-_Phase 3_ : Monitor features
-Internal scheduling
-External scheduling
-
-_Phase 4_ : Kernel features
+_Phase 3_ : Kernel features
 Preemption
 Detach thread
 Cluster migration
+
+_Phase 4_ : Monitor features
+External scheduling
 
 _Phase 5_ : Performance

src/libcfa/concurrency/invoke.h

@@ -38 +38 @@
       };
 
-      struct simple_thread_stack {
-            struct thread_desc * top;
-      };
-
       #ifdef __CFORALL__
       extern "Cforall" {
@@ -47 +43 @@
             void append( struct simple_thread_list *, struct thread_desc * );
             struct thread_desc * pop_head( struct simple_thread_list * );
-
-            void ?{}( struct simple_thread_stack * );
-            void push( struct simple_thread_stack *, struct thread_desc * );            
-            struct thread_desc * pop( struct simple_thread_stack * );
 
             void ?{}(spinlock * this);
@@ -82 +74 @@
             struct thread_desc * owner;
             struct simple_thread_list entry_queue;
-            struct simple_thread_stack signal_stack;
-            struct monitor_desc * stack_owner;
             unsigned int recursion;
       };

src/libcfa/concurrency/kernel.c

@@ -294 +294 @@
 // Scheduler routines
 void ScheduleThread( thread_desc * thrd ) {
-        if( !thrd ) return;
-
         assertf( thrd->next == NULL, "Expected null got %p", thrd->next );
         
@@ -470 +468 @@
         return head;
 }
-
-void ?{}( simple_thread_stack * this ) {
-        this->top = NULL;
-}
-
-void push( simple_thread_stack * this, thread_desc * t ) {
-        assert(t->next != NULL);
-        t->next = this->top;
-        this->top = t;
-}
-
-thread_desc * pop( simple_thread_stack * this ) {
-        thread_desc * top = this->top;
-        if( top ) {
-                this->top = top->next;
-                top->next = NULL;
-        }       
-        return top;
-}
 // Local Variables: //
 // mode: c //

src/libcfa/concurrency/monitor

@@ -18 +18 @@
 #define MONITOR_H
 
-#include <stddef.h>
-
 #include "assert"
 #include "invoke.h"
@@ -25 +23 @@
 
 static inline void ?{}(monitor_desc * this) {
-        this->owner = NULL;
-      this->stack_owner = NULL;
+        this->owner = 0;
         this->recursion = 0;
 }

src/libcfa/concurrency/monitor.c

@@ -18 +18 @@
 
 #include "kernel_private.h"
-
-void set_owner( monitor_desc * this, thread_desc * owner ) {
-        //Pass the monitor appropriately
-        this->owner = owner;
-
-        //We are passing the monitor to someone else, which means recursion level is not 0
-        this->recursion = owner ? 1 : 0;
-}
 
 extern "C" {
@@ -54 +46 @@
         }
 
-        // leave pseudo code :
-        //      decrement level
-        //      leve == 0 ?
-        //              no : done
-        //              yes :
-        //                      signal stack empty ?
-        //                              has leader :
-        //                                      bulk acquiring means we don't own the signal stack
-        //                                      ignore it but don't release the monitor
-        //                              yes :
-        //                                      next in entry queue is new owner
-        //                              no :
-        //                                      top of the signal stack is the owner
-        //                                      context switch to him right away
-        //
         void __leave_monitor_desc(monitor_desc * this) {
                 lock( &this->lock );
@@ -78 +55 @@
                 this->recursion -= 1;
 
-                //If we haven't left the last level of recursion
-                //it means we don't need to do anything
-                if( this->recursion != 0) {
-                        unlock( &this->lock );
-                        return;
-                }
-                        
-                //If we don't own the signal stack then just leave it to the owner
-                if( this->stack_owner ) {
-                        assert( this->owner == this->stack_owner );
-                        unlock( &this->lock );
-                        return;
-                }
+                //If we left the last level of recursion it means we are changing who owns the monitor
+                thread_desc * 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 the stack owner and have left the last recursion level.
-                //We are in charge of passing the monitor
-                thread_desc * new_owner = 0;
+                        //We are passing the monitor to someone else, which means recursion level is not 0
+                        this->recursion = new_owner ? 1 : 0;
+                }       
 
-                //Check the signaller stack
-                new_owner = pop( &this->signal_stack );
-                if( new_owner ) {
-                        //The signaller stack is not empty,
-                        //transfer control immediately
-                        set_owner( this, new_owner );
-                        ScheduleInternal( &this->lock, new_owner );
-                        return;
-                }
-                
-                // No signaller thread
-                // Get the next thread in the entry_queue
-                new_owner = pop_head( &this->entry_queue );
-                set_owner( this, new_owner );
-
-                //We can now let other threads in safely
                 unlock( &this->lock );
 
-                //We need to wake-up the thread
-                ScheduleThread( new_owner );
+                //If we have a new owner, we need to wake-up the thread
+                if( new_owner ) {
+                        ScheduleThread( new_owner );
+                }
         }
 }