Changeset 6b224a52 for src/libcfa/concurrency

Timestamp:

Aug 25, 2017, 12:11:53 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

bf7b9da7

Parents:

135b431 (diff), f676b84 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

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

Location:

src/libcfa/concurrency

Files:

• alarm.c (modified) (2 diffs)
• alarm.h (modified) (3 diffs)
• coroutine (modified) (4 diffs)
• coroutine.c (modified) (1 diff)
• invoke.h (modified) (1 diff)
• kernel (modified) (4 diffs)
• kernel.c (modified) (13 diffs)
• monitor (modified) (4 diffs)
• monitor.c (modified) (6 diffs)
• preemption.c (modified) (3 diffs)
• preemption.h (modified) (1 diff)
• thread (modified) (3 diffs)
• thread.c (modified) (3 diffs)

src/libcfa/concurrency/alarm.c

@@ -40 +40 @@
 __cfa_time_t zero_time = { 0 };
 
-void ?{}( __cfa_time_t * this ) { this->val = 0; }
-void ?{}( __cfa_time_t * this, zero_t zero ) { this->val = 0; }
-
-void ?{}( itimerval * this, __cfa_time_t * alarm ) {
-        this->it_value.tv_sec = alarm->val / one_second;                        // seconds
-        this->it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
-        this->it_interval.tv_sec = 0;
-        this->it_interval.tv_usec = 0;
-}
-
-
-void ?{}( __cfa_time_t * this, timespec * curr ) {
+void ?{}( __cfa_time_t & this ) { this.val = 0; }
+void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; }
+
+void ?{}( itimerval & this, __cfa_time_t * alarm ) {
+        this.it_value.tv_sec = alarm->val / one_second;                 // seconds
+        this.it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
+        this.it_interval.tv_sec = 0;
+        this.it_interval.tv_usec = 0;
+}
+
+
+void ?{}( __cfa_time_t & this, timespec * curr ) {
         uint64_t secs  = curr->tv_sec;
         uint64_t nsecs = curr->tv_nsec;
-        this->val = (secs * one_second) + nsecs;
-}
-
-__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ) {
-        this->val = 0;
-        return *this;
+        this.val = (secs * one_second) + nsecs;
+}
+
+__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ) {
+        this.val = 0;
+        return this;
 }
 
@@ -86 +86 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
-        this->thrd = thrd;
-        this->alarm = alarm;
-        this->period = period;
-        this->next = 0;
-        this->set = false;
-        this->kernel_alarm = false;
-}
-
-void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
-        this->proc = proc;
-        this->alarm = alarm;
-        this->period = period;
-        this->next = 0;
-        this->set = false;
-        this->kernel_alarm = true;
-}
-
-void ^?{}( alarm_node_t * this ) {
-        if( this->set ) {
-                unregister_self( this );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+        this.thrd = thrd;
+        this.alarm = alarm;
+        this.period = period;
+        this.next = 0;
+        this.set = false;
+        this.kernel_alarm = false;
+}
+
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+        this.proc = proc;
+        this.alarm = alarm;
+        this.period = period;
+        this.next = 0;
+        this.set = false;
+        this.kernel_alarm = true;
+}
+
+void ^?{}( alarm_node_t & this ) {
+        if( this.set ) {
+                unregister_self( &this );
         }
 }

src/libcfa/concurrency/alarm.h

@@ -36 +36 @@
 
 // ctors
-void ?{}( __cfa_time_t * this );
-void ?{}( __cfa_time_t * this, zero_t zero );
-void ?{}( __cfa_time_t * this, timespec * curr );
-void ?{}( itimerval * this, __cfa_time_t * alarm );
+void ?{}( __cfa_time_t & this );
+void ?{}( __cfa_time_t & this, zero_t zero );
+void ?{}( __cfa_time_t & this, timespec * curr );
+void ?{}( itimerval & this, __cfa_time_t * alarm );
 
-__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs );
+__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs );
 
 // logical ops
@@ -105 +105 @@
 typedef alarm_node_t ** __alarm_it_t;
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
-void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
-void ^?{}( alarm_node_t * this );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ^?{}( alarm_node_t & this );
 
 struct alarm_list_t {
@@ -114 +114 @@
 };
 
