Changes in / [a505021:c744563a]

Files:

• libcfa/src/bits/containers.hfa (modified) (2 diffs)
• libcfa/src/bits/locks.hfa (modified) (4 diffs)
• libcfa/src/concurrency/coroutine.hfa (modified) (3 diffs)
• libcfa/src/concurrency/invoke.h (modified) (4 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (18 diffs)
• libcfa/src/concurrency/kernel.hfa (modified) (4 diffs)
• libcfa/src/concurrency/kernel_private.hfa (modified) (3 diffs)
• libcfa/src/concurrency/monitor.cfa (modified) (19 diffs)
• libcfa/src/concurrency/monitor.hfa (modified) (1 diff)
• libcfa/src/concurrency/mutex.cfa (modified) (8 diffs)
• libcfa/src/concurrency/preemption.cfa (modified) (4 diffs)
• libcfa/src/concurrency/thread.cfa (modified) (4 diffs)
• libcfa/src/concurrency/thread.hfa (modified) (2 diffs)
• tests/concurrent/examples/.expect/datingService.txt (modified) (1 diff)
• tests/concurrent/examples/datingService.cfa (modified) (3 diffs)
• tests/concurrent/multi-monitor.cfa (modified) (1 diff)
• tests/concurrent/park/.expect/contention.txt (deleted)
• tests/concurrent/park/.expect/force_preempt.txt (deleted)
• tests/concurrent/park/contention.cfa (deleted)
• tests/concurrent/park/force_preempt.cfa (deleted)

libcfa/src/bits/containers.hfa

@@ -146 +146 @@
         static inline forall( dtype T | is_node(T) ) {
                 void ?{}( __queue(T) & this ) with( this ) {
-                        head{ 1p };
+                        head{ 0p };
                         tail{ &head };
-                        verify(*tail == 1p);
                 }
 
                 void append( __queue(T) & this, T * val ) with( this ) {
                         verify(tail != 0p);
-                        verify(*tail == 1p);
                         *tail = val;
                         tail = &get_next( *val );
-                        *tail = 1p;
                 }
 
                 T * pop_head( __queue(T) & this ) {
-                        verify(*this.tail == 1p);
                         T * head = this.head;
-                        if( head != 1p ) {
+                        if( head ) {
                                 this.head = get_next( *head );
-                                if( get_next( *head ) == 1p ) {
+                                if( !get_next( *head ) ) {
                                         this.tail = &this.head;
                                 }
                                 get_next( *head ) = 0p;
-                                verify(*this.tail == 1p);
-                                return head;
-                        }
-                        verify(*this.tail == 1p);
-                        return 0p;
+                        }
+                        return head;
                 }
 
@@ -187 +180 @@
                         get_next( *val ) = 0p;
 
-                        verify( (head == 1p) == (&head == tail) );
-                        verify( *tail == 1p );
+                        verify( (head == 0p) == (&head == tail) );
+                        verify( *tail == 0p );
                         return val;
                 }

libcfa/src/bits/locks.hfa

@@ -60 +60 @@
         }
 
+        extern void yield( unsigned int );
+
         static inline void ?{}( __spinlock_t & this ) {
                 this.lock = 0;
@@ -66 +68 @@
         // Lock the spinlock, return false if already acquired
         static inline bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
-                disable_interrupts();
                 bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0);
                 if( result ) {
+                        disable_interrupts();
                         __cfaabi_dbg_record( this, caller );
-                } else {
-                        enable_interrupts_noPoll();
                 }
                 return result;
@@ -83 +83 @@
                 #endif
 
-                disable_interrupts();
                 for ( unsigned int i = 1;; i += 1 ) {
                         if ( (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0) ) break;
@@ -99 +98 @@
                         #endif
                 }
+                disable_interrupts();
                 __cfaabi_dbg_record( this, caller );
         }
 
         static inline void unlock( __spinlock_t & this ) {
+                enable_interrupts_noPoll();
                 __atomic_clear( &this.lock, __ATOMIC_RELEASE );
-                enable_interrupts_noPoll();
         }
 

libcfa/src/concurrency/coroutine.hfa

@@ -54 +54 @@
 void prime(T & cor);
 
-static inline struct coroutine_desc * active_coroutine() __attribute__((const)) { return TL_GET( this_thread )->curr_cor; }
+static inline struct coroutine_desc * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
 
 //-----------------------------------------------------------------------------
@@ -73 +73 @@
 // Private wrappers for context switch and stack creation
 // Wrapper for co
-static inline void CoroutineCtxSwitch( coroutine_desc * src, coroutine_desc * dst ) __attribute__((nonnull (1, 2))) {
+static inline void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Inactive;
@@ -152 +152 @@
 }
 
-static inline void resume( coroutine_desc * dst ) __attribute__((nonnull (1))) {
+static inline void resume(coroutine_desc * dst) {
         // optimization : read TLS once and reuse it
         // Safety note: this is preemption safe since if

libcfa/src/concurrency/invoke.h

@@ -92 +92 @@
         };
 
-        enum coroutine_state { Halted, Start, Primed, Inactive, Active, Rerun };
-        enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION, __MANUAL_PREEMPTION };
+        enum coroutine_state { Halted, Start, Inactive, Active, Primed };
 
         struct coroutine_desc {
@@ -165 +164 @@
 
                 // current execution status for coroutine
-                volatile int state;
-                enum __Preemption_Reason preempted;
+                enum coroutine_state state;
 
                 //SKULLDUGGERY errno is not save in the thread data structure because returnToKernel appears to be the only function to require saving and restoring it
@@ -200 +198 @@
         #ifdef __cforall
         extern "Cforall" {
-                static inline thread_desc *& get_next( thread_desc & this ) __attribute__((const)) {
+                static inline thread_desc *& get_next( thread_desc & this ) {
                         return this.next;
                 }
 
-                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) /*__attribute__((const))*/ {
+                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
                         return this.node.[next, prev];
                 }
@@ -220 +218 @@
                 }
 
-                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) __attribute__((const)) {
+                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
                         if( (lhs.data != 0) != (rhs.data != 0) ) return false;
                         if( lhs.size != rhs.size ) return false;

libcfa/src/concurrency/kernel.cfa

@@ -110 +110 @@
 //-----------------------------------------------------------------------------
 //Start and stop routine for the kernel, declared first to make sure they run first
-static void __kernel_startup (void) __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
-static void __kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
+static void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
+static void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
 
 //-----------------------------------------------------------------------------
@@ -208 +208 @@
 }
 
