Index: libcfa/src/concurrency/alarm.cfa =================================================================== --- libcfa/src/concurrency/alarm.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/alarm.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -51,5 +51,5 @@ //============================================================================================= -void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period) with( this ) { +void ?{}( alarm_node_t & this, thread$ * thrd, Duration alarm, Duration period) with( this ) { this.initial = alarm; this.period = period; Index: libcfa/src/concurrency/alarm.hfa =================================================================== --- libcfa/src/concurrency/alarm.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/alarm.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -25,5 +25,5 @@ #include "containers/list.hfa" -struct $thread; +struct thread$; struct processor; @@ -52,5 +52,5 @@ union { - $thread * thrd; // thrd who created event + thread$ * thrd; // thrd who created event processor * proc; // proc who created event Alarm_Callback callback; // callback to handle event @@ -63,5 +63,5 @@ P9_EMBEDDED( alarm_node_t, dlink(alarm_node_t) ) -void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period ); +void ?{}( alarm_node_t & this, thread$ * thrd, Duration alarm, Duration period ); void ?{}( alarm_node_t & this, processor * proc, Duration alarm, Duration period ); void ?{}( alarm_node_t & this, Alarm_Callback callback, Duration alarm, Duration period ); Index: libcfa/src/concurrency/clib/cfathread.cfa =================================================================== --- libcfa/src/concurrency/clib/cfathread.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/clib/cfathread.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -23,5 +23,5 @@ #include "cfathread.h" -extern void ?{}(processor &, const char[], cluster &, $thread *); +extern void ?{}(processor &, const char[], cluster &, thread$ *); extern "C" { extern void __cfactx_invoke_thread(void (*main)(void *), void * this); @@ -34,5 +34,5 @@ struct cfathread_object { - $thread self; + thread$ self; void * (*themain)( void * ); void * arg; @@ -42,5 +42,5 @@ void ^?{}(cfathread_object & mutex this); -static inline $thread * get_thread( cfathread_object & this ) { return &this.self; } +static inline thread$ * get_thread( cfathread_object & this ) { return &this.self; } typedef ThreadCancelled(cfathread_object) cfathread_exception; @@ -81,5 +81,5 @@ // Special Init Thread responsible for the initialization or processors struct __cfainit { - $thread self; + thread$ self; void (*init)( void * ); void * arg; @@ -88,5 +88,5 @@ void ^?{}(__cfainit & mutex this); -static inline $thread * get_thread( __cfainit & this ) { return &this.self; } +static inline thread$ * get_thread( __cfainit & this ) { return &this.self; } typedef ThreadCancelled(__cfainit) __cfainit_exception; @@ -109,5 +109,5 @@ // Don't use __thrd_start! just prep the context manually - $thread * this_thrd = get_thread(this); + thread$ * this_thrd = get_thread(this); void (*main_p)(__cfainit &) = main; Index: libcfa/src/concurrency/coroutine.cfa =================================================================== --- libcfa/src/concurrency/coroutine.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/coroutine.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -37,5 +37,5 @@ extern "C" { - void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct $coroutine *) __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 *) { @@ -62,5 +62,5 @@ forall(T & | is_coroutine(T)) void __cfaehm_cancelled_coroutine( - T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) { + T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) { verify( desc->cancellation ); desc->state = Cancelled; @@ -114,5 +114,5 @@ } -void ?{}( $coroutine & 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}; @@ -124,8 +124,8 @@ } -void ^?{}($coroutine& this) { +void ^?{}(coroutine$& this) { if(this.state != Halted && this.state != Start && this.state != Primed) { - $coroutine * src = active_coroutine(); - $coroutine * dst = &this; + coroutine$ * src = active_coroutine(); + coroutine$ * dst = &this; struct _Unwind_Exception storage; @@ -148,5 +148,5 @@ forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); }) void prime(T& cor) { - $coroutine* this = get_coroutine(cor); + coroutine$* this = get_coroutine(cor); assert(this->state == Start); @@ -248,6 +248,6 @@ // is not inline (We can't inline Cforall in C) extern "C" { - void __cfactx_cor_leave( struct $coroutine * src ) { - $coroutine * 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; @@ -265,9 +265,9 @@ } - struct $coroutine * __cfactx_cor_finish(void) { - struct $coroutine * cor = active_coroutine(); + struct coroutine$ * __cfactx_cor_finish(void) { + struct coroutine$ * cor = active_coroutine(); // get the active thread once - $thread * athrd = active_thread(); + thread$ * athrd = active_thread(); /* paranoid */ verify( athrd->corctx_flag ); Index: libcfa/src/concurrency/coroutine.hfa =================================================================== --- libcfa/src/concurrency/coroutine.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/coroutine.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -39,8 +39,8 @@ trait is_coroutine(T & | IS_RESUMPTION_EXCEPTION(CoroutineCancelled, (T))) { void main(T & this); - $coroutine * get_coroutine(T & this); + coroutine$ * get_coroutine(T & this); }; -#define DECL_COROUTINE(X) static inline $coroutine* 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) //----------------------------------------------------------------------------- @@ -49,12 +49,12 @@ // void ^?{}( coStack_t & this ); -void ?{}( $coroutine & this, const char name[], void * storage, size_t storageSize ); -void ^?{}( $coroutine & this ); - -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 }; } +void ?{}( coroutine$ & this, const char name[], void * storage, size_t storageSize ); +void ^?{}( coroutine$ & this ); + +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 }; } //----------------------------------------------------------------------------- @@ -63,5 +63,5 @@ void prime(T & cor); -static inline struct $coroutine * active_coroutine() { return active_thread()->curr_cor; } +static inline struct coroutine$ * active_coroutine() { return active_thread()->curr_cor; } //----------------------------------------------------------------------------- @@ -73,7 +73,7 @@ forall(T &) - void __cfactx_start(void (*main)(T &), struct $coroutine * cor, T & this, void (*invoke)(void (*main)(void *), void *)); - - extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine *) __attribute__ ((__noreturn__)); + void __cfactx_start(void (*main)(T &), struct coroutine$ * cor, T & this, void (*invoke)(void (*main)(void *), void *)); + + extern void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct coroutine$ *) __attribute__ ((__noreturn__)); extern void __cfactx_switch( struct __stack_context_t * from, struct __stack_context_t * to ) asm ("__cfactx_switch"); @@ -82,10 +82,10 @@ // Private wrappers for context switch and stack creation // Wrapper for co -static inline void $ctx_switch( $coroutine * src, $coroutine * dst ) __attribute__((nonnull (1, 2))) { +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 : Blocked; // get the active thread once - $thread * athrd = active_thread(); + thread$ * athrd = active_thread(); // Mark the coroutine @@ -124,5 +124,5 @@ // will also migrate which means this value will // stay in syn with the TLS - $coroutine * src = active_coroutine(); + coroutine$ * src = active_coroutine(); assertf( src->last != 0, @@ -141,5 +141,5 @@ forall(T & | is_coroutine(T)) void __cfaehm_cancelled_coroutine( - T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ); + T & cor, coroutine$ * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ); // Resume implementation inlined for performance @@ -151,6 +151,6 @@ // will also migrate which means this value will // stay in syn with the TLS - $coroutine * src = active_coroutine(); - $coroutine * dst = get_coroutine(cor); + coroutine$ * src = active_coroutine(); + coroutine$ * dst = get_coroutine(cor); if( unlikely(dst->context.SP == 0p) ) { @@ -180,5 +180,5 @@ } -static inline void resume( $coroutine * dst ) __attribute__((nonnull (1))) { +static inline void resume( coroutine$ * dst ) __attribute__((nonnull (1))) { // optimization : read TLS once and reuse it // Safety note: this is preemption safe since if @@ -186,5 +186,5 @@ // will also migrate which means this value will // stay in syn with the TLS - $coroutine * src = active_coroutine(); + coroutine$ * src = active_coroutine(); // not resuming self ? Index: libcfa/src/concurrency/exception.cfa =================================================================== --- libcfa/src/concurrency/exception.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/exception.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -20,5 +20,5 @@ #include "coroutine.hfa" -extern struct $thread * mainThread; +extern struct thread$ * mainThread; extern "C" { extern void __cfactx_thrd_leave(); @@ -55,6 +55,6 @@ STOP_AT_END_FUNCTION(coroutine_cancelstop, - struct $coroutine * src = ($coroutine *)stop_param; - struct $coroutine * dst = src->last; + struct coroutine$ * src = (coroutine$ *)stop_param; + struct coroutine$ * dst = src->last; $ctx_switch( src, dst ); @@ -72,7 +72,7 @@ void * stop_param; - struct $thread * this_thread = active_thread(); + struct thread$ * this_thread = active_thread(); if ( &this_thread->self_cor != this_thread->curr_cor ) { - struct $coroutine * cor = this_thread->curr_cor; + struct coroutine$ * cor = this_thread->curr_cor; cor->cancellation = unwind_exception; Index: libcfa/src/concurrency/future.hfa =================================================================== --- libcfa/src/concurrency/future.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/future.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -37,5 +37,5 @@ // Fulfil the future, returns whether or not someone was unblocked - $thread * fulfil( future(T) & this, T result ) { + thread$ * fulfil( future(T) & this, T result ) { this.result = result; return fulfil( (future_t&)this ); Index: libcfa/src/concurrency/invoke.c =================================================================== --- libcfa/src/concurrency/invoke.c (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/invoke.c (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -29,6 +29,6 @@ // Called from the kernel when starting a coroutine or task so must switch back to user mode. -extern struct $coroutine * __cfactx_cor_finish(void); -extern void __cfactx_cor_leave ( struct $coroutine * ); +extern struct coroutine$ * __cfactx_cor_finish(void); +extern void __cfactx_cor_leave ( struct coroutine$ * ); extern void __cfactx_thrd_leave(); @@ -41,5 +41,5 @@ ) { // Finish setting up the coroutine by setting its state - struct $coroutine * cor = __cfactx_cor_finish(); + struct coroutine$ * cor = __cfactx_cor_finish(); // Call the main of the coroutine @@ -70,6 +70,6 @@ } -void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * cor) __attribute__ ((__noreturn__)); -void __cfactx_coroutine_unwind(struct _Unwind_Exception * storage, struct $coroutine * 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); @@ -100,5 +100,5 @@ void __cfactx_start( void (*main)(void *), - struct $coroutine * cor, + struct coroutine$ * cor, void *this, void (*invoke)(void *) Index: libcfa/src/concurrency/invoke.h =================================================================== --- libcfa/src/concurrency/invoke.h (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/invoke.h (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -71,5 +71,5 @@ enum __Coroutine_State { Halted, Start, Primed, Blocked, Ready, Active, Cancelled, Halting }; - struct $coroutine { + struct coroutine$ { // context that is switch during a __cfactx_switch struct __stack_context_t context; @@ -85,8 +85,8 @@ // first coroutine to resume this one - struct $coroutine * starter; + struct coroutine$ * starter; // last coroutine to resume this one - struct $coroutine * last; + struct coroutine$ * last; // If non-null stack must be unwound with this exception @@ -95,7 +95,7 @@ }; // Wrapper for gdb - struct cfathread_coroutine_t { struct $coroutine debug; }; - - static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { + struct cfathread_coroutine_t { struct coroutine$ debug; }; + + static inline struct __stack_t * __get_stack( struct coroutine$ * cor ) { return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); } @@ -110,13 +110,13 @@ }; - struct $monitor { + struct monitor$ { // spinlock to protect internal data struct __spinlock_t lock; // current owner of the monitor - struct $thread * owner; + struct thread$ * owner; // queue of threads that are blocked waiting for the monitor - __queue_t(struct $thread) entry_queue; + __queue_t(struct thread$) entry_queue; // stack of conditions to run next once we exit the monitor @@ -133,9 +133,9 @@ }; // Wrapper for gdb - struct cfathread_monitor_t { struct $monitor debug; }; + struct cfathread_monitor_t { struct monitor$ debug; }; struct __monitor_group_t { // currently held monitors - __cfa_anonymous_object( __small_array_t($monitor*) ); + __cfa_anonymous_object( __small_array_t(monitor$*) ); // last function that acquired monitors @@ -146,9 +146,9 @@ // instrusive link field for threads struct __thread_desc_link { - struct $thread * next; + struct thread$ * next; volatile unsigned long long ts; }; - struct $thread { + struct thread$ { // Core threading fields // context that is switch during a __cfactx_switch @@ -179,14 +179,14 @@ // coroutine body used to store context - struct $coroutine self_cor; + struct coroutine$ self_cor; // current active context - struct $coroutine * curr_cor; + struct coroutine$ * curr_cor; // monitor body used for mutual exclusion - struct $monitor self_mon; + struct monitor$ self_mon; // pointer to monitor with sufficient lifetime for current monitors - struct $monitor * self_mon_p; + struct monitor$ * self_mon_p; // monitors currently held by this thread @@ -195,14 +195,14 @@ // used to put threads on user data structures struct { - struct $thread * next; - struct $thread * back; + struct thread$ * next; + struct thread$ * back; } seqable; // used to put threads on dlist data structure - __cfa_dlink($thread); + __cfa_dlink(thread$); struct { - struct $thread * next; - struct $thread * prev; + struct thread$ * next; + struct thread$ * prev; } node; @@ -214,11 +214,11 @@ }; #ifdef __cforall - P9_EMBEDDED( $thread, dlink($thread) ) + P9_EMBEDDED( thread$, dlink(thread$) ) #endif // Wrapper for gdb - struct cfathread_thread_t { struct $thread debug; }; + struct cfathread_thread_t { struct thread$ debug; }; #ifdef __CFA_DEBUG__ - void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]); + void __cfaabi_dbg_record_thrd(thread$ & this, bool park, const char prev_name[]); #else #define __cfaabi_dbg_record_thrd(x, y, z) @@ -228,25 +228,25 @@ extern "Cforall" { - static inline $thread *& get_next( $thread & this ) __attribute__((const)) { + static inline thread$ *& get_next( thread$ & this ) __attribute__((const)) { return this.link.next; } - static inline [$thread *&, $thread *& ] __get( $thread & this ) __attribute__((const)) { + static inline [thread$ *&, thread$ *& ] __get( thread$ & this ) __attribute__((const)) { return this.node.[next, prev]; } - static inline $thread * volatile & ?`next ( $thread * this ) __attribute__((const)) { + static inline thread$ * volatile & ?`next ( thread$ * this ) __attribute__((const)) { return this->seqable.next; } - static inline $thread *& Back( $thread * this ) __attribute__((const)) { + static inline thread$ *& Back( thread$ * this ) __attribute__((const)) { return this->seqable.back; } - static inline $thread *& Next( $thread * this ) __attribute__((const)) { + static inline thread$ *& Next( thread$ * this ) __attribute__((const)) { return this->seqable.next; } - static inline bool listed( $thread * this ) { + static inline bool listed( thread$ * this ) { return this->seqable.next != 0p; } @@ -258,5 +258,5 @@ } - static inline void ?{}(__monitor_group_t & this, struct $monitor ** 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}; Index: libcfa/src/concurrency/io.cfa =================================================================== --- libcfa/src/concurrency/io.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/io.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -90,5 +90,5 @@ static inline unsigned __flush( struct $io_context & ); static inline __u32 __release_sqes( struct $io_context & ); - extern void __kernel_unpark( $thread * thrd ); + extern void __kernel_unpark( thread$ * thrd ); bool __cfa_io_drain( processor * proc ) { Index: libcfa/src/concurrency/io/types.hfa =================================================================== --- libcfa/src/concurrency/io/types.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/io/types.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -179,5 +179,5 @@ static inline { - $thread * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) { + thread$ * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) { this.result = result; return fulfil(this.self, do_unpark); Index: libcfa/src/concurrency/kernel.cfa =================================================================== --- libcfa/src/concurrency/kernel.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/kernel.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -110,13 +110,13 @@ #endif -extern $thread * mainThread; +extern thread$ * mainThread; extern processor * mainProcessor; //----------------------------------------------------------------------------- // Kernel Scheduling logic -static $thread * __next_thread(cluster * this); -static $thread * __next_thread_slow(cluster * this); -static inline bool __must_unpark( $thread * thrd ) __attribute((nonnull(1))); -static void __run_thread(processor * this, $thread * dst); +static thread$ * __next_thread(cluster * this); +static thread$ * __next_thread_slow(cluster * this); +static inline bool __must_unpark( thread$ * thrd ) __attribute((nonnull(1))); +static void __run_thread(processor * this, thread$ * dst); static void __wake_one(cluster * cltr); @@ -181,5 +181,5 @@ __cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this); - $thread * readyThread = 0p; + thread$ * readyThread = 0p; MAIN_LOOP: for() { @@ -388,5 +388,5 @@ // runThread runs a thread by context switching // from the processor coroutine to the target thread -static void __run_thread(processor * this, $thread * thrd_dst) { +static void __run_thread(processor * this, thread$ * thrd_dst) { /* paranoid */ verify( ! __preemption_enabled() ); /* paranoid */ verifyf( thrd_dst->state == Ready || thrd_dst->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", thrd_dst->state, thrd_dst->preempted); @@ -396,5 +396,5 @@ __cfadbg_print_safe(runtime_core, "Kernel : core %p running thread %p (%s)\n", this, thrd_dst, thrd_dst->self_cor.name); - $coroutine * proc_cor = get_coroutine(this->runner); + coroutine$ * proc_cor = get_coroutine(this->runner); // set state of processor coroutine to inactive @@ -415,6 +415,6 @@ /* paranoid */ verify( thrd_dst->context.SP ); /* paranoid */ verify( thrd_dst->state != Halted ); - /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "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 || thrd_dst->corctx_flag, "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 */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "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 || thrd_dst->corctx_flag, "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( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary ); @@ -428,6 +428,6 @@ /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary ); - /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "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 ) || thrd_dst->corctx_flag, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); + /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "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 ) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); /* paranoid */ verify( thrd_dst->context.SP ); /* paranoid */ verify( thrd_dst->curr_cluster == this->cltr ); @@ -497,6 +497,6 @@ void returnToKernel() { /* paranoid */ verify( ! __preemption_enabled() ); - $coroutine * proc_cor = get_coroutine(kernelTLS().this_processor->runner); - $thread * thrd_src = kernelTLS().this_thread; + coroutine$ * proc_cor = get_coroutine(kernelTLS().this_processor->runner); + thread$ * thrd_src = kernelTLS().this_thread; __STATS( thrd_src->last_proc = kernelTLS().this_processor; ) @@ -526,6 +526,6 @@ /* paranoid */ verify( ! __preemption_enabled() ); - /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ) || thrd_src->corctx_flag, "ERROR : Returning $thread %p has been corrupted.\n StackPointer too small.\n", thrd_src ); - /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit) || thrd_src->corctx_flag, "ERROR : Returning $thread %p has been corrupted.\n StackPointer too large.\n", thrd_src ); + /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) < ((uintptr_t)__get_stack(thrd_src->curr_cor)->base ) || thrd_src->corctx_flag, "ERROR : Returning thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_src ); + /* paranoid */ verifyf( ((uintptr_t)thrd_src->context.SP) > ((uintptr_t)__get_stack(thrd_src->curr_cor)->limit) || thrd_src->corctx_flag, "ERROR : Returning thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_src ); } @@ -533,5 +533,5 @@ // Scheduler routines // KERNEL ONLY -static void __schedule_thread( $thread * thrd ) { +static void __schedule_thread( thread$ * thrd ) { /* paranoid */ verify( ! __preemption_enabled() ); /* paranoid */ verify( ready_schedule_islocked()); @@ -583,5 +583,5 @@ } -void schedule_thread$( $thread * thrd ) { +void schedule_thread$( thread$ * thrd ) { ready_schedule_lock(); __schedule_thread( thrd ); @@ -590,9 +590,9 @@ // KERNEL ONLY -static inline $thread * __next_thread(cluster * this) with( *this ) { +static inline thread$ * __next_thread(cluster * this) with( *this ) { /* paranoid */ verify( ! __preemption_enabled() ); ready_schedule_lock(); - $thread * thrd = pop_fast( this ); + thread$ * thrd = pop_fast( this ); ready_schedule_unlock(); @@ -602,9 +602,9 @@ // KERNEL ONLY -static inline $thread * __next_thread_slow(cluster * this) with( *this ) { +static inline thread$ * __next_thread_slow(cluster * this) with( *this ) { /* paranoid */ verify( ! __preemption_enabled() ); ready_schedule_lock(); - $thread * thrd; + thread$ * thrd; for(25) { thrd = pop_slow( this ); @@ -620,5 +620,5 @@ } -static inline bool __must_unpark( $thread * thrd ) { +static inline bool __must_unpark( thread$ * thrd ) { int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST); switch(old_ticket) { @@ -636,5 +636,5 @@ } -void __kernel_unpark( $thread * thrd ) { +void __kernel_unpark( thread$ * thrd ) { /* paranoid */ verify( ! __preemption_enabled() ); /* paranoid */ verify( ready_schedule_islocked()); @@ -651,5 +651,5 @@ } -void unpark( $thread * thrd ) { +void unpark( thread$ * thrd ) { if( !thrd ) return; @@ -675,6 +675,6 @@ // Should never return void __cfactx_thrd_leave() { - $thread * thrd = active_thread(); - $monitor * this = &thrd->self_mon; + thread$ * thrd = active_thread(); + monitor$ * this = &thrd->self_mon; // Lock the monitor now @@ -688,6 +688,6 @@ /* paranoid */ verify( kernelTLS().this_thread == thrd ); /* paranoid */ verify( thrd->context.SP ); - /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : $thread %p has been corrupted.\n StackPointer too large.\n", thrd ); - /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : $thread %p has been corrupted.\n StackPointer too small.\n", thrd ); + /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : thread$ %p has been corrupted.\n StackPointer too large.\n", thrd ); + /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : thread$ %p has been corrupted.\n StackPointer too small.\n", thrd ); thrd->state = Halting; @@ -707,5 +707,5 @@ bool force_yield( __Preemption_Reason reason ) { __disable_interrupts_checked(); - $thread * thrd = kernelTLS().this_thread; + thread$ * thrd = kernelTLS().this_thread; /* paranoid */ verify(thrd->state == Active); @@ -819,5 +819,5 @@ //============================================================================================= void __kernel_abort_msg( char * abort_text, int abort_text_size ) { - $thread * thrd = __cfaabi_tls.this_thread; + thread$ * thrd = __cfaabi_tls.this_thread; if(thrd) { Index: libcfa/src/concurrency/kernel.hfa =================================================================== --- libcfa/src/concurrency/kernel.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/kernel.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -115,5 +115,5 @@ // it is not a particularly safe scheme as it can make processors less homogeneous struct { - $thread * thrd; + thread$ * thrd; } init; @@ -215,5 +215,5 @@ // List of threads __spinlock_t thread_list_lock; - __dllist_t(struct $thread) threads; + __dllist_t(struct thread$) threads; unsigned int nthreads; Index: libcfa/src/concurrency/kernel/fwd.hfa =================================================================== --- libcfa/src/concurrency/kernel/fwd.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/kernel/fwd.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -24,5 +24,5 @@ #endif -struct $thread; +struct thread$; struct processor; struct cluster; @@ -36,5 +36,5 @@ extern "Cforall" { extern __attribute__((aligned(128))) thread_local struct KernelThreadData { - struct $thread * volatile this_thread; + struct thread$ * volatile this_thread; struct processor * volatile this_processor; volatile bool sched_lock; @@ -120,7 +120,7 @@ extern "Cforall" { extern void park( void ); - extern void unpark( struct $thread * this ); - static inline struct $thread * active_thread () { - struct $thread * t = publicTLS_get( this_thread ); + extern void unpark( struct thread$ * this ); + static inline struct thread$ * active_thread () { + struct thread$ * t = publicTLS_get( this_thread ); /* paranoid */ verify( t ); return t; @@ -144,5 +144,5 @@ // Semaphore which only supports a single thread struct single_sem { - struct $thread * volatile ptr; + struct thread$ * volatile ptr; }; @@ -156,5 +156,5 @@ bool wait(single_sem & this) { for() { - struct $thread * expected = this.ptr; + struct thread$ * expected = this.ptr; if(expected == 1p) { if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { @@ -175,5 +175,5 @@ bool post(single_sem & this) { for() { - struct $thread * expected = this.ptr; + struct thread$ * expected = this.ptr; if(expected == 1p) return false; if(expected == 0p) { @@ -200,5 +200,5 @@ // 1p : fulfilled (wait won't block) // any thread : a thread is currently waiting - struct $thread * volatile ptr; + struct thread$ * volatile ptr; }; @@ -214,5 +214,5 @@ bool wait(oneshot & this) { for() { - struct $thread * expected = this.ptr; + struct thread$ * expected = this.ptr; if(expected == 1p) return false; /* paranoid */ verify( expected == 0p ); @@ -227,6 +227,6 @@ // Mark as fulfilled, wake thread if needed // return true if a thread was unparked - $thread * post(oneshot & this, bool do_unpark = true) { - struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST); + thread$ * post(oneshot & this, bool do_unpark = true) { + struct thread$ * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST); if( got == 0p ) return 0p; if(do_unpark) unpark( got ); @@ -343,5 +343,5 @@ // from the server side, mark the future as fulfilled // delete it if needed - $thread * fulfil( future_t & this, bool do_unpark = true ) { + thread$ * fulfil( future_t & this, bool do_unpark = true ) { for() { struct oneshot * expected = this.ptr; @@ -364,5 +364,5 @@ if(__atomic_compare_exchange_n(&this.ptr, &expected, want, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return 0p; } - $thread * ret = post( *expected, do_unpark ); + thread$ * ret = post( *expected, do_unpark ); __atomic_store_n( &this.ptr, 1p, __ATOMIC_SEQ_CST); return ret; Index: libcfa/src/concurrency/kernel/startup.cfa =================================================================== --- libcfa/src/concurrency/kernel/startup.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/kernel/startup.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -77,5 +77,5 @@ static void __kernel_first_resume( processor * this ); static void __kernel_last_resume ( processor * this ); -static void init(processor & this, const char name[], cluster & _cltr, $thread * initT); +static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT); static void deinit(processor & this); static void doregister( struct cluster & cltr ); @@ -83,6 +83,6 @@ static void register_tls( processor * this ); static void unregister_tls( processor * this ); -static void ?{}( $coroutine & this, current_stack_info_t * info); -static void ?{}( $thread & this, current_stack_info_t * info); +static void ?{}( coroutine$ & this, current_stack_info_t * info); +static void ?{}( thread$ & this, current_stack_info_t * info); static void ?{}(processorCtx_t & this) {} static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info); @@ -105,5 +105,5 @@ KERNEL_STORAGE(cluster, mainCluster); KERNEL_STORAGE(processor, mainProcessor); -KERNEL_STORAGE($thread, mainThread); +KERNEL_STORAGE(thread$, mainThread); KERNEL_STORAGE(__stack_t, mainThreadCtx); KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock); @@ -114,5 +114,5 @@ cluster * mainCluster; processor * mainProcessor; -$thread * mainThread; +thread$ * mainThread; __scheduler_RWLock_t * __scheduler_lock; @@ -203,5 +203,5 @@ // SKULLDUGGERY: the mainThread steals the process main thread // which will then be scheduled by the mainProcessor normally - mainThread = ($thread *)&storage_mainThread; + mainThread = (thread$ *)&storage_mainThread; current_stack_info_t info; info.storage = (__stack_t*)&storage_mainThreadCtx; @@ -397,6 +397,6 @@ static void __kernel_first_resume( processor * this ) { - $thread * src = mainThread; - $coroutine * dst = get_coroutine(this->runner); + thread$ * src = mainThread; + coroutine$ * dst = get_coroutine(this->runner); /* paranoid */ verify( ! __preemption_enabled() ); @@ -430,6 +430,6 @@ // KERNEL_ONLY static void __kernel_last_resume( processor * this ) { - $coroutine * src = &mainThread->self_cor; - $coroutine * dst = get_coroutine(this->runner); + coroutine$ * src = &mainThread->self_cor; + coroutine$ * dst = get_coroutine(this->runner); /* paranoid */ verify( ! __preemption_enabled() ); @@ -459,5 +459,5 @@ //----------------------------------------------------------------------------- // Main thread construction -static void ?{}( $coroutine & this, current_stack_info_t * info) with( this ) { +static void ?{}( coroutine$ & this, current_stack_info_t * info) with( this ) { stack.storage = info->storage; with(*stack.storage) { @@ -474,5 +474,5 @@ } -static void ?{}( $thread & this, current_stack_info_t * info) with( this ) { +static void ?{}( thread$ & this, current_stack_info_t * info) with( this ) { ticket = TICKET_RUNNING; state = Start; @@ -506,5 +506,5 @@ } -static void init(processor & this, const char name[], cluster & _cltr, $thread * initT) with( this ) { +static void init(processor & this, const char name[], cluster & _cltr, thread$ * initT) with( this ) { this.name = name; this.cltr = &_cltr; @@ -545,5 +545,5 @@ } -void ?{}(processor & this, const char name[], cluster & _cltr, $thread * initT) { +void ?{}(processor & this, const char name[], cluster & _cltr, thread$ * initT) { ( this.terminated ){}; ( this.runner ){}; @@ -663,5 +663,5 @@ } -void doregister( cluster * cltr, $thread & thrd ) { +void doregister( cluster * cltr, thread$ & thrd ) { lock (cltr->thread_list_lock __cfaabi_dbg_ctx2); cltr->nthreads += 1; @@ -670,5 +670,5 @@ } -void unregister( cluster * cltr, $thread & thrd ) { +void unregister( cluster * cltr, thread$ & thrd ) { lock (cltr->thread_list_lock __cfaabi_dbg_ctx2); remove(cltr->threads, thrd ); Index: libcfa/src/concurrency/kernel_private.hfa =================================================================== --- libcfa/src/concurrency/kernel_private.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/kernel_private.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -46,10 +46,10 @@ } -void schedule_thread$( $thread * ) __attribute__((nonnull (1))); +void schedule_thread$( thread$ * ) __attribute__((nonnull (1))); extern bool __preemption_enabled(); //release/wake-up the following resources -void __thread_finish( $thread * thrd ); +void __thread_finish( thread$ * thrd ); //----------------------------------------------------------------------------- @@ -95,6 +95,6 @@ __cfaabi_dbg_debug_do( - extern void __cfaabi_dbg_thread_register ( $thread * thrd ); - extern void __cfaabi_dbg_thread_unregister( $thread * thrd ); + extern void __cfaabi_dbg_thread_register ( thread$ * thrd ); + extern void __cfaabi_dbg_thread_unregister( thread$ * thrd ); ) @@ -105,6 +105,6 @@ //----------------------------------------------------------------------------- // Utils -void doregister( struct cluster * cltr, struct $thread & thrd ); -void unregister( struct cluster * cltr, struct $thread & thrd ); +void doregister( struct cluster * cltr, struct thread$ & thrd ); +void unregister( struct cluster * cltr, struct thread$ & thrd ); //----------------------------------------------------------------------------- @@ -300,5 +300,5 @@ // push thread onto a ready queue for a cluster // returns true if the list was previously empty, false otherwise -__attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool local); +__attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool local); //----------------------------------------------------------------------- @@ -306,5 +306,5 @@ // returns 0p if empty // May return 0p spuriously -__attribute__((hot)) struct $thread * pop_fast(struct cluster * cltr); +__attribute__((hot)) struct thread$ * pop_fast(struct cluster * cltr); //----------------------------------------------------------------------- @@ -312,5 +312,5 @@ // returns 0p if empty // May return 0p spuriously -__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr); +__attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr); //----------------------------------------------------------------------- @@ -318,5 +318,5 @@ // returns 0p if empty // guaranteed to find any threads added before this call -__attribute__((hot)) struct $thread * pop_search(struct cluster * cltr); +__attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr); //----------------------------------------------------------------------- Index: libcfa/src/concurrency/locks.cfa =================================================================== --- libcfa/src/concurrency/locks.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/locks.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -32,5 +32,5 @@ // waiting thread - struct $thread * t; + struct thread$ * t; // shadow field @@ -45,5 +45,5 @@ P9_EMBEDDED( info_thread(L), dlink(info_thread(L)) ) - void ?{}( info_thread(L) & this, $thread * t, uintptr_t info, L * l ) { + void ?{}( info_thread(L) & this, thread$ * t, uintptr_t info, L * l ) { this.t = t; this.info = info; @@ -71,5 +71,5 @@ void lock( blocking_lock & this ) with( this ) { lock( lock __cfaabi_dbg_ctx2 ); - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); // single acquisition lock is held by current thread @@ -117,5 +117,5 @@ void pop_and_set_new_owner( blocking_lock & this ) with( this ) { - $thread * t = &try_pop_front( blocked_threads ); + thread$ * t = &try_pop_front( blocked_threads ); owner = t; recursion_count = ( t ? 1 : 0 ); @@ -142,5 +142,5 @@ } -void on_notify( blocking_lock & this, $thread * t ) with( this ) { +void on_notify( blocking_lock & this, thread$ * t ) with( this ) { lock( lock __cfaabi_dbg_ctx2 ); // lock held @@ -366,6 +366,6 @@ } -$thread * V (semaphore & this, const bool doUnpark ) with( this ) { - $thread * thrd = 0p; +thread$ * V (semaphore & this, const bool doUnpark ) with( this ) { + thread$ * thrd = 0p; lock( lock __cfaabi_dbg_ctx2 ); count += 1; @@ -384,10 +384,10 @@ bool V(semaphore & this) with( this ) { - $thread * thrd = V(this, true); + thread$ * thrd = V(this, true); return thrd != 0p; } bool V(semaphore & this, unsigned diff) with( this ) { - $thread * thrd = 0p; + thread$ * thrd = 0p; lock( lock __cfaabi_dbg_ctx2 ); int release = max(-count, (int)diff); Index: libcfa/src/concurrency/locks.hfa =================================================================== --- libcfa/src/concurrency/locks.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/locks.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -39,8 +39,8 @@ struct Semaphore0nary { __spinlock_t lock; // needed to protect - mpsc_queue($thread) queue; -}; - -static inline bool P(Semaphore0nary & this, $thread * thrd) { + mpsc_queue(thread$) queue; +}; + +static inline bool P(Semaphore0nary & this, thread$ * thrd) { /* paranoid */ verify(!thrd`next); /* paranoid */ verify(!(&(*thrd)`next)); @@ -51,5 +51,5 @@ static inline bool P(Semaphore0nary & this) { - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); P(this, thrd); park(); @@ -57,6 +57,6 @@ } -static inline $thread * V(Semaphore0nary & this, bool doUnpark = true) { - $thread * next; +static inline thread$ * V(Semaphore0nary & this, bool doUnpark = true) { + thread$ * next; lock(this.lock __cfaabi_dbg_ctx2); for (;;) { @@ -124,5 +124,5 @@ static inline bool P(ThreadBenaphore & this, bool wait) { return wait ? P(this) : tryP(this); } -static inline $thread * V(ThreadBenaphore & this, bool doUnpark = true) { +static inline thread$ * V(ThreadBenaphore & this, bool doUnpark = true) { if (V(this.ben)) return 0p; return V(this.sem, doUnpark); @@ -134,5 +134,5 @@ __spinlock_t lock; int count; - __queue_t($thread) waiting; + __queue_t(thread$) waiting; }; @@ -142,5 +142,5 @@ bool V (semaphore & this); bool V (semaphore & this, unsigned count); -$thread * V (semaphore & this, bool ); +thread$ * V (semaphore & this, bool ); //---------- @@ -156,5 +156,5 @@ static inline size_t on_wait ( single_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); } static inline void on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); } -static inline void on_notify( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); } +static inline void on_notify( single_acquisition_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); } //---------- @@ -170,8 +170,8 @@ static inline size_t on_wait ( owner_lock & this ) { return on_wait ( (blocking_lock &)this ); } static inline void on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); } -static inline void on_notify( owner_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); } +static inline void on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); } struct fast_lock { - $thread * volatile owner; + thread$ * volatile owner; ThreadBenaphore sem; }; @@ -179,6 +179,6 @@ static inline void ?{}(fast_lock & this) { this.owner = 0p; } -static inline bool $try_lock(fast_lock & this, $thread * thrd) { - $thread * exp = 0p; +static inline bool $try_lock(fast_lock & this, thread$ * thrd) { + thread$ * exp = 0p; return __atomic_compare_exchange_n(&this.owner, &exp, thrd, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED); } @@ -186,5 +186,5 @@ static inline void lock( fast_lock & this ) __attribute__((artificial)); static inline void lock( fast_lock & this ) { - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); /* paranoid */verify(thrd != this.owner); @@ -197,11 +197,11 @@ static inline bool try_lock( fast_lock & this ) __attribute__((artificial)); static inline bool try_lock ( fast_lock & this ) { - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); /* paranoid */ verify(thrd != this.owner); return $try_lock(this, thrd); } -static inline $thread * unlock( fast_lock & this ) __attribute__((artificial)); -static inline $thread * unlock( fast_lock & this ) { +static inline thread$ * unlock( fast_lock & this ) __attribute__((artificial)); +static inline thread$ * unlock( fast_lock & this ) { /* paranoid */ verify(active_thread() == this.owner); @@ -216,5 +216,5 @@ static inline size_t on_wait( fast_lock & this ) { unlock(this); return 0; } static inline void on_wakeup( fast_lock & this, size_t ) { lock(this); } -static inline void on_notify( fast_lock &, struct $thread * t ) { unpark(t); } +static inline void on_notify( fast_lock &, struct thread$ * t ) { unpark(t); } struct mcs_node { @@ -248,8 +248,8 @@ // Current thread owning the lock - struct $thread * owner; + struct thread$ * owner; // List of blocked threads - dlist( $thread ) blocked_threads; + dlist( thread$ ) blocked_threads; // Used for comparing and exchanging @@ -343,5 +343,5 @@ // block until signalled while (block(this)) if(try_lock_contention(this)) return true; - + // this should never be reached as block(this) always returns true return false; @@ -385,5 +385,5 @@ // block until signalled while (block(this)) if(try_lock_contention(this)) return true; - + // this should never be reached as block(this) always returns true return false; @@ -395,10 +395,10 @@ if (__atomic_exchange_n(&lock_value, 0, __ATOMIC_RELEASE) == 1) return; lock( spinlock __cfaabi_dbg_ctx2 ); - $thread * t = &try_pop_front( blocked_threads ); + thread$ * t = &try_pop_front( blocked_threads ); unlock( spinlock ); unpark( t ); } -static inline void on_notify(linear_backoff_then_block_lock & this, struct $thread * t ) { unpark(t); } +static inline void on_notify(linear_backoff_then_block_lock & this, struct thread$ * t ) { unpark(t); } static inline size_t on_wait(linear_backoff_then_block_lock & this) { unlock(this); return 0; } static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock_improved(this); } @@ -408,5 +408,5 @@ trait is_blocking_lock(L & | sized(L)) { // For synchronization locks to use when acquiring - void on_notify( L &, struct $thread * ); + void on_notify( L &, struct thread$ * ); // For synchronization locks to use when releasing @@ -442,5 +442,5 @@ int count; }; - + void ?{}( condition_variable(L) & this ); Index: libcfa/src/concurrency/monitor.cfa =================================================================== --- libcfa/src/concurrency/monitor.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/monitor.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// $monitor.c -- +// monitor.cfa -- // // Author : Thierry Delisle @@ -28,31 +28,31 @@ //----------------------------------------------------------------------------- // Forward declarations -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 __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 * 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 * 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 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 *, int] search_entry_queue( const __waitfor_mask_t &, $monitor * monitors [], __lock_size_t count ); +static inline [thread$ *, int] search_entry_queue( const __waitfor_mask_t &, monitor$ * monitors [], __lock_size_t count ); forall(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 * storage [], const __waitfor_mask_t & mask ); +static inline __lock_size_t aggregate ( monitor$ * storage [], const __waitfor_mask_t & mask ); //----------------------------------------------------------------------------- @@ -69,5 +69,5 @@ #define monitor_ctx( mons, cnt ) /* Define that create the necessary struct for internal/external scheduling operations */ \ - $monitor ** 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 */ \ @@ -82,6 +82,6 @@ // Enter/Leave routines // Enter single monitor -static void __enter( $monitor * this, const __monitor_group_t & group ) { - $thread * thrd = active_thread(); +static void __enter( monitor$ * this, const __monitor_group_t & group ) { + thread$ * thrd = active_thread(); // Lock the monitor spinlock @@ -141,6 +141,6 @@ } -static void __dtor_enter( $monitor * this, fptr_t func, bool join ) { - $thread * thrd = active_thread(); +static void __dtor_enter( monitor$ * this, fptr_t func, bool join ) { + thread$ * thrd = active_thread(); #if defined( __CFA_WITH_VERIFY__ ) bool is_thrd = this == &thrd->self_mon; @@ -173,5 +173,5 @@ // because join will not release the monitor after it executed. // to avoid that it sets the owner to the special value thrd | 1p before exiting - else if( this->owner == ($thread*)(1 | (uintptr_t)thrd) ) { + else if( this->owner == (thread$*)(1 | (uintptr_t)thrd) ) { // restore the owner and just return __cfaabi_dbg_print_safe( "Kernel : Destroying free mon %p\n", this); @@ -191,5 +191,5 @@ __lock_size_t count = 1; - $monitor ** monitors = &this; + monitor$ ** monitors = &this; __monitor_group_t group = { &this, 1, func }; if( is_accepted( this, group) ) { @@ -243,5 +243,5 @@ // Leave single monitor -void __leave( $monitor * this ) { +void __leave( monitor$ * this ) { // Lock the monitor spinlock lock( this->lock __cfaabi_dbg_ctx2 ); @@ -263,5 +263,5 @@ // Get the next thread, will be null on low contention monitor - $thread * new_owner = next_thread( this ); + thread$ * new_owner = next_thread( this ); // Check the new owner is consistent with who we wake-up @@ -278,5 +278,5 @@ // Leave single monitor for the last time -void __dtor_leave( $monitor * this, bool join ) { +void __dtor_leave( monitor$ * this, bool join ) { __cfaabi_dbg_debug_do( if( active_thread() != this->owner ) { @@ -288,9 +288,9 @@ ) - this->owner = ($thread*)(1 | (uintptr_t)this->owner); -} - -void __thread_finish( $thread * thrd ) { - $monitor * this = &thrd->self_mon; + this->owner = (thread$*)(1 | (uintptr_t)this->owner); +} + +void __thread_finish( thread$ * thrd ) { + monitor$ * this = &thrd->self_mon; // Lock the monitor now @@ -298,6 +298,6 @@ /* paranoid */ verify( this->lock.lock ); /* paranoid */ verify( thrd->context.SP ); - /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : $thread %p has been corrupted.\n StackPointer too large.\n", thrd ); - /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : $thread %p has been corrupted.\n StackPointer too small.\n", thrd ); + /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) > ((uintptr_t)__get_stack(thrd->curr_cor)->limit), "ERROR : thread$ %p has been corrupted.\n StackPointer too large.\n", thrd ); + /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : thread$ %p has been corrupted.\n StackPointer too small.\n", thrd ); /* paranoid */ verify( ! __preemption_enabled() ); @@ -311,5 +311,5 @@ // Fetch the next thread, can be null - $thread * new_owner = next_thread( this ); + thread$ * new_owner = next_thread( this ); // Mark the state as fully halted @@ -336,5 +336,5 @@ // Leave multiple monitor // relies on the monitor array being sorted -static inline void leave($monitor * 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( monitors[i] ); @@ -344,6 +344,6 @@ // Ctor for monitor guard // Sorts monitors before entering -void ?{}( monitor_guard_t & this, $monitor * m [], __lock_size_t count, fptr_t func ) { - $thread * thrd = active_thread(); +void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func ) { + thread$ * thrd = active_thread(); // Store current array @@ -385,7 +385,7 @@ // Ctor for monitor guard // Sorts monitors before entering -void ?{}( monitor_dtor_guard_t & this, $monitor * m [], fptr_t func, bool join ) { +void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, bool join ) { // optimization - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); // Store current array @@ -415,5 +415,5 @@ //----------------------------------------------------------------------------- // Internal scheduling types -void ?{}(__condition_node_t & this, $thread * 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; @@ -429,5 +429,5 @@ } -void ?{}(__condition_criterion_t & this, $monitor * target, __condition_node_t & owner ) { +void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t & owner ) { this.ready = false; this.target = target; @@ -463,5 +463,5 @@ // Find the next thread(s) to run __lock_size_t thread_count = 0; - $thread * threads[ count ]; + thread$ * threads[ count ]; __builtin_memset( threads, 0, sizeof( threads ) ); @@ -471,5 +471,5 @@ // Remove any duplicate threads for( __lock_size_t i = 0; i < count; i++) { - $thread * new_owner = next_thread( monitors[i] ); + thread$ * new_owner = next_thread( monitors[i] ); insert_unique( threads, thread_count, new_owner ); } @@ -501,5 +501,5 @@ //Some more checking in debug __cfaabi_dbg_debug_do( - $thread * this_thrd = active_thread(); + thread$ * this_thrd = active_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 ); @@ -555,5 +555,5 @@ //Find the thread to run - $thread * signallee = pop_head( this.blocked )->waiting_thread; + thread$ * signallee = pop_head( this.blocked )->waiting_thread; __set_owner( monitors, count, signallee ); @@ -608,5 +608,5 @@ // Create one! __lock_size_t max = count_max( mask ); - $monitor * mon_storage[max]; + monitor$ * mon_storage[max]; __builtin_memset( mon_storage, 0, sizeof( mon_storage ) ); __lock_size_t actual_count = aggregate( mon_storage, mask ); @@ -626,5 +626,5 @@ { // Check if the entry queue - $thread * next; int index; + thread$ * next; int index; [next, index] = search_entry_queue( mask, monitors, count ); @@ -636,5 +636,5 @@ verifyf( accepted.size == 1, "ERROR: Accepted dtor has more than 1 mutex parameter." ); - $monitor * mon2dtor = accepted[0]; + monitor$ * mon2dtor = accepted[0]; verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." ); @@ -730,5 +730,5 @@ // Utilities -static inline void __set_owner( $monitor * this, $thread * owner ) { +static inline void __set_owner( monitor$ * this, thread$ * owner ) { /* paranoid */ verify( this->lock.lock ); @@ -740,5 +740,5 @@ } -static inline void __set_owner( $monitor * monitors [], __lock_size_t count, $thread * owner ) { +static inline void __set_owner( monitor$ * monitors [], __lock_size_t count, thread$ * owner ) { /* paranoid */ verify ( monitors[0]->lock.lock ); /* paranoid */ verifyf( monitors[0]->owner == active_thread(), "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), monitors[0]->owner, monitors[0]->recursion, monitors[0] ); @@ -753,5 +753,5 @@ } -static inline void set_mask( $monitor * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) { +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; @@ -759,5 +759,5 @@ } -static inline void reset_mask( $monitor * this ) { +static inline void reset_mask( monitor$ * this ) { this->mask.accepted = 0p; this->mask.data = 0p; @@ -765,5 +765,5 @@ } -static inline $thread * next_thread( $monitor * 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); @@ -781,5 +781,5 @@ // No signaller thread // Get the next thread in the entry_queue - $thread * new_owner = pop_head( this->entry_queue ); + thread$ * new_owner = pop_head( this->entry_queue ); /* paranoid */ verifyf( !this->owner || active_thread() == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", active_thread(), this->owner, this->recursion, this ); /* paranoid */ verify( !new_owner || new_owner->link.next == 0p ); @@ -789,5 +789,5 @@ } -static inline bool is_accepted( $monitor * 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; @@ -811,5 +811,5 @@ } -static inline void init( __lock_size_t count, $monitor * 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 }; @@ -819,5 +819,5 @@ } -static inline void init_push( __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 [] ) { for( __lock_size_t i = 0; i < count; i++) { (criteria[i]){ monitors[i], waiter }; @@ -835,5 +835,5 @@ } -static inline void lock_all( $monitor * 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; @@ -849,5 +849,5 @@ } -static inline void unlock_all( $monitor * 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 ); @@ -856,5 +856,5 @@ static inline void save( - $monitor * ctx [], + monitor$ * ctx [], __lock_size_t count, __attribute((unused)) __spinlock_t * locks [], @@ -869,5 +869,5 @@ static inline void restore( - $monitor * ctx [], + monitor$ * ctx [], __lock_size_t count, __spinlock_t * locks [], @@ -887,5 +887,5 @@ // 2 - Checks if all the monitors are ready to run // if so return the thread to run -static inline $thread * 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; @@ -910,5 +910,5 @@ static inline void brand_condition( condition & this ) { - $thread * thrd = active_thread(); + thread$ * thrd = active_thread(); if( !this.monitors ) { // __cfaabi_dbg_print_safe( "Branding\n" ); @@ -916,5 +916,5 @@ this.monitor_count = thrd->monitors.size; - this.monitors = ($monitor **)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]; @@ -923,10 +923,10 @@ } -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; +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 ** thrd_it = &entry_queue.head; + for( thread$ ** thrd_it = &entry_queue.head; (*thrd_it) != 1p; thrd_it = &(*thrd_it)->link.next @@ -972,5 +972,5 @@ } -static inline __lock_size_t aggregate( $monitor * 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++ ) { Index: libcfa/src/concurrency/monitor.hfa =================================================================== --- libcfa/src/concurrency/monitor.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/monitor.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -23,9 +23,9 @@ trait is_monitor(T &) { - $monitor * get_monitor( T & ); + monitor$ * get_monitor( T & ); void ^?{}( T & mutex ); }; -static inline void ?{}($monitor & this) with( this ) { +static inline void ?{}(monitor$ & this) with( this ) { lock{}; entry_queue{}; @@ -39,22 +39,22 @@ } -static inline void ^?{}($monitor & ) {} +static inline void ^?{}(monitor$ & ) {} struct monitor_guard_t { - $monitor ** m; + monitor$ ** m; __lock_size_t count; __monitor_group_t prev; }; -void ?{}( monitor_guard_t & this, $monitor ** 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 * m; + monitor$ * m; __monitor_group_t prev; bool join; }; -void ?{}( monitor_dtor_guard_t & this, $monitor ** m, void (*func)(), bool join ); +void ?{}( monitor_dtor_guard_t & this, monitor$ ** m, void (*func)(), bool join ); void ^?{}( monitor_dtor_guard_t & this ); @@ -73,5 +73,5 @@ // The monitor this criterion concerns - $monitor * target; + monitor$ * target; // The parent node to which this criterion belongs @@ -88,5 +88,5 @@ struct __condition_node_t { // Thread that needs to be woken when all criteria are met - $thread * waiting_thread; + thread$ * waiting_thread; // Array of criteria (Criterions are contiguous in memory) @@ -107,7 +107,7 @@ } -void ?{}(__condition_node_t & this, $thread * 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 * target, __condition_node_t * owner ); +void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner ); struct condition { @@ -116,5 +116,5 @@ // Array of monitor pointers (Monitors are NOT contiguous in memory) - $monitor ** monitors; + monitor$ ** monitors; // Number of monitors in the array Index: libcfa/src/concurrency/mutex.cfa =================================================================== --- libcfa/src/concurrency/mutex.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/mutex.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -122,5 +122,5 @@ recursion_count--; if( recursion_count == 0 ) { - $thread * thrd = pop_head( blocked_threads ); + thread$ * thrd = pop_head( blocked_threads ); owner = thrd; recursion_count = (thrd ? 1 : 0); Index: libcfa/src/concurrency/mutex.hfa =================================================================== --- libcfa/src/concurrency/mutex.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/mutex.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -36,5 +36,5 @@ // List of blocked threads - __queue_t(struct $thread) blocked_threads; + __queue_t(struct thread$) blocked_threads; // Locked flag @@ -55,8 +55,8 @@ // List of blocked threads - __queue_t(struct $thread) blocked_threads; + __queue_t(struct thread$) blocked_threads; // Current thread owning the lock - struct $thread * owner; + struct thread$ * owner; // Number of recursion level @@ -83,5 +83,5 @@ // List of blocked threads - __queue_t(struct $thread) blocked_threads; + __queue_t(struct thread$) blocked_threads; }; Index: libcfa/src/concurrency/preemption.cfa =================================================================== --- libcfa/src/concurrency/preemption.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/preemption.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -61,5 +61,5 @@ // FwdDeclarations : timeout handlers static void preempt( processor * this ); -static void timeout( $thread * this ); +static void timeout( thread$ * this ); // FwdDeclarations : Signal handlers @@ -420,5 +420,5 @@ // reserved for future use -static void timeout( $thread * this ) { +static void timeout( thread$ * this ) { unpark( this ); } Index: libcfa/src/concurrency/ready_queue.cfa =================================================================== --- libcfa/src/concurrency/ready_queue.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/ready_queue.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -67,7 +67,7 @@ #endif -static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)); -static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)); -static inline struct $thread * search(struct cluster * cltr); +static inline struct thread$ * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)); +static inline struct thread$ * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)); +static inline struct thread$ * search(struct cluster * cltr); static inline [unsigned, bool] idx_from_r(unsigned r, unsigned preferred); @@ -274,5 +274,5 @@ //----------------------------------------------------------------------- #if defined(USE_CPU_WORK_STEALING) - __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) { + __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) { __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr); @@ -316,5 +316,5 @@ // Pop from the ready queue from a given cluster - __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { /* paranoid */ verify( lanes.count > 0 ); /* paranoid */ verify( kernelTLS().this_processor ); @@ -371,5 +371,5 @@ proc->rdq.target = -1u; if(lanes.tscs[target].tv < cutoff && ts(lanes.data[target]) < cutoff) { - $thread * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help)); + thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help)); proc->rdq.last = target; if(t) return t; @@ -379,5 +379,5 @@ unsigned last = proc->rdq.last; if(last != -1u && lanes.tscs[last].tv < cutoff && ts(lanes.data[last]) < cutoff) { - $thread * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.help)); + thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.help)); if(t) return t; } @@ -389,5 +389,5 @@ for(READYQ_SHARD_FACTOR) { unsigned i = start + (proc->rdq.itr++ % READYQ_SHARD_FACTOR); - if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t; + if(thread$ * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t; } @@ -396,9 +396,9 @@ } - __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) with (cltr->ready_queue) { processor * const proc = kernelTLS().this_processor; unsigned last = proc->rdq.last; if(last != -1u) { - struct $thread * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.steal)); + struct thread$ * t = try_pop(cltr, last __STATS(, __tls_stats()->ready.pop.steal)); if(t) return t; proc->rdq.last = -1u; @@ -408,5 +408,5 @@ return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal)); } - __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) { + __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) { return search(cltr); } @@ -435,5 +435,5 @@ } - __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) { + __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) { __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr); @@ -482,5 +482,5 @@ // Pop from the ready queue from a given cluster - __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { /* paranoid */ verify( lanes.count > 0 ); /* paranoid */ verify( kernelTLS().this_processor ); @@ -506,5 +506,5 @@ // try popping from the 2 picked lists - struct $thread * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help))); + struct thread$ * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help))); if(thrd) { return thrd; @@ -516,11 +516,11 @@ } - __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) { return pop_fast(cltr); } - __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) { + __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) { return pop_fast(cltr); } + __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) { return search(cltr); } #endif #if defined(USE_WORK_STEALING) - __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd, bool push_local) with (cltr->ready_queue) { + __attribute__((hot)) void push(struct cluster * cltr, struct thread$ * thrd, bool push_local) with (cltr->ready_queue) { __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr); @@ -576,5 +576,5 @@ // Pop from the ready queue from a given cluster - __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) thread$ * pop_fast(struct cluster * cltr) with (cltr->ready_queue) { /* paranoid */ verify( lanes.count > 0 ); /* paranoid */ verify( kernelTLS().this_processor ); @@ -598,5 +598,5 @@ const unsigned long long cutoff = proc->rdq.cutoff > bias ? proc->rdq.cutoff - bias : proc->rdq.cutoff; if(lanes.tscs[target].tv < cutoff && ts(lanes.data[target]) < cutoff) { - $thread * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help)); + thread$ * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help)); if(t) return t; } @@ -605,15 +605,15 @@ for(READYQ_SHARD_FACTOR) { unsigned i = proc->rdq.id + (proc->rdq.itr++ % READYQ_SHARD_FACTOR); - if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t; + if(thread$ * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t; } return 0p; } - __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) struct thread$ * pop_slow(struct cluster * cltr) with (cltr->ready_queue) { unsigned i = __tls_rand() % lanes.count; return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal)); } - __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) with (cltr->ready_queue) { + __attribute__((hot)) struct thread$ * pop_search(struct cluster * cltr) with (cltr->ready_queue) { return search(cltr); } @@ -628,5 +628,5 @@ //----------------------------------------------------------------------- // try to pop from a lane given by index w -static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) { +static inline struct thread$ * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) { __STATS( stats.attempt++; ) @@ -651,5 +651,5 @@ // Actually pop the list - struct $thread * thrd; + struct thread$ * thrd; unsigned long long tsv; [thrd, tsv] = pop(lane); @@ -678,5 +678,5 @@ // try to pop from any lanes making sure you don't miss any threads push // before the start of the function -static inline struct $thread * search(struct cluster * cltr) with (cltr->ready_queue) { +static inline struct thread$ * search(struct cluster * cltr) with (cltr->ready_queue) { /* paranoid */ verify( lanes.count > 0 ); unsigned count = __atomic_load_n( &lanes.count, __ATOMIC_RELAXED ); @@ -684,5 +684,5 @@ for(i; count) { unsigned idx = (offset + i) % count; - struct $thread * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search)); + struct thread$ * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search)); if(thrd) { return thrd; @@ -719,5 +719,5 @@ //----------------------------------------------------------------------- // Given 2 indexes, pick the list with the oldest push an try to pop from it -static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) { +static inline struct thread$ * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) { // Pick the bet list int w = i; @@ -854,5 +854,5 @@ // As long as we can pop from this lane to push the threads somewhere else in the queue while(!is_empty(lanes.data[idx])) { - struct $thread * thrd; + struct thread$ * thrd; unsigned long long _; [thrd, _] = pop(lanes.data[idx]); Index: libcfa/src/concurrency/ready_subqueue.hfa =================================================================== --- libcfa/src/concurrency/ready_subqueue.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/ready_subqueue.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -7,5 +7,5 @@ // Intrusives lanes which are used by the relaxed ready queue struct __attribute__((aligned(128))) __intrusive_lane_t { - struct $thread * prev; + struct thread$ * prev; // spin lock protecting the queue @@ -20,7 +20,7 @@ // Get the head pointer (one before the first element) from the anchor -static inline $thread * mock_head(const __intrusive_lane_t & this) { - $thread * rhead = ($thread *)( - (uintptr_t)( &this.anchor ) - __builtin_offsetof( $thread, link ) +static inline thread$ * mock_head(const __intrusive_lane_t & this) { + thread$ * rhead = (thread$ *)( + (uintptr_t)( &this.anchor ) - __builtin_offsetof( thread$, link ) ); return rhead; @@ -38,7 +38,7 @@ // We add a boat-load of assertions here because the anchor code is very fragile - /* paranoid */ _Static_assert( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) ); - /* paranoid */ verify( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) ); - /* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( $thread, link )) == (uintptr_t)(&this.anchor) ); + /* paranoid */ _Static_assert( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) ); + /* paranoid */ verify( offsetof( thread$, link ) == offsetof(__intrusive_lane_t, anchor) ); + /* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( thread$, link )) == (uintptr_t)(&this.anchor) ); /* paranoid */ verify( &mock_head(this)->link.next == &this.anchor.next ); /* paranoid */ verify( &mock_head(this)->link.ts == &this.anchor.ts ); @@ -61,5 +61,5 @@ // Push a thread onto this lane // returns true of lane was empty before push, false otherwise -static inline void push( __intrusive_lane_t & this, $thread * node ) { +static inline void push( __intrusive_lane_t & this, thread$ * node ) { /* paranoid */ verify( this.lock ); /* paranoid */ verify( node->link.next == 0p ); @@ -91,5 +91,5 @@ // returns popped // returns true of lane was empty before push, false otherwise -static inline [* $thread, unsigned long long] pop( __intrusive_lane_t & this ) { +static inline [* thread$, unsigned long long] pop( __intrusive_lane_t & this ) { /* paranoid */ verify( this.lock ); /* paranoid */ verify( this.anchor.next != 0p ); @@ -99,5 +99,5 @@ // Get the relevant nodes locally unsigned long long ts = this.anchor.ts; - $thread * node = this.anchor.next; + thread$ * node = this.anchor.next; this.anchor.next = node->link.next; this.anchor.ts = node->link.ts; Index: libcfa/src/concurrency/thread.cfa =================================================================== --- libcfa/src/concurrency/thread.cfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/thread.cfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -27,5 +27,5 @@ //----------------------------------------------------------------------------- // Thread ctors and dtors -void ?{}($thread & 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 }; @@ -57,5 +57,5 @@ } -void ^?{}($thread& this) with( this ) { +void ^?{}(thread$& this) with( this ) { #if defined( __CFA_WITH_VERIFY__ ) canary = 0xDEADDEADDEADDEADp; @@ -87,6 +87,6 @@ void ?{}( thread_dtor_guard_t & this, T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) { - $monitor * m = get_monitor(thrd); - $thread * desc = get_thread(thrd); + monitor$ * m = get_monitor(thrd); + thread$ * desc = get_thread(thrd); // Setup the monitor guard @@ -130,5 +130,5 @@ forall( T & | is_thread(T) ) void __thrd_start( T & this, void (*main_p)(T &) ) { - $thread * this_thrd = get_thread(this); + thread$ * this_thrd = get_thread(this); disable_interrupts(); Index: libcfa/src/concurrency/thread.hfa =================================================================== --- libcfa/src/concurrency/thread.hfa (revision eba9d27bfb9dbe67e33550e6260af21e2f88541a) +++ libcfa/src/concurrency/thread.hfa (revision b2386184d4e03c2f6d3e5292c567610b3b2d6da4) @@ -29,5 +29,5 @@ void ^?{}(T& mutex this); void main(T& this); - $thread* get_thread(T& this); + thread$ * get_thread(T& this); }; @@ -45,11 +45,11 @@ // Inline getters for threads/coroutines/monitors forall( T & | is_thread(T) ) -static inline $coroutine* get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; } +static inline coroutine$ * get_coroutine(T & this) __attribute__((const)) { return &get_thread(this)->self_cor; } forall( T & | is_thread(T) ) -static inline $monitor * get_monitor (T & this) __attribute__((const)) { return &get_thread(this)->self_mon; } +static inline monitor$ * get_monitor (T & this) __attribute__((const)) { 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$ * get_coroutine(thread$ * this) __attribute__((const)) { return &this->self_cor; } +static inline monitor$ * get_monitor (thread$ * this) __attribute__((const)) { return &this->self_mon; } //----------------------------------------------------------------------------- @@ -62,16 +62,16 @@ //----------------------------------------------------------------------------- // Ctors and dtors -void ?{}($thread & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize ); -void ^?{}($thread & this); +void ?{}(thread$ & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize ); +void ^?{}(thread$ & this); -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 }; } +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 }; } struct thread_dtor_guard_t { @@ -111,5 +111,5 @@ // 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 ); +void unpark( thread$ * this ); forall( T & | is_thread(T) )