-static inline void ?{}( alarm_list_t * this ) {
-        this->head = 0;
-        this->tail = &this->head;
+static inline void ?{}( alarm_list_t & this ) {
+        this.head = 0;
+        this.tail = &this.head;
 }
 

src/libcfa/concurrency/coroutine

@@ -25 +25 @@
 // Anything that is resumed is a coroutine.
 trait is_coroutine(dtype T) {
-      void main(T * this);
-      coroutine_desc * get_coroutine(T * this);
+      void main(T & this);
+      coroutine_desc * get_coroutine(T & this);
 };
 
-#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this)
+#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(coStack_t * this);
-void ?{}(coroutine_desc * this);
-void ?{}(coroutine_desc * this, const char * name);
-void ^?{}(coStack_t * this);
-void ^?{}(coroutine_desc * this);
+void ?{}(coStack_t & this);
+void ?{}(coroutine_desc & this);
+void ?{}(coroutine_desc & this, const char * name);
+void ^?{}(coStack_t & this);
+void ^?{}(coroutine_desc & this);
 
 //-----------------------------------------------------------------------------
@@ -44 +44 @@
 
 forall(dtype T | is_coroutine(T))
-static inline void resume(T * cor);
+static inline void resume(T & cor);
 
 forall(dtype T | is_coroutine(T))
-void prime(T * cor);
+void prime(T & cor);
 
 //-----------------------------------------------------------------------------
@@ -86 +86 @@
 // Resume implementation inlined for performance
 forall(dtype T | is_coroutine(T))
-static inline void resume(T * cor) {
+static inline void resume(T & cor) {
         coroutine_desc * src = this_coroutine;          // optimization
         coroutine_desc * dst = get_coroutine(cor);
@@ -92 +92 @@
         if( unlikely(!dst->stack.base) ) {
                 create_stack(&dst->stack, dst->stack.size);
-                CtxStart(cor, CtxInvokeCoroutine);
+                CtxStart(&cor, CtxInvokeCoroutine);
         }
 

src/libcfa/concurrency/coroutine.c

@@ -40 +40 @@
 //-----------------------------------------------------------------------------
 // Coroutine ctors and dtors
-void ?{}(coStack_t* this) {
-        this->size              = 65000;        // size of stack
-        this->storage   = NULL; // pointer to stack
-        this->limit             = NULL; // stack grows towards stack limit
-        this->base              = NULL; // base of stack
-        this->context   = NULL; // address of cfa_context_t
-        this->top               = NULL; // address of top of storage
-        this->userStack = false;
+void ?{}(coStack_t& this) {
+        this.size               = 65000;        // size of stack
+        this.storage    = NULL; // pointer to stack
+        this.limit              = NULL; // stack grows towards stack limit
+        this.base               = NULL; // base of stack
+        this.context    = NULL; // address of cfa_context_t
+        this.top                = NULL; // address of top of storage
+        this.userStack  = false;
 }
 
-void ?{}(coStack_t* this, size_t size) {
+void ?{}(coStack_t& this, size_t size) {
         this{};
-        this->size = size;
+        this.size = size;
 
-        create_stack(this, this->size);
+        create_stack(&this, this.size);
 }
 
-void ?{}(coroutine_desc* this) {
+void ?{}(coroutine_desc& this) {
         this{ "Anonymous Coroutine" };
 }
 
-void ?{}(coroutine_desc* this, const char * name) {
-        this->name = name;
-        this->errno_ = 0;
-        this->state = Start;
-        this->starter = NULL;
-        this->last = NULL;
+void ?{}(coroutine_desc& this, const char * name) {
+        this.name = name;
+        this.errno_ = 0;
+        this.state = Start;
+        this.starter = NULL;
+        this.last = NULL;
 }
 
-void ?{}(coroutine_desc* this, size_t size) {
+void ?{}(coroutine_desc& this, size_t size) {
         this{};
-        (&this->stack){size};
+        (this.stack){size};
 }
 
-void ^?{}(coStack_t* this) {
-        if ( ! this->userStack ) {
+void ^?{}(coStack_t& this) {
+        if ( ! this.userStack ) {
                 LIB_DEBUG_DO(
-                        if ( mprotect( this->storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
-                                abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", this, errno, strerror( errno ) );
+                        if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
+                                abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
                         }
                 );
-                free( this->storage );
+                free( this.storage );
         }
 }
 
-void ^?{}(coroutine_desc* this) {}
+void ^?{}(coroutine_desc& this) {}
 
 // Part of the Public API
 // Not inline since only ever called once per coroutine
 forall(dtype T | is_coroutine(T))
-void prime(T* cor) {
+void prime(T& cor) {
         coroutine_desc* this = get_coroutine(cor);
         assert(this->state == Start);

src/libcfa/concurrency/invoke.h

@@ -49 +49 @@
       #ifdef __CFORALL__
       extern "Cforall" {
-            void ?{}( struct __thread_queue_t * );
+            void ?{}( struct __thread_queue_t & );
             void append( struct __thread_queue_t *, struct thread_desc * );
             struct thread_desc * pop_head( struct __thread_queue_t * );
             struct thread_desc * remove( struct __thread_queue_t *, struct thread_desc ** );
 
-            void ?{}( struct __condition_stack_t * );
+            void ?{}( struct __condition_stack_t & );
             void push( struct __condition_stack_t *, struct __condition_criterion_t * );
             struct __condition_criterion_t * pop( struct __condition_stack_t * );
 
-            void ?{}(spinlock * this);
-            void ^?{}(spinlock * this);
+            void ?{}(spinlock & this);
+            void ^?{}(spinlock & this);
       }
       #endif

src/libcfa/concurrency/kernel

@@ -37 +37 @@
 };
 
-void  ?{}(semaphore * this, int count = 1);
-void ^?{}(semaphore * this);
+void  ?{}(semaphore & this, int count = 1);
+void ^?{}(semaphore & this);
 void P(semaphore * this);
 void V(semaphore * this);
@@ -51 +51 @@
 };
 
-void ?{}(cluster * this);
-void ^?{}(cluster * this);
+void ?{}(cluster & this);
+void ^?{}(cluster & this);
 
 //-----------------------------------------------------------------------------
@@ -68 +68 @@
         unsigned short thrd_count;
 };
-static inline void ?{}(FinishAction * this) {
-        this->action_code = No_Action;
-        this->thrd = NULL;
-        this->lock = NULL;
+static inline void ?{}(FinishAction & this) {
+        this.action_code = No_Action;
+        this.thrd = NULL;
+        this.lock = NULL;
 }
-static inline void ^?{}(FinishAction * this) {}
+static inline void ^?{}(FinishAction & this) {}
 
 // Processor
@@ -99 +99 @@
 };
 
-void ?{}(processor * this);
-void ?{}(processor * this, cluster * cltr);
-void ^?{}(processor * this);
+void ?{}(processor & this);
+void ?{}(processor & this, cluster * cltr);
+void ^?{}(processor & this);
 
 // Local Variables: //

src/libcfa/concurrency/kernel.c

@@ -73 +73 @@
 };
 
-void ?{}( current_stack_info_t * this ) {
-        CtxGet( this->ctx );
-        this->base = this->ctx.FP;
-        this->storage = this->ctx.SP;
+void ?{}( current_stack_info_t & this ) {
+        CtxGet( this.ctx );
+        this.base = this.ctx.FP;
+        this.storage = this.ctx.SP;
 
         rlimit r;
         getrlimit( RLIMIT_STACK, &r);
-        this->size = r.rlim_cur;
-
-        this->limit = (void *)(((intptr_t)this->base) - this->size);
-        this->context = &storage_mainThreadCtx;
-        this->top = this->base;
-}
-
-void ?{}( coStack_t * this, current_stack_info_t * info) {
-        this->size = info->size;
-        this->storage = info->storage;
-        this->limit = info->limit;
-        this->base = info->base;
-        this->context = info->context;
-        this->top = info->top;
-        this->userStack = true;
-}
-
-void ?{}( coroutine_desc * this, current_stack_info_t * info) {
-        (&this->stack){ info };
-        this->name = "Main Thread";
-        this->errno_ = 0;
-        this->state = Start;
-}
-
-void ?{}( thread_desc * this, current_stack_info_t * info) {
-        (&this->cor){ info };
+        this.size = r.rlim_cur;
+
+        this.limit = (void *)(((intptr_t)this.base) - this.size);
+        this.context = &storage_mainThreadCtx;
+        this.top = this.base;
+}
+
+void ?{}( coStack_t & this, current_stack_info_t * info) {
+        this.size = info->size;
+        this.storage = info->storage;
+        this.limit = info->limit;
+        this.base = info->base;
+        this.context = info->context;
+        this.top = info->top;
+        this.userStack = true;
+}
+
+void ?{}( coroutine_desc & this, current_stack_info_t * info) {
+        (this.stack){ info };
+        this.name = "Main Thread";
+        this.errno_ = 0;
+        this.state = Start;
+}
+
+void ?{}( thread_desc & this, current_stack_info_t * info) {
+        (this.cor){ info };
 }
 
 //-----------------------------------------------------------------------------
 // Processor coroutine
-void ?{}(processorCtx_t * this, processor * proc) {
-        (&this->__cor){ "Processor" };
-        this->proc = proc;
-        proc->runner = this;
-}
-
-void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
-        (&this->__cor){ info };
-        this->proc = proc;
-        proc->runner = this;
-}
-
-void ?{}(processor * this) {
+void ?{}(processorCtx_t & this, processor * proc) {
+        (this.__cor){ "Processor" };
+        this.proc = proc;
+        proc->runner = &this;
+}
+
+void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
+        (this.__cor){ info };
+        this.proc = proc;
+        proc->runner = &this;
+}
+
+void ?{}(processor & this) {
         this{ mainCluster };
 }
 
-void ?{}(processor * this, cluster * cltr) {
-        this->cltr = cltr;
-        (&this->terminated){ 0 };
-        this->do_terminate = false;
-        this->preemption_alarm = NULL;
-        this->pending_preemption = false;
-
-        start( this );
-}
-
-void ?{}(processor * this, cluster * cltr, processorCtx_t * runner) {
-        this->cltr = cltr;
-        (&this->terminated){ 0 };
-        this->do_terminate = false;
-        this->preemption_alarm = NULL;
-        this->pending_preemption = false;
-        this->kernel_thread = pthread_self();
-
-        this->runner = runner;
-        LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", runner);
-        runner{ this };
-}
-
-void ^?{}(processor * this) {
-        if( ! this->do_terminate ) {
-                LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
-                this->do_terminate = true;
-                P( &this->terminated );
-                pthread_join( this->kernel_thread, NULL );
-        }
-}
-
-void ?{}(cluster * this) {
-        ( &this->ready_queue ){};
-        ( &this->ready_queue_lock ){};
-
-        this->preemption = default_preemption();
-}
-
-void ^?{}(cluster * this) {
+void ?{}(processor & this, cluster * cltr) {
+        this.cltr = cltr;
+        (this.terminated){ 0 };
+        this.do_terminate = false;
+        this.preemption_alarm = NULL;
+        this.pending_preemption = false;
+
+        start( &this );
+}
+
+void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
+        this.cltr = cltr;
+        (this.terminated){ 0 };
+        this.do_terminate = false;
+        this.preemption_alarm = NULL;
+        this.pending_preemption = false;
+        this.kernel_thread = pthread_self();
+
+        this.runner = &runner;
+        LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner);
+        runner{ &this };
+}
+
+void ^?{}(processor & this) {
+        if( ! this.do_terminate ) {
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
+                this.do_terminate = true;
+                P( &this.terminated );
+                pthread_join( this.kernel_thread, NULL );
+        }
+}
+
+void ?{}(cluster & this) {
+        ( this.ready_queue ){};
+        ( this.ready_queue_lock ){};
+
+        this.preemption = default_preemption();
+}
+
+void ^?{}(cluster & this) {
 
 }
@@ -173 +173 @@
 //=============================================================================================
 //Main of the processor contexts
-void main(processorCtx_t * runner) {
-        processor * this = runner->proc;
+void main(processorCtx_t & runner) {
+        processor * this = runner.proc;
 
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
@@ -219 +219 @@
 // from the processor coroutine to the target thread
 void runThread(processor * this, thread_desc * dst) {
-        coroutine_desc * proc_cor = get_coroutine(this->runner);
+        coroutine_desc * proc_cor = get_coroutine(*this->runner);
         coroutine_desc * thrd_cor = get_coroutine(dst);
 
@@ -301 +301 @@
         // appropriate stack.
         proc_cor_storage.__cor.state = Active;
-        main( &proc_cor_storage );
+        main( proc_cor_storage );
         proc_cor_storage.__cor.state = Halted;
 
@@ -443 +443 @@
         mainThread = (thread_desc *)&storage_mainThread;
         current_stack_info_t info;
-        mainThread{ &info };
+        (*mainThread){ &info };
 
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
@@ -449 +449 @@
         // Initialize the main cluster
         mainCluster = (cluster *)&storage_mainCluster;
-        mainCluster{};
+        (*mainCluster){};
 
         LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
@@ -456 +456 @@
         // (the coroutine that contains the processing control flow)
         mainProcessor = (processor *)&storage_mainProcessor;
-        mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx };
+        (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx };
 
         //initialize the global state variables
@@ -473 +473 @@
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
-        resume( mainProcessor->runner );
+        resume( *mainProcessor->runner );
 
 
@@ -501 +501 @@
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(mainProcessor->runner){};
+        ^(*mainProcessor->runner){};
         ^(mainProcessor){};
 
@@ -569 +569 @@
 //-----------------------------------------------------------------------------
 // Locks
-void ?{}( spinlock * this ) {
-        this->lock = 0;
-}
-void ^?{}( spinlock * this ) {
+void ?{}( spinlock & this ) {
+        this.lock = 0;
+}
+void ^?{}( spinlock & this ) {
 
 }
@@ -606 +606 @@
 }
 
-void  ?{}( semaphore * this, int count = 1 ) {
-        (&this->lock){};
-        this->count = count;
-        (&this->waiting){};
-}
-void ^?{}(semaphore * this) {}
+void  ?{}( semaphore & this, int count = 1 ) {
+        (this.lock){};
+        this.count = count;
+        (this.waiting){};
+}
+void ^?{}(semaphore & this) {}
 
 void P(semaphore * this) {
@@ -645 +645 @@
 //-----------------------------------------------------------------------------
 // Queues
-void ?{}( __thread_queue_t * this ) {
-        this->head = NULL;
-        this->tail = &this->head;
+void ?{}( __thread_queue_t & this ) {
+        this.head = NULL;
+        this.tail = &this.head;
 }
 
@@ -685 +685 @@
 }
 
-
-
-void ?{}( __condition_stack_t * this ) {
-        this->top = NULL;
+void ?{}( __condition_stack_t & this ) {
+        this.top = NULL;
 }
 

src/libcfa/concurrency/monitor

@@ -22 +22 @@
 #include "stdlib"
 
-static inline void ?{}(monitor_desc * this) {
-        (&this->lock){};
-        this->owner = NULL;
-        (&this->entry_queue){};
-        (&this->signal_stack){};
-        this->recursion = 0;
-        this->acceptables = NULL;
-        this->acceptable_count = 0;
-        this->accepted_index = -1;
+static inline void ?{}(monitor_desc & this) {
+        (this.lock){};
+        this.owner = NULL;
+        (this.entry_queue){};
+        (this.signal_stack){};
+        this.recursion = 0;
+        this.acceptables = NULL;
+        this.acceptable_count = 0;
+        this.accepted_index = -1;
 }
 
@@ -45 +45 @@
 }
 
-void ?{}( monitor_guard_t * this, monitor_desc ** m, int count, void (*func)() );
-void ^?{}( monitor_guard_t * this );
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count );
+void ^?{}( monitor_guard_t & this );
 
 //-----------------------------------------------------------------------------
@@ -71 +71 @@
 };
 
-void ?{}( __condition_blocked_queue_t * );
+void ?{}( __condition_blocked_queue_t & );
 void append( __condition_blocked_queue_t *, __condition_node_t * );
 __condition_node_t * pop_head( __condition_blocked_queue_t * );
@@ -81 +81 @@
 };
 
-static inline void ?{}( condition * this ) {
-        this->monitors = NULL;
-        this->monitor_count = 0;
+static inline void ?{}( condition & this ) {
+        this.monitors = NULL;
+        this.monitor_count = 0;
 }
 
-static inline void ^?{}( condition * this ) {
-        free( this->monitors );
+static inline void ^?{}( condition & this ) {
+        free( this.monitors );
 }
 

src/libcfa/concurrency/monitor.c

@@ -194 +194 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t * this, monitor_desc ** m, int count, void (*func)() ) {
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() ) {
         // Store current array
-        this->m = m;
-        this->count = count;
+        this.m = m;
+        this.count = count;
 
         // Sort monitors based on address -> TODO use a sort specialized for small numbers
-        qsort(this->m, count);
+        qsort(this.m, count);
 
         // Save previous thread context
-        this->prev_mntrs = this_thread->current_monitors;
-        this->prev_count = this_thread->current_monitor_count;
-        this->prev_func  = this_thread->current_monitor_func;
+        this.prev_mntrs = this_thread->current_monitors;
+        this.prev_count = this_thread->current_monitor_count;
+        this.prev_func  = this_thread->current_monitor_func;
 
         // Update thread context (needed for conditions)
@@ -213 +213 @@
 
         // Enter the monitors in order
-        enter( this->m, this->count, func );
-}
+        enter( this.m, this.count, func );
+}
+
 
 // Dtor for monitor guard
-void ^?{}( monitor_guard_t * this ) {
+void ^?{}( monitor_guard_t & this ) {
         // Leave the monitors in order
-        leave( this->m, this->count );
+        leave( this.m, this.count );
 
         // Restore thread context
-        this_thread->current_monitors      = this->prev_mntrs;
-        this_thread->current_monitor_count = this->prev_count;
-        this_thread->current_monitor_func  = this->prev_func;
+        this_thread->current_monitors      = this.prev_mntrs;
+        this_thread->current_monitor_count = this.prev_count;
+        this_thread->current_monitor_func  = this.prev_func;
 }
 
 //-----------------------------------------------------------------------------
 // Internal scheduling types
-
-void ?{}(__condition_node_t * this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
-        this->waiting_thread = waiting_thread;
-        this->count = count;
-        this->next = NULL;
-        this->user_info = user_info;
-}
-
-void ?{}(__condition_criterion_t * this ) {
-        this->ready  = false;
-        this->target = NULL;
-        this->owner  = NULL;
-        this->next   = NULL;
-}
-
-void ?{}(__condition_criterion_t * this, monitor_desc * target, __condition_node_t * owner ) {
-        this->ready  = false;
-        this->target = target;
-        this->owner  = owner;
-        this->next   = NULL;
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
+        this.waiting_thread = waiting_thread;
+        this.count = count;
+        this.next = NULL;
+        this.user_info = user_info;
+}
+
+void ?{}(__condition_criterion_t & this ) {
+        this.ready  = false;
+        this.target = NULL;
+        this.owner  = NULL;
+        this.next   = NULL;
+}
+
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner ) {
+        this.ready  = false;
+        this.target = target;
+        this.owner  = owner;
+        this.next   = NULL;
 }
 
@@ -523 +523 @@
 static inline void init( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
         for(int i = 0; i < count; i++) {
-                (&criteria[i]){ monitors[i], waiter };
+                (criteria[i]){ monitors[i], waiter };
         }
 
@@ -531 +531 @@
 static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
         for(int i = 0; i < count; i++) {
-                (&criteria[i]){ monitors[i], waiter };
+                (criteria[i]){ monitors[i], waiter };
                 push( &criteria[i].target->signal_stack, &criteria[i] );
         }
@@ -627 +627 @@
         return end + 1;
 }
+
 
 static inline bool match( __acceptable_t * acc, thread_desc * thrd ) {
@@ -660 +661 @@
         return NULL;
 }
-
-void ?{}( __condition_blocked_queue_t * this ) {
-        this->head = NULL;
-        this->tail = &this->head;
+void ?{}( __condition_blocked_queue_t & this ) {
+        this.head = NULL;
+        this.tail = &this.head;
 }
 

src/libcfa/concurrency/preemption.c

@@ -71 +71 @@
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
 
-void ?{}(event_kernel_t * this) {
-        (&this->alarms){};
-        (&this->lock){};
+void ?{}(event_kernel_t & this) {
+        (this.alarms){};
+        (this.lock){};
 }
 
@@ -240 +240 @@
         // Initialize the event kernel
         event_kernel = (event_kernel_t *)&storage_event_kernel;
-        event_kernel{};
+        (*event_kernel){};
 
         // Setup proper signal handlers
@@ -276 +276 @@
 // Raii ctor/dtor for the preemption_scope
 // Used by thread to control when they want to receive preemption signals
-void ?{}( preemption_scope * this, processor * proc ) {
-        (&this->alarm){ proc, zero_time, zero_time };
-        this->proc = proc;
-        this->proc->preemption_alarm = &this->alarm;
-
-        update_preemption( this->proc, from_us(this->proc->cltr->preemption) );
-}
-
-void ^?{}( preemption_scope * this ) {
+void ?{}( preemption_scope & this, processor * proc ) {
+        (this.alarm){ proc, zero_time, zero_time };
+        this.proc = proc;
+        this.proc->preemption_alarm = &this.alarm;
+
+        update_preemption( this.proc, from_us(this.proc->cltr->preemption) );
+}
+
+void ^?{}( preemption_scope & this ) {
         disable_interrupts();
 
-        update_preemption( this->proc, zero_time );
+        update_preemption( this.proc, zero_time );
 }
 

src/libcfa/concurrency/preemption.h

@@ -30 +30 @@
 };
 
-void ?{}( preemption_scope * this, processor * proc );
-void ^?{}( preemption_scope * this );
+void ?{}( preemption_scope & this, processor * proc );
+void ^?{}( preemption_scope & this );
 
 // Local Variables: //

src/libcfa/concurrency/thread

@@ -27 +27 @@
 // Anything that is resumed is a coroutine.
 trait is_thread(dtype T) {
-      void ^?{}(T* mutex this);
-      void main(T* this);
-      thread_desc* get_thread(T* this);
+      void ^?{}(T& mutex this);
+      void main(T& this);
+      thread_desc* get_thread(T& this);
 };
 
-#define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->__thrd; } void main(X* this)
+#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)
 
 forall( dtype T | is_thread(T) )
-static inline coroutine_desc* get_coroutine(T* this) {
+static inline coroutine_desc* get_coroutine(T & this) {
         return &get_thread(this)->cor;
 }
 
 forall( dtype T | is_thread(T) )
-static inline monitor_desc* get_monitor(T * this) {
+static inline monitor_desc* get_monitor(T & this) {
         return &get_thread(this)->mon;
 }
@@ -55 +55 @@
 
 forall( dtype T | is_thread(T) )
-void __thrd_start( T* this );
+void __thrd_start( T & this );
 
 //-----------------------------------------------------------------------------
 // Ctors and dtors
-void ?{}(thread_desc* this);
-void ^?{}(thread_desc* this);
+void ?{}(thread_desc& this);
+void ^?{}(thread_desc& this);
 
 //-----------------------------------------------------------------------------
@@ -70 +70 @@
 };
 
-forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
-void ?{}( scoped(T)* this );
+forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+void ?{}( scoped(T)& this );
 
-forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
-void ?{}( scoped(T)* this, P params );
+forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
+void ?{}( scoped(T)& this, P params );
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)* this );
+void ^?{}( scoped(T)& this );
 
 void yield();

src/libcfa/concurrency/thread.c

@@ -32 +32 @@
 // Thread ctors and dtors
 
-void ?{}(thread_desc* this) {
-        (&this->cor){};
-        this->cor.name = "Anonymous Coroutine";
-        this->mon.owner = this;
-        this->mon.recursion = 1;
-        this->next = NULL;
+void ?{}(thread_desc& this) {
+        (this.cor){};
+        this.cor.name = "Anonymous Coroutine";
+        this.mon.owner = &this;
+        this.mon.recursion = 1;
+        this.next = NULL;
 
-        this->current_monitors      = &this->mon;
-        this->current_monitor_count = 1;
+        this.current_monitors      = &this.mon;
+        this.current_monitor_count = 1;
 }
 
-void ^?{}(thread_desc* this) {
-        ^(&this->cor){};
+void ^?{}(thread_desc& this) {
+        ^(this.cor){};
 }
 
-forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
-void ?{}( scoped(T)* this ) {
-        (&this->handle){};
-        __thrd_start(&this->handle);
+forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+void ?{}( scoped(T)& this ) {
+        (this.handle){};
+        __thrd_start(this.handle);
 }
 
-forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
-void ?{}( scoped(T)* this, P params ) {
-        (&this->handle){ params };
-        __thrd_start(&this->handle);
+forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
+void ?{}( scoped(T)& this, P params ) {
+        (this.handle){ params };
+        __thrd_start(this.handle);
 }
 
 forall( dtype T | sized(T) | is_thread(T) )
-void ^?{}( scoped(T)* this ) {
-        ^(&this->handle){};
+void ^?{}( scoped(T)& this ) {
+        ^(this.handle){};
 }
 
@@ -67 +67 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void __thrd_start( T* this ) {
+void __thrd_start( T& this ) {
         coroutine_desc* thrd_c = get_coroutine(this);
         thread_desc*  thrd_h = get_thread   (this);
@@ -77 +77 @@
         create_stack(&thrd_c->stack, thrd_c->stack.size);
         this_coroutine = thrd_c;
-        CtxStart(this, CtxInvokeThread);
+        CtxStart(&this, CtxInvokeThread);
         assert( thrd_c->last->stack.context );
         CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context );