Changeset 04e6f93 for libcfa

Timestamp:

Feb 27, 2020, 4:04:25 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

a037f85

Parents:

41efd33 (diff), 930b504 (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:software/cfa/cfa-cc

Location:

libcfa/src

Files:

• bits/containers.hfa (modified) (2 diffs)
• bits/locks.hfa (modified) (4 diffs)
• concurrency/CtxSwitch-arm.S (modified) (2 diffs)
• concurrency/CtxSwitch-i386.S (modified) (2 diffs)
• concurrency/CtxSwitch-x86_64.S (modified) (3 diffs)
• concurrency/alarm.cfa (modified) (1 diff)
• concurrency/alarm.hfa (modified) (3 diffs)
• concurrency/coroutine.cfa (modified) (7 diffs)
• concurrency/coroutine.hfa (modified) (12 diffs)
• concurrency/invoke.c (modified) (7 diffs)
• concurrency/invoke.h (modified) (11 diffs)
• concurrency/kernel.cfa (modified) (29 diffs)
• concurrency/kernel.hfa (modified) (7 diffs)
• concurrency/kernel_private.hfa (modified) (5 diffs)
• concurrency/monitor.cfa (modified) (41 diffs)
• concurrency/monitor.hfa (modified) (7 diffs)
• concurrency/mutex.cfa (modified) (8 diffs)
• concurrency/mutex.hfa (modified) (3 diffs)
• concurrency/preemption.cfa (modified) (7 diffs)
• concurrency/thread.cfa (modified) (3 diffs)
• concurrency/thread.hfa (modified) (3 diffs)
• exception.c (modified) (4 diffs)
• fstream.hfa (modified) (3 diffs)
• interpose.cfa (modified) (2 diffs)
• iostream.cfa (modified) (5 diffs)
• iostream.hfa (modified) (3 diffs)

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/CtxSwitch-arm.S

@@ -13 +13 @@
         .text
         .align  2
-        .global CtxSwitch
-        .type   CtxSwitch, %function
+        .global __cfactx_switch
+        .type   __cfactx_switch, %function
 
-CtxSwitch:
+__cfactx_switch:
         @ save callee-saved registers: r4-r8, r10, r11, r13(sp) (plus r9 depending on platform specification)
         @ I've seen reference to 31 registers on 64-bit, if this is the case, more need to be saved
@@ -52 +52 @@
         mov r15, r14
         #endif // R9_SPECIAL
-        
+
         .text
         .align  2
-        .global CtxInvokeStub
-        .type   CtxInvokeStub, %function
+        .global __cfactx_invoke_stub
+        .type   __cfactx_invoke_stub, %function
 
-CtxInvokeStub:
+__cfactx_invoke_stub:
         ldmfd r13!, {r0-r1}
         mov r15, r1

libcfa/src/concurrency/CtxSwitch-i386.S

@@ -43 +43 @@
         .text
         .align 2
-        .globl CtxSwitch
-        .type  CtxSwitch, @function
-CtxSwitch:
+        .globl __cfactx_switch
+        .type  __cfactx_switch, @function
+__cfactx_switch:
 
         // Copy the "from" context argument from the stack to register eax
@@ -83 +83 @@
 
         ret
-        .size  CtxSwitch, .-CtxSwitch
+        .size  __cfactx_switch, .-__cfactx_switch
 
 // Local Variables: //

libcfa/src/concurrency/CtxSwitch-x86_64.S

@@ -44 +44 @@
         .text
         .align 2
-        .globl CtxSwitch
-        .type  CtxSwitch, @function
-CtxSwitch:
+        .globl __cfactx_switch
+        .type  __cfactx_switch, @function
+__cfactx_switch:
 
         // Save volatile registers on the stack.
@@ -77 +77 @@
 
         ret
-        .size  CtxSwitch, .-CtxSwitch
+        .size  __cfactx_switch, .-__cfactx_switch
 
 //-----------------------------------------------------------------------------
@@ -83 +83 @@
         .text
         .align 2
-        .globl CtxInvokeStub
-        .type    CtxInvokeStub, @function
-CtxInvokeStub:
+        .globl __cfactx_invoke_stub
+        .type    __cfactx_invoke_stub, @function
+__cfactx_invoke_stub:
         movq %rbx, %rdi
         movq %r12, %rsi
         jmp *%r13
-        .size  CtxInvokeStub, .-CtxInvokeStub
+        .size  __cfactx_invoke_stub, .-__cfactx_invoke_stub
 
 // Local Variables: //

libcfa/src/concurrency/alarm.cfa

@@ -47 +47 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period ) with( this ) {
+void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period ) with( this ) {
         this.thrd = thrd;
         this.alarm = alarm;

libcfa/src/concurrency/alarm.hfa

@@ -23 +23 @@
 #include "time.hfa"
 
-struct thread_desc;
+struct $thread;
 struct processor;
 
@@ -43 +43 @@
 
         union {
-                thread_desc * thrd;     // thrd who created event
+                $thread * thrd; // thrd who created event
                 processor * proc;               // proc who created event
         };
@@ -53 +53 @@
 typedef alarm_node_t ** __alarm_it_t;
 
-void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period );
+void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period );
 void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period );
 void ^?{}( alarm_node_t & this );

libcfa/src/concurrency/coroutine.cfa

@@ -37 +37 @@
 
 extern "C" {
-        void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
+        void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
         static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) __attribute__ ((__noreturn__));
         static void _CtxCoroutine_UnwindCleanup(_Unwind_Reason_Code, struct _Unwind_Exception *) {
@@ -89 +89 @@
 }
 
-void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize ) with( this ) {
+void ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize ) with( this ) {
         (this.context){0p, 0p};
         (this.stack){storage, storageSize};
@@ -99 +99 @@
 }
 
-void ^?{}(coroutine_desc& this) {
+void ^?{}($coroutine& this) {
         if(this.state != Halted && this.state != Start && this.state != Primed) {
-                coroutine_desc * src = TL_GET( this_thread )->curr_cor;
-                coroutine_desc * dst = &this;
+                $coroutine * src = TL_GET( this_thread )->curr_cor;
+                $coroutine * dst = &this;
 
                 struct _Unwind_Exception storage;
@@ -115 +115 @@
                 }
 
-                CoroutineCtxSwitch( src, dst );
+                $ctx_switch( src, dst );
         }
 }
