Changeset ca37445 for src/libcfa/concurrency

Timestamp:

Apr 10, 2018, 3:31:07 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

33f5b57

Parents:

9d1e3f7 (diff), 8ad6533 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Location:

src/libcfa/concurrency

Files:

• alarm.c (modified) (4 diffs)
• alarm.h (modified) (5 diffs)
• coroutine (modified) (5 diffs)
• coroutine.c (modified) (5 diffs)
• invoke.h (modified) (4 diffs)
• kernel (modified) (3 diffs)
• kernel.c (modified) (32 diffs)
• kernel_private.h (modified) (2 diffs)
• monitor.c (modified) (18 diffs)
• preemption.c (modified) (15 diffs)
• preemption.h (modified) (2 diffs)
• thread (modified) (2 diffs)
• thread.c (modified) (7 diffs)

src/libcfa/concurrency/alarm.c

@@ -10 +10 @@
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 22:35:18 2017
-// Update Count     : 1
+// Last Modified On : Mon Apr  9 13:36:18 2018
+// Update Count     : 61
 //
 
@@ -26 +26 @@
 #include "preemption.h"
 
-
-static inline void ?{}( itimerval & this, __cfa_time_t * alarm ) with( this ) {
-        it_value.tv_sec = alarm->val / (1`cfa_s).val;                   // seconds
-        it_value.tv_usec = max( (alarm->val % (1`cfa_s).val) / (1`cfa_us).val, 1000 ); // microseconds
-        it_interval.tv_sec = 0;
-        it_interval.tv_usec = 0;
-}
-
-static inline void ?{}( __cfa_time_t & this, timespec * curr ) {
-        uint64_t secs  = curr->tv_sec;
-        uint64_t nsecs = curr->tv_nsec;
-        this.val = from_s(secs).val + nsecs;
-}
-
 //=============================================================================================
 // Clock logic
 //=============================================================================================
 
-__cfa_time_t __kernel_get_time() {
+Time __kernel_get_time() {
         timespec curr;
-        clock_gettime( CLOCK_REALTIME, &curr );
-        return (__cfa_time_t){ &curr };
+        clock_gettime( CLOCK_MONOTONIC_RAW, &curr );            // CLOCK_REALTIME
+        return (Time){ curr };
 }
 
-void __kernel_set_timer( __cfa_time_t alarm ) {
-        itimerval val = { &alarm };
-        setitimer( ITIMER_REAL, &val, NULL );
+void __kernel_set_timer( Duration alarm ) {
+        setitimer( ITIMER_REAL, &(itimerval){ alarm }, NULL );
 }
 
@@ -59 +44 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) {
+void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period ) with( this ) {
         this.thrd = thrd;
         this.alarm = alarm;
@@ -68 +53 @@
 }
 
-void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) {
+void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period ) with( this ) {
         this.proc = proc;
         this.alarm = alarm;

src/libcfa/concurrency/alarm.h

@@ -10 +10 @@
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:59:27 2017
-// Update Count     : 3
+// Last Modified On : Mon Mar 26 16:25:41 2018
+// Update Count     : 11
 //
 
@@ -21 +21 @@
 #include <assert.h>
 
-#include "bits/cfatime.h"
+#include "time"
 
 struct thread_desc;
@@ -30 +30 @@
 //=============================================================================================
 
-__cfa_time_t __kernel_get_time();
-void __kernel_set_timer( __cfa_time_t alarm );
+Time __kernel_get_time();
+void __kernel_set_timer( Duration alarm );
 
 //=============================================================================================
@@ -38 +38 @@
 
 struct alarm_node_t {
-        __cfa_time_t alarm;             // time when alarm goes off
-        __cfa_time_t period;            // if > 0 => period of alarm
+        Time alarm;                             // time when alarm goes off
+        Duration period;                        // if > 0 => period of alarm
         alarm_node_t * next;            // intrusive link list field
 
@@ -53 +53 @@
 typedef alarm_node_t ** __alarm_it_t;
 
-void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s );
-void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s );
+void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period );
+void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period );
 void ^?{}( alarm_node_t & this );
 

src/libcfa/concurrency/coroutine

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug 30 07:58:29 2017
-// Update Count     : 3
+// Last Modified On : Fri Mar 30 18:23:45 2018
+// Update Count     : 8
 //
 
@@ -60 +60 @@
 }
 
-// Get current coroutine
-extern thread_local coroutine_desc * volatile this_coroutine;
-
 // Private wrappers for context switch and stack creation
 extern void CoroutineCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
@@ -69 +66 @@
 // Suspend implementation inlined for performance
 static inline void suspend() {
-        coroutine_desc * src = this_coroutine;          // optimization
+        coroutine_desc * src = TL_GET( this_coroutine );                        // optimization
 
         assertf( src->last != 0,
@@ -86 +83 @@
 forall(dtype T | is_coroutine(T))
 static inline void resume(T & cor) {
-        coroutine_desc * src = this_coroutine;          // optimization
+        coroutine_desc * src = TL_GET( this_coroutine );                        // optimization
         coroutine_desc * dst = get_coroutine(cor);
 
@@ -111 +108 @@
 
 static inline void resume(coroutine_desc * dst) {
-        coroutine_desc * src = this_coroutine;          // optimization
+        coroutine_desc * src = TL_GET( this_coroutine );                        // optimization
 
         // not resuming self ?

src/libcfa/concurrency/coroutine.c

@@ -10 +10 @@
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  8 16:10:31 2018
-// Update Count     : 4
+// Last Modified On : Fri Mar 30 17:20:57 2018
+// Update Count     : 9
 //
 
@@ -99 +99 @@
 // Wrapper for co
 void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
-        verify( preemption_state.enabled || this_processor->do_terminate );
+        verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
         disable_interrupts();
 
@@ -106 +106 @@
 
         // set new coroutine that task is executing
-        this_coroutine = dst;
+        TL_SET( this_coroutine, dst );
 
         // context switch to specified coroutine
@@ -117 +117 @@
 
         enable_interrupts( __cfaabi_dbg_ctx );
-        verify( preemption_state.enabled || this_processor->do_terminate );
+        verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
 } //ctxSwitchDirect
 
@@ -172 +172 @@
 
         void __leave_coroutine(void) {
-                coroutine_desc * src = this_coroutine;          // optimization
+                coroutine_desc * src = TL_GET( this_coroutine ); // optimization
 
                 assertf( src->starter != 0,

src/libcfa/concurrency/invoke.h

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  9 14:41:55 2018
-// Update Count     : 6
+// Last Modified On : Fri Mar 30 22:33:59 2018
+// Update Count     : 30
 //
 
@@ -17 +17 @@
 #include "bits/defs.h"
 #include "bits/locks.h"
+
+#define TL_GET( member ) kernelThreadData.member
+#define TL_SET( member, value ) kernelThreadData.member = value;
 
 #ifdef __cforall
@@ -30 +33 @@
                 static inline struct thread_desc             * & get_next( struct thread_desc             & this );
                 static inline struct __condition_criterion_t * & get_next( struct __condition_criterion_t & this );
+
+                extern thread_local struct KernelThreadData {
+                        struct coroutine_desc * volatile this_coroutine;
+                        struct thread_desc    * volatile this_thread;
+                        struct processor      * volatile this_processor;
+
+                        struct {
+                                volatile unsigned short disable_count;
+                                volatile bool enabled;
+                                volatile bool in_progress;
+                        } preemption_state;
+                } kernelThreadData;
         }
+
+        static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_coroutine ); }
+        static inline struct thread_desc * volatile active_thread() { return TL_GET( this_thread ); }
+        static inline struct processor * volatile active_processor() { return TL_GET( this_processor ); }
         #endif
 
         struct coStack_t {
-                // size of stack
-                size_t size;
-
-                // pointer to stack
-                void *storage;
-
-                // stack grows towards stack limit
-                void *limit;
-
-                // base of stack
-                void *base;
-
-                // address of cfa_context_t
-                void *context;
-
-                // address of top of storage
-                void *top;
-
-                // whether or not the user allocated the stack
-                bool userStack;
+                size_t size;                                                                    // size of stack
+                void * storage;                                                                 // pointer to stack
+                void * limit;                                                                   // stack grows towards stack limit
+                void * base;                                                                    // base of stack
+                void * context;                                                                 // address of cfa_context_t
+                void * top;                                                                             // address of top of storage
+                bool userStack;                                                                 // whether or not the user allocated the stack
         };
 
@@ -59 +65 @@
 
         struct coroutine_desc {
-                // stack information of the coroutine
-                struct coStack_t stack;
-
-                // textual name for coroutine/task, initialized by uC++ generated code
-                const char *name;
-
-                // copy of global UNIX variable errno
-                int errno_;
-
-                // current execution status for coroutine
-                enum coroutine_state state;
-
-                // first coroutine to resume this one
-                struct coroutine_desc * starter;
-
-                // last coroutine to resume this one
-                struct coroutine_desc * last;
+                struct coStack_t stack;                                                 // stack information of the coroutine
+                const char * name;                                                              // textual name for coroutine/task, initialized by uC++ generated code
+                int errno_;                                                                             // copy of global UNIX variable errno
+                enum coroutine_state state;                                             // current execution status for coroutine
+                struct coroutine_desc * starter;                                // first coroutine to resume this one
+                struct coroutine_desc * last;                                   // last coroutine to resume this one
         };
 

src/libcfa/concurrency/kernel

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:58:39 2017
-// Update Count     : 2
+// Last Modified On : Fri Mar 23 17:08:20 2018
+// Update Count     : 3
 //
 
@@ -19 +19 @@
 
 #include "invoke.h"
-#include "bits/cfatime.h"
+#include "time"
 
 extern "C" {
@@ -49 +49 @@
 
         // Preemption rate on this cluster
-        __cfa_time_t preemption_rate;
+        Duration preemption_rate;
 };
 
-extern __cfa_time_t default_preemption();
+extern Duration default_preemption();
 
 void ?{} (cluster & this);

src/libcfa/concurrency/kernel.c

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  8 23:52:19 2018
-// Update Count     : 5
+// Last Modified On : Fri Mar 30 18:26:11 2018
+// Update Count     : 23
 //
 
@@ -52 +52 @@
 // Global state
 
-thread_local coroutine_desc * volatile this_coroutine;
-thread_local thread_desc *    volatile this_thread;
-thread_local processor *      volatile this_processor;
-
 // volatile thread_local bool preemption_in_progress = 0;
 // volatile thread_local bool preemption_enabled = false;
 // volatile thread_local unsigned short disable_preempt_count = 1;
 
-volatile thread_local __cfa_kernel_preemption_state_t preemption_state = { false, false, 1 };
+thread_local struct KernelThreadData kernelThreadData = {
+        NULL,
+        NULL,
+        NULL,
+        { 1, false, false }
+};
 
 //-----------------------------------------------------------------------------
@@ -172 +173 @@
                 terminate(&this);
                 verify(this.do_terminate);
-                verify(this_processor != &this);
+                verify(TL_GET( this_processor ) != &this);
                 P( terminated );
-                verify(this_processor != &this);
+                verify(TL_GET( this_processor ) != &this);
                 pthread_join( kernel_thread, NULL );
         }
@@ -213 +214 @@
                         if(readyThread)
                         {
-                                verify( !preemption_state.enabled );
+                                verify( ! TL_GET( preemption_state ).enabled );
 
                                 runThread(this, readyThread);
 
-                                verify( !preemption_state.enabled );
+                                verify( ! TL_GET( preemption_state ).enabled );
 
                                 //Some actions need to be taken from the kernel
@@ -249 +250 @@
 
         //Update global state
-        this_thread = dst;
+        TL_SET( this_thread, dst );
 
         // Context Switch to the thread
@@ -257 +258 @@
 
 void returnToKernel() {
-        coroutine_desc * proc_cor = get_coroutine(this_processor->runner);
-        coroutine_desc * thrd_cor = this_thread->curr_cor = this_coroutine;
+        coroutine_desc * proc_cor = get_coroutine(TL_GET( this_processor )->runner);
+        coroutine_desc * thrd_cor = TL_GET( this_thread )->curr_cor = TL_GET( this_coroutine );
         ThreadCtxSwitch(thrd_cor, proc_cor);
 }
@@ -266 +267 @@
 void finishRunning(processor * this) with( this->finish ) {
         if( action_code == Release ) {
-                verify( !preemption_state.enabled );
+                verify( ! TL_GET( preemption_state ).enabled );
                 unlock( *lock );
         }
@@ -273 +274 @@
         }
         else if( action_code == Release_Schedule ) {
-                verify( !preemption_state.enabled );
+                verify( ! TL_GET( preemption_state ).enabled );
                 unlock( *lock );
                 ScheduleThread( thrd );
         }
         else if( action_code == Release_Multi ) {
-                verify( !preemption_state.enabled );
+                verify( ! TL_GET( preemption_state ).enabled );
                 for(int i = 0; i < lock_count; i++) {
                         unlock( *locks[i] );
@@ -307 +308 @@
 void * CtxInvokeProcessor(void * arg) {
         processor * proc = (processor *) arg;
-        this_processor = proc;
-        this_coroutine = NULL;
-        this_thread = NULL;
-        preemption_state.enabled = false;
-        preemption_state.disable_count = 1;
+        TL_SET( this_processor, proc );
+        TL_SET( this_coroutine, NULL );
+        TL_SET( this_thread, NULL );
+        TL_GET( preemption_state ).enabled = false;
+        TL_GET( preemption_state ).disable_count = 1;
         // SKULLDUGGERY: We want to create a context for the processor coroutine
         // which is needed for the 2-step context switch. However, there is no reason
@@ -323 +324 @@
 
         //Set global state
-        this_coroutine = get_coroutine(proc->runner);
-        this_thread = NULL;
+        TL_SET( this_coroutine, get_coroutine(proc->runner) );
+        TL_SET( this_thread, NULL );
 
         //We now have a proper context from which to schedule threads
@@ -352 +353 @@
 
 void kernel_first_resume(processor * this) {
-        coroutine_desc * src = this_coroutine;
+        coroutine_desc * src = TL_GET( this_coroutine );
         coroutine_desc * dst = get_coroutine(this->runner);
 
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 
         create_stack(&dst->stack, dst->stack.size);
         CtxStart(&this->runner, CtxInvokeCoroutine);
 
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 
         dst->last = src;
@@ -369 +370 @@
 
         // set new coroutine that task is executing
-        this_coroutine = dst;
+        TL_SET( this_coroutine, dst );
 
         // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
@@ -386 +387 @@
         src->state = Active;
 
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 }
 
@@ -392 +393 @@
 // Scheduler routines
 void ScheduleThread( thread_desc * thrd ) {
-        // if( !thrd ) return;
+        // if( ! thrd ) return;
         verify( thrd );
         verify( thrd->self_cor.state != Halted );
 
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        with( *this_processor->cltr ) {
+        with( *TL_GET( this_processor )->cltr ) {
                 lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
                 append( ready_queue, thrd );
@@ -406 +407 @@
         }
 
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 }
 
 thread_desc * nextThread(cluster * this) with( *this ) {
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
         thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
         return head;
 }
@@ -420 +421 @@
 void BlockInternal() {
         disable_interrupts();
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
         returnToKernel();
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
@@ -428 +429 @@
 void BlockInternal( __spinlock_t * lock ) {
         disable_interrupts();
-        this_processor->finish.action_code = Release;
-        this_processor->finish.lock        = lock;
-
-        verify( !preemption_state.enabled );
+        TL_GET( this_processor )->finish.action_code = Release;
+        TL_GET( this_processor )->finish.lock        = lock;
+
+        verify( ! TL_GET( preemption_state ).enabled );
         returnToKernel();
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -440 +441 @@
 void BlockInternal( thread_desc * thrd ) {
         disable_interrupts();
-        this_processor->finish.action_code = Schedule;
-        this_processor->finish.thrd        = thrd;
-
-        verify( !preemption_state.enabled );
+        TL_GET( this_processor )->finish.action_code = Schedule;
+        TL_GET( this_processor )->finish.thrd        = thrd;
+
+        verify( ! TL_GET( preemption_state ).enabled );
         returnToKernel();
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -453 +454 @@
         assert(thrd);
         disable_interrupts();
-        this_processor->finish.action_code = Release_Schedule;
-        this_processor->finish.lock        = lock;
-        this_processor->finish.thrd        = thrd;
-
-        verify( !preemption_state.enabled );
+        TL_GET( this_processor )->finish.action_code = Release_Schedule;
+        TL_GET( this_processor )->finish.lock        = lock;
+        TL_GET( this_processor )->finish.thrd        = thrd;
+
+        verify( ! TL_GET( preemption_state ).enabled );
         returnToKernel();
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -466 +467 @@
 void BlockInternal(__spinlock_t * locks [], unsigned short count) {
         disable_interrupts();
-        this_processor->finish.action_code = Release_Multi;
-        this_processor->finish.locks       = locks;
-        this_processor->finish.lock_count  = count;
-
-        verify( !preemption_state.enabled );
+        TL_GET( this_processor )->finish.action_code = Release_Multi;
+        TL_GET( this_processor )->finish.locks       = locks;
+        TL_GET( this_processor )->finish.lock_count  = count;
+
+        verify( ! TL_GET( preemption_state ).enabled );
         returnToKernel();
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -479 +480 @@
 void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
         disable_interrupts();
-        this_processor->finish.action_code = Release_Multi_Schedule;
-        this_processor->finish.locks       = locks;
-        this_processor->finish.lock_count  = lock_count;
-        this_processor->finish.thrds       = thrds;
-        this_processor->finish.thrd_count  = thrd_count;
-
-        verify( !preemption_state.enabled );
+        TL_GET( this_processor )->finish.action_code = Release_Multi_Schedule;
+        TL_GET( this_processor )->finish.locks       = locks;
+        TL_GET( this_processor )->finish.lock_count  = lock_count;
+        TL_GET( this_processor )->finish.thrds       = thrds;
+        TL_GET( this_processor )->finish.thrd_count  = thrd_count;
+
+        verify( ! TL_GET( preemption_state ).enabled );
         returnToKernel();
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -493 +494 @@
 
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
-        verify( !preemption_state.enabled );
-        this_processor->finish.action_code = thrd ? Release_Schedule : Release;
-        this_processor->finish.lock        = lock;
-        this_processor->finish.thrd        = thrd;
+        verify( ! TL_GET( preemption_state ).enabled );
+        TL_GET( this_processor )->finish.action_code = thrd ? Release_Schedule : Release;
+        TL_GET( this_processor )->finish.lock        = lock;
+        TL_GET( this_processor )->finish.thrd        = thrd;
 
         returnToKernel();
@@ -507 +508 @@
 // Kernel boot procedures
 void kernel_startup(void) {
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 
@@ -531 +532 @@
 
         //initialize the global state variables
-        this_processor = mainProcessor;
-        this_thread = mainThread;
-        this_coroutine = &mainThread->self_cor;
+        TL_SET( this_processor, mainProcessor );
+        TL_SET( this_thread, mainThread );
+        TL_SET( this_coroutine, &mainThread->self_cor );
 
         // Enable preemption
@@ -545 +546 @@
         // 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( this_processor );
+        kernel_first_resume( TL_GET( this_processor ) );
 
 
@@ -552 +553 @@
         __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
 
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
-        verify( preemption_state.enabled );
+        verify( TL_GET( preemption_state ).enabled );
 }
 
@@ -560 +561 @@
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
-        verify( preemption_state.enabled );
+        verify( TL_GET( preemption_state ).enabled );
         disable_interrupts();
-        verify( !preemption_state.enabled );
+        verify( ! TL_GET( preemption_state ).enabled );
 
         // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
@@ -602 +603 @@
 
         // first task to abort ?
-        if ( !kernel_abort_called ) {                   // not first task to abort ?
+        if ( ! kernel_abort_called ) {                  // not first task to abort ?
                 kernel_abort_called = true;
                 unlock( kernel_abort_lock );
@@ -617 +618 @@
         }
 
-        return this_thread;
+        return TL_GET( this_thread );
 }
 
@@ -626 +627 @@
         __cfaabi_dbg_bits_write( abort_text, len );
 
-        if ( thrd != this_coroutine ) {
-                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
+        if ( thrd != TL_GET( this_coroutine ) ) {
+                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", TL_GET( this_coroutine )->name, TL_GET( this_coroutine ) );
                 __cfaabi_dbg_bits_write( abort_text, len );
         }
@@ -636 +637 @@
 
 int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
-        return get_coroutine(this_thread) == get_coroutine(mainThread) ? 4 : 2;
+        return get_coroutine(TL_GET( this_thread )) == get_coroutine(mainThread) ? 4 : 2;
 }
 
@@ -666 +667 @@
         if ( count < 0 ) {
                 // queue current task
-                append( waiting, (thread_desc *)this_thread );
+                append( waiting, (thread_desc *)TL_GET( this_thread ) );
 
                 // atomically release spin lock and block

src/libcfa/concurrency/kernel_private.h

@@ -10 +10 @@
 // Created On       : Mon Feb 13 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:58:09 2017
-// Update Count     : 2
+// Last Modified On : Thu Mar 29 14:06:40 2018
+// Update Count     : 3
 //
 
@@ -66 +66 @@
 extern event_kernel_t * event_kernel;
 
-extern thread_local coroutine_desc * volatile this_coroutine;
-extern thread_local thread_desc *    volatile this_thread;
-extern thread_local processor *      volatile this_processor;
+//extern thread_local coroutine_desc * volatile this_coroutine;
+//extern thread_local thread_desc *    volatile this_thread;
+//extern thread_local processor *      volatile this_processor;
 
 // extern volatile thread_local bool preemption_in_progress;

src/libcfa/concurrency/monitor.c

@@ -10 +10 @@
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb 16 14:49:53 2018
-// Update Count     : 5
+// Last Modified On : Fri Mar 30 14:30:26 2018
+// Update Count     : 9
 //
 
@@ -85 +85 @@
                 // Lock the monitor spinlock
                 lock( this->lock __cfaabi_dbg_ctx2 );
-                thread_desc * thrd = this_thread;
+                thread_desc * thrd = TL_GET( this_thread );
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
@@ -134 +134 @@
                 // Lock the monitor spinlock
                 lock( this->lock __cfaabi_dbg_ctx2 );
-                thread_desc * thrd = this_thread;
+                thread_desc * thrd = TL_GET( this_thread );
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
@@ -168 +168 @@
 
                         // Create the node specific to this wait operation
-                        wait_ctx_primed( this_thread, 0 )
+                        wait_ctx_primed( TL_GET( this_thread ), 0 )
 
                         // Some one else has the monitor, wait for him to finish and then run
@@ -179 +179 @@
                         __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
 
-                        wait_ctx( this_thread, 0 )
+                        wait_ctx( TL_GET( this_thread ), 0 )
                         this->dtor_node = &waiter;
 
@@ -199 +199 @@
                 lock( this->lock __cfaabi_dbg_ctx2 );
 
-                __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
-
-                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
+                __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", TL_GET( this_thread ), this, this->owner);
+
+                verifyf( TL_GET( this_thread ) == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", TL_GET( this_thread ), this->owner, this->recursion, this );
 
                 // Leaving a recursion level, decrement the counter
@@ -227 +227 @@
         void __leave_dtor_monitor_desc( monitor_desc * this ) {
                 __cfaabi_dbg_debug_do(
-                        if( this_thread != this->owner ) {
-                                abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
+                        if( TL_GET( this_thread ) != this->owner ) {
+                                abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, TL_GET( this_thread ), this->owner);
                         }
                         if( this->recursion != 1 ) {
@@ -297 +297 @@
 
         // Save previous thread context
-        this.prev = this_thread->monitors;
+        this.prev = TL_GET( this_thread )->monitors;
 
         // Update thread context (needed for conditions)
-        (this_thread->monitors){m, count, func};
+        (TL_GET( this_thread )->monitors){m, count, func};
 
         // __cfaabi_dbg_print_safe( "MGUARD : enter %d\n", count);
@@ -322 +322 @@
 
         // Restore thread context
-        this_thread->monitors = this.prev;
+        TL_GET( this_thread )->monitors = this.prev;
 }
 
@@ -332 +332 @@
 
         // Save previous thread context
-        this.prev = this_thread->monitors;
+        this.prev = TL_GET( this_thread )->monitors;
 
         // Update thread context (needed for conditions)
-        (this_thread->monitors){m, 1, func};
+        (TL_GET( this_thread )->monitors){m, 1, func};
 
         __enter_monitor_dtor( this.m, func );
@@ -346 +346 @@
 
         // Restore thread context
-        this_thread->monitors = this.prev;
+        TL_GET( this_thread )->monitors = this.prev;
 }
 
@@ -386 +386 @@
 
         // Create the node specific to this wait operation
-        wait_ctx( this_thread, user_info );
+        wait_ctx( TL_GET( this_thread ), user_info );
 
         // Append the current wait operation to the ones already queued on the condition
@@ -425 +425 @@
         //Some more checking in debug
         __cfaabi_dbg_debug_do(
-                thread_desc * this_thrd = this_thread;
+                thread_desc * this_thrd = TL_GET( this_thread );
                 if ( this.monitor_count != this_thrd->monitors.size ) {
                         abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size );
@@ -473 +473 @@
 
         // Create the node specific to this wait operation
-        wait_ctx_primed( this_thread, 0 )
+        wait_ctx_primed( TL_GET( this_thread ), 0 )
 
         //save contexts
@@ -566 +566 @@
 
                                 // Create the node specific to this wait operation
-                                wait_ctx_primed( this_thread, 0 );
+                                wait_ctx_primed( TL_GET( this_thread ), 0 );
 
                                 // Save monitor states
@@ -612 +612 @@
 
         // Create the node specific to this wait operation
-        wait_ctx_primed( this_thread, 0 );
+        wait_ctx_primed( TL_GET( this_thread ), 0 );
 
         monitor_save;
@@ -618 +618 @@
 
         for( __lock_size_t i = 0; i < count; i++) {
-                verify( monitors[i]->owner == this_thread );
+                verify( monitors[i]->owner == TL_GET( this_thread ) );
         }
 
@@ -812 +812 @@
 
 static inline void brand_condition( condition & this ) {
-        thread_desc * thrd = this_thread;
+        thread_desc * thrd = TL_GET( this_thread );
         if( !this.monitors ) {
                 // __cfaabi_dbg_print_safe( "Branding\n" );

src/libcfa/concurrency/preemption.c

@@ -10 +10 @@
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  9 16:38:13 2018
-// Update Count     : 14
+// Last Modified On : Mon Apr  9 13:52:39 2018
+// Update Count     : 36
 //
 
@@ -23 +23 @@
 }
 
-#include "bits/cfatime.h"
 #include "bits/signal.h"
 
 #if !defined(__CFA_DEFAULT_PREEMPTION__)
-#define __CFA_DEFAULT_PREEMPTION__ 10`cfa_ms
+#define __CFA_DEFAULT_PREEMPTION__ 10`ms
 #endif
 
-__cfa_time_t default_preemption() __attribute__((weak)) {
+Duration default_preemption() __attribute__((weak)) {
         return __CFA_DEFAULT_PREEMPTION__;
 }
@@ -78 +77 @@
 
 // Get next expired node
-static inline alarm_node_t * get_expired( alarm_list_t * alarms, __cfa_time_t currtime ) {
+static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) {
         if( !alarms->head ) return NULL;                          // If no alarms return null
         if( alarms->head->alarm >= currtime ) return NULL;        // If alarms head not expired return null
@@ -88 +87 @@
         alarm_node_t * node = NULL;                     // Used in the while loop but cannot be declared in the while condition
         alarm_list_t * alarms = &event_kernel->alarms;  // Local copy for ease of reading
-        __cfa_time_t currtime = __kernel_get_time();    // Check current time once so we everything "happens at once"
+        Time currtime = __kernel_get_time();                    // Check current time once so we everything "happens at once"
 
         //Loop throught every thing expired
@@ -102 +101 @@
 
                 // Check if this is a periodic alarm
-                __cfa_time_t period = node->period;
+                Duration period = node->period;
                 if( period > 0 ) {
                         node->alarm = currtime + period;    // Alarm is periodic, add currtime to it (used cached current time)
@@ -117 +116 @@
 
 // Update the preemption of a processor and notify interested parties
-void update_preemption( processor * this, __cfa_time_t duration ) {
+void update_preemption( processor * this, Duration duration ) {
         alarm_node_t * alarm = this->preemption_alarm;
 
         // Alarms need to be enabled
-        if ( duration > 0 && !alarm->set ) {
+        if ( duration > 0 && ! alarm->set ) {
                 alarm->alarm = __kernel_get_time() + duration;
                 alarm->period = duration;
                 register_self( alarm );
         }
-        // Zero duraction but alarm is set
+        // Zero duration but alarm is set
         else if ( duration == 0 && alarm->set ) {
                 unregister_self( alarm );
@@ -150 +149 @@
         // Disable interrupts by incrementing the counter
         void disable_interrupts() {
-                preemption_state.enabled = false;
-                __attribute__((unused)) unsigned short new_val = preemption_state.disable_count + 1;
-                preemption_state.disable_count = new_val;
+                TL_GET( preemption_state ).enabled = false;
+                __attribute__((unused)) unsigned short new_val = TL_GET( preemption_state ).disable_count + 1;
+                TL_GET( preemption_state ).disable_count = new_val;
                 verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
         }
@@ -159 +158 @@
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                processor   * proc = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
-                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
-
-                unsigned short prev = preemption_state.disable_count;
-                preemption_state.disable_count -= 1;
+                processor   * proc = TL_GET( this_processor ); // Cache the processor now since interrupts can start happening after the atomic add
+                thread_desc * thrd = TL_GET( this_thread );       // Cache the thread now since interrupts can start happening after the atomic add
+
+                unsigned short prev = TL_GET( preemption_state ).disable_count;
+                TL_GET( preemption_state ).disable_count -= 1;
                 verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
 
                 // Check if we need to prempt the thread because an interrupt was missed
                 if( prev == 1 ) {
-                        preemption_state.enabled = true;
+                        TL_GET( preemption_state ).enabled = true;
                         if( proc->pending_preemption ) {
                                 proc->pending_preemption = false;
@@ -182 +181 @@
         // Don't execute any pending CtxSwitch even if counter reaches 0
         void enable_interrupts_noPoll() {
-                unsigned short prev = preemption_state.disable_count;
-                preemption_state.disable_count -= 1;
+                unsigned short prev = TL_GET( preemption_state ).disable_count;
+                TL_GET( preemption_state ).disable_count -= 1;
                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
-                        preemption_state.enabled = true;
+                        TL_GET( preemption_state ).enabled = true;
                 }
         }
@@ -236 +235 @@
 // If false : preemption is unsafe and marked as pending
 static inline bool preemption_ready() {
-        bool ready = preemption_state.enabled && !preemption_state.in_progress; // Check if preemption is safe
-        this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
+        bool ready = TL_GET( preemption_state ).enabled && !TL_GET( preemption_state ).in_progress; // Check if preemption is safe
+        TL_GET( this_processor )->pending_preemption = !ready;                  // Adjust the pending flag accordingly
         return ready;
 }
@@ -251 +250 @@
 
         // Start with preemption disabled until ready
-        preemption_state.enabled = false;
-        preemption_state.disable_count = 1;
+        TL_GET( preemption_state ).enabled = false;
+        TL_GET( preemption_state ).disable_count = 1;
 
         // Initialize the event kernel
@@ -291 +290 @@
 // Used by thread to control when they want to receive preemption signals
 void ?{}( preemption_scope & this, processor * proc ) {
-        (this.alarm){ proc, 0`cfa_s, 0`cfa_s };
+        (this.alarm){ proc, (Time){ 0 }, 0`s };
         this.proc = proc;
         this.proc->preemption_alarm = &this.alarm;
@@ -301 +300 @@
         disable_interrupts();
 
-        update_preemption( this.proc, 0`cfa_s );
+        update_preemption( this.proc, 0`s );
 }
 
@@ -317 +316 @@
         // before the kernel thread has even started running. When that happens an iterrupt
         // we a null 'this_processor' will be caught, just ignore it.
-        if(!this_processor) return;
+        if(!TL_GET( this_processor )) return;
 
         choose(sfp->si_value.sival_int) {
                 case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
-                case PREEMPT_TERMINATE: verify(this_processor->do_terminate);
+                case PREEMPT_TERMINATE: verify(TL_GET( this_processor )->do_terminate);
                 default:
                         abort( "internal error, signal value is %d", sfp->si_value.sival_int );
@@ -331 +330 @@
         __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
 
-        preemption_state.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
+        TL_GET( preemption_state ).in_progress = true;  // Sync flag : prevent recursive calls to the signal handler
         signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
-        preemption_state.in_progress = false;                     // Clear the in progress flag
+        TL_GET( preemption_state ).in_progress = false; // Clear the in progress flag
 
         // Preemption can occur here
 
-        BlockInternal( (thread_desc*)this_thread );         // Do the actual CtxSwitch
+        BlockInternal( (thread_desc*)TL_GET( this_thread ) ); // Do the actual CtxSwitch
 }
 

src/libcfa/concurrency/preemption.h

@@ -10 +10 @@
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 22:34:25 2017
-// Update Count     : 1
+// Last Modified On : Fri Mar 23 17:18:53 2018
+// Update Count     : 2
 //
 
@@ -21 +21 @@
 void kernel_start_preemption();
 void kernel_stop_preemption();
-void update_preemption( processor * this, __cfa_time_t duration );
+void update_preemption( processor * this, Duration duration );
 void tick_preemption();
 

src/libcfa/concurrency/thread

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:59:40 2017
-// Update Count     : 3
+// Last Modified On : Thu Mar 29 14:07:11 2018
+// Update Count     : 4
 //
 
@@ -52 +52 @@
 }
 
-extern thread_local thread_desc * volatile this_thread;
+//extern thread_local thread_desc * volatile this_thread;
 
 forall( dtype T | is_thread(T) )

src/libcfa/concurrency/thread.c

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 22:34:46 2017
-// Update Count     : 1
+// Last Modified On : Fri Mar 30 17:19:52 2018
+// Update Count     : 8
 //
 
@@ -26 +26 @@
 }
 
-extern volatile thread_local processor * this_processor;
+//extern volatile thread_local processor * this_processor;
 
 //-----------------------------------------------------------------------------
@@ -75 +75 @@
         coroutine_desc* thrd_c = get_coroutine(this);
         thread_desc   * thrd_h = get_thread   (this);
-        thrd_c->last = this_coroutine;
+        thrd_c->last = TL_GET( this_coroutine );
 
         // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
@@ -81 +81 @@
         disable_interrupts();
         create_stack(&thrd_c->stack, thrd_c->stack.size);
-        this_coroutine = thrd_c;
+        TL_SET( this_coroutine, thrd_c );
         CtxStart(&this, CtxInvokeThread);
         assert( thrd_c->last->stack.context );
@@ -92 +92 @@
 extern "C" {
         void __finish_creation(void) {
-                coroutine_desc* thrd_c = this_coroutine;
+                coroutine_desc* thrd_c = TL_GET( this_coroutine );
                 ThreadCtxSwitch( thrd_c, thrd_c->last );
         }
@@ -98 +98 @@
 
 void yield( void ) {
-        verify( preemption_state.enabled );
-        BlockInternal( this_thread );
-        verify( preemption_state.enabled );
+        verify( TL_GET( preemption_state ).enabled );
+        BlockInternal( TL_GET( this_thread ) );
+        verify( TL_GET( preemption_state ).enabled );
 }
 
@@ -116 +116 @@
         // set new coroutine that the processor is executing
         // and context switch to it
-        this_coroutine = dst;
+        TL_SET( this_coroutine, dst );
         assert( src->stack.context );
         CtxSwitch( src->stack.context, dst->stack.context );
-        this_coroutine = src;
+        TL_SET( this_coroutine, src );
 
         // set state of new coroutine to active