Changeset 690f13c for src/libcfa/concurrency

Timestamp:

Mar 28, 2017, 1:03:01 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:

72dc82a

Parents:

f32a013

Message:

First step in implementing internal scheduling

Location:

src/libcfa/concurrency

Files:

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

src/libcfa/concurrency/invoke.h

@@ -38 +38 @@
       };
 
+      struct simple_thread_stack {
+            struct thread_desc * top;
+      };
+
       #ifdef __CFORALL__
       extern "Cforall" {
@@ -43 +47 @@
             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);
@@ -74 +82 @@
             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 );
         
@@ -468 +470 @@
         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"
@@ -23 +25 @@
 
 static inline void ?{}(monitor_desc * this) {
-        this->owner = 0;
+        this->owner = NULL;
+      this->stack_owner = NULL;
         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" {
@@ -46 +54 @@
         }
 
+        // 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 );
@@ -55 +78 @@
                 this->recursion -= 1;
 
-                //If we left the last level of recursion it means we are changing who owns the monitor
+                //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;
+                }
+
+                //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;
-                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;
-                }       
+                //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 );
 
-                //If we have a new owner, we need to wake-up the thread
-                if( new_owner ) {
-                        ScheduleThread( new_owner );
-                }
+                //We need to wake-up the thread
+                ScheduleThread( new_owner );
         }
 }