-static void * CtxInvokeProcessor(void * arg);
-
+static void start(processor * this);
 void ?{}(processor & this, const char name[], cluster & cltr) with( this ) {
         this.name = name;
         this.cltr = &cltr;
         terminated{ 0 };
-        destroyer = 0p;
         do_terminate = false;
         preemption_alarm = 0p;
@@ -222 +220 @@
         idleLock{};
 
-        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", &this);
-
-        this.stack = __create_pthread( &this.kernel_thread, CtxInvokeProcessor, (void *)&this );
-
-        __cfaabi_dbg_print_safe("Kernel : core %p started\n", &this);
+        start( &this );
 }
 
@@ -264 +258 @@
 // Kernel Scheduling logic
 //=============================================================================================
-static thread_desc * __next_thread(cluster * this);
-static void __run_thread(processor * this, thread_desc * dst);
-static void __halt(processor * this);
+static void runThread(processor * this, thread_desc * dst);
+static void finishRunning(processor * this);
+static void halt(processor * this);
 
 //Main of the processor contexts
@@ -289 +283 @@
                 thread_desc * readyThread = 0p;
                 for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
-                        readyThread = __next_thread( this->cltr );
+                        readyThread = nextThread( this->cltr );
 
                         if(readyThread) {
-                                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-                                /* paranoid */ verifyf( readyThread->state == Inactive || readyThread->state == Start || readyThread->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", readyThread->state, readyThread->preempted);
-                                /* paranoid */ verifyf( readyThread->next == 0p, "Expected null got %p", readyThread->next );
-
-                                __run_thread(this, readyThread);
-
-                                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                                verify( ! kernelTLS.preemption_state.enabled );
+
+                                runThread(this, readyThread);
+
+                                verify( ! kernelTLS.preemption_state.enabled );
+
+                                //Some actions need to be taken from the kernel
+                                finishRunning(this);
 
                                 spin_count = 0;
                         } else {
                                 // spin(this, &spin_count);
-                                __halt(this);
+                                halt(this);
                         }
                 }
@@ -323 +318 @@
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-static void __run_thread(processor * this, thread_desc * thrd_dst) {
+static void runThread(processor * this, thread_desc * thrd_dst) {
         coroutine_desc * proc_cor = get_coroutine(this->runner);
+
+        // Reset the terminating actions here
+        this->finish.action_code = No_Action;
 
         // Update global state
         kernelTLS.this_thread = thrd_dst;
 
-        // set state of processor coroutine to inactive
-        verify(proc_cor->state == Active);
-        proc_cor->state = Inactive;
-
-        // Actually run the thread
-        RUNNING:  while(true) {
-                if(unlikely(thrd_dst->preempted)) {
-                        thrd_dst->preempted = __NO_PREEMPTION;
-                        verify(thrd_dst->state == Active || thrd_dst->state == Rerun);
-                } else {
-                        verify(thrd_dst->state == Start || thrd_dst->state == Primed || thrd_dst->state == Inactive);
-                        thrd_dst->state = Active;
-                }
-
-                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-
-                // set context switch to the thread that the processor is executing
-                verify( thrd_dst->context.SP );
-                CtxSwitch( &proc_cor->context, &thrd_dst->context );
-                // when CtxSwitch returns we are back in the processor coroutine
-
-                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-
-
-                // We just finished running a thread, there are a few things that could have happened.
-                // 1 - Regular case : the thread has blocked and now one has scheduled it yet.
-                // 2 - Racy case    : the thread has blocked but someone has already tried to schedule it.
-                // 3 - Polite Racy case : the thread has blocked, someone has already tried to schedule it, but the thread is nice and wants to go through the ready-queue any way
-                // 4 - Preempted
-                // In case 1, we may have won a race so we can't write to the state again.
-                // In case 2, we lost the race so we now own the thread.
-                // In case 3, we lost the race but can just reschedule the thread.
-
-                if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
-                        // The thread was preempted, reschedule it and reset the flag
-                        __schedule_thread( thrd_dst );
-                        break RUNNING;
-                }
-
-                // set state of processor coroutine to active and the thread to inactive
-                static_assert(sizeof(thrd_dst->state) == sizeof(int));
-                enum coroutine_state old_state = __atomic_exchange_n(&thrd_dst->state, Inactive, __ATOMIC_SEQ_CST);
-                switch(old_state) {
-                        case Halted:
-                                // The thread has halted, it should never be scheduled/run again, leave it back to Halted and move on
-                                thrd_dst->state = Halted;
-
-                                // We may need to wake someone up here since
-                                unpark( this->destroyer );
-                                this->destroyer = 0p;
-                                break RUNNING;
-                        case Active:
-                                // This is case 1, the regular case, nothing more is needed
-                                break RUNNING;
-                        case Rerun:
-                                // This is case 2, the racy case, someone tried to run this thread before it finished blocking
-                                // In this case, just run it again.
-                                continue RUNNING;
-                        default:
-                                // This makes no sense, something is wrong abort
-                                abort("Finished running a thread that was Inactive/Start/Primed %d\n", old_state);
-                }
-        }
-
-        // Just before returning to the processor, set the processor coroutine to active
+        // set state of processor coroutine to inactive and the thread to active
+        proc_cor->state = proc_cor->state == Halted ? Halted : Inactive;
+        thrd_dst->state = Active;
+
+        // set context switch to the thread that the processor is executing
+        verify( thrd_dst->context.SP );
+        CtxSwitch( &proc_cor->context, &thrd_dst->context );
+        // when CtxSwitch returns we are back in the processor coroutine
+
+        // set state of processor coroutine to active and the thread to inactive
+        thrd_dst->state = thrd_dst->state == Halted ? Halted : Inactive;
         proc_cor->state = Active;
 }
 
 // KERNEL_ONLY
