Changes in / [c744563a:a505021]

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 (added)
• tests/concurrent/park/.expect/force_preempt.txt (added)
• tests/concurrent/park/contention.cfa (added)
• tests/concurrent/park/force_preempt.cfa (added)

libcfa/src/bits/containers.hfa

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

libcfa/src/bits/locks.hfa

@@ -60 +60 @@
         }
 
-        extern void yield( unsigned int );
-
         static inline void ?{}( __spinlock_t & this ) {
                 this.lock = 0;
@@ -68 +66 @@
         // 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;
@@ -98 +99 @@
                         #endif
                 }
-                disable_interrupts();
                 __cfaabi_dbg_record( this, caller );
         }
 
         static inline void unlock( __spinlock_t & this ) {
+                __atomic_clear( &this.lock, __ATOMIC_RELEASE );
                 enable_interrupts_noPoll();
-                __atomic_clear( &this.lock, __ATOMIC_RELEASE );
         }
 

libcfa/src/concurrency/coroutine.hfa

@@ -54 +54 @@
 void prime(T & cor);
 
-static inline struct coroutine_desc * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
+static inline struct coroutine_desc * active_coroutine() __attribute__((const)) { 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) {
+static inline void CoroutineCtxSwitch( coroutine_desc * src, coroutine_desc * dst ) __attribute__((nonnull (1, 2))) {
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Inactive;
@@ -152 +152 @@
 }
 
-static inline void resume(coroutine_desc * dst) {
+static inline void resume( coroutine_desc * dst ) __attribute__((nonnull (1))) {
         // 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, Inactive, Active, Primed };
+        enum coroutine_state { Halted, Start, Primed, Inactive, Active, Rerun };
+        enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION, __MANUAL_PREEMPTION };
 
         struct coroutine_desc {
@@ -164 +165 @@
 
                 // current execution status for coroutine
-                enum coroutine_state state;
+                volatile int state;
+                enum __Preemption_Reason preempted;
 
                 //SKULLDUGGERY errno is not save in the thread data structure because returnToKernel appears to be the only function to require saving and restoring it
@@ -198 +200 @@
         #ifdef __cforall
         extern "Cforall" {
-                static inline thread_desc *& get_next( thread_desc & this ) {
+                static inline thread_desc *& get_next( thread_desc & this ) __attribute__((const)) {
                         return this.next;
                 }
 
-                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
+                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) /*__attribute__((const))*/ {
                         return this.node.[next, prev];
                 }
@@ -218 +220 @@
                 }
 
-                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
+                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) __attribute__((const)) {
                         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 start(processor * this);
+static void * CtxInvokeProcessor(void * arg);
+
 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;
@@ -220 +222 @@
         idleLock{};
 
-        start( &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);
 }
 
@@ -258 +264 @@
 // Kernel Scheduling logic
 //=============================================================================================
-static void runThread(processor * this, thread_desc * dst);
-static void finishRunning(processor * this);
-static void halt(processor * this);
+static thread_desc * __next_thread(cluster * this);
+static void __run_thread(processor * this, thread_desc * dst);
+static void __halt(processor * this);
 
 //Main of the processor contexts
@@ -283 +289 @@
                 thread_desc * readyThread = 0p;
                 for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
-                        readyThread = nextThread( this->cltr );
+                        readyThread = __next_thread( this->cltr );
 
                         if(readyThread) {
-                                verify( ! kernelTLS.preemption_state.enabled );
-
-                                runThread(this, readyThread);
-
-                                verify( ! kernelTLS.preemption_state.enabled );
-
-                                //Some actions need to be taken from the kernel
-                                finishRunning(this);
+                                /* 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 );
 
                                 spin_count = 0;
                         } else {
                                 // spin(this, &spin_count);
-                                halt(this);
+                                __halt(this);
                         }
                 }
@@ -318 +323 @@
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-static void runThread(processor * this, thread_desc * thrd_dst) {
+static void __run_thread(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 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;
+        // 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
         proc_cor->state = Active;
 }
 
 // KERNEL_ONLY
-static void returnToKernel() {
+void returnToKernel() {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
         thread_desc * thrd_src = kernelTLS.this_thread;
 
-        // 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");
-        }
+        // 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 );
 }
 
@@ -447 +465 @@
 } // 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;
 
@@ -475 +493 @@
 }
 
-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
-void kernel_first_resume( processor * this ) {
+static void __kernel_first_resume( processor * this ) {
         thread_desc * src = mainThread;
         coroutine_desc * dst = get_coroutine(this->runner);
@@ -516 +526 @@
 
 // KERNEL_ONLY
-void kernel_last_resume( processor * this ) {
+static void __kernel_last_resume( processor * this ) {
         coroutine_desc * src = &mainThread->self_cor;
         coroutine_desc * dst = get_coroutine(this->runner);
@@ -530 +540 @@
 //-----------------------------------------------------------------------------
 // Scheduler routines
-
 // KERNEL ONLY
-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);
+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);
                 }
-                else if( struct processor * idle = idles.head ) {
-                        wake_fast(idle);
-                }
-
-        }
-
-        verify( ! kernelTLS.preemption_state.enabled );
+                unlock    (proc_list_lock);
+        }
+        else if( struct processor * idle = idles.head ) {
+                wake_fast(idle);
+        }
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 }
 
 // KERNEL ONLY
-thread_desc * nextThread(cluster * this) with( *this ) {
-        verify( ! kernelTLS.preemption_state.enabled );
+static thread_desc * __next_thread(cluster * this) with( *this ) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
         thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
-        verify( ! kernelTLS.preemption_state.enabled );
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         return head;
 }
 
-void BlockInternal() {
+void unpark( thread_desc * thrd ) {
+        if( !thrd ) return;
+
         disable_interrupts();
-        verify( ! kernelTLS.preemption_state.enabled );
+        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();
+        }
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+void park( void ) {
+        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
+        disable_interrupts();
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION );
+
         returnToKernel();
-        verify( ! kernelTLS.preemption_state.enabled );
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-void BlockInternal( __spinlock_t * lock ) {
+        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
+
+}
+
+// KERNEL ONLY
+void __leave_thread() {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        abort();
+}
+
+// KERNEL ONLY
+bool force_yield( __Preemption_Reason reason ) {
+        /* paranoid */ verify( kernelTLS.preemption_state.enabled );
         disable_interrupts();
-        with( *kernelTLS.this_processor ) {
-                finish.action_code = Release;
-                finish.lock        = lock;
-        }
-
-        verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        verify( ! kernelTLS.preemption_state.enabled );
-
-        enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-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 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();
+        /* 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;
 }
 
@@ -687 +665 @@
 //-----------------------------------------------------------------------------
 // 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");
@@ -748 +726 @@
         // 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
-        ScheduleThread(mainThread);
+        __schedule_thread(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 );
 
 
@@ -765 +743 @@
 }
 
-static void kernel_shutdown(void) {
+static void __kernel_shutdown(void) {
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
@@ -776 +754 @@
         // 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;
 
@@ -802 +780 @@
 // 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) );
 
@@ -913 +891 @@
 
                 // atomically release spin lock and block
-                BlockInternal( &lock );
+                unlock( lock );
+                park();
         }
         else {
@@ -932 +911 @@
 
         // make new owner
-        WakeThread( thrd );
+        unpark( thrd );
 }
 
@@ -990 +969 @@
 //-----------------------------------------------------------------------------
 // Debug
-bool threading_enabled(void) {
+bool threading_enabled(void) __attribute__((const)) {
         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 {
@@ -116 +67 @@
         // RunThread data
         // Action to do after a thread is ran
-        struct FinishAction finish;
+        thread_desc * destroyer;
 
         // Preemption data
@@ -157 +108 @@
 static inline void  ?{}(processor & this, const char name[]) { this{name, *mainCluster }; }
 
-static inline [processor *&, processor *& ] __get( processor & this ) {
-        return this.node.[next, prev];
-}
+static inline [processor *&, processor *& ] __get( processor & this ) /*__attribute__((const))*/ { return this.node.[next, prev]; }
 
 //-----------------------------------------------------------------------------
@@ -202 +151 @@
 static inline void ?{} (cluster & this, const char name[])        { this{name, default_preemption()}; }
 
-static inline [cluster *&, cluster *& ] __get( cluster & this ) {
-        return this.node.[next, prev];
-}
+static inline [cluster *&, cluster *& ] __get( cluster & this ) /*__attribute__((const))*/ { 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; }
+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; }
 
 // Local Variables: //

libcfa/src/concurrency/kernel_private.hfa

@@ -31 +31 @@
 }
 
-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);
+void __schedule_thread( thread_desc * ) __attribute__((nonnull (1)));
 
 //Block current thread and release/wake-up the following resources
