Changeset 83a071f9 for src/libcfa/concurrency

Timestamp:

Aug 11, 2017, 10:10:26 AM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

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

Children:

fd344aa

Parents:

8499c707

Message:

Fix concurrency library, tests, and keywords for references

Location:

src/libcfa/concurrency

Files:

• coroutine (modified) (4 diffs)
• coroutine.c (modified) (1 diff)
• kernel.c (modified) (10 diffs)
• thread (modified) (2 diffs)
• thread.c (modified) (4 diffs)

src/libcfa/concurrency/coroutine

@@ -26 +26 @@
 // 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)
 
 //-----------------------------------------------------------------------------
@@ -45 +45 @@
 
 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);
 
 //-----------------------------------------------------------------------------
@@ -87 +87 @@
 // 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);
@@ -93 +93 @@
         if( unlikely(!dst->stack.base) ) {
                 create_stack(&dst->stack, dst->stack.size);
-                CtxStart(cor, CtxInvokeCoroutine);
+                CtxStart(&cor, CtxInvokeCoroutine);
         }
 

src/libcfa/concurrency/coroutine.c

@@ -93 +93 @@
 // 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/kernel.c

@@ -139 +139 @@
 }
 
-void ?{}(processor & this, cluster * cltr, processorCtx_t * runner) {
+void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
         this.cltr = cltr;
         (this.terminated){ 0 };
@@ -148 +148 @@
         this.kernel_thread = pthread_self();
 
-        this.runner = runner;
-        LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", runner);
-        (*runner){ &this };
+        this.runner = &runner;
+        LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", &runner);
+        runner{ &this };
 }
 
 LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
 
-void ?{}(system_proc_t & this, cluster * cltr, processorCtx_t * runner) {
+void ?{}(system_proc_t & this, cluster * cltr, processorCtx_t & runner) {
         (this.alarms){};
         (this.alarm_lock){};
@@ -187 +187 @@
 //=============================================================================================
 //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);
@@ -233 +233 @@
 // 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);
 
@@ -315 +315 @@
         // appropriate stack.
         proc_cor_storage.__cor.state = Active;
-        main( &proc_cor_storage );
+        main( proc_cor_storage );
         proc_cor_storage.__cor.state = Halted;
 
@@ -455 +455 @@
         mainThread = (thread_desc *)&mainThreadStorage;
         current_stack_info_t info;
-        mainThread{ &info };
+        (*mainThread){ &info };
 
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
@@ -461 +461 @@
         // Initialize the system cluster
         systemCluster = (cluster *)&systemClusterStorage;
-        systemCluster{};
+        (*systemCluster){};
 
         LIB_DEBUG_PRINT_SAFE("Kernel : System cluster ready\n");
@@ -468 +468 @@
         // (the coroutine that contains the processing control flow)
         systemProcessor = (system_proc_t *)&systemProcessorStorage;
-        (*systemProcessor){ systemCluster, (processorCtx_t *)&systemProcessorCtxStorage };
+        (*systemProcessor){ systemCluster, *(processorCtx_t *)&systemProcessorCtxStorage };
 
         // Add the main thread to the ready queue
@@ -486 +486 @@
         // 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( systemProcessor->proc.runner );
+        resume( *systemProcessor->proc.runner );
 
 
@@ -514 +514 @@
         // Destroy the system processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
-        ^(systemProcessor->proc.runner){};
+        ^(*systemProcessor->proc.runner){};
         ^(systemProcessor){};
 

src/libcfa/concurrency/thread

@@ -30 +30 @@
 trait is_thread(dtype T) {
       void ^?{}(T& mutex this);
-      void main(T* this);
-      thread_desc* get_thread(T* 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;
 }
@@ -57 +57 @@
 
 forall( dtype T | is_thread(T) )
-void __thrd_start( T* this );
+void __thrd_start( T & this );
 
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/thread.c

@@ -51 +51 @@
 void ?{}( scoped(T)& this ) {
         (this.handle){};
-        __thrd_start(&this.handle);
+        __thrd_start(this.handle);
 }
 
@@ -57 +57 @@
 void ?{}( scoped(T)& this, P params ) {
         (this.handle){ params };
-        __thrd_start(&this.handle);
+        __thrd_start(this.handle);
 }
 
@@ -68 +68 @@
 // 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);
@@ -78 +78 @@
         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 );