Changes in / [17b6fc9:dd53f75]

Files:

• benchmark/io/http/main.cfa (modified) (1 diff)
• benchmark/io/http/worker.cfa (modified) (1 diff)
• benchmark/io/readv.cfa (modified) (2 diffs)
• benchmark/readyQ/yield.cfa (modified) (2 diffs)
• doc/theses/thierry_delisle_PhD/code/readQ_example/Makefile (added)
• doc/theses/thierry_delisle_PhD/code/readQ_example/proto-gui/main.cpp (modified) (12 diffs)
• doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/Makefile (added)
• doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/cforall.cpp (added)
• doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/fibre.cpp (added)
• doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/pthread.cpp (added)
• doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.cpp (added)
• doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.h (deleted)
• doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.hpp (added)
• doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread_pthread.h (deleted)
• libcfa/src/bits/locks.hfa (modified) (5 diffs)
• libcfa/src/concurrency/alarm.cfa (modified) (1 diff)
• libcfa/src/concurrency/clib/cfathread.cfa (modified) (2 diffs)
• libcfa/src/concurrency/clib/cfathread.h (modified) (2 diffs)
• libcfa/src/concurrency/invoke.h (modified) (3 diffs)
• libcfa/src/concurrency/io.cfa (modified) (2 diffs)
• libcfa/src/concurrency/io/setup.cfa (modified) (1 diff)
• libcfa/src/concurrency/kernel.cfa (modified) (12 diffs)
• libcfa/src/concurrency/kernel/fwd.hfa (modified) (1 diff)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (1 diff)
• libcfa/src/concurrency/kernel_private.hfa (modified) (2 diffs)
• libcfa/src/concurrency/monitor.cfa (modified) (8 diffs)
• libcfa/src/concurrency/mutex.cfa (modified) (8 diffs)
• libcfa/src/concurrency/preemption.cfa (modified) (1 diff)
• libcfa/src/concurrency/thread.cfa (modified) (2 diffs)
• libcfa/src/concurrency/thread.hfa (modified) (1 diff)
• tests/concurrent/park/contention.cfa (modified) (2 diffs)
• tests/concurrent/park/force_preempt.cfa (modified) (2 diffs)
• tests/concurrent/park/start_parked.cfa (modified) (2 diffs)

benchmark/io/http/main.cfa

@@ -125 +125 @@
                                                 workers[i].flags   = 0;
                                         }
-                                        unpark( workers[i] __cfaabi_dbg_ctx2 );
+                                        unpark( workers[i] );
                                 }
                                 printf("%d workers started on %d processors\n", options.clopts.nworkers, options.clopts.nprocs);

benchmark/io/http/worker.cfa