-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);
+void __leave_thread() __attribute__((noreturn));
 
 //-----------------------------------------------------------------------------
@@ -57 +40 @@
 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) {
@@ -102 +85 @@
 #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 );
-
-                        BlockInternal( &this->lock );
+                        /* paranoid */ verify( thrd->next == 1p );
+
+                        unlock( this->lock );
+                        park();
 
                         __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
-                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        /* 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 );
                         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
@@ -149 +155 @@
                         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;
@@ -166 +174 @@
                         // Wake the thread that is waiting for this
                         __condition_criterion_t * urgent = pop( this->signal_stack );
-                        verify( urgent );
+                        /* paranoid */ verify( urgent );
 
                         // Reset mask
@@ -175 +183 @@
 
                         // Some one else has the monitor, wait for him to finish and then run
-                        BlockInternal( &this->lock, urgent->owner->waiting_thread );
+                        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();
 
                         // Some one was waiting for us, enter
-                        set_owner( this, thrd );
+                        /* 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 );
                 }
                 else {
@@ -187 +202 @@
 
                         // Some one else has the monitor, wait in line for it
+                        /* paranoid */ verify( thrd->next == 0p );
                         append( this->entry_queue, thrd );
-                        BlockInternal( &this->lock );
-
-                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        /* 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 );
                         return;
                 }
@@ -205 +225 @@
                 __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
 
-                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 */ 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
@@ -221 +241 @@
                 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
-                WakeThread( new_owner );
+                /* 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 );
         }
 
@@ -252 +277 @@
                 disable_interrupts();
 
-                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 );
+                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 );
 
                 // Leaving a recursion level, decrement the counter
@@ -266 +291 @@
                 thread_desc * new_owner = next_thread( this );
 
-                // 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 );
+                // 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();
 
                 // Control flow should never reach here!
@@ -400 +434 @@
         // 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)
@@ -419 +455 @@
         }
 
+        // 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
-        BlockInternal( locks, count, threads, thread_count );
+        park();
 
         // We are back, restore the owners and recursions
@@ -490 +536 @@
         //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
-        BlockInternal( locks, count, &signallee, 1 );
+        park();
 
 
@@ -592 +645 @@
                                 set_owner( monitors, count, next );
 
-                                // Everything is ready to go to sleep
-                                BlockInternal( locks, count, &next, 1 );
+                                // unlock all the monitors
+                                unlock_all( locks, count );
+
+                                // unpark the thread we signalled
+                                unpark( next );
+
+                                //Everything is ready to go to sleep
+                                park();
 
                                 // We are back, restore the owners and recursions
@@ -631 +690 @@
         }
 
+        // unlock all the monitors
+        unlock_all( locks, count );
+
         //Everything is ready to go to sleep
-        BlockInternal( locks, count );
+        park();
 
 
@@ -650 +712 @@
 
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
-        // __cfaabi_dbg_print_safe( "Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
+        /* paranoid */ verify( this->lock.lock );
 
         //Pass the monitor appropriately
@@ -660 +722 @@
 
 static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
-        monitors[0]->owner     = owner;
-        monitors[0]->recursion = 1;
+        /* 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;
         for( __lock_size_t i = 1; i < count; i++ ) {
-                monitors[i]->owner     = owner;
-                monitors[i]->recursion = 0;
+                /* 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;
         }
 }
@@ -688 +754 @@
                 //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 );
 
@@ -696 +763 @@
         // 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 );
 
@@ -841 +910 @@
         // For each thread in the entry-queue
         for(    thread_desc ** thrd_it = &entry_queue.head;
-                *thrd_it;
+                *thrd_it != 1p;
                 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; }
+static inline bool is_empty    ( condition & this ) { return this.blocked.head == 1p; }
          uintptr_t front       ( condition & this );
 

libcfa/src/concurrency/mutex.cfa

@@ -40 +40 @@
         if( is_locked ) {
                 append( blocked_threads, kernelTLS.this_thread );
-                BlockInternal( &lock );
+                unlock( lock );
+                park();
         }
         else {
@@ -62 +63 @@
         lock( this.lock __cfaabi_dbg_ctx2 );
         this.is_locked = (this.blocked_threads != 0);
-        WakeThread(
+        unpark(
                 pop_head( this.blocked_threads )
         );
@@ -94 +95 @@
         else {
                 append( blocked_threads, kernelTLS.this_thread );
-                BlockInternal( &lock );
+                unlock( lock );
+                park();
         }
 }
@@ -121 +123 @@
                 owner = thrd;
                 recursion_count = (thrd ? 1 : 0);
-                WakeThread( thrd );
+                unpark( thrd );
         }
         unlock( lock );
@@ -138 +140 @@
 void notify_one(condition_variable & this) with(this) {
         lock( lock __cfaabi_dbg_ctx2 );
-        WakeThread(
+        unpark(
                 pop_head( this.blocked_threads )
         );
@@ -147 +149 @@
         lock( lock __cfaabi_dbg_ctx2 );
         while(this.blocked_threads) {
-                WakeThread(
+                unpark(
                         pop_head( this.blocked_threads )
                 );
@@ -157 +159 @@
         lock( this.lock __cfaabi_dbg_ctx2 );
         append( this.blocked_threads, kernelTLS.this_thread );
-        BlockInternal( &this.lock );
+        unlock( this.lock );
+        park();
 }
 
@@ -164 +167 @@
         lock( this.lock __cfaabi_dbg_ctx2 );
         append( this.blocked_threads, kernelTLS.this_thread );
-        void __unlock(void) {
-                unlock(l);
-                unlock(this.lock);
-        }
-        BlockInternal( __unlock );
+        unlock(l);
+        unlock(this.lock);
+        park();
         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 ){
@@ -209 +208 @@
                                 if( proc->pending_preemption ) {
                                         proc->pending_preemption = false;
-                                        BlockInternal( thrd );
+                                        force_yield( __POLL_PREEMPTION );
                                 }
                         }
@@ -307 +306 @@
         signal_block( SIGALRM );
 
-        alarm_stack = create_pthread( &alarm_thread, alarm_loop, 0p );
+        alarm_stack = __create_pthread( &alarm_thread, alarm_loop, 0p );
 }
 
@@ -394 +393 @@
         // Preemption can occur here
 
-        BlockInternal( kernelTLS.this_thread ); // Do the actual CtxSwitch
+        force_yield( __ALARM_PREEMPTION ); // 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
@@ -36 +29 @@
         self_cor{ name, storage, storageSize };
         state = Start;
+        preempted = __NO_PREEMPTION;
         curr_cor = &self_cor;
         self_mon.owner = &this;
@@ -55 +49 @@
 }
 
+//-----------------------------------------------------------------------------
+// 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 ) {
@@ -72 +84 @@
 }
 
-//-----------------------------------------------------------------------------
-// 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 DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)
+// 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; }
 
 forall( dtype T | is_thread(T) )
-static inline coroutine_desc* get_coroutine(T & this) {
-        return &get_thread(this)->self_cor;
-}
+static inline monitor_desc  * get_monitor  (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; }
 
-forall( dtype T | is_thread(T) )
-static inline monitor_desc* get_monitor(T & this) {
-        return &get_thread(this)->self_mon;
-}
+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; }
 
-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;
-}
-
+//-----------------------------------------------------------------------------
+// forward declarations needed for threads
 extern struct cluster * mainCluster;
 
@@ -88 +83 @@
 void ^?{}( scoped(T)& this );
 
-void yield();
-void yield( unsigned times );
+//-----------------------------------------------------------------------------
+// Thread getters
+static inline struct thread_desc * active_thread () { return TL_GET( this_thread ); }
 
-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);
 }