-void returnToKernel() {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+static void returnToKernel() {
         coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
         thread_desc * thrd_src = kernelTLS.this_thread;
 
-        // Run the thread on this processor
-        {
-                int local_errno = *__volatile_errno();
-                #if defined( __i386 ) || defined( __x86_64 )
-                        __x87_store;
-                #endif
-                verify( proc_cor->context.SP );
-                CtxSwitch( &thrd_src->context, &proc_cor->context );
-                #if defined( __i386 ) || defined( __x86_64 )
-                        __x87_load;
-                #endif
-                *__volatile_errno() = local_errno;
-        }
-
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        // set state of current coroutine to inactive
+        thrd_src->state = thrd_src->state == Halted ? Halted : Inactive;
+        proc_cor->state = Active;
+        int local_errno = *__volatile_errno();
+        #if defined( __i386 ) || defined( __x86_64 )
+                __x87_store;
+        #endif
+
+        // set new coroutine that the processor is executing
+        // and context switch to it
+        verify( proc_cor->context.SP );
+        CtxSwitch( &thrd_src->context, &proc_cor->context );
+
+        // set state of new coroutine to active
+        proc_cor->state = proc_cor->state == Halted ? Halted : Inactive;
+        thrd_src->state = Active;
+
+        #if defined( __i386 ) || defined( __x86_64 )
+                __x87_load;
+        #endif
+        *__volatile_errno() = local_errno;
+}
+
+// KERNEL_ONLY
+// Once a thread has finished running, some of
+// its final actions must be executed from the kernel
+static void finishRunning(processor * this) with( this->finish ) {
+        verify( ! kernelTLS.preemption_state.enabled );
+        choose( action_code ) {
+        case No_Action:
+                break;
+        case Release:
+                unlock( *lock );
+        case Schedule:
+                ScheduleThread( thrd );
+        case Release_Schedule:
+                unlock( *lock );
+                ScheduleThread( thrd );
+        case Release_Multi:
+                for(int i = 0; i < lock_count; i++) {
+                        unlock( *locks[i] );
+                }
+        case Release_Multi_Schedule:
+                for(int i = 0; i < lock_count; i++) {
+                        unlock( *locks[i] );
+                }
+                for(int i = 0; i < thrd_count; i++) {
+                        ScheduleThread( thrds[i] );
+                }
+        case Callback:
+                callback();
+        default:
+                abort("KERNEL ERROR: Unexpected action to run after thread");
+        }
 }
 
@@ -465 +447 @@
 } // Abort
 
