Changes in / [3febb2d:7d651a6]

Location:

libcfa/src/concurrency

Files:

• alarm.cfa (modified) (2 diffs)
• alarm.hfa (modified) (3 diffs)
• locks.cfa (modified) (13 diffs)
• locks.hfa (modified) (5 diffs)
• preemption.cfa (modified) (1 diff)

libcfa/src/concurrency/alarm.cfa

@@ -45 +45 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period) with( this ) {
+void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period ) with( this ) {
         this.thrd = thrd;
         this.alarm = alarm;
         this.period = period;
         set = false;
-        type = User;
+        kernel_alarm = false;
 }
 
@@ -58 +58 @@
         this.period = period;
         set = false;
-        type = Kernel;
-}
-void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback ) with( this ) {
-        this.thrd = thrd;
-        this.alarm = alarm;
-        this.period = period;
-        this.callback = callback;
-        set = false;
-        type = Callback;
+        kernel_alarm = true;
 }
 

libcfa/src/concurrency/alarm.hfa

@@ -39 +39 @@
 //=============================================================================================
 
-enum alarm_type{ Kernel = 0, User = 1, Callback = 2 };
-
-struct alarm_node_t;
-
-typedef void (*Alarm_Callback)(alarm_node_t & );
-
 struct alarm_node_t {
         Time alarm;                             // time when alarm goes off
@@ -56 +50 @@
         };
 
-        Alarm_Callback callback;
-
         bool set                :1;             // whether or not the alarm has be registered
-        enum alarm_type type;           // true if this is not a user defined alarm
+        bool kernel_alarm       :1;             // true if this is not a user defined alarm
 };
 DLISTED_MGD_IMPL_OUT(alarm_node_t)
@@ -65 +57 @@
 void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period );
 void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period );
-void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback );
 void ^?{}( alarm_node_t & this );
 

libcfa/src/concurrency/locks.cfa

@@ -15 +15 @@
                 this.t = t;
                 this.lock = 0p;
-                this.listed = false;
         }
 
@@ -22 +21 @@
                 this.info = info;
                 this.lock = 0p;
-                this.listed = false;
         }
 
@@ -79 +77 @@
         if ( owner == kernelTLS.this_thread && !multi_acquisition) {
                 fprintf(stderr, "A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock."); // Possibly throw instead
-        exit(EXIT_FAILURE);
+                exit(EXIT_FAILURE);
         } else if ( owner != 0p && owner != kernelTLS.this_thread ) {
                 append( blocked_threads, kernelTLS.this_thread );
                 wait_count++;
                 unlock( lock );
-                park( );
+                park( __cfaabi_dbg_ctx );
         } else if ( owner == kernelTLS.this_thread && multi_acquisition ) {
                 recursion_count++;
@@ -113 +111 @@
         lock( lock __cfaabi_dbg_ctx2 );
         if ( owner == 0p ){ // no owner implies lock isn't held
-                fprintf( stderr, "There was an attempt to release a lock that isn't held" ); 
+                fprintf( stderr, "There was an attempt to release a lock that isn't held" );
                 return;
         } else if ( strict_owner && owner != kernelTLS.this_thread ) {
-                fprintf( stderr, "A thread other than the owner attempted to release an owner lock" ); 
+                fprintf( stderr, "A thread other than the owner attempted to release an owner lock" );
                 return;
         }
@@ -125 +123 @@
                 recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
                 wait_count--;
-                unpark( thrd );
+                unpark( thrd __cfaabi_dbg_ctx2 );
         }
         unlock( lock );
@@ -152 +150 @@
                 owner = t;
                 if ( multi_acquisition ) recursion_count = 1;
-                #if !defined( __CFA_NO_STATISTICS__ )
-                        kernelTLS.this_stats = t->curr_cluster->stats;
-                #endif
-                unpark( t );
+                unpark( t __cfaabi_dbg_ctx2 );
                 unlock( lock );
         }
@@ -163 +158 @@
     lock( lock __cfaabi_dbg_ctx2 );
         if ( owner == 0p ){ // no owner implies lock isn't held
-                fprintf( stderr, "A lock that is not held was passed to a synchronization lock" ); 
+                fprintf( stderr, "A lock that is not held was passed to a synchronization lock" );
         } else if ( strict_owner && owner != kernelTLS.this_thread ) {
-                fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" ); 
+                fprintf( stderr, "A thread other than the owner of a lock passed it to a synchronization lock" );
         } else {
                 $thread * thrd = pop_head( blocked_threads );
@@ -171 +166 @@
                 recursion_count = ( thrd && multi_acquisition ? 1 : 0 );
                 wait_count--;
-                unpark( thrd );
+                unpark( thrd __cfaabi_dbg_ctx2 );
         }
         unlock( lock );