@@ -22 +22 @@
 
 void main( Worker & this ) {
-        park( __cfaabi_dbg_ctx );
+        park();
         /* paranoid */ assert( this.pipe[0] != -1 );
         /* paranoid */ assert( this.pipe[1] != -1 );

benchmark/io/readv.cfa

@@ -54 +54 @@
 
 void main( Reader & ) {
-        park( __cfaabi_dbg_ctx );
+        park();
         /* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) );
 
@@ -151 +151 @@
 
                                 for(i; nthreads) {
-                                        unpark( threads[i] __cfaabi_dbg_ctx2 );
+                                        unpark( threads[i] );
                                 }
                                 wait(duration, start, end, is_tty);

benchmark/readyQ/yield.cfa

@@ -32 +32 @@
 
 void main( Yielder & this ) {
-        park( __cfaabi_dbg_ctx );
+        park();
         /* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) );
 
@@ -70 +70 @@
 
                                 for(i; nthreads) {
-                                        unpark( threads[i] __cfaabi_dbg_ctx2 );
+                                        unpark( threads[i] );
                                 }
                                 wait(duration, start, end, is_tty);

doc/theses/thierry_delisle_PhD/code/readQ_example/proto-gui/main.cpp

@@ -1 @@
-#include "thrdlib/thread.h"
+#include "thrdlib/thread.hpp"
 
 #include <cassert>
@@ -5 +5 @@
 #include <algorithm>
 #include <atomic>
+#include <iostream>
 #include <memory>
 #include <vector>
 
 #include <getopt.h>
+using thrdlib::thread_t;
+
+
+extern __attribute__((aligned(128))) thread_local struct {
+        void * volatile this_thread;
+        void * volatile this_processor;
+        void * volatile this_stats;
+
+        struct {
+                volatile unsigned short disable_count;
+                volatile bool enabled;
+                volatile bool in_progress;
+        } preemption_state;
+
+        #if defined(__SIZEOF_INT128__)
+                __uint128_t rand_seed;
+        #else
+                uint64_t rand_seed;
+        #endif
+        struct {
+                uint64_t fwd_seed;
+                uint64_t bck_seed;
+        } ready_rng;
+} kernelTLS __attribute__ ((tls_model ( "initial-exec" )));
 
 //--------------------
@@ -36 +61 @@
                         assert( expected == reset );
                         if( std::atomic_compare_exchange_strong( &state, &expected, self) ) {
-                                thrdlib_park( self );
+                                thrdlib::park( self );
                                 ret = true;
                                 goto END;
@@ -54 +79 @@
                 if( got == reset ) return false;
 
-                thrdlib_unpark( got );
+                thrdlib::unpark( got );
                 return true;
         }
@@ -109 +134 @@
         the_stats_thread = self;
         fence();
-        thrdlib_park( self );
+        thrdlib::park( self );
 
         std::vector<bool> seen;
@@ -115 +140 @@
 
         while(last_produced < nproduce) {
-                thrdlib_yield();
+                thrdlib::yield();
                 thrd_stats.stats.ran++;
                 if( last_produced > 0 ) seen.at(last_produced - 1) = true;
@@ -147 +172 @@
 
 void Renderer( thread_t self ) {
-        thrdlib_unpark( the_stats_thread );
+        thrdlib::unpark( the_stats_thread );
         for(unsigned i = 0; i < nproduce; i++) {
                 auto & frame = frames[i % nframes];
@@ -178 +203 @@
         fsize    = 1000;
         nproduce = 60;
+
+        const char * framework;
 
         for(;;) {
@@ -196 +223 @@
                         case -1:
                                 /* paranoid */ assert(optind <= argc);
+                                if( optind == argc ) {
+                                        std::cerr << "Must specify a framework" << std::endl;
+                                        goto usage;
+
+                                }
+                                framework = argv[optind];
                                 goto run;
                         case 'b':
@@ -228 +261 @@
                                 std::cerr << opt << std::endl;
                         usage:
-                                std::cerr << "Usage: " << argv[0] << " [options]" << std::endl;
+                                std::cerr << "Usage: " << argv[0] << " [options] framework" << std::endl;
                                 std::cerr << std::endl;
                                 std::cerr << "  -b, --buff=COUNT    Number of frames to buffer" << std::endl;
@@ -237 +270 @@
         }
         run:
+        assert( framework );
 
         frames.reset(new Frame[nframes]);
@@ -246 +280 @@
         std::cout << "(Buffering " << nframes << ")" << std::endl;
 
-        thrdlib_setproccnt( 2 );
-
-        thread_t stats     = thrdlib_create( Stats     );
+        thrdlib::init( framework, 2 );
+
+        thread_t stats     = thrdlib::create( Stats );
         std::cout << "Created Stats Thread" << std::endl;
-        while( the_stats_thread == nullptr ) thrdlib_yield();
+        while( the_stats_thread == nullptr ) thrdlib::yield();
+
         std::cout << "Creating Main Threads" << std::endl;
-        thread_t renderer  = thrdlib_create( Renderer  );
-        // while(true);
-        thread_t simulator = thrdlib_create( Simulator );
+        thread_t renderer  = thrdlib::create( Renderer  );
+        thread_t simulator = thrdlib::create( Simulator );
 
         std::cout << "Running" << std::endl;
 
-        thrdlib_join( simulator );
-        thrdlib_join( renderer  );
-        thrdlib_join( stats     );
+        thrdlib::join( simulator );
+        thrdlib::join( renderer  );
+        thrdlib::join( stats     );
+
+        thrdlib::clean();
 
         std::cout << "----------" << std::endl;

libcfa/src/bits/locks.hfa

@@ -164 +164 @@
 
         struct $thread;
-        extern void park( __cfaabi_dbg_ctx_param );
-        extern void unpark( struct $thread * this __cfaabi_dbg_ctx_param2 );
+        extern void park( void );
+        extern void unpark( struct $thread * this );
         static inline struct $thread * active_thread ();
 
@@ -191 +191 @@
                                         /* paranoid */ verify( expected == 0p );
                                         if(__atomic_compare_exchange_n(&this.ptr, &expected, active_thread(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                                park( __cfaabi_dbg_ctx );
+                                                park();
                                                 return true;
                                         }
@@ -210 +210 @@
                                 else {
                                         if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                                unpark( expected __cfaabi_dbg_ctx2 );
+                                                unpark( expected );
                                                 return true;
                                         }
@@ -244 +244 @@
                                 /* paranoid */ verify( expected == 0p );
                                 if(__atomic_compare_exchange_n(&this.ptr, &expected, active_thread(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                        park( __cfaabi_dbg_ctx );
+                                        park();
                                         /* paranoid */ verify( this.ptr == 1p );
                                         return true;
@@ -256 +256 @@
                         struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
                         if( got == 0p ) return false;
-                        unpark( got __cfaabi_dbg_ctx2 );
+                        unpark( got );
                         return true;
                 }

libcfa/src/concurrency/alarm.cfa

@@ -130 +130 @@
 
         register_self( &node );
-        park( __cfaabi_dbg_ctx );
+        park();
 
         /* paranoid */ verify( !node.set );

libcfa/src/concurrency/clib/cfathread.cfa

@@ -34 +34 @@
 extern "C" {
         //--------------------
-        // Basic thread managenemt
+        // Basic thread management
         CRunner * cfathread_create( void (*main)( CRunner * ) ) {
                 return new( main );
@@ -44 +44 @@
 
         void cfathread_park( void ) {
-                park( __cfaabi_dbg_ctx );
+                park();
         }
 
         void cfathread_unpark( CRunner * thrd ) {
-                unpark( *thrd __cfaabi_dbg_ctx2 );
+                unpark( *thrd );
         }
 

libcfa/src/concurrency/clib/cfathread.h

@@ -17 +17 @@
 #include "invoke.h"
 
-#if defined(__cforall) || defined(__cpluplus)
+#if defined(__cforall) || defined(__cplusplus)
 extern "C" {
 #endif
@@ -39 +39 @@
 
 
-#if defined(__cforall) || defined(__cpluplus)
+#if defined(__cforall) || defined(__cplusplus)
 }
 #endif

libcfa/src/concurrency/invoke.h

@@ -93 +93 @@
 
         };
+        // Wrapper for gdb
+        struct cfathread_coroutine_t { struct $coroutine debug; };
 
         static inline struct __stack_t * __get_stack( struct $coroutine * cor ) {
@@ -129 +131 @@
                 struct __condition_node_t * dtor_node;
         };
+        // Wrapper for gdb
+        struct cfathread_monitor_t { struct $monitor debug; };
 
         struct __monitor_group_t {
@@ -186 +190 @@
                 } node;
 
-                #ifdef __CFA_DEBUG__
-                        // previous function to park/unpark the thread
-                        const char * park_caller;
-                        int park_result;
-                        enum __Coroutine_State park_state;
-                        bool park_stale;
-                        const char * unpark_caller;
-                        int unpark_result;
-                        enum __Coroutine_State unpark_state;
-                        bool unpark_stale;
+                #if defined( __CFA_WITH_VERIFY__ )
+                        unsigned long long canary;
                 #endif
         };
+        // Wrapper for gdb
+        struct cfathread_thread_t { struct $thread debug; };
 
         #ifdef __CFA_DEBUG__

libcfa/src/concurrency/io.cfa

@@ -69 +69 @@
                 if( block ) {
                         enable_interrupts( __cfaabi_dbg_ctx );
-                        park( __cfaabi_dbg_ctx );
+                        park();
                         disable_interrupts();
                 }
@@ -97 +97 @@
 
                 if(nextt) {
-                        unpark( nextt __cfaabi_dbg_ctx2 );
+                        unpark( nextt );
                         enable_interrupts( __cfaabi_dbg_ctx );
                         return true;

libcfa/src/concurrency/io/setup.cfa

@@ -247 +247 @@
                                         thrd.link.next = 0p;
                                         thrd.link.prev = 0p;
-                                        __cfaabi_dbg_debug_do( thrd.unpark_stale = true );
 
                                         // Fixup the thread state

libcfa/src/concurrency/kernel.cfa

@@ -246 +246 @@
                 thrd_dst->state = Active;
 
-                __cfaabi_dbg_debug_do(
-                        thrd_dst->park_stale   = true;
-                        thrd_dst->unpark_stale = true;
-                )
                 // Update global state
                 kernelTLS.this_thread = thrd_dst;
@@ -255 +251 @@
                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
                 /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
+                /* paranoid */ verify( thrd_dst->context.SP );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
+                /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_dst->canary );
+
 
 
                 // 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( 0x0D15EA5E0D15EA5E == thrd_dst->canary );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
+                /* paranoid */ verify( thrd_dst->context.SP );
                 /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -288 +288 @@
                         // The thread has halted, it should never be scheduled/run again
                         // We may need to wake someone up here since
-                        unpark( this->destroyer __cfaabi_dbg_ctx2 );
+                        unpark( this->destroyer );
                         this->destroyer = 0p;
                         break RUNNING;
@@ -298 +298 @@
                 // set state of processor coroutine to active and the thread to inactive
                 int old_ticket = __atomic_fetch_sub(&thrd_dst->ticket, 1, __ATOMIC_SEQ_CST);
-                __cfaabi_dbg_debug_do( thrd_dst->park_result = old_ticket; )
                 switch(old_ticket) {
                         case 1:
@@ -335 +334 @@
                         __x87_store;
                 #endif
-                verify( proc_cor->context.SP );
+                /* paranoid */ verify( proc_cor->context.SP );
+                /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_src->canary );
                 __cfactx_switch( &thrd_src->context, &proc_cor->context );
+                /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_src->canary );
                 #if defined( __i386 ) || defined( __x86_64 )
                         __x87_load;
@@ -368 +369 @@
         /* paranoid */ #endif
         /* paranoid */ verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next );
+        /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd->canary );
+
 
         if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
@@ -404 +407 @@
 
 // KERNEL ONLY unpark with out disabling interrupts
-void __unpark(  struct __processor_id_t * id, $thread * thrd __cfaabi_dbg_ctx_param2 ) {
-        // record activity
-        __cfaabi_dbg_record_thrd( *thrd, false, caller );
-
+void __unpark(  struct __processor_id_t * id, $thread * thrd ) {
         int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
-        __cfaabi_dbg_debug_do( thrd->unpark_result = old_ticket; thrd->unpark_state = thrd->state; )
         switch(old_ticket) {
                 case 1:
@@ -427 +426 @@
 }
 
-void unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) {
+void unpark( $thread * thrd ) {
         if( !thrd ) return;
 
         disable_interrupts();
-        __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd __cfaabi_dbg_ctx_fwd2 );
+        __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
 
-void park( __cfaabi_dbg_ctx_param ) {
+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 );
-
-        // record activity
-        __cfaabi_dbg_record_thrd( *kernelTLS.this_thread, true, caller );
 
         returnToKernel();
@@ -650 +646 @@
                 // atomically release spin lock and block
                 unlock( lock );
-                park( __cfaabi_dbg_ctx );
+                park();
                 return true;
         }
@@ -671 +667 @@
 
         // make new owner
-        unpark( thrd __cfaabi_dbg_ctx2 );
+        unpark( thrd );
 
         return thrd != 0p;
@@ -682 +678 @@
         count += diff;
         for(release) {
-                unpark( pop_head( waiting ) __cfaabi_dbg_ctx2 );
+                unpark( pop_head( waiting ) );
         }
 
@@ -698 +694 @@
                         this.prev_thrd = kernelTLS.this_thread;
                 }
-
-                void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]) {
-                        if(park) {
-                                this.park_caller   = prev_name;
-                                this.park_stale    = false;
-                        }
-                        else {
-                                this.unpark_caller = prev_name;
-                                this.unpark_stale  = false;
-                        }
-                }
         }
 )