@@ -123 +123 @@
 forall(dtype T | is_coroutine(T))
 void prime(T& cor) {
-        coroutine_desc* this = get_coroutine(cor);
+        $coroutine* this = get_coroutine(cor);
         assert(this->state == Start);
 
@@ -187 +187 @@
 // is not inline (We can't inline Cforall in C)
 extern "C" {
-        void __leave_coroutine( struct coroutine_desc * src ) {
-                coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
+        void __cfactx_cor_leave( struct $coroutine * src ) {
+                $coroutine * starter = src->cancellation != 0 ? src->last : src->starter;
 
                 src->state = Halted;
@@ -201 +201 @@
                         src->name, src, starter->name, starter );
 
-                CoroutineCtxSwitch( src, starter );
-        }
-
-        struct coroutine_desc * __finish_coroutine(void) {
-                struct coroutine_desc * cor = kernelTLS.this_thread->curr_cor;
+                $ctx_switch( src, starter );
+        }
+
+        struct $coroutine * __cfactx_cor_finish(void) {
+                struct $coroutine * cor = kernelTLS.this_thread->curr_cor;
 
                 if(cor->state == Primed) {

libcfa/src/concurrency/coroutine.hfa

@@ -25 +25 @@
 trait is_coroutine(dtype T) {
       void main(T & this);
-      coroutine_desc * get_coroutine(T & this);
+      $coroutine * get_coroutine(T & this);
 };
 
-#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
+#define DECL_COROUTINE(X) static inline $coroutine* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 
 //-----------------------------------------------------------------------------
@@ -35 +35 @@
 // void ^?{}( coStack_t & this );
 
-void ?{}( coroutine_desc & this, const char name[], void * storage, size_t storageSize );
-void ^?{}( coroutine_desc & this );
+void  ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize );
+void ^?{}( $coroutine & this );
 
-static inline void ?{}( coroutine_desc & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
-static inline void ?{}( coroutine_desc & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
-static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
-static inline void ?{}( coroutine_desc & this, const char name[])                    { this{ name, 0p, 0 }; }
-static inline void ?{}( coroutine_desc & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
+static inline void ?{}( $coroutine & this)                                       { this{ "Anonymous Coroutine", 0p, 0 }; }
+static inline void ?{}( $coroutine & this, size_t stackSize)                     { this{ "Anonymous Coroutine", 0p, stackSize }; }
+static inline void ?{}( $coroutine & this, void * storage, size_t storageSize )  { this{ "Anonymous Coroutine", storage, storageSize }; }
+static inline void ?{}( $coroutine & this, const char name[])                    { this{ name, 0p, 0 }; }
+static inline void ?{}( $coroutine & this, const char name[], size_t stackSize ) { this{ name, 0p, stackSize }; }
 
 //-----------------------------------------------------------------------------
@@ -54 +54 @@
 void prime(T & cor);
 
-static inline struct coroutine_desc * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
+static inline struct $coroutine * active_coroutine() { return TL_GET( this_thread )->curr_cor; }
 
 //-----------------------------------------------------------------------------
@@ -61 +61 @@
 // Start coroutine routines
 extern "C" {
-        void CtxInvokeCoroutine(void (*main)(void *), void * this);
+        void __cfactx_invoke_coroutine(void (*main)(void *), void * this);
 
         forall(dtype T)
-        void CtxStart(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
+        void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *));
 
-        extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
+        extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__));
 
-        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
+        extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
 }
 
 // Private wrappers for context switch and stack creation
 // Wrapper for co
-static inline void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
+static inline void $ctx_switch( $coroutine * src, $coroutine * dst ) __attribute__((nonnull (1, 2))) {
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Inactive;
@@ -82 +82 @@
         // context switch to specified coroutine
         verify( dst->context.SP );
-        CtxSwitch( &src->context, &dst->context );
-        // when CtxSwitch returns we are back in the src coroutine
+        __cfactx_switch( &src->context, &dst->context );
+        // when __cfactx_switch returns we are back in the src coroutine
 
         // set state of new coroutine to active
@@ -89 +89 @@
 
         if( unlikely(src->cancellation != 0p) ) {
-                _CtxCoroutine_Unwind(src->cancellation, src);
+                __cfactx_coroutine_unwind(src->cancellation, src);
         }
 }
@@ -102 +102 @@
         // will also migrate which means this value will
         // stay in syn with the TLS
-        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+        $coroutine * src = TL_GET( this_thread )->curr_cor;
 
         assertf( src->last != 0,
@@ -113 +113 @@
                 src->name, src, src->last->name, src->last );
 
-        CoroutineCtxSwitch( src, src->last );
+        $ctx_switch( src, src->last );
 }
 
@@ -124 +124 @@
         // will also migrate which means this value will
         // stay in syn with the TLS
-        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
-        coroutine_desc * dst = get_coroutine(cor);
+        $coroutine * src = TL_GET( this_thread )->curr_cor;
+        $coroutine * dst = get_coroutine(cor);
 
         if( unlikely(dst->context.SP == 0p) ) {
                 TL_GET( this_thread )->curr_cor = dst;
                 __stack_prepare(&dst->stack, 65000);
-                CtxStart(main, dst, cor, CtxInvokeCoroutine);
+                __cfactx_start(main, dst, cor, __cfactx_invoke_coroutine);
                 TL_GET( this_thread )->curr_cor = src;
         }
@@ -147 +147 @@
 
         // always done for performance testing
-        CoroutineCtxSwitch( src, dst );
+        $ctx_switch( src, dst );
 
         return cor;
 }
 
-static inline void resume(coroutine_desc * dst) {
+static inline void resume( $coroutine * dst ) __attribute__((nonnull (1))) {
         // optimization : read TLS once and reuse it
         // Safety note: this is preemption safe since if
@@ -158 +158 @@
         // will also migrate which means this value will
         // stay in syn with the TLS
-        coroutine_desc * src = TL_GET( this_thread )->curr_cor;
+        $coroutine * src = TL_GET( this_thread )->curr_cor;
 
         // not resuming self ?
@@ -172 +172 @@
 
         // always done for performance testing
-        CoroutineCtxSwitch( src, dst );
+        $ctx_switch( src, dst );
 }
 

libcfa/src/concurrency/invoke.c

@@ -29 +29 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
-extern void __leave_coroutine ( struct coroutine_desc * );
-extern struct coroutine_desc * __finish_coroutine(void);
-extern void __leave_thread_monitor();
+extern struct $coroutine * __cfactx_cor_finish(void);
+extern void __cfactx_cor_leave ( struct $coroutine * );
+extern void __cfactx_thrd_leave();
+
 extern void disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
 
-void CtxInvokeCoroutine(
+void __cfactx_invoke_coroutine(
         void (*main)(void *),
         void *this
 ) {
         // Finish setting up the coroutine by setting its state
-        struct coroutine_desc * cor = __finish_coroutine();
+        struct $coroutine * cor = __cfactx_cor_finish();
 
         // Call the main of the coroutine
@@ -46 +47 @@
 
         //Final suspend, should never return
-        __leave_coroutine( cor );
+        __cfactx_cor_leave( cor );
         __cabi_abort( "Resumed dead coroutine" );
 }
 
-static _Unwind_Reason_Code _CtxCoroutine_UnwindStop(
+static _Unwind_Reason_Code __cfactx_coroutine_unwindstop(
         __attribute((__unused__)) int version,
         _Unwind_Action actions,
@@ -61 +62 @@
                 // We finished unwinding the coroutine,
                 // leave it
-                __leave_coroutine( param );
+                __cfactx_cor_leave( param );
                 __cabi_abort( "Resumed dead coroutine" );
         }
@@ -69 +70 @@
 }
 
-void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) __attribute__ ((__noreturn__));
-void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc * cor) {
-        _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, _CtxCoroutine_UnwindStop, cor );
+void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) __attribute__ ((__noreturn__));
+void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) {
+        _Unwind_Reason_Code ret = _Unwind_ForcedUnwind( storage, __cfactx_coroutine_unwindstop, cor );
         printf("UNWIND ERROR %d after force unwind\n", ret);
         abort();
 }
 