@@ -180 +175 @@
 ///////////////////////////////////////////////////////////////////
 
-// This is temporary until an inheritance bug is fixed
+// In an ideal world this may not be necessary
+// Is it possible for nominal inheritance to inherit traits??
+// If that occurs we would avoid all this extra code
 
 void lock( mutex_lock & this ){
@@ -231 +228 @@
 
 ///////////////////////////////////////////////////////////////////
-//// condition variable
+//// Synchronization Locks
 ///////////////////////////////////////////////////////////////////
 
 forall(dtype L | is_blocking_lock(L)) {
-
-        void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
-        // This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
-            lock( cond->lock __cfaabi_dbg_ctx2 );
-            if ( (*i)->listed ) {                       // is thread on queue
-                info_thread(L) * copy = *i;
-                        remove( cond->blocked_threads, i );              //remove this thread O(1)
-                        cond->wait_count--;
-                        if( !copy->lock ) {
-                                unlock( cond->lock );
-                                #if !defined( __CFA_NO_STATISTICS__ )
-                                        kernelTLS.this_stats = copy->t->curr_cluster->stats;
-                                #endif
-                                unpark( copy->t );
-                } else {
-                        add_(*copy->lock, copy->t);                     // call lock's add_
-                }
-            }
-            unlock( cond->lock );
-        }
-
-        void alarm_node_wrap_cast( alarm_node_t & a ) {
-                timeout_handler( (alarm_node_wrap(L) &)a );
-        }
-
-        void ?{}( condition_variable(L) & this ){
+        void ?{}( synchronization_lock(L) & this, bool reacquire_after_signal ){
                 this.lock{};
                 this.blocked_threads{};
                 this.count = 0;
+                this.reacquire_after_signal = reacquire_after_signal;
+        }
+
+        void ^?{}( synchronization_lock(L) & this ){
+                // default
+        }
+
+        void ?{}( condition_variable(L) & this ){
+                ((synchronization_lock(L) &)this){ true };
         }
 
@@ -270 +251 @@
         }
 
-        void ?{}( alarm_node_wrap(L) & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback ) {
-                this.alarm_node{ thrd, alarm, period, callback };
-        }
-
-        void ^?{}( alarm_node_wrap(L) & this ) {
-                // default
-        }
-
-        bool notify_one( condition_variable(L) & this ) with( this ) {
+        void ?{}( thread_queue(L) & this ){
+                ((synchronization_lock(L) &)this){ false };
+        }
+
+        void ^?{}( thread_queue(L) & this ){
+                // default
+        }
+
+        bool notify_one( synchronization_lock(L) & this ) with( this ) {
                 lock( lock __cfaabi_dbg_ctx2 );
                 bool ret = !!blocked_threads;
                 info_thread(L) * popped = pop_head( blocked_threads );
-                popped->listed = false;
                 if(popped != 0p) {
-                        count--;
-                        if (popped->lock) {
+                        if( reacquire_after_signal ){
                                 add_(*popped->lock, popped->t);
                         } else {
-                                unpark(popped->t);
+                                unpark(
+                                        popped->t __cfaabi_dbg_ctx2
+                                );
                         }
                 }
@@ -295 +276 @@
         }
 
-        bool notify_all( condition_variable(L) & this ) with(this) {
+        bool notify_all( synchronization_lock(L) & this ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
                 bool ret = blocked_threads ? true : false;
                 while( blocked_threads ) {
                         info_thread(L) * popped = pop_head( blocked_threads );
-                        popped->listed = false;
                         if(popped != 0p){
-                                count--;
-                                if (popped->lock) {
+                                if( reacquire_after_signal ){
                                         add_(*popped->lock, popped->t);
                                 } else {
-                                        unpark(popped->t);
+                                        unpark(
+                                                popped->t __cfaabi_dbg_ctx2
+                                        );
                                 }
                         }
@@ -314 +295 @@
         }
 
-        uintptr_t front( condition_variable(L) & this ) with(this) {
-                if(!blocked_threads) return NULL;
-                return peek(blocked_threads)->info;
-        }
-
-        bool empty( condition_variable(L) & this ) with(this) {
+        uintptr_t front( synchronization_lock(L) & this ) with(this) {
+                return (*peek(blocked_threads)).info;
+        }
+
+        bool empty( synchronization_lock(L) & this ) with(this) {
                 return blocked_threads ? false : true;
         }
 
-        int counter( condition_variable(L) & this ) with(this) {
+        int counter( synchronization_lock(L) & this ) with(this) {
                 return count;
         }
 
-        // helper for wait()'s' without a timeout
-        void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
+        void queue_info_thread( synchronization_lock(L) & this, info_thread(L) & i ) with(this) {
+                lock( lock __cfaabi_dbg_ctx2 );
+                append( blocked_threads, &i );
+                count++;
+                unlock( lock );
+                park( __cfaabi_dbg_ctx );
+        }
+
+
+        void wait( synchronization_lock(L) & this ) with(this) {
+                info_thread( L ) i = { kernelTLS.this_thread };
+                queue_info_thread( this, i );
+        }
+
+        void wait( synchronization_lock(L) & this, uintptr_t info ) with(this) {
+                info_thread( L ) i = { kernelTLS.this_thread, info };
+                queue_info_thread( this, i );
+        }
+        // I still need to implement the time delay wait routines
+        bool wait( synchronization_lock(L) & this, Duration duration ) with(this) {
+                timeval tv = { time(0) };
+                Time t = { tv };
+                return wait( this, t + duration );
+        }
+
+        bool wait( synchronization_lock(L) & this, uintptr_t info, Duration duration ) with(this) {
+                // TODO: ADD INFO
+                return wait( this, duration );
+        }
+
+        bool wait( synchronization_lock(L) & this, Time time ) with(this) {
+                return false; //default
+        }
+
+        bool wait( synchronization_lock(L) & this, uintptr_t info, Time time ) with(this) {
+                // TODO: ADD INFO
+                return wait( this, time );
+        }
+
+        void queue_info_thread_unlock( synchronization_lock(L) & this, L & l, info_thread(L) & i ) with(this) {
                 lock( lock __cfaabi_dbg_ctx2 );
                 append( this.blocked_threads, &i );
                 count++;
-                i.listed = true;
-                size_t recursion_count;
-                if (i.lock) {
-                        recursion_count = get_recursion_count(*i.lock);
-                        remove_( *i.lock );
-                }
-                
-                unlock( lock );
-                park( ); // blocks here
-
-                if (i.lock) set_recursion_count(*i.lock, recursion_count); // resets recursion count here after waking
-        }
-
-        // helper for wait()'s' with a timeout
-        void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Time t ) with(this) {
-                lock( lock __cfaabi_dbg_ctx2 );
-
-                info_thread(L) * queue_ptr = &info;
-
-                alarm_node_wrap(L) node_wrap = { info.t, t, 0`s, alarm_node_wrap_cast };
-                node_wrap.cond = &this;
-                node_wrap.i = &queue_ptr;
-
-                register_self( &node_wrap.alarm_node );
-
-                append( blocked_threads, queue_ptr );
-                info.listed = true;
-                count++;
-
-                size_t recursion_count;
-                if (info.lock) {
-                        recursion_count = get_recursion_count(*info.lock);
-                        remove_( *info.lock );
-                }
-
-                unlock( lock );
-                park();
-
-                if (info.lock) set_recursion_count(*info.lock, recursion_count);
-        }
-
-        void wait( condition_variable(L) & this ) with(this) {
-                info_thread( L ) i = { kernelTLS.this_thread };
-                queue_info_thread( this, i );
-        }
-
-        void wait( condition_variable(L) & this, uintptr_t info ) with(this) {
-                info_thread( L ) i = { kernelTLS.this_thread, info };
-                queue_info_thread( this, i );
-        }
-        
-        void wait( condition_variable(L) & this, Duration duration ) with(this) {
-                info_thread( L ) i = { kernelTLS.this_thread };
-                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-        }
-
-        void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { 
-                info_thread( L ) i = { kernelTLS.this_thread, info };
-                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-        }
-
-        void wait( condition_variable(L) & this, Time time ) with(this) {
-                info_thread( L ) i = { kernelTLS.this_thread };
-                queue_info_thread_timeout(this, i, time);
-        }
-
-        void wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) {
-                info_thread( L ) i = { kernelTLS.this_thread, info };
-                queue_info_thread_timeout(this, i, time);
-        }
-
-        void wait( condition_variable(L) & this, L & l ) with(this) {
+                i.lock = &l;
+                size_t recursion_count = get_recursion_count(l);
+                remove_( l );
+                unlock( lock );
+                park( __cfaabi_dbg_ctx ); // blocks here
+
+                set_recursion_count(l, recursion_count); // resets recursion count here after waking
+        }
+
+        void wait( synchronization_lock(L) & this, L & l ) with(this) {
                 info_thread(L) i = { kernelTLS.this_thread };
-                i.lock = &l;
-                queue_info_thread( this, i );
-        }
-
-        void wait( condition_variable(L) & this, L & l, uintptr_t info ) with(this) {
+                queue_info_thread_unlock( this, l, i );
+        }
+
+        void wait( synchronization_lock(L) & this, L & l, uintptr_t info ) with(this) {
                 info_thread(L) i = { kernelTLS.this_thread, info };
-                i.lock = &l;
-                queue_info_thread( this, i );
-        }
-        
-        void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
-                info_thread(L) i = { kernelTLS.this_thread };
-                i.lock = &l;
-                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-        }
-        
-        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
-                info_thread(L) i = { kernelTLS.this_thread, info };
-                i.lock = &l;
-                queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-        }
-        
-        void wait( condition_variable(L) & this, L & l, Time time ) with(this) {
-                info_thread(L) i = { kernelTLS.this_thread };
-                i.lock = &l;
-                queue_info_thread_timeout(this, i, time );
-        }
-        
-        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
-                info_thread(L) i = { kernelTLS.this_thread, info };
-                i.lock = &l;
-                queue_info_thread_timeout(this, i, time );
-        }
-}
+                queue_info_thread_unlock( this, l, i );
+        }
+
+        bool wait( synchronization_lock(L) & this, L & l, Duration duration ) with(this) {
+                timeval tv = { time(0) };
+                Time t = { tv };
+                return wait( this, l, t + duration );
+        }
+
+        bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
+                // TODO: ADD INFO
+                return wait( this, l, duration );
+        }
+
+        bool wait( synchronization_lock(L) & this, L & l, Time time ) with(this) {
+                return false; //default
+        }
+
+        bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Time time ) with(this) {
+                // TODO: ADD INFO
+                return wait( this, l, time );
+        }
+}
+
+///////////////////////////////////////////////////////////////////
+//// condition lock alternative approach
+///////////////////////////////////////////////////////////////////
+
+// the solution below is less efficient but does not require the lock to have a specific add/remove routine
+
+///////////////////////////////////////////////////////////////////
+//// is_simple_lock
+///////////////////////////////////////////////////////////////////
+
+forall(dtype L | is_simple_lock(L)) {
+        void ?{}( condition_lock(L) & this ){
+                // default
+        }
+
+        void ^?{}( condition_lock(L) & this ){
+                // default
+        }
+
+        bool notify_one( condition_lock(L) & this ) with(this) {
+                return notify_one( c_var );
+        }
+
+        bool notify_all( condition_lock(L) & this ) with(this) {
+                return notify_all( c_var );
+        }
+
+        void wait( condition_lock(L) & this, L & l ) with(this) {
+                lock( m_lock );
+                size_t recursion = get_recursion_count( l );
+                unlock( l );
+                wait( c_var, m_lock );
+                lock( l );
+                set_recursion_count( l , recursion );
+                unlock( m_lock );
+        }
+}

libcfa/src/concurrency/locks.hfa

@@ -1 @@
-#pragma once
-
 #include <stdbool.h>
 
@@ -12 +10 @@
 #include "time.hfa"
 #include <sys/time.h>
-#include "alarm.hfa"
 
 ///////////////////////////////////////////////////////////////////
@@ -35 +32 @@
                 info_thread(L) * next;
                 L * lock;
-                bool listed;                                    // true if info_thread is on queue, false otherwise;
         };
 
@@ -123 +119 @@
 ///////////////////////////////////////////////////////////////////
 forall(dtype L | is_blocking_lock(L)) {
-        struct condition_variable {
+        struct synchronization_lock {
                 // Spin lock used for mutual exclusion
                 __spinlock_t lock;
@@ -132 +128 @@
                 // Count of current blocked threads
                 int count;
-        };
+
+                // If true threads will reacquire the lock they block on upon waking
+                bool reacquire_after_signal;
+        };
+
+        struct condition_variable {
+                inline synchronization_lock(L);
+        };
+
+        struct thread_queue {
+                inline synchronization_lock(L);
+        };
+
+
+        void ?{}( synchronization_lock(L) & this, bool multi_acquisition, bool strict_owner );
+        void ^?{}( synchronization_lock(L) & this );
 
         void ?{}( condition_variable(L) & this );
         void ^?{}( condition_variable(L) & this );
 
-        struct alarm_node_wrap {
-                alarm_node_t alarm_node;
-
-                condition_variable(L) * cond;
-
-                info_thread(L) ** i;
-        };
-
-        void ?{}( alarm_node_wrap(L) & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback );
-        void ^?{}( alarm_node_wrap(L) & this );
-
-        void alarm_node_callback( alarm_node_wrap(L) & this );
-
-        void alarm_node_wrap_cast( alarm_node_t & a );
-
-        bool notify_one( condition_variable(L) & this );
-        bool notify_all( condition_variable(L) & this );
-
-        uintptr_t front( condition_variable(L) & this );
-
-        bool empty( condition_variable(L) & this );
-        int counter( condition_variable(L) & this );
-
-        // TODO: look into changing timout routines to return bool showing if signalled or woken by kernel
-        void wait( condition_variable(L) & this );
-        void wait( condition_variable(L) & this, uintptr_t info );
-        void wait( condition_variable(L) & this, Duration duration );
-        void wait( condition_variable(L) & this, uintptr_t info, Duration duration );
-        void wait( condition_variable(L) & this, Time time );
-        void wait( condition_variable(L) & this, uintptr_t info, Time time );
-
-        void wait( condition_variable(L) & this, L & l );
-        void wait( condition_variable(L) & this, L & l, uintptr_t info );
-        void wait( condition_variable(L) & this, L & l, Duration duration );
-        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
-        void wait( condition_variable(L) & this, L & l, Time time );
-        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
+        void ?{}( thread_queue(L) & this );
+        void ^?{}( thread_queue(L) & this );
+
+        bool notify_one( synchronization_lock(L) & this );
+        bool notify_all( synchronization_lock(L) & this );
+
+        uintptr_t front( synchronization_lock(L) & this );
+
+        bool empty( synchronization_lock(L) & this );
+        int counter( synchronization_lock(L) & this );
+
+        // wait functions that are not passed a mutex lock
+        void wait( synchronization_lock(L) & this );
+        void wait( synchronization_lock(L) & this, uintptr_t info );
+        bool wait( synchronization_lock(L) & this, Duration duration );
+        bool wait( synchronization_lock(L) & this, uintptr_t info, Duration duration );
+        bool wait( synchronization_lock(L) & this, Time time );
+        bool wait( synchronization_lock(L) & this, uintptr_t info, Time time );
+
+        // wait functions that are passed a lock
+        bool notify_one( synchronization_lock(L) & this, L & l );
+        bool notify_all( synchronization_lock(L) & this, L & l );
+
+        void wait( synchronization_lock(L) & this, L & l );
+        void wait( synchronization_lock(L) & this, L & l, uintptr_t info );
+        bool wait( synchronization_lock(L) & this, L & l, Duration duration );
+        bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Duration duration );
+        bool wait( synchronization_lock(L) & this, L & l, Time time );
+        bool wait( synchronization_lock(L) & this, L & l, uintptr_t info, Time time );
 }
+
+///////////////////////////////////////////////////////////////////
+//// condition lock alternative approach
+///////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////
+//// is_simple_lock
+///////////////////////////////////////////////////////////////////
+
+trait is_simple_lock(dtype L | sized(L)) {
+        void lock( L & );               // For synchronization locks to use when acquiring
+        void unlock( L & );    // For synchronization locks to use when releasing
+        size_t get_recursion_count( L & ); // to get recursion count for cond lock to reset after waking
+        void set_recursion_count( L &, size_t recursion ); // to set recursion count after getting signalled;
+};
+
+forall(dtype L | is_simple_lock(L)) {
+        struct condition_lock {
+                // Spin lock used for mutual exclusion
+                mutex_lock m_lock;
+
+                condition_variable( mutex_lock ) c_var;
+        };
+
+        void ?{}( condition_lock(L) & this );
+        void ^?{}( condition_lock(L) & this );
+
+        bool notify_one( condition_lock(L) & this );
+        bool notify_all( condition_lock(L) & this );
+        void wait( condition_lock(L) & this, L & l );
+}

libcfa/src/concurrency/preemption.cfa

@@ -105 +105 @@
 
                 // Check if this is a kernel
-                if( node->type == Kernel ) {
+                if( node->kernel_alarm ) {
                         preempt( node->proc );
                 }
-                else if( node->type == User ) {
+                else {
                         timeout( node->thrd );
-                }
-                else {
-                        node->callback(*node);
                 }