libcfa/src/concurrency/kernel/fwd.hfa

@@ -118 +118 @@
 
         extern "Cforall" {
-                extern void park( __cfaabi_dbg_ctx_param );
-                extern void unpark( struct $thread * this __cfaabi_dbg_ctx_param2 );
+                extern void park( void );
+                extern void unpark( struct $thread * this );
                 static inline struct $thread * active_thread () { return TL_GET( this_thread ); }
 

libcfa/src/concurrency/kernel/startup.cfa

@@ -451 +451 @@
         link.next = 0p;
         link.prev = 0p;
+        #if defined( __CFA_WITH_VERIFY__ )
+                canary = 0x0D15EA5E0D15EA5E;
+        #endif
 
         node.next = 0p;

libcfa/src/concurrency/kernel_private.hfa

@@ -64 +64 @@
 
 // KERNEL ONLY unpark with out disabling interrupts
-void __unpark( struct __processor_id_t *, $thread * thrd __cfaabi_dbg_ctx_param2 );
+void __unpark( struct __processor_id_t *, $thread * thrd );
 
 static inline bool __post(single_sem & this, struct __processor_id_t * id) {
@@ -77 +77 @@
                 else {
                         if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                __unpark( id, expected __cfaabi_dbg_ctx2 );
+                                __unpark( id, expected );
                                 return true;
                         }

libcfa/src/concurrency/monitor.cfa

@@ -122 +122 @@
 
                 unlock( this->lock );
-                park( __cfaabi_dbg_ctx );
+                park();
 
                 __cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
@@ -201 +201 @@
                 // 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 __cfaabi_dbg_ctx2 );
+                unpark( urgent->owner->waiting_thread );
 
                 // Park current thread waiting
-                park( __cfaabi_dbg_ctx );
+                park();
 
                 // Some one was waiting for us, enter
@@ -222 +222 @@
 
                 // Park current thread waiting
-                park( __cfaabi_dbg_ctx );
+                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 );
@@ -264 +264 @@
         //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 __cfaabi_dbg_ctx2 );
+        unpark( new_owner );
 }
 