-void * __create_pthread( pthread_t * pthread, void * (*start)(void *), void * arg ) {
+void * create_pthread( pthread_t * pthread, void * (*start)(void *), void * arg ) {
         pthread_attr_t attr;
 
@@ -493 +475 @@
 }
 
+static void start(processor * this) {
+        __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", this);
+
+        this->stack = create_pthread( &this->kernel_thread, CtxInvokeProcessor, (void *)this );
+
+        __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
+}
+
 // KERNEL_ONLY
-static void __kernel_first_resume( processor * this ) {
+void kernel_first_resume( processor * this ) {
         thread_desc * src = mainThread;
         coroutine_desc * dst = get_coroutine(this->runner);
@@ -526 +516 @@
 
 // KERNEL_ONLY
-static void __kernel_last_resume( processor * this ) {
+void kernel_last_resume( processor * this ) {
         coroutine_desc * src = &mainThread->self_cor;
         coroutine_desc * dst = get_coroutine(this->runner);
@@ -540 +530 @@
 //-----------------------------------------------------------------------------
 // Scheduler routines
+
 // KERNEL ONLY
-void __schedule_thread( thread_desc * thrd ) with( *thrd->curr_cluster ) {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
-        /* paranoid */ if( thrd->state == Inactive || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
-                          "Error inactive thread marked as preempted, state %d, preemption %d\n", thrd->state, thrd->preempted );
-        /* paranoid */ if( thrd->preempted != __NO_PREEMPTION ) assertf(thrd->state == Active || thrd->state == Rerun,
-                          "Error preempted thread marked as not currently running, state %d, preemption %d\n", thrd->state, thrd->preempted );
-        /* paranoid */ #endif
-        /* paranoid */ verifyf( thrd->next == 0p, "Expected null got %p", thrd->next );
-
-        lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
-        bool was_empty = !(ready_queue != 0);
-        append( ready_queue, thrd );
-        unlock( ready_queue_lock );
-
-        if(was_empty) {
-                lock      (proc_list_lock __cfaabi_dbg_ctx2);
-                if(idles) {
-                        wake_fast(idles.head);
+void ScheduleThread( thread_desc * thrd ) {
+        verify( thrd );
+        verify( thrd->state != Halted );
+
+        verify( ! kernelTLS.preemption_state.enabled );
+
+        verifyf( thrd->next == 0p, "Expected null got %p", thrd->next );
+
+        with( *thrd->curr_cluster ) {
+                lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+                bool was_empty = !(ready_queue != 0);
+                append( ready_queue, thrd );
+                unlock( ready_queue_lock );
+
+                if(was_empty) {
+                        lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                        if(idles) {
+                                wake_fast(idles.head);
+                        }
+                        unlock    (proc_list_lock);
                 }
-                unlock    (proc_list_lock);
-        }
-        else if( struct processor * idle = idles.head ) {
-                wake_fast(idle);
-        }
-
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                else if( struct processor * idle = idles.head ) {
+                        wake_fast(idle);
+                }
+
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
 }
 
 // KERNEL ONLY
-static thread_desc * __next_thread(cluster * this) with( *this ) {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-
+thread_desc * nextThread(cluster * this) with( *this ) {
+        verify( ! kernelTLS.preemption_state.enabled );
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
         thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
-
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         return head;
 }
 
-void unpark( thread_desc * thrd ) {
-        if( !thrd ) return;
-
+void BlockInternal() {
         disable_interrupts();
-        static_assert(sizeof(thrd->state) == sizeof(int));
-        enum coroutine_state old_state = __atomic_exchange_n(&thrd->state, Rerun, __ATOMIC_SEQ_CST);
-        switch(old_state) {
-                case Active:
-                        // Wake won the race, the thread will reschedule/rerun itself
-                        break;
-                case Inactive:
-                        /* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
-
-                        // Wake lost the race,
-                        thrd->state = Inactive;
-                        __schedule_thread( thrd );
-                        break;
-                case Rerun:
-                        abort("More than one thread attempted to schedule thread %p\n", thrd);
-                        break;
-                case Halted:
-                case Start:
-                case Primed:
-                default:
-                        // This makes no sense, something is wrong abort
-                        abort();
-        }
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
 
-void park( void ) {
-        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
+void BlockInternal( __spinlock_t * lock ) {
         disable_interrupts();
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        /* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION );
-
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Release;
+                finish.lock        = lock;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
+
         enable_interrupts( __cfaabi_dbg_ctx );
-        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
-
+}
+
+void BlockInternal( thread_desc * thrd ) {
+        disable_interrupts();
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = Schedule;
+                finish.thrd        = thrd;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+void BlockInternal( __spinlock_t * lock, thread_desc * thrd ) {
+        assert(thrd);
+        disable_interrupts();
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = Release_Schedule;
+                finish.lock        = lock;
+                finish.thrd        = thrd;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+void BlockInternal(__spinlock_t * locks [], unsigned short count) {
+        disable_interrupts();
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = Release_Multi;
+                finish.locks       = locks;
+                finish.lock_count  = count;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
+        disable_interrupts();
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Release_Multi_Schedule;
+                finish.locks       = locks;
+                finish.lock_count  = lock_count;
+                finish.thrds       = thrds;
+                finish.thrd_count  = thrd_count;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+void BlockInternal(__finish_callback_fptr_t callback) {
+        disable_interrupts();
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Callback;
+                finish.callback    = callback;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+
+        enable_interrupts( __cfaabi_dbg_ctx );
 }
 
 // KERNEL ONLY
-void __leave_thread() {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
+        verify( ! kernelTLS.preemption_state.enabled );
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = thrd ? Release_Schedule : Release;
+                finish.lock        = lock;
+                finish.thrd        = thrd;
+        }
+
         returnToKernel();
-        abort();
-}
-
-// KERNEL ONLY
-bool force_yield( __Preemption_Reason reason ) {
-        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
-        disable_interrupts();
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-
-        thread_desc * thrd = kernelTLS.this_thread;
-        /* paranoid */ verify(thrd->state == Active || thrd->state == Rerun);
-
-        // SKULLDUGGERY: It is possible that we are preempting this thread just before
-        // it was going to park itself. If that is the case and it is already using the
-        // intrusive fields then we can't use them to preempt the thread
-        // If that is the case, abandon the preemption.
-        bool preempted = false;
-        if(thrd->next == 0p) {
-                preempted = true;
-                thrd->preempted = reason;
-                returnToKernel();
-        }
-
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        enable_interrupts_noPoll();
-        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
-
-        return preempted;
 }
 
@@ -665 +687 @@
 //-----------------------------------------------------------------------------
 // Kernel boot procedures
-static void __kernel_startup(void) {
+static void kernel_startup(void) {
         verify( ! kernelTLS.preemption_state.enabled );
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
@@ -726 +748 @@
         // Add the main thread to the ready queue
         // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
-        __schedule_thread(mainThread);
+        ScheduleThread(mainThread);
 
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
-        __kernel_first_resume( kernelTLS.this_processor );
+        kernel_first_resume( kernelTLS.this_processor );
 
 
@@ -743 +765 @@
 }
 
-static void __kernel_shutdown(void) {
+static void kernel_shutdown(void) {
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
@@ -754 +776 @@
         // which is currently here
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
-        __kernel_last_resume( kernelTLS.this_processor );
+        kernel_last_resume( kernelTLS.this_processor );
         mainThread->self_cor.state = Halted;
 
@@ -780 +802 @@
 // Kernel Quiescing
 //=============================================================================================
-static void __halt(processor * this) with( *this ) {
+static void halt(processor * this) with( *this ) {
         // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
 
@@ -891 +913 @@
 
                 // atomically release spin lock and block
-                unlock( lock );
-                park();
+                BlockInternal( &lock );
         }
         else {
@@ -911 +932 @@
 
         // make new owner
-        unpark( thrd );
+        WakeThread( thrd );
 }
 
@@ -969 +990 @@
 //-----------------------------------------------------------------------------
 // Debug
-bool threading_enabled(void) __attribute__((const)) {
+bool threading_enabled(void) {
         return true;
 }

libcfa/src/concurrency/kernel.hfa

@@ -45 +45 @@
 extern struct cluster * mainCluster;
 
+enum FinishOpCode { No_Action, Release, Schedule, Release_Schedule, Release_Multi, Release_Multi_Schedule, Callback };
+
+typedef void (*__finish_callback_fptr_t)(void);
+
+//TODO use union, many of these fields are mutually exclusive (i.e. MULTI vs NOMULTI)
+struct FinishAction {
+        FinishOpCode action_code;
+        /*
+        // Union of possible actions
+        union {
+                // Option 1 : locks and threads
+                struct {
+                        // 1 thread or N thread
+                        union {
+                                thread_desc * thrd;
+                                struct {
+                                        thread_desc ** thrds;
+                                        unsigned short thrd_count;
+                                };
+                        };
+                        // 1 lock or N lock
+                        union {
+                                __spinlock_t * lock;
+                                struct {
+                                        __spinlock_t ** locks;
+                                        unsigned short lock_count;
+                                };
+                        };
+                };
+                // Option 2 : action pointer
+                __finish_callback_fptr_t callback;
+        };
+        /*/
+        thread_desc * thrd;
+        thread_desc ** thrds;
+        unsigned short thrd_count;
+        __spinlock_t * lock;
+        __spinlock_t ** locks;
+        unsigned short lock_count;
+        __finish_callback_fptr_t callback;
+        //*/
+};
+static inline void ?{}(FinishAction & this) {
+        this.action_code = No_Action;
+        this.thrd = 0p;
+        this.lock = 0p;
+}
+static inline void ^?{}(FinishAction &) {}
+
 // Processor
 coroutine processorCtx_t {
@@ -67 +116 @@
         // RunThread data
         // Action to do after a thread is ran
-        thread_desc * destroyer;
+        struct FinishAction finish;
 
         // Preemption data
@@ -108 +157 @@
 static inline void  ?{}(processor & this, const char name[]) { this{name, *mainCluster }; }
 
-static inline [processor *&, processor *& ] __get( processor & this ) /*__attribute__((const))*/ { return this.node.[next, prev]; }
+static inline [processor *&, processor *& ] __get( processor & this ) {
+        return this.node.[next, prev];
+}
 
 //-----------------------------------------------------------------------------
@@ -151 +202 @@
 static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
 
-static inline [cluster *&, cluster *& ] __get( cluster & this ) /*__attribute__((const))*/ { return this.node.[next, prev]; }
-
-static inline struct processor * active_processor() __attribute__((const)) { return TL_GET( this_processor ); } // UNSAFE
-static inline struct cluster   * active_cluster  () __attribute__((const)) { return TL_GET( this_processor )->cltr; }
+static inline [cluster *&, cluster *& ] __get( cluster & this ) {
+        return this.node.[next, prev];
+}
+
+static inline struct processor * active_processor() { return TL_GET( this_processor ); } // UNSAFE
+static inline struct cluster   * active_cluster  () { return TL_GET( this_processor )->cltr; }
 
 // Local Variables: //

libcfa/src/concurrency/kernel_private.hfa

@@ -31 +31 @@
 }
 
-void __schedule_thread( thread_desc * ) __attribute__((nonnull (1)));
+void ScheduleThread( thread_desc * );
+static inline void WakeThread( thread_desc * thrd ) {
+        if( !thrd ) return;
+
+        verify(thrd->state == Inactive);
+
+        disable_interrupts();
+        ScheduleThread( thrd );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+thread_desc * nextThread(cluster * this);
 
 //Block current thread and release/wake-up the following resources
-void __leave_thread() __attribute__((noreturn));
+void BlockInternal(void);
+void BlockInternal(__spinlock_t * lock);
+void BlockInternal(thread_desc * thrd);
+void BlockInternal(__spinlock_t * lock, thread_desc * thrd);
+void BlockInternal(__spinlock_t * locks [], unsigned short count);
+void BlockInternal(__spinlock_t * locks [], unsigned short count, thread_desc * thrds [], unsigned short thrd_count);
+void BlockInternal(__finish_callback_fptr_t callback);
+void LeaveThread(__spinlock_t * lock, thread_desc * thrd);
 
 //-----------------------------------------------------------------------------
@@ -40 +57 @@
 void main(processorCtx_t *);
 
-void * __create_pthread( pthread_t *, void * (*)(void *), void * );
+void * create_pthread( pthread_t *, void * (*)(void *), void * );
 
 static inline void wake_fast(processor * this) {
@@ -85 +102 @@
 #define KERNEL_STORAGE(T,X) static char storage_##X[sizeof(T)]
 
-static inline uint32_t __tls_rand() {
+static inline uint32_t tls_rand() {
         kernelTLS.rand_seed ^= kernelTLS.rand_seed << 6;
         kernelTLS.rand_seed ^= kernelTLS.rand_seed >> 21;

libcfa/src/concurrency/monitor.cfa

@@ -117 +117 @@
 
                         // Some one else has the monitor, wait in line for it
-                        /* paranoid */ verify( thrd->next == 0p );
                         append( this->entry_queue, thrd );
-                        /* paranoid */ verify( thrd->next == 1p );
-
-                        unlock( this->lock );
-                        park();
+
+                        BlockInternal( &this->lock );
 
                         __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
-                        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                        // BlockInternal will unlock spinlock, no need to unlock ourselves
                         return;
                 }
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
-
-                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-                /* paranoid */ verify( this->lock.lock );
 
                 // Release the lock and leave
@@ -155 +149 @@
                         set_owner( this, thrd );
 
-                        verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-
                         unlock( this->lock );
                         return;
@@ -174 +166 @@
                         // Wake the thread that is waiting for this
                         __condition_criterion_t * urgent = pop( this->signal_stack );
-                        /* paranoid */ verify( urgent );
+                        verify( urgent );
 
                         // Reset mask
@@ -183 +175 @@
 
                         // Some one else has the monitor, wait for him to finish and then run
-                        unlock( this->lock );
-
-                        // Release the next thread
-                        /* paranoid */ verifyf( urgent->owner->waiting_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-                        unpark( urgent->owner->waiting_thread );
-
-                        // Park current thread waiting
-                        park();
+                        BlockInternal( &this->lock, urgent->owner->waiting_thread );
 
                         // Some one was waiting for us, enter
-                        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                        set_owner( this, thrd );
                 }
                 else {
@@ -202 +187 @@
 
                         // Some one else has the monitor, wait in line for it
-                        /* paranoid */ verify( thrd->next == 0p );
                         append( this->entry_queue, thrd );
-                        /* paranoid */ verify( thrd->next == 1p );
-                        unlock( this->lock );
-
-                        // Park current thread waiting
-                        park();
-
-                        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                        BlockInternal( &this->lock );
+
+                        // BlockInternal will unlock spinlock, no need to unlock ourselves
                         return;
                 }
@@ -225 +205 @@
                 __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
 
-                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -241 +221 @@
                 thread_desc * new_owner = next_thread( this );
 
-                // Check the new owner is consistent with who we wake-up
-                // new_owner might be null even if someone owns the monitor when the owner is still waiting for another monitor
-                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
-
                 // We can now let other threads in safely
                 unlock( this->lock );
 
                 //We need to wake-up the thread
-                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
-                unpark( new_owner );
+                WakeThread( new_owner );
         }
 
@@ -277 +252 @@
                 disable_interrupts();
 
-                thrd->state = Halted;
-
-                /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
+                thrd->self_cor.state = Halted;
+
+                verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -291 +266 @@
                 thread_desc * new_owner = next_thread( this );
 
-                // Release the monitor lock
-                unlock( this->lock );
-
-                // Unpark the next owner if needed
-                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
-                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-                /* paranoid */ verify( ! kernelTLS.this_processor->destroyer );
-                /* paranoid */ verify( thrd->state == Halted );
-
-                kernelTLS.this_processor->destroyer = new_owner;
-
-                // Leave the thread
-                __leave_thread();
+                // Leave the thread, this will unlock the spinlock
+                // Use leave thread instead of BlockInternal which is
+                // specialized for this case and supports null new_owner
+                LeaveThread( &this->lock, new_owner );
 
                 // Control flow should never reach here!
@@ -434 +400 @@
         // Append the current wait operation to the ones already queued on the condition
         // We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion
-        /* paranoid */ verify( waiter.next == 0p );
         append( this.blocked, &waiter );
-        /* paranoid */ verify( waiter.next == 1p );
 
         // Lock all monitors (aggregates the locks as well)
@@ -455 +419 @@
         }
 
-        // Unlock the locks, we don't need them anymore
-        for(int i = 0; i < count; i++) {
-                unlock( *locks[i] );
-        }
-
-        // Wake the threads
-        for(int i = 0; i < thread_count; i++) {
-                unpark( threads[i] );
-        }
-
         // Everything is ready to go to sleep
-        park();
+        BlockInternal( locks, count, threads, thread_count );
 
         // We are back, restore the owners and recursions
@@ -536 +490 @@
         //Find the thread to run
         thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
-        /* paranoid */ verify( signallee->next == 0p );
         set_owner( monitors, count, signallee );
 
         __cfaabi_dbg_print_buffer_decl( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
 
-        // unlock all the monitors
-        unlock_all( locks, count );
-
-        // unpark the thread we signalled
-        unpark( signallee );
-
         //Everything is ready to go to sleep
-        park();
+        BlockInternal( locks, count, &signallee, 1 );
 
 
@@ -645 +592 @@
                                 set_owner( monitors, count, next );
 
-                                // unlock all the monitors
-                                unlock_all( locks, count );
-
-                                // unpark the thread we signalled
-                                unpark( next );
-
-                                //Everything is ready to go to sleep
-                                park();
+                                // Everything is ready to go to sleep
+                                BlockInternal( locks, count, &next, 1 );
 
                                 // We are back, restore the owners and recursions
@@ -690 +631 @@
         }
 
-        // unlock all the monitors
-        unlock_all( locks, count );
-
         //Everything is ready to go to sleep
-        park();
+        BlockInternal( locks, count );
 
 
@@ -712 +650 @@
 
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
-        /* paranoid */ verify( this->lock.lock );
+        // __cfaabi_dbg_print_safe( "Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
 
         //Pass the monitor appropriately
@@ -722 +660 @@
 
 static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
-        /* paranoid */ verify ( monitors[0]->lock.lock );
-        /* paranoid */ verifyf( monitors[0]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[0]->owner, monitors[0]->recursion, monitors[0] );
-        monitors[0]->owner        = owner;
-        monitors[0]->recursion    = 1;
+        monitors[0]->owner     = owner;
+        monitors[0]->recursion = 1;
         for( __lock_size_t i = 1; i < count; i++ ) {
-                /* paranoid */ verify ( monitors[i]->lock.lock );
-                /* paranoid */ verifyf( monitors[i]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[i]->owner, monitors[i]->recursion, monitors[i] );
-                monitors[i]->owner        = owner;
-                monitors[i]->recursion    = 0;
+                monitors[i]->owner     = owner;
+                monitors[i]->recursion = 0;
         }
 }
@@ -754 +688 @@
                 //regardless of if we are ready to baton pass,
                 //we need to set the monitor as in use
-                /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
                 set_owner( this,  urgent->owner->waiting_thread );
 
@@ -763 +696 @@
         // Get the next thread in the entry_queue
         thread_desc * new_owner = pop_head( this->entry_queue );
-        /* paranoid */ verifyf( !this->owner || kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-        /* paranoid */ verify( !new_owner || new_owner->next == 0p );
         set_owner( this, new_owner );
 
@@ -910 +841 @@
         // For each thread in the entry-queue
         for(    thread_desc ** thrd_it = &entry_queue.head;
-                *thrd_it != 1p;
+                *thrd_it;
                 thrd_it = &(*thrd_it)->next
         ) {

libcfa/src/concurrency/monitor.hfa

@@ -133 +133 @@
               bool signal      ( condition & this );
               bool signal_block( condition & this );
-static inline bool is_empty    ( condition & this ) { return this.blocked.head == 1p; }
+static inline bool is_empty    ( condition & this ) { return !this.blocked.head; }
          uintptr_t front       ( condition & this );
 

libcfa/src/concurrency/mutex.cfa

@@ -40 +40 @@
         if( is_locked ) {
                 append( blocked_threads, kernelTLS.this_thread );
-                unlock( lock );
-                park();
+                BlockInternal( &lock );
         }
         else {
@@ -63 +62 @@
         lock( this.lock __cfaabi_dbg_ctx2 );
         this.is_locked = (this.blocked_threads != 0);
-        unpark(
+        WakeThread(
                 pop_head( this.blocked_threads )
         );
@@ -95 +94 @@
         else {
                 append( blocked_threads, kernelTLS.this_thread );
-                unlock( lock );
-                park();
+                BlockInternal( &lock );
         }
 }
@@ -123 +121 @@
                 owner = thrd;
                 recursion_count = (thrd ? 1 : 0);
-                unpark( thrd );
+                WakeThread( thrd );
         }
         unlock( lock );
@@ -140 +138 @@
 void notify_one(condition_variable & this) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
-        unpark(
+        WakeThread(
                 pop_head( this.blocked_threads )
         );
@@ -149 +147 @@
         lock( lock __cfaabi_dbg_ctx2 );
         while(this.blocked_threads) {
-                unpark(
+                WakeThread(
                         pop_head( this.blocked_threads )
                 );
@@ -159 +157 @@
         lock( this.lock __cfaabi_dbg_ctx2 );
         append( this.blocked_threads, kernelTLS.this_thread );
-        unlock( this.lock );
-        park();
+        BlockInternal( &this.lock );
 }
 
@@ -167 +164 @@
         lock( this.lock __cfaabi_dbg_ctx2 );
         append( this.blocked_threads, kernelTLS.this_thread );
-        unlock(l);
-        unlock(this.lock);
-        park();
+        void __unlock(void) {
+                unlock(l);
+                unlock(this.lock);
+        }
+        BlockInternal( __unlock );
         lock(l);
 }

libcfa/src/concurrency/preemption.cfa

@@ -187 +187 @@
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
                 processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
+                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic store
 
                 with( kernelTLS.preemption_state ){
@@ -208 +209 @@
                                 if( proc->pending_preemption ) {
                                         proc->pending_preemption = false;
-                                        force_yield( __POLL_PREEMPTION );
+                                        BlockInternal( thrd );
                                 }
                         }
@@ -306 +307 @@
         signal_block( SIGALRM );
 
-        alarm_stack = __create_pthread( &alarm_thread, alarm_loop, 0p );
+        alarm_stack = create_pthread( &alarm_thread, alarm_loop, 0p );
 }
 
@@ -393 +394 @@
         // Preemption can occur here
 
-        force_yield( __ALARM_PREEMPTION ); // Do the actual CtxSwitch
+        BlockInternal( kernelTLS.this_thread ); // Do the actual CtxSwitch
 }
 

libcfa/src/concurrency/thread.cfa

@@ -23 +23 @@
 #include "invoke.h"
 
+extern "C" {
+        #include <fenv.h>
+        #include <stddef.h>
+}
+
+//extern volatile thread_local processor * this_processor;
+
 //-----------------------------------------------------------------------------
 // Thread ctors and dtors
@@ -29 +36 @@
         self_cor{ name, storage, storageSize };
         state = Start;
-        preempted = __NO_PREEMPTION;
         curr_cor = &self_cor;
         self_mon.owner = &this;
@@ -49 +55 @@
 }
 
-//-----------------------------------------------------------------------------
-// Starting and stopping threads
-forall( dtype T | is_thread(T) )
-void __thrd_start( T & this, void (*main_p)(T &) ) {
-        thread_desc * this_thrd = get_thread(this);
-
-        disable_interrupts();
-        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
-
-        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
-        verify( this_thrd->context.SP );
-
-        __schedule_thread(this_thrd);
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-//-----------------------------------------------------------------------------
-// Support for threads that don't ues the thread keyword
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
 void ?{}( scoped(T)& this ) with( this ) {
@@ -84 +72 @@
 }
 
+//-----------------------------------------------------------------------------
+// Starting and stopping threads
+forall( dtype T | is_thread(T) )
+void __thrd_start( T & this, void (*main_p)(T &) ) {
+        thread_desc * this_thrd = get_thread(this);
+
+        disable_interrupts();
+        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
+
+        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
+        verify( this_thrd->context.SP );
+
+        ScheduleThread(this_thrd);
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+void yield( void ) {
+        // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) );
+        BlockInternal( TL_GET( this_thread ) );
+        // Safety note : This could cause some false positives due to preemption
+      verify( TL_GET( preemption_state.enabled ) );
+}
+
+void yield( unsigned times ) {
+        for( unsigned i = 0; i < times; i++ ) {
+                yield();
+        }
+}
+
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/thread.hfa

@@ -31 +31 @@
 };
 
-// define that satisfies the trait without using the thread keyword
-#define DECL_THREAD(X) thread_desc* get_thread(X& this) __attribute__((const)) { return &this.__thrd; } void main(X& this)
-
-// Inline getters for threads/coroutines/monitors
-forall( dtype T | is_thread(T) )
-static inline coroutine_desc* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; }
+#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)
 
 forall( dtype T | is_thread(T) )
-static inline monitor_desc  * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
+static inline coroutine_desc* get_coroutine(T & this) {
+        return &get_thread(this)->self_cor;
+}
 
-static inline coroutine_desc* get_coroutine(thread_desc * this) __attribute__((const)) { return &this->self_cor; }
-static inline monitor_desc  * get_monitor  (thread_desc * this) __attribute__((const)) { return &this->self_mon; }
+forall( dtype T | is_thread(T) )
+static inline monitor_desc* get_monitor(T & this) {
+        return &get_thread(this)->self_mon;
+}
 
-//-----------------------------------------------------------------------------
-// forward declarations needed for threads
+static inline coroutine_desc* get_coroutine(thread_desc * this) {
+        return &this->self_cor;
+}
+
+static inline monitor_desc* get_monitor(thread_desc * this) {
+        return &this->self_mon;
+}
+
 extern struct cluster * mainCluster;
 
@@ -83 +88 @@
 void ^?{}( scoped(T)& this );
 
-//-----------------------------------------------------------------------------
-// Thread getters
+void yield();
+void yield( unsigned times );
+
 static inline struct thread_desc * active_thread () { return TL_GET( this_thread ); }
-
-//-----------------------------------------------------------------------------
-// Scheduler API
-
-//----------
-// Park thread: block until corresponding call to unpark, won't block if unpark is already called
-void park( void );
-
-//----------
-// Unpark a thread, if the thread is already blocked, schedule it
-//                  if the thread is not yet block, signal that it should rerun immediately
-void unpark( thread_desc * this );
-
-forall( dtype T | is_thread(T) )
-static inline void unpark( T & this ) { if(!&this) return; unpark( get_thread( this ) );}
-
-//----------
-// Yield: force thread to block and be rescheduled
-bool force_yield( enum __Preemption_Reason );
-
-static inline void yield() {
-        force_yield(__MANUAL_PREEMPTION);
-}
-
-// Yield: yield N times
-static inline void yield( unsigned times ) {
-        for( times ) {
-                yield();
-        }
-}
 
 // Local Variables: //

tests/concurrent/examples/.expect/datingService.txt

@@ +1 @@
+Girl:17 is dating Boy at 2 with ccode 17
+ Boy:2 is dating Girl 17 with ccode 17
+ Boy:14 is dating Girl 5 with ccode 5
+Girl:5 is dating Boy at 14 with ccode 5
+ Boy:9 is dating Girl 10 with ccode 10
+Girl:10 is dating Boy at 9 with ccode 10
+ Boy:1 is dating Girl 18 with ccode 18
+Girl:18 is dating Boy at 1 with ccode 18
+ Boy:16 is dating Girl 3 with ccode 3
+Girl:3 is dating Boy at 16 with ccode 3
+ Boy:5 is dating Girl 14 with ccode 14
+Girl:14 is dating Boy at 5 with ccode 14
+ Boy:15 is dating Girl 4 with ccode 4
+Girl:4 is dating Boy at 15 with ccode 4
+Girl:0 is dating Boy at 19 with ccode 0
+ Boy:19 is dating Girl 0 with ccode 0
+Girl:9 is dating Boy at 10 with ccode 9
+ Boy:10 is dating Girl 9 with ccode 9
+Girl:11 is dating Boy at 8 with ccode 11
+ Boy:8 is dating Girl 11 with ccode 11
+ Boy:12 is dating Girl 7 with ccode 7
+Girl:7 is dating Boy at 12 with ccode 7
+ Boy:11 is dating Girl 8 with ccode 8
+Girl:8 is dating Boy at 11 with ccode 8
+Girl:16 is dating Boy at 3 with ccode 16
+ Boy:3 is dating Girl 16 with ccode 16
+Girl:15 is dating Boy at 4 with ccode 15
+ Boy:4 is dating Girl 15 with ccode 15
+Girl:19 is dating Boy at 0 with ccode 19
+ Boy:0 is dating Girl 19 with ccode 19
+Girl:2 is dating Boy at 17 with ccode 2
+ Boy:17 is dating Girl 2 with ccode 2
+ Boy:13 is dating Girl 6 with ccode 6
+Girl:6 is dating Boy at 13 with ccode 6
+ Boy:7 is dating Girl 12 with ccode 12
+Girl:12 is dating Boy at 7 with ccode 12
+Girl:13 is dating Boy at 6 with ccode 13
+ Boy:6 is dating Girl 13 with ccode 13
+Girl:1 is dating Boy at 18 with ccode 1
+ Boy:18 is dating Girl 1 with ccode 1

tests/concurrent/examples/datingService.cfa

@@ -1 +1 @@
 //
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
-//
+// 
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
@@ -35 +35 @@
                 signal_block( Boys[ccode] );                                    // restart boy to set phone number
         } // if
-        //sout | "Girl:" | PhoneNo | "is dating Boy at" | BoyPhoneNo | "with ccode" | ccode;
+        sout | "Girl:" | PhoneNo | "is dating Boy at" | BoyPhoneNo | "with ccode" | ccode;
         return BoyPhoneNo;
 } // DatingService girl
@@ -47 +47 @@
                 signal_block( Girls[ccode] );                                   // restart girl to set phone number
         } // if
-        //sout | " Boy:" | PhoneNo | "is dating Girl" | GirlPhoneNo | "with ccode" | ccode;
+        sout | " Boy:" | PhoneNo | "is dating Girl" | GirlPhoneNo | "with ccode" | ccode;
         return GirlPhoneNo;
 } // DatingService boy

tests/concurrent/multi-monitor.cfa

@@ -11 +11 @@
 
 void increment( monitor_t & mutex p1, monitor_t & mutex p2, int & value ) {
-        assert(active_thread() == get_monitor(p1)->owner);
-        assert(active_thread() == get_monitor(p2)->owner);
         value += 1;
-        assert(active_thread() == get_monitor(p1)->owner);
-        assert(active_thread() == get_monitor(p2)->owner);
 }