-void CtxInvokeThread(
+void __cfactx_invoke_thread(
         void (*main)(void *),
         void *this
@@ -93 +94 @@
         // The order of these 4 operations is very important
         //Final suspend, should never return
-        __leave_thread_monitor();
+        __cfactx_thrd_leave();
         __cabi_abort( "Resumed dead thread" );
 }
 
-void CtxStart(
+void __cfactx_start(
         void (*main)(void *),
-        struct coroutine_desc * cor,
+        struct $coroutine * cor,
         void *this,
         void (*invoke)(void *)
@@ -139 +140 @@
 
         fs->dummyReturn = NULL;
-        fs->rturn = CtxInvokeStub;
+        fs->rturn = __cfactx_invoke_stub;
         fs->fixedRegisters[0] = main;
         fs->fixedRegisters[1] = this;
@@ -157 +158 @@
         struct FakeStack *fs = (struct FakeStack *)cor->context.SP;
 
-        fs->intRegs[8] = CtxInvokeStub;
+        fs->intRegs[8] = __cfactx_invoke_stub;
         fs->arg[0] = this;
         fs->arg[1] = invoke;

libcfa/src/concurrency/invoke.h

@@ -47 +47 @@
         extern "Cforall" {
                 extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
-                        struct thread_desc    * volatile this_thread;
+                        struct $thread    * volatile this_thread;
                         struct processor      * volatile this_processor;
 
@@ -92 +92 @@
         };
 
-        enum coroutine_state { Halted, Start, Inactive, Active, Primed };
-
-        struct coroutine_desc {
-                // context that is switch during a CtxSwitch
+        enum coroutine_state { Halted, Start, Primed, Inactive, Active, Rerun };
+        enum __Preemption_Reason { __NO_PREEMPTION, __ALARM_PREEMPTION, __POLL_PREEMPTION, __MANUAL_PREEMPTION };
+
+        struct $coroutine {
+                // context that is switch during a __cfactx_switch
                 struct __stack_context_t context;
 
@@ -108 +109 @@
 
                 // first coroutine to resume this one
-                struct coroutine_desc * starter;
+                struct $coroutine * starter;
 
                 // last coroutine to resume this one
-                struct coroutine_desc * last;
+                struct $coroutine * last;
 
                 // If non-null stack must be unwound with this exception
@@ -127 +128 @@
         };
 
-        struct monitor_desc {
+        struct $monitor {
                 // spinlock to protect internal data
                 struct __spinlock_t lock;
 
                 // current owner of the monitor
-                struct thread_desc * owner;
+                struct $thread * owner;
 
                 // queue of threads that are blocked waiting for the monitor
-                __queue_t(struct thread_desc) entry_queue;
+                __queue_t(struct $thread) entry_queue;
 
                 // stack of conditions to run next once we exit the monitor
@@ -152 +153 @@
         struct __monitor_group_t {
                 // currently held monitors
-                __cfa_anonymous_object( __small_array_t(monitor_desc*) );
+                __cfa_anonymous_object( __small_array_t($monitor*) );
 
                 // last function that acquired monitors
@@ -158 +159 @@
         };
 
-        struct thread_desc {
+        struct $thread {
                 // Core threading fields
-                // context that is switch during a CtxSwitch
+                // context that is switch during a __cfactx_switch
                 struct __stack_context_t context;
 
                 // 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
 
                 // coroutine body used to store context
-                struct coroutine_desc  self_cor;
+                struct $coroutine  self_cor;
 
                 // current active context
-                struct coroutine_desc * curr_cor;
+                struct $coroutine * curr_cor;
 
                 // monitor body used for mutual exclusion
-                struct monitor_desc    self_mon;
+                struct $monitor    self_mon;
 
                 // pointer to monitor with sufficient lifetime for current monitors
-                struct monitor_desc *  self_mon_p;
+                struct $monitor *  self_mon_p;
 
                 // pointer to the cluster on which the thread is running
@@ -188 +190 @@
                 // Link lists fields
                 // instrusive link field for threads
-                struct thread_desc * next;
+                struct $thread * next;
 
                 struct {
-                        struct thread_desc * next;
-                        struct thread_desc * prev;
+                        struct $thread * next;
+                        struct $thread * prev;
                 } node;
         };
@@ -198 +200 @@
         #ifdef __cforall
         extern "Cforall" {
-                static inline thread_desc *& get_next( thread_desc & this ) {
+                static inline $thread *& get_next( $thread & this ) __attribute__((const)) {
                         return this.next;
                 }
 
-                static inline [thread_desc *&, thread_desc *& ] __get( thread_desc & this ) {
+                static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) {
                         return this.node.[next, prev];
                 }
@@ -212 +214 @@
                 }
 
-                static inline void ?{}(__monitor_group_t & this, struct monitor_desc ** data, __lock_size_t size, fptr_t func) {
+                static inline void ?{}(__monitor_group_t & this, struct $monitor ** data, __lock_size_t size, fptr_t func) {
                         (this.data){data};
                         (this.size){size};
@@ -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;
@@ -252 +254 @@
 
         // assembler routines that performs the context switch
-        extern void CtxInvokeStub( void );
-        extern void CtxSwitch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("CtxSwitch");
+        extern void __cfactx_invoke_stub( void );
+        extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch");
         // void CtxStore ( void * this ) asm ("CtxStore");
         // void CtxRet   ( void * dst  ) asm ("CtxRet");

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 ) ));
 
 //-----------------------------------------------------------------------------
@@ -117 +117 @@
 KERNEL_STORAGE(cluster,         mainCluster);
 KERNEL_STORAGE(processor,       mainProcessor);
-KERNEL_STORAGE(thread_desc,     mainThread);
+KERNEL_STORAGE($thread, mainThread);
 KERNEL_STORAGE(__stack_t,       mainThreadCtx);
 
 cluster     * mainCluster;
 processor   * mainProcessor;
-thread_desc * mainThread;
+$thread * mainThread;
 
 extern "C" {
@@ -164 +164 @@
 // Main thread construction
 
-void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
+void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) {
         stack.storage = info->storage;
         with(*stack.storage) {
@@ -179 +179 @@
 }
 
-void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
+void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
         state = Start;
         self_cor{ info };
@@ -208 +208 @@
 }
 
-static void start(processor * this);
+static void * __invoke_processor(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, __invoke_processor, (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 * __next_thread(cluster * this);
+static void __run_thread(processor * this, $thread * dst);
+static void __halt(processor * this);
 
 //Main of the processor contexts
@@ -281 +287 @@
                 __cfaabi_dbg_print_safe("Kernel : core %p started\n", this);
 
-                thread_desc * readyThread = 0p;
+                $thread * 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) {
-        coroutine_desc * proc_cor = get_coroutine(this->runner);
-
-        // Reset the terminating actions here
-        this->finish.action_code = No_Action;
+static void __run_thread(processor * this, $thread * thrd_dst) {
+        $coroutine * proc_cor = get_coroutine(this->runner);
 
         // 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 );
+                __cfactx_switch( &proc_cor->context, &thrd_dst->context );
+                // when __cfactx_switch 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() {
-        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");
-        }
+void returnToKernel() {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        $coroutine * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
+        $thread * thrd_src = kernelTLS.this_thread;
+
+        // Run the thread on this processor
+        {
+                int local_errno = *__volatile_errno();
+                #if defined( __i386 ) || defined( __x86_64 )
+                        __x87_store;
+                #endif
+                verify( proc_cor->context.SP );
+                __cfactx_switch( &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 );
 }
 
@@ -406 +424 @@
 // This is the entry point for processors (kernel threads)
 // It effectively constructs a coroutine by stealing the pthread stack
-static void * CtxInvokeProcessor(void * arg) {
+static void * __invoke_processor(void * arg) {
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
@@ -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 ) {
-        thread_desc * src = mainThread;
-        coroutine_desc * dst = get_coroutine(this->runner);
+static void __kernel_first_resume( processor * this ) {
+        $thread * src = mainThread;
+        $coroutine * dst = get_coroutine(this->runner);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -492 +502 @@
         kernelTLS.this_thread->curr_cor = dst;
         __stack_prepare( &dst->stack, 65000 );
-        CtxStart(main, dst, this->runner, CtxInvokeCoroutine);
+        __cfactx_start(main, dst, this->runner, __cfactx_invoke_coroutine);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -504 +514 @@
         // context switch to specified coroutine
         verify( dst->context.SP );
-        CtxSwitch( &src->context, &dst->context );
-        // when CtxSwitch returns we are back in the src coroutine
+        __cfactx_switch( &src->context, &dst->context );
+        // when __cfactx_switch returns we are back in the src coroutine
 
         mainThread->curr_cor = &mainThread->self_cor;
@@ -516 +526 @@
 
 // KERNEL_ONLY
-void kernel_last_resume( processor * this ) {
-        coroutine_desc * src = &mainThread->self_cor;
-        coroutine_desc * dst = get_coroutine(this->runner);
+static void __kernel_last_resume( processor * this ) {
+        $coroutine * src = &mainThread->self_cor;
+        $coroutine * dst = get_coroutine(this->runner);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -525 +535 @@
 
         // context switch to the processor
-        CtxSwitch( &src->context, &dst->context );
+        __cfactx_switch( &src->context, &dst->context );
 }
 
 //-----------------------------------------------------------------------------
 // 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 * 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 * __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 );
+        $thread * 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 * 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 * 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");
@@ -705 +683 @@
         // SKULLDUGGERY: the mainThread steals the process main thread
         // which will then be scheduled by the mainProcessor normally
-        mainThread = (thread_desc *)&storage_mainThread;
+        mainThread = ($thread *)&storage_mainThread;
         current_stack_info_t info;
         info.storage = (__stack_t*)&storage_mainThreadCtx;
@@ -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
+        // context. Hence, the main thread does not begin through __cfactx_invoke_thread, 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) );
 
@@ -857 +835 @@
 
 void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
-        thread_desc * thrd = kernel_data;
+        $thread * thrd = kernel_data;
 
         if(thrd) {
@@ -913 +891 @@
 
                 // atomically release spin lock and block
-                BlockInternal( &lock );
+                unlock( lock );
+                park();
         }
         else {
@@ -921 +900 @@
 
 void V(semaphore & this) with( this ) {
-        thread_desc * thrd = 0p;
+        $thread * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
         count += 1;
@@ -932 +911 @@
 
         // make new owner
-        WakeThread( thrd );
+        unpark( thrd );
 }
 
@@ -949 +928 @@
 }
 
-void doregister( cluster * cltr, thread_desc & thrd ) {
+void doregister( cluster * cltr, $thread & thrd ) {
         lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         cltr->nthreads += 1;
@@ -956 +935 @@
 }
 
-void unregister( cluster * cltr, thread_desc & thrd ) {
+void unregister( cluster * cltr, $thread & thrd ) {
         lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
         remove(cltr->threads, thrd );
@@ -990 +969 @@
 //-----------------------------------------------------------------------------
 // Debug
-bool threading_enabled(void) {
+bool threading_enabled(void) __attribute__((const)) {
         return true;
 }

libcfa/src/concurrency/kernel.hfa

@@ -32 +32 @@
         __spinlock_t lock;
         int count;
-        __queue_t(thread_desc) waiting;
+        __queue_t($thread) waiting;
 };
 
@@ -44 +44 @@
 // Processor
 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
@@ -116 +67 @@
         // RunThread data
         // Action to do after a thread is ran
-        struct FinishAction finish;
+        $thread * 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]; }
 
 //-----------------------------------------------------------------------------
@@ -168 +117 @@
 
         // Ready queue for threads
-        __queue_t(thread_desc) ready_queue;
+        __queue_t($thread) ready_queue;
 
         // Name of the cluster
@@ -184 +133 @@
         // List of threads
         __spinlock_t thread_list_lock;
-        __dllist_t(struct thread_desc) threads;
+        __dllist_t(struct $thread) threads;
         unsigned int nthreads;
 
@@ -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

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 * ) __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) {
@@ -88 +71 @@
 // Threads
 extern "C" {
-      void CtxInvokeThread(void (*main)(void *), void * this);
+      void __cfactx_invoke_thread(void (*main)(void *), void * this);
 }
 
-extern void ThreadCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
-
 __cfaabi_dbg_debug_do(
-        extern void __cfaabi_dbg_thread_register  ( thread_desc * thrd );
-        extern void __cfaabi_dbg_thread_unregister( thread_desc * thrd );
+        extern void __cfaabi_dbg_thread_register  ( $thread * thrd );
+        extern void __cfaabi_dbg_thread_unregister( $thread * thrd );
 )
 
@@ -102 +83 @@
 #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;
@@ -113 +94 @@
 void unregister( struct cluster & cltr );
 
-void doregister( struct cluster * cltr, struct thread_desc & thrd );
-void unregister( struct cluster * cltr, struct thread_desc & thrd );
+void doregister( struct cluster * cltr, struct $thread & thrd );
+void unregister( struct cluster * cltr, struct $thread & thrd );
 
 void doregister( struct cluster * cltr, struct processor * proc );

libcfa/src/concurrency/monitor.cfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// monitor_desc.c --
+// $monitor.c --
 //
 // Author           : Thierry Delisle
@@ -27 +27 @@
 //-----------------------------------------------------------------------------
 // Forward declarations
-static inline void set_owner ( monitor_desc * this, thread_desc * owner );
-static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner );
-static inline void set_mask  ( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
-static inline void reset_mask( monitor_desc * this );
-
-static inline thread_desc * next_thread( monitor_desc * this );
-static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
+static inline void __set_owner ( $monitor * this, $thread * owner );
+static inline void __set_owner ( $monitor * storage [], __lock_size_t count, $thread * owner );
+static inline void set_mask  ( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
+static inline void reset_mask( $monitor * this );
+
+static inline $thread * next_thread( $monitor * this );
+static inline bool is_accepted( $monitor * this, const __monitor_group_t & monitors );
 
 static inline void lock_all  ( __spinlock_t * locks [], __lock_size_t count );
-static inline void lock_all  ( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
+static inline void lock_all  ( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count );
 static inline void unlock_all( __spinlock_t * locks [], __lock_size_t count );
-static inline void unlock_all( monitor_desc * locks [], __lock_size_t count );
-
-static inline void save   ( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
-static inline void restore( monitor_desc * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
-
-static inline void init     ( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
-
-static inline thread_desc *        check_condition   ( __condition_criterion_t * );
+static inline void unlock_all( $monitor * locks [], __lock_size_t count );
+
+static inline void save   ( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
+static inline void restore( $monitor * ctx [], __lock_size_t count, __spinlock_t * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
+
+static inline void init     ( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+
+static inline $thread *        check_condition   ( __condition_criterion_t * );
 static inline void                 brand_condition   ( condition & );
-static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], __lock_size_t count );
+static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count );
 
 forall(dtype T | sized( T ))
 static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val );
 static inline __lock_size_t count_max    ( const __waitfor_mask_t & mask );
-static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( $monitor * storage [], const __waitfor_mask_t & mask );
 
 //-----------------------------------------------------------------------------
@@ -68 +68 @@
 
 #define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
-        monitor_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+        $monitor ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
         __lock_size_t count = cnt;                                /* Save the count to a local variable                                                  */ \
         unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
@@ -80 +80 @@
 //-----------------------------------------------------------------------------
 // Enter/Leave routines
-
-
-extern "C" {
-        // Enter single monitor
-        static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
-                // Lock the monitor spinlock
-                lock( this->lock __cfaabi_dbg_ctx2 );
-                // Interrupts disable inside critical section
-                thread_desc * thrd = kernelTLS.this_thread;
-
-                __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
-
-                if( !this->owner ) {
-                        // No one has the monitor, just take it
-                        set_owner( this, thrd );
-
-                        __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
-                }
-                else if( this->owner == thrd) {
-                        // We already have the monitor, just note how many times we took it
-                        this->recursion += 1;
-
-                        __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
-                }
-                else if( is_accepted( this, group) ) {
-                        // Some one was waiting for us, enter
-                        set_owner( this, thrd );
-
-                        // Reset mask
-                        reset_mask( this );
-
-                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
-                }
-                else {
-                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
-
-                        // Some one else has the monitor, wait in line for it
-                        append( this->entry_queue, thrd );
-
-                        BlockInternal( &this->lock );
-
-                        __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
-
-                        // BlockInternal will unlock spinlock, no need to unlock ourselves
-                        return;
-                }
+// Enter single monitor
+static void __enter( $monitor * this, const __monitor_group_t & group ) {
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+        // Interrupts disable inside critical section
+        $thread * thrd = kernelTLS.this_thread;
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
+
+        if( !this->owner ) {
+                // No one has the monitor, just take it
+                __set_owner( this, thrd );
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon is free \n" );
+        }
+        else if( this->owner == thrd) {
+                // We already have the monitor, just note how many times we took it
+                this->recursion += 1;
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon already owned \n" );
+        }
+        else if( is_accepted( this, group) ) {
+                // Some one was waiting for us, enter
+                __set_owner( this, thrd );
+
+                // Reset mask
+                reset_mask( this );
+
+                __cfaabi_dbg_print_safe( "Kernel :  mon accepts \n" );
+        }
+        else {
+                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+
+                // Some one else has the monitor, wait in line for it
+                /* paranoid */ verify( thrd->next == 0p );
+                append( this->entry_queue, thrd );
+                /* paranoid */ verify( thrd->next == 1p );
+
+                unlock( this->lock );
+                park();
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
 
-                // Release the lock and leave
+                /* 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
+        unlock( this->lock );
+        return;
+}
+
+static void __dtor_enter( $monitor * this, fptr_t func ) {
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+        // Interrupts disable inside critical section
+        $thread * thrd = kernelTLS.this_thread;
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+
+
+        if( !this->owner ) {
+                __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
+
+                // No one has the monitor, just take it
+                __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;
         }
-
-        static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
-                // Lock the monitor spinlock
-                lock( this->lock __cfaabi_dbg_ctx2 );
-                // Interrupts disable inside critical section
-                thread_desc * thrd = kernelTLS.this_thread;
-
-                __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
-
-
-                if( !this->owner ) {
-                        __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this);
-
-                        // No one has the monitor, just take it
-                        set_owner( this, thrd );
-
-                        unlock( this->lock );
-                        return;
+        else if( this->owner == thrd) {
+                // We already have the monitor... but where about to destroy it so the nesting will fail
+                // Abort!
+                abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
+        }
+
+        __lock_size_t count = 1;
+        $monitor ** monitors = &this;
+        __monitor_group_t group = { &this, 1, func };
+        if( is_accepted( this, group) ) {
+                __cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
+
+                // Wake the thread that is waiting for this
+                __condition_criterion_t * urgent = pop( this->signal_stack );
+                /* paranoid */ verify( urgent );
+
+                // Reset mask
+                reset_mask( this );
+
+                // Create the node specific to this wait operation
+                wait_ctx_primed( thrd, 0 )
+
+                // Some one else has the monitor, wait for him to finish and then run
+                unlock( this->lock );
+
+                // Release the next thread
+                /* paranoid */ verifyf( urgent->owner->waiting_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                unpark( urgent->owner->waiting_thread );
+
+                // Park current thread waiting
+                park();
+
+                // Some one was waiting for us, enter
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+        }
+        else {
+                __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
+
+                wait_ctx( thrd, 0 )
+                this->dtor_node = &waiter;
+
+                // Some one else has the monitor, wait in line for it
+                /* paranoid */ verify( thrd->next == 0p );
+                append( this->entry_queue, thrd );
+                /* paranoid */ verify( thrd->next == 1p );
+                unlock( this->lock );
+
+                // Park current thread waiting
+                park();
+
+                /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+                return;
+        }
+
+        __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
+
+}
+
+// Leave single monitor
+void __leave( $monitor * this ) {
+        // Lock the monitor spinlock
+        lock( this->lock __cfaabi_dbg_ctx2 );
+
+        __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", kernelTLS.this_thread, this, this->owner);
+
+        /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
+
+        // Leaving a recursion level, decrement the counter
+        this->recursion -= 1;
+
+        // If we haven't left the last level of recursion
+        // it means we don't need to do anything
+        if( this->recursion != 0) {
+                __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
+                unlock( this->lock );
+                return;
+        }
+
+        // Get the next thread, will be null on low contention monitor
+        $thread * new_owner = next_thread( this );
+
+        // Check the new owner is consistent with who we wake-up
+        // new_owner might be null even if someone owns the monitor when the owner is still waiting for another monitor
+        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+
+        // We can now let other threads in safely
+        unlock( this->lock );
+
+        //We need to wake-up the thread
+        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+        unpark( new_owner );
+}
+
+// Leave single monitor for the last time
+void __dtor_leave( $monitor * this ) {
+        __cfaabi_dbg_debug_do(
+                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);
                 }
-                else if( this->owner == thrd) {
-                        // We already have the monitor... but where about to destroy it so the nesting will fail
-                        // Abort!
-                        abort( "Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.", this, thrd->self_cor.name, thrd );
+                if( this->recursion != 1 ) {
+                        abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
                 }
-
-                __lock_size_t count = 1;
-                monitor_desc ** monitors = &this;
-                __monitor_group_t group = { &this, 1, func };
-                if( is_accepted( this, group) ) {
-                        __cfaabi_dbg_print_safe( "Kernel :  mon accepts dtor, block and signal it \n" );
-
-                        // Wake the thread that is waiting for this
-                        __condition_criterion_t * urgent = pop( this->signal_stack );
-                        verify( urgent );
-
-                        // Reset mask
-                        reset_mask( this );
-
-                        // Create the node specific to this wait operation
-                        wait_ctx_primed( thrd, 0 )
-
-                        // Some one else has the monitor, wait for him to finish and then run
-                        BlockInternal( &this->lock, urgent->owner->waiting_thread );
-
-                        // Some one was waiting for us, enter
-                        set_owner( this, thrd );
-                }
-                else {
-                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
-
-                        wait_ctx( thrd, 0 )
-                        this->dtor_node = &waiter;
-
-                        // Some one else has the monitor, wait in line for it
-                        append( this->entry_queue, thrd );
-                        BlockInternal( &this->lock );
-
-                        // BlockInternal will unlock spinlock, no need to unlock ourselves
-                        return;
-                }
-
-                __cfaabi_dbg_print_safe( "Kernel : Destroying %p\n", this);
-
-        }
-
-        // Leave single monitor
-        void __leave_monitor_desc( monitor_desc * this ) {
-                // Lock the monitor spinlock
-                lock( this->lock __cfaabi_dbg_ctx2 );
-
-                __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 );
-
-                // Leaving a recursion level, decrement the counter
-                this->recursion -= 1;
-
-                // If we haven't left the last level of recursion
-                // it means we don't need to do anything
-                if( this->recursion != 0) {
-                        __cfaabi_dbg_print_safe( "Kernel :  recursion still %d\n", this->recursion);
-                        unlock( this->lock );
-                        return;
-                }
-
-                // Get the next thread, will be null on low contention monitor
-                thread_desc * new_owner = next_thread( this );
-
-                // We can now let other threads in safely
-                unlock( this->lock );
-
-                //We need to wake-up the thread
-                WakeThread( new_owner );
-        }
-
-        // Leave single monitor for the last time
-        void __leave_dtor_monitor_desc( monitor_desc * this ) {
-                __cfaabi_dbg_debug_do(
-                        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 ) {
-                                abort( "Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
-                        }
-                )
-        }
-
+        )
+}
+
+extern "C" {
         // Leave the thread monitor
         // last routine called by a thread.
         // Should never return
-        void __leave_thread_monitor() {
-                thread_desc * thrd = TL_GET( this_thread );
-                monitor_desc * this = &thrd->self_mon;
+        void __cfactx_thrd_leave() {
+                $thread * thrd = TL_GET( this_thread );
+                $monitor * this = &thrd->self_mon;
 
                 // Lock the monitor now
@@ -252 +275 @@
                 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
@@ -264 +287 @@
 
                 // Fetch the next thread, can be null
-                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 );
+                $thread * new_owner = next_thread( this );
+
+                // Release the monitor lock
+                unlock( this->lock );
+
+                // Unpark the next owner if needed
+                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                /* paranoid */ verify( ! kernelTLS.this_processor->destroyer );
+                /* paranoid */ verify( thrd->state == Halted );
+
+                kernelTLS.this_processor->destroyer = new_owner;
+
+                // Leave the thread
+                __leave_thread();
 
                 // Control flow should never reach here!
@@ -279 +311 @@
 static inline void enter( __monitor_group_t monitors ) {
         for( __lock_size_t i = 0; i < monitors.size; i++) {
-                __enter_monitor_desc( monitors[i], monitors );
+                __enter( monitors[i], monitors );
         }
 }
@@ -285 +317 @@
 // Leave multiple monitor
 // relies on the monitor array being sorted
-static inline void leave(monitor_desc * monitors [], __lock_size_t count) {
+static inline void leave($monitor * monitors [], __lock_size_t count) {
         for( __lock_size_t i = count - 1; i >= 0; i--) {
-                __leave_monitor_desc( monitors[i] );
+                __leave( monitors[i] );
         }
 }
@@ -293 +325 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor_desc * m [], __lock_size_t count, fptr_t func ) {
-        thread_desc * thrd = TL_GET( this_thread );
+void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) {
+        $thread * thrd = TL_GET( this_thread );
 
         // Store current array
@@ -334 +366 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
+void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func ) {
         // optimization
-        thread_desc * thrd = TL_GET( this_thread );
+        $thread * thrd = TL_GET( this_thread );
 
         // Store current array
@@ -347 +379 @@
         (thrd->monitors){m, 1, func};
 
-        __enter_monitor_dtor( this.m, func );
+        __dtor_enter( this.m, func );
 }
 
@@ -353 +385 @@
 void ^?{}( monitor_dtor_guard_t & this ) {
         // Leave the monitors in order
-        __leave_dtor_monitor_desc( this.m );
+        __dtor_leave( this.m );
 
         // Restore thread context
@@ -361 +393 @@
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
+void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
         this.count = count;
@@ -375 +407 @@
 }
 
-void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
+void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) {
         this.ready  = false;
         this.target = target;
@@ -400 +432 @@
         // 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)
@@ -407 +441 @@
         // Find the next thread(s) to run
         __lock_size_t thread_count = 0;
-        thread_desc * threads[ count ];
+        $thread * threads[ count ];
         __builtin_memset( threads, 0, sizeof( threads ) );
 
@@ -415 +449 @@
         // Remove any duplicate threads
         for( __lock_size_t i = 0; i < count; i++) {
-                thread_desc * new_owner = next_thread( monitors[i] );
+                $thread * new_owner = next_thread( monitors[i] );
                 insert_unique( threads, thread_count, new_owner );
         }
 
+        // 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
@@ -435 +479 @@
         //Some more checking in debug
         __cfaabi_dbg_debug_do(
-                thread_desc * this_thrd = TL_GET( this_thread );
+                $thread * 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 );
@@ -489 +533 @@
 
         //Find the thread to run
-        thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
-        set_owner( monitors, count, signallee );
+        $thread * 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();
 
 
@@ -536 +587 @@
         // Create one!
         __lock_size_t max = count_max( mask );
-        monitor_desc * mon_storage[max];
+        $monitor * mon_storage[max];
         __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
         __lock_size_t actual_count = aggregate( mon_storage, mask );
@@ -554 +605 @@
         {
                 // Check if the entry queue
-                thread_desc * next; int index;
+                $thread * next; int index;
                 [next, index] = search_entry_queue( mask, monitors, count );
 
@@ -564 +615 @@
                                 verifyf( accepted.size == 1,  "ERROR: Accepted dtor has more than 1 mutex parameter." );
 
-                                monitor_desc * mon2dtor = accepted[0];
+                                $monitor * mon2dtor = accepted[0];
                                 verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
 
@@ -590 +641 @@
 
                                 // Set the owners to be the next thread
-                                set_owner( monitors, count, next );
-
-                                // Everything is ready to go to sleep
-                                BlockInternal( locks, count, &next, 1 );
+                                __set_owner( monitors, count, next );
+
+                                // unlock all the monitors
+                                unlock_all( locks, count );
+
+                                // unpark the thread we signalled
+                                unpark( next );
+
+                                //Everything is ready to go to sleep
+                                park();
 
                                 // We are back, restore the owners and recursions
@@ -631 +688 @@
         }
 
+        // unlock all the monitors
+        unlock_all( locks, count );
+
         //Everything is ready to go to sleep
-        BlockInternal( locks, count );
+        park();
 
 
@@ -649 +709 @@
 // Utilities
 
-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 );
+static inline void __set_owner( $monitor * this, $thread * owner ) {
+        /* paranoid */ verify( this->lock.lock );
 
         //Pass the monitor appropriately
@@ -659 +719 @@
 }
 
-static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
-        monitors[0]->owner     = owner;
-        monitors[0]->recursion = 1;
+static inline void __set_owner( $monitor * monitors [], __lock_size_t count, $thread * owner ) {
+        /* paranoid */ verify ( monitors[0]->lock.lock );
+        /* paranoid */ verifyf( monitors[0]->owner == kernelTLS.this_thread, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, monitors[0]->owner, monitors[0]->recursion, monitors[0] );
+        monitors[0]->owner        = owner;
+        monitors[0]->recursion    = 1;
         for( __lock_size_t i = 1; i < count; i++ ) {
-                monitors[i]->owner     = owner;
-                monitors[i]->recursion = 0;
-        }
-}
-
-static inline void set_mask( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
+                /* 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;
+        }
+}
+
+static inline void set_mask( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 storage[i]->mask = mask;
@@ -674 +738 @@
 }
 
-static inline void reset_mask( monitor_desc * this ) {
+static inline void reset_mask( $monitor * this ) {
         this->mask.accepted = 0p;
         this->mask.data = 0p;
@@ -680 +744 @@
 }
 
-static inline thread_desc * next_thread( monitor_desc * this ) {
+static inline $thread * next_thread( $monitor * this ) {
         //Check the signaller stack
         __cfaabi_dbg_print_safe( "Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
@@ -688 +752 @@
                 //regardless of if we are ready to baton pass,
                 //we need to set the monitor as in use
-                set_owner( this,  urgent->owner->waiting_thread );
+                /* 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 );
 
                 return check_condition( urgent );
@@ -695 +760 @@
         // No signaller thread
         // Get the next thread in the entry_queue
-        thread_desc * new_owner = pop_head( this->entry_queue );
-        set_owner( this, new_owner );
+        $thread * 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 );
 
         return new_owner;
 }
 
-static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
+static inline bool is_accepted( $monitor * this, const __monitor_group_t & group ) {
         __acceptable_t * it = this->mask.data; // Optim
         __lock_size_t count = this->mask.size;
@@ -723 +790 @@
 }
 
-static inline void init( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -731 +798 @@
 }
 
-static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+static inline void init_push( __lock_size_t count, $monitor * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
         for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
@@ -747 +814 @@
 }
 
-static inline void lock_all( monitor_desc * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
+static inline void lock_all( $monitor * source [], __spinlock_t * /*out*/ locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 __spinlock_t * l = &source[i]->lock;
@@ -761 +828 @@
 }
 
-static inline void unlock_all( monitor_desc * locks [], __lock_size_t count ) {
+static inline void unlock_all( $monitor * locks [], __lock_size_t count ) {
         for( __lock_size_t i = 0; i < count; i++ ) {
                 unlock( locks[i]->lock );
@@ -768 +835 @@
 
 static inline void save(
-        monitor_desc * ctx [],
+        $monitor * ctx [],
         __lock_size_t count,
         __attribute((unused)) __spinlock_t * locks [],
@@ -781 +848 @@
 
 static inline void restore(
-        monitor_desc * ctx [],
+        $monitor * ctx [],
         __lock_size_t count,
         __spinlock_t * locks [],
@@ -799 +866 @@
 // 2 - Checks if all the monitors are ready to run
 //     if so return the thread to run
-static inline thread_desc * check_condition( __condition_criterion_t * target ) {
+static inline $thread * check_condition( __condition_criterion_t * target ) {
         __condition_node_t * node = target->owner;
         unsigned short count = node->count;
@@ -822 +889 @@
 
 static inline void brand_condition( condition & this ) {
-        thread_desc * thrd = TL_GET( this_thread );
+        $thread * thrd = TL_GET( this_thread );
         if( !this.monitors ) {
                 // __cfaabi_dbg_print_safe( "Branding\n" );
@@ -828 +895 @@
                 this.monitor_count = thrd->monitors.size;
 
-                this.monitors = (monitor_desc **)malloc( this.monitor_count * sizeof( *this.monitors ) );
+                this.monitors = ($monitor **)malloc( this.monitor_count * sizeof( *this.monitors ) );
                 for( int i = 0; i < this.monitor_count; i++ ) {
                         this.monitors[i] = thrd->monitors[i];
@@ -835 +902 @@
 }
 
-static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
-
-        __queue_t(thread_desc) & entry_queue = monitors[0]->entry_queue;
+static inline [$thread *, int] search_entry_queue( const __waitfor_mask_t & mask, $monitor * monitors [], __lock_size_t count ) {
+
+        __queue_t($thread) & entry_queue = monitors[0]->entry_queue;
 
         // For each thread in the entry-queue
-        for(    thread_desc ** thrd_it = &entry_queue.head;
-                *thrd_it;
+        for(    $thread ** thrd_it = &entry_queue.head;
+                *thrd_it != 1p;
                 thrd_it = &(*thrd_it)->next
         ) {
@@ -884 +951 @@
 }
 
-static inline __lock_size_t aggregate( monitor_desc * storage [], const __waitfor_mask_t & mask ) {
+static inline __lock_size_t aggregate( $monitor * storage [], const __waitfor_mask_t & mask ) {
         __lock_size_t size = 0;
         for( __lock_size_t i = 0; i < mask.size; i++ ) {

libcfa/src/concurrency/monitor.hfa

@@ -23 +23 @@
 
 trait is_monitor(dtype T) {
-        monitor_desc * get_monitor( T & );
+        $monitor * get_monitor( T & );
         void ^?{}( T & mutex );
 };
 
-static inline void ?{}(monitor_desc & this) with( this ) {
+static inline void ?{}($monitor & this) with( this ) {
         lock{};
         entry_queue{};
@@ -39 +39 @@
 }
 
-static inline void ^?{}(monitor_desc & ) {}
+static inline void ^?{}($monitor & ) {}
 
 struct monitor_guard_t {
-        monitor_desc **         m;
+        $monitor **     m;
         __lock_size_t           count;
         __monitor_group_t prev;
 };
 
-void ?{}( monitor_guard_t & this, monitor_desc ** m, __lock_size_t count, void (*func)() );
+void ?{}( monitor_guard_t & this, $monitor ** m, __lock_size_t count, void (*func)() );
 void ^?{}( monitor_guard_t & this );
 
 struct monitor_dtor_guard_t {
-        monitor_desc *    m;
+        $monitor *    m;
         __monitor_group_t prev;
 };
 
-void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, void (*func)() );
+void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)() );
 void ^?{}( monitor_dtor_guard_t & this );
 
@@ -72 +72 @@
 
         // The monitor this criterion concerns
-        monitor_desc * target;
+        $monitor * target;
 
         // The parent node to which this criterion belongs
@@ -87 +87 @@
 struct __condition_node_t {
         // Thread that needs to be woken when all criteria are met
-        thread_desc * waiting_thread;
+        $thread * waiting_thread;
 
         // Array of criteria (Criterions are contiguous in memory)
@@ -106 +106 @@
 }
 
-void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info );
+void ?{}(__condition_node_t & this, $thread * waiting_thread, __lock_size_t count, uintptr_t user_info );
 void ?{}(__condition_criterion_t & this );
-void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
+void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t * owner );
 
 struct condition {
@@ -115 +115 @@
 
         // Array of monitor pointers (Monitors are NOT contiguous in memory)
-        monitor_desc ** monitors;
+        $monitor ** monitors;
 
         // Number of monitors in the array
@@ -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();
         }
 }
@@ -118 +120 @@
         recursion_count--;
         if( recursion_count == 0 ) {
-                thread_desc * thrd = pop_head( blocked_threads );
+                $thread * thrd = pop_head( blocked_threads );
                 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/mutex.hfa

@@ -36 +36 @@
 
         // List of blocked threads
-        __queue_t(struct thread_desc) blocked_threads;
+        __queue_t(struct $thread) blocked_threads;
 
         // Locked flag
@@ -55 +55 @@
 
         // List of blocked threads
-        __queue_t(struct thread_desc) blocked_threads;
+        __queue_t(struct $thread) blocked_threads;
 
         // Current thread owning the lock
-        struct thread_desc * owner;
+        struct $thread * owner;
 
         // Number of recursion level
@@ -83 +83 @@
 
         // List of blocked threads
-        __queue_t(struct thread_desc) blocked_threads;
+        __queue_t(struct $thread) blocked_threads;
 };
 

libcfa/src/concurrency/preemption.cfa

@@ -39 +39 @@
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
-static void timeout( thread_desc * this );
+static void timeout( $thread * this );
 
 // FwdDeclarations : Signal handlers
@@ -184 +184 @@
 
         // Enable interrupts by decrementing the counter
-        // If counter reaches 0, execute any pending CtxSwitch
+        // If counter reaches 0, execute any pending __cfactx_switch
         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 );
                                 }
                         }
@@ -219 +218 @@
 
         // Disable interrupts by incrementint the counter
-        // Don't execute any pending CtxSwitch even if counter reaches 0
+        // Don't execute any pending __cfactx_switch even if counter reaches 0
         void enable_interrupts_noPoll() {
                 unsigned short prev = kernelTLS.preemption_state.disable_count;
@@ -268 +267 @@
 
 // reserved for future use
-static void timeout( thread_desc * this ) {
+static void timeout( $thread * this ) {
         //TODO : implement waking threads
 }
 
 // KERNEL ONLY
-// Check if a CtxSwitch signal handler shoud defer
+// Check if a __cfactx_switch signal handler shoud defer
 // If true  : preemption is safe
 // If false : preemption is unsafe and marked as pending
@@ -303 +302 @@
 
         // Setup proper signal handlers
-        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // CtxSwitch handler
+        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // __cfactx_switch handler
 
         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 __cfactx_switch
 }
 

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
-void ?{}(thread_desc & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
+void ?{}($thread & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
         context{ 0p, 0p };
         self_cor{ name, storage, storageSize };
         state = Start;
+        preempted = __NO_PREEMPTION;
         curr_cor = &self_cor;
         self_mon.owner = &this;
@@ -50 +44 @@
 }
 
-void ^?{}(thread_desc& this) with( this ) {
+void ^?{}($thread& this) with( this ) {
         unregister(curr_cluster, this);
         ^self_cor{};
 }
 
+//-----------------------------------------------------------------------------
+// Starting and stopping threads
+forall( dtype T | is_thread(T) )
+void __thrd_start( T & this, void (*main_p)(T &) ) {
+        $thread * this_thrd = get_thread(this);
+
+        disable_interrupts();
+        __cfactx_start(main_p, get_coroutine(this), this, __cfactx_invoke_thread);
+
+        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);
-        thread_desc * curr_thrd = TL_GET( this_thread );
-
-        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 );
-        // CtxSwitch( &curr_thrd->context, &this_thrd->context );
-
-        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

@@ -28 +28 @@
       void ^?{}(T& mutex this);
       void main(T& this);
-      thread_desc* get_thread(T& this);
+      $thread* get_thread(T& this);
 };
 
-#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* 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* 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  * 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* get_coroutine($thread * this) __attribute__((const)) { return &this->self_cor; }
+static inline $monitor  * get_monitor  ($thread * 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;
 
@@ -58 +53 @@
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(thread_desc & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
-void ^?{}(thread_desc & this);
+void ?{}($thread & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize );
+void ^?{}($thread & this);
 
-static inline void ?{}(thread_desc & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
-static inline void ?{}(thread_desc & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
-static inline void ?{}(thread_desc & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
-static inline void ?{}(thread_desc & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
-static inline void ?{}(thread_desc & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
-static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
+static inline void ?{}($thread & this)                                                                  { this{ "Anonymous Thread", *mainCluster, 0p, 65000 }; }
+static inline void ?{}($thread & this, size_t stackSize )                                               { this{ "Anonymous Thread", *mainCluster, 0p, stackSize }; }
+static inline void ?{}($thread & this, void * storage, size_t storageSize )                             { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; }
+static inline void ?{}($thread & this, struct cluster & cl )                                            { this{ "Anonymous Thread", cl, 0p, 65000 }; }
+static inline void ?{}($thread & this, struct cluster & cl, size_t stackSize )                          { this{ "Anonymous Thread", cl, 0p, stackSize }; }
+static inline void ?{}($thread & this, struct cluster & cl, void * storage, size_t storageSize )        { this{ "Anonymous Thread", cl, storage, storageSize }; }
+static inline void ?{}($thread & this, const char * const name)                                         { this{ name, *mainCluster, 0p, 65000 }; }
+static inline void ?{}($thread & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
+static inline void ?{}($thread & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
 
 //-----------------------------------------------------------------------------
@@ -88 +83 @@
 void ^?{}( scoped(T)& this );
 
-void yield();
-void yield( unsigned times );
+//-----------------------------------------------------------------------------
+// Thread getters
+static inline struct $thread * 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 * 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: //

libcfa/src/exception.c

@@ -248 +248 @@
 }
 
-#if defined(PIC)
-#warning Exceptions not yet supported when using Position-Independent Code
-__attribute__((noinline))
-void __cfaabi_ehm__try_terminate(void (*try_block)(),
-                void (*catch_block)(int index, exception_t * except),
-                __attribute__((unused)) int (*match_block)(exception_t * except)) {
-        abort();
-}
-#else // PIC
+#pragma GCC push_options
+#pragma GCC optimize("O0")
+
 // This is our personality routine. For every stack frame annotated with
 // ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
@@ -431 +425 @@
 
         // Setup the personality routine and exception table.
+#ifdef __PIC__
+        asm volatile (".cfi_personality 0x9b,CFA.ref.__gcfa_personality_v0");
+        asm volatile (".cfi_lsda 0x1b, .LLSDACFA2");
+#else
         asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
         asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
+#endif
 
         // Label which defines the start of the area for which the handler is setup.
@@ -464 +463 @@
 // have a single call to the try routine.
 
+#ifdef __PIC__
+#if defined( __i386 ) || defined( __x86_64 )
+asm (
+        // HEADER
+        ".LFECFA1:\n"
+        "       .globl  __gcfa_personality_v0\n"
+        "       .section        .gcc_except_table,\"a\",@progbits\n"
+        // TABLE HEADER (important field is the BODY length at the end)
+        ".LLSDACFA2:\n"
+        "       .byte   0xff\n"
+        "       .byte   0xff\n"
+        "       .byte   0x1\n"
+        "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
+        // BODY (language specific data)
+        // This uses language specific data and can be modified arbitrarily
+        // We use handled area offset, handled area length,
+        // handler landing pad offset and 1 (action code, gcc seems to use 0).
+        ".LLSDACSBCFA2:\n"
+        "       .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 .TRYEND-.TRYSTART\n"
+        "       .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n"
+        "       .uleb128 1\n"
+        ".LLSDACSECFA2:\n"
+        // TABLE FOOTER
+        "       .text\n"
+        "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
+);
+
+// Somehow this piece of helps with the resolution of debug symbols.
+__attribute__((unused)) static const int dummy = 0;
+
+asm (
+        // Add a hidden symbol which points at the function.
+        "       .hidden CFA.ref.__gcfa_personality_v0\n"
+        "       .weak   CFA.ref.__gcfa_personality_v0\n"
+        // No clue what this does specifically
+        "       .section        .data.rel.local.CFA.ref.__gcfa_personality_v0,\"awG\",@progbits,CFA.ref.__gcfa_personality_v0,comdat\n"
+        "       .align 8\n"
+        "       .type CFA.ref.__gcfa_personality_v0, @object\n"
+        "       .size CFA.ref.__gcfa_personality_v0, 8\n"
+        "CFA.ref.__gcfa_personality_v0:\n"
+#if defined( __x86_64 )
+        "       .quad __gcfa_personality_v0\n"
+#else // then __i386
+        "   .long __gcfa_personality_v0\n"
+#endif
+);
+#else
+#error Exception Handling: unknown architecture for position independent code.
+#endif // __i386 || __x86_64
+#else // __PIC__
 #if defined( __i386 ) || defined( __x86_64 )
 asm (
@@ -491 +541 @@
         "       .size   __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n"
         "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
-//      "       .section        .note.GNU-stack,\"x\",@progbits\n"
+        "       .section        .note.GNU-stack,\"x\",@progbits\n"
 );
+#else
+#error Exception Handling: unknown architecture for position dependent code.
 #endif // __i386 || __x86_64
-#endif // PIC
+#endif // __PIC__
+
+#pragma GCC pop_options

libcfa/src/fstream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 19:00:51 2020
-// Update Count     : 174
+// Last Modified On : Mon Feb 17 08:29:23 2020
+// Update Count     : 175
 //
 
@@ -67 +67 @@
 void close( ofstream & );
 ofstream & write( ofstream &, const char data[], size_t size );
-int fmt( ofstream &, const char format[], ... );
+int fmt( ofstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
 
 void ?{}( ofstream & os );
@@ -97 +97 @@
 ifstream & read( ifstream & is, char * data, size_t size );
 ifstream & ungetc( ifstream & is, char c );
-int fmt( ifstream &, const char format[], ... );
+int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 
 void ?{}( ifstream & is );

libcfa/src/interpose.cfa

@@ -10 +10 @@
 // Created On       : Wed Mar 29 16:10:31 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb  8 08:40:34 2020
-// Update Count     : 163
+// Last Modified On : Mon Feb 17 10:18:53 2020
+// Update Count     : 166
 //
 
@@ -237 +237 @@
         if ( fmt[strlen( fmt ) - 1] != '\n' ) {                         // add optional newline if missing at the end of the format text
                 __cfaabi_dbg_write( "\n", 1 );
-        }
-
+        } // if
         kernel_abort_msg( kernel_data, abort_text, abort_text_size );
-        __cfaabi_backtrace( signalAbort ? 4 : 3 );
+
+        __cfaabi_backtrace( signalAbort ? 4 : 2 );
 
         __cabi_libc.abort();                                                            // print stack trace in handler

libcfa/src/iostream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 18:48:38 2020
-// Update Count     : 825
+// Last Modified On : Thu Feb 20 15:53:23 2020
+// Update Count     : 829
 //
 
@@ -19 +19 @@
 #include <stdio.h>
 #include <stdbool.h>                                                                    // true/false
+#include <stdint.h>                                                                             // UINT64_MAX
 //#include <string.h>                                                                   // strlen, strcmp
 extern size_t strlen (const char *__s) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
@@ -159 +160 @@
                 (ostype &)(os | ulli); ends( os );
         } // ?|?
+
+#if defined( __SIZEOF_INT128__ )
+        //      UINT64_MAX 18_446_744_073_709_551_615_ULL
+        #define P10_UINT64 10_000_000_000_000_000_000_ULL       // 19 zeroes
+
+        static void base10_128( ostype & os, unsigned int128 val ) {
+                if ( val > UINT64_MAX ) {
+                        base10_128( os, val / P10_UINT64 );                     // recursive
+                        fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) );
+                } else {
+                        fmt( os, "%lu", (uint64_t)val );
+                } // if
+        } // base10_128
+
+        static void base10_128( ostype & os, int128 val ) {
+                if ( val < 0 ) {
+                        fmt( os, "-" );                                                         // leading negative sign
+                        val = -val;
+                } // if
+                base10_128( os, (unsigned int128)val );                 // print zero/positive value
+        } // base10_128
+
+        ostype & ?|?( ostype & os, int128 llli ) {
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                base10_128( os, llli );
+                return os;
+        } // ?|?
+        void & ?|?( ostype & os, int128 llli ) {
+                (ostype &)(os | llli); ends( os );
+        } // ?|?
+
+        ostype & ?|?( ostype & os, unsigned int128 ullli ) {
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                base10_128( os, ullli );
+                return os;
+        } // ?|?
+        void & ?|?( ostype & os, unsigned int128 ullli ) {
+                (ostype &)(os | ullli); ends( os );
+        } // ?|?
+#endif // __SIZEOF_INT128__
 
         #define PrintWithDP( os, format, val, ... ) \
@@ -464 +505 @@
 \
                 if ( ! f.flags.pc ) {                                                   /* no precision */ \
-                        /* printf( "%s\n", &fmtstr[star] ); */ \
                         fmtstr[sizeof(IFMTNP)-2] = f.base;                      /* sizeof includes '\0' */ \
+                        /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
                         fmt( os, &fmtstr[star], f.wd, f.val ); \
                 } else {                                                                                /* precision */ \
                         fmtstr[sizeof(IFMTP)-2] = f.base;                       /* sizeof includes '\0' */ \
-                        /* printf( "%s\n", &fmtstr[star] ); */ \
+                        /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
                         fmt( os, &fmtstr[star], f.wd, f.pc, f.val ); \
                 } /* if */ \
@@ -487 +528 @@
 IntegralFMTImpl( signed long long int, 'd', "%    *ll ", "%    *.*ll " )
 IntegralFMTImpl( unsigned long long int, 'u', "%    *ll ", "%    *.*ll " )
+
+
+#if defined( __SIZEOF_INT128__ )
+// Default prefix for non-decimal prints is 0b, 0, 0x.
+#define IntegralFMTImpl128( T, SIGNED, CODE, IFMTNP, IFMTP ) \
+forall( dtype ostype | ostream( ostype ) ) \
+static void base10_128( ostype & os, _Ostream_Manip(T) fmt ) { \
+        if ( fmt.val > UINT64_MAX ) { \
+                fmt.val /= P10_UINT64; \
+                base10_128( os, fmt ); /* recursive */ \
+                _Ostream_Manip(unsigned long long int) fmt2 @= { (uint64_t)(fmt.val % P10_UINT64), 0, 19, 'u', { .all : 0 } }; \
+                fmt2.flags.nobsdp = true; \
+                printf( "fmt2 %c %lld %d\n", fmt2.base, fmt2.val, fmt2.all );   \
+                sepOff( os ); \
+                (ostype &)(os | fmt2); \
+        } else { \
+                printf( "fmt %c %lld %d\n", fmt.base, fmt.val, fmt.all ); \
+                (ostype &)(os | fmt); \
+        } /* if */ \
+} /* base10_128 */                                                 \
+forall( dtype ostype | ostream( ostype ) ) { \
+        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+\
+                if ( f.base == 'b' | f.base == 'o' | f.base == 'x' | f.base == 'X' ) { \
+                        unsigned long long int msig = (unsigned long long int)(f.val >> 64); \
+                        unsigned long long int lsig = (unsigned long long int)(f.val); \
+                        _Ostream_Manip(SIGNED long long int) fmt @= { msig, f.wd, f.pc, f.base, { .all : f.all } }; \
+                        _Ostream_Manip(unsigned long long int) fmt2 @= { lsig, 0, 0, f.base, { .all : 0 } }; \
+                        if ( msig == 0 ) { \
+                                fmt.val = lsig; \
+                                (ostype &)(os | fmt); \
+                        } else { \
+                                fmt2.flags.pad0 = fmt2.flags.nobsdp = true;     \
+                                if ( f.base == 'b' ) { \
+                                        if ( f.wd > 64 ) fmt.wd = f.wd - 64; \
+                                        fmt2.wd = 64; \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                } else if ( f.base == 'o' ) { \
+                                        fmt.val = (unsigned long long int)fmt.val >> 2; \
+                                        if ( f.wd > 21 ) fmt.wd = f.wd - 21; \
+                                        fmt2.wd = 1; \
+                                        fmt2.val = ((msig & 0x3) << 1) + 1; \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                        sepOff( os ); \
+                                        fmt2.wd = 21; \
+                                        fmt2.val = lsig & 0x7fffffffffffffff; \
+                                        (ostype &)(os | fmt2); \
+                                } else { \
+                                        if ( f.flags.left ) { \
+                                                if ( f.wd > 16 ) fmt2.wd = f.wd - 16;   \
+                                                fmt.wd = 16;                                                    \
+                                        } else { \
+                                                if ( f.wd > 16 ) fmt.wd = f.wd - 16;    \
+                                                fmt2.wd = 16;                                                   \
+                                        } /* if */ \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                } /* if */ \
+                        } /* if */ \
+                } else { \
+                        base10_128( os, f ); \
+                } /* if */ \
+                return os; \
+        } /* ?|? */ \
+        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
+} // distribution
+
+IntegralFMTImpl128( int128, signed, 'd', "%    *ll ", "%    *.*ll " )
+IntegralFMTImpl128( unsigned int128, unsigned, 'u', "%    *ll ", "%    *.*ll " )
+#endif // __SIZEOF_INT128__
 
 //*********************************** floating point ***********************************

libcfa/src/iostream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 17:53:52 2020
-// Update Count     : 336
+// Last Modified On : Thu Feb 20 15:30:56 2020
+// Update Count     : 337
 //
 
@@ -98 +98 @@
         ostype & ?|?( ostype &, unsigned long long int );
         void ?|?( ostype &, unsigned long long int );
+#if defined( __SIZEOF_INT128__ )
+        ostype & ?|?( ostype &, int128 );
+        void ?|?( ostype &, int128 );
+        ostype & ?|?( ostype &, unsigned int128 );
+        void ?|?( ostype &, unsigned int128 );
+#endif // __SIZEOF_INT128__
 
         ostype & ?|?( ostype &, float );
@@ -206 +212 @@
 IntegralFMTDecl( signed long long int, 'd' )
 IntegralFMTDecl( unsigned long long int, 'u' )
+#if defined( __SIZEOF_INT128__ )
+IntegralFMTDecl( int128, 'd' )
+IntegralFMTDecl( unsigned int128, 'u' )
+#endif
 
 //*********************************** floating point ***********************************