@@ -493 +493 @@
         // Wake the threads
         for(int i = 0; i < thread_count; i++) {
-                unpark( threads[i] __cfaabi_dbg_ctx2 );
+                unpark( threads[i] );
         }
 
         // Everything is ready to go to sleep
-        park( __cfaabi_dbg_ctx );
+        park();
 
         // We are back, restore the owners and recursions
@@ -575 +575 @@
 
         // unpark the thread we signalled
-        unpark( signallee __cfaabi_dbg_ctx2 );
+        unpark( signallee );
 
         //Everything is ready to go to sleep
-        park( __cfaabi_dbg_ctx );
+        park();
 
 
@@ -679 +679 @@
 
                                 // unpark the thread we signalled
-                                unpark( next __cfaabi_dbg_ctx2 );
+                                unpark( next );
 
                                 //Everything is ready to go to sleep
-                                park( __cfaabi_dbg_ctx );
+                                park();
 
                                 // We are back, restore the owners and recursions
@@ -724 +724 @@
 
         //Everything is ready to go to sleep
-        park( __cfaabi_dbg_ctx );
+        park();
 
 

libcfa/src/concurrency/mutex.cfa

@@ -42 +42 @@
                 append( blocked_threads, kernelTLS.this_thread );
                 unlock( lock );
-                park( __cfaabi_dbg_ctx );
+                park();
         }
         else {
@@ -65 +65 @@
         this.is_locked = (this.blocked_threads != 0);
         unpark(
-                pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
+                pop_head( this.blocked_threads )
         );
         unlock( this.lock );
@@ -97 +97 @@
                 append( blocked_threads, kernelTLS.this_thread );
                 unlock( lock );
-                park( __cfaabi_dbg_ctx );
+                park();
         }
 }
@@ -124 +124 @@
                 owner = thrd;
                 recursion_count = (thrd ? 1 : 0);
-                unpark( thrd __cfaabi_dbg_ctx2 );
+                unpark( thrd );
         }
         unlock( lock );
@@ -142 +142 @@
         lock( lock __cfaabi_dbg_ctx2 );
         unpark(
-                pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
+                pop_head( this.blocked_threads )
         );
         unlock( lock );
@@ -151 +151 @@
         while(this.blocked_threads) {
                 unpark(
-                        pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
+                        pop_head( this.blocked_threads )
                 );
         }
@@ -161 +161 @@
         append( this.blocked_threads, kernelTLS.this_thread );
         unlock( this.lock );
-        park( __cfaabi_dbg_ctx );
+        park();
 }
 
@@ -170 +170 @@
         unlock(l);
         unlock(this.lock);
-        park( __cfaabi_dbg_ctx );
+        park();
         lock(l);
 }

libcfa/src/concurrency/preemption.cfa

@@ -274 +274 @@
                 kernelTLS.this_stats = this->curr_cluster->stats;
         #endif
-        __unpark( id, this __cfaabi_dbg_ctx2 );
+        __unpark( id, this );
 }
 

libcfa/src/concurrency/thread.cfa

@@ -39 +39 @@
         link.prev = 0p;
         link.preferred = -1;
+        #if defined( __CFA_WITH_VERIFY__ )
+                canary = 0x0D15EA5E0D15EA5E;
+        #endif
 
         node.next = 0p;
@@ -48 +51 @@
 
 void ^?{}($thread& this) with( this ) {
+        #if defined( __CFA_WITH_VERIFY__ )
+                canary = 0xDEADDEADDEADDEAD;
+        #endif
         unregister(curr_cluster, this);
         ^self_cor{};

libcfa/src/concurrency/thread.hfa

@@ -88 +88 @@
 //----------
 // Park thread: block until corresponding call to unpark, won't block if unpark is already called
-void park( __cfaabi_dbg_ctx_param );
+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 __cfaabi_dbg_ctx_param2 );
+void unpark( $thread * this );
 
 forall( dtype T | is_thread(T) )
-static inline void unpark( T & this __cfaabi_dbg_ctx_param2 ) { if(!&this) return; unpark( get_thread( this ) __cfaabi_dbg_ctx_fwd2 );}
+static inline void unpark( T & this ) { if(!&this) return; unpark( get_thread( this ) );}
 
 //----------

tests/concurrent/park/contention.cfa

@@ -21 +21 @@
                 if(blocked[idx]) {
                         Thread * thrd = __atomic_exchange_n(&blocked[idx], 0p, __ATOMIC_SEQ_CST);
-                        unpark( *thrd __cfaabi_dbg_ctx2 );
+                        unpark( *thrd );
                 } else {
                         Thread * thrd = __atomic_exchange_n(&blocked[idx], &this, __ATOMIC_SEQ_CST);
-                        unpark( *thrd __cfaabi_dbg_ctx2 );
-                        park( __cfaabi_dbg_ctx );
+                        unpark( *thrd );
+                        park();
                 }
         }
@@ -41 +41 @@
                         int idx = myrand() % blocked_size;
                         Thread * thrd = __atomic_exchange_n(&blocked[idx], 0p, __ATOMIC_SEQ_CST);
-                        unpark( *thrd __cfaabi_dbg_ctx2 );
+                        unpark( *thrd );
                         yield( myrand() % 20 );
                 }

tests/concurrent/park/force_preempt.cfa

@@ -30 +30 @@
 
                 // Unpark this thread, don't force a yield
-                unpark( this __cfaabi_dbg_ctx2 );
+                unpark( this );
                 assert(mask == 0xCAFEBABA);
 
@@ -43 +43 @@
                 // Park this thread,
                 assert(mask == (id_hash ^ 0xCAFEBABA));
-                park( __cfaabi_dbg_ctx );
+                park();
                 assert(mask == (id_hash ^ 0xCAFEBABA));
 

tests/concurrent/park/start_parked.cfa

@@ -3 +3 @@
 thread Parker {};
 void main( Parker & ) {
-        park( __cfaabi_dbg_ctx );
+        park();
 }
 
@@ -9 +9 @@
         for(1000) {
                 Parker parker;
-                unpark( parker __cfaabi_dbg_ctx2 );
+                unpark( parker );
         }
         printf( "done\n" );                                                                     // non-empty .expect file