Changeset 52142c2 for libcfa/src

Timestamp:

Feb 4, 2020, 2:03:19 PM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

74e3263

Parents:

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

Message:

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

Location:

libcfa/src/concurrency

Files:

• CtxSwitch-x86_64.S (modified) (1 diff)
• coroutine.cfa (modified) (2 diffs)
• coroutine.hfa (modified) (2 diffs)
• invoke.c (modified) (6 diffs)
• kernel.cfa (modified) (3 diffs)
• kernel_private.hfa (modified) (1 diff)
• monitor.cfa (modified) (1 diff)
• thread.cfa (modified) (3 diffs)
• thread.hfa (modified) (1 diff)

libcfa/src/concurrency/CtxSwitch-x86_64.S

@@ -87 +87 @@
 CtxInvokeStub:
         movq %rbx, %rdi
-        jmp *%r12
+        movq %r12, %rsi
+        jmp *%r13
         .size  CtxInvokeStub, .-CtxInvokeStub
 

libcfa/src/concurrency/coroutine.cfa

@@ -187 +187 @@
 // is not inline (We can't inline Cforall in C)
 extern "C" {
-        void __suspend_internal(void) {
-                suspend();
-        }
-
-        void __leave_coroutine( coroutine_desc * src ) {
+        void __leave_coroutine( struct coroutine_desc * src ) {
                 coroutine_desc * starter = src->cancellation != 0 ? src->last : src->starter;
 
@@ -207 +203 @@
                 CoroutineCtxSwitch( src, starter );
         }
+
+        struct coroutine_desc * __finish_coroutine(void) {
+                struct coroutine_desc * cor = kernelTLS.this_thread->curr_cor;
+
+                if(cor->state == Primed) {
+                        suspend();
+                }
+
+                cor->state = Active;
+
+                return cor;
+        }
 }
 

libcfa/src/concurrency/coroutine.hfa

@@ -61 +61 @@
 // Start coroutine routines
 extern "C" {
-      forall(dtype T | is_coroutine(T))
-      void CtxInvokeCoroutine(T * this);
+        void CtxInvokeCoroutine(void (*main)(void *), void * this);
 
-      forall(dtype T | is_coroutine(T))
-      void CtxStart(T * this, void ( *invoke)(T *));
+        forall(dtype T)
+        void CtxStart(void (*main)(T &), struct coroutine_desc * cor, T & this, void (*invoke)(void (*main)(void *), void *));
 
         extern void _CtxCoroutine_Unwind(struct _Unwind_Exception * storage, struct coroutine_desc *) __attribute__ ((__noreturn__));
@@ -129 +128 @@
 
         if( unlikely(dst->context.SP == 0p) ) {
+                TL_GET( this_thread )->curr_cor = dst;
                 __stack_prepare(&dst->stack, 65000);
-                CtxStart(&cor, CtxInvokeCoroutine);
+                CtxStart(main, dst, cor, CtxInvokeCoroutine);
+                TL_GET( this_thread )->curr_cor = src;
         }
 

libcfa/src/concurrency/invoke.c

@@ -29 +29 @@
 // Called from the kernel when starting a coroutine or task so must switch back to user mode.
 
-extern void __suspend_internal(void);
-extern void __leave_coroutine( struct coroutine_desc * );
-extern void __finish_creation( struct thread_desc * );
-extern void __leave_thread_monitor( struct thread_desc * this );
+extern void __leave_coroutine ( struct coroutine_desc * );
+extern struct coroutine_desc * __finish_coroutine(void);
+extern void __leave_thread_monitor();
 extern void disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
@@ -38 +37 @@
 void CtxInvokeCoroutine(
         void (*main)(void *),
-        struct coroutine_desc *(*get_coroutine)(void *),
         void *this
 ) {
-        struct coroutine_desc* cor = get_coroutine( this );
+        // Finish setting up the coroutine by setting its state
+        struct coroutine_desc * cor = __finish_coroutine();
 
-        if(cor->state == Primed) {
-                __suspend_internal();
-        }
-
-        cor->state = Active;
-
+        // Call the main of the coroutine
         main( this );
 
@@ -83 +77 @@
 
 void CtxInvokeThread(
-        void (*dtor)(void *),
         void (*main)(void *),
-        struct thread_desc *(*get_thread)(void *),
         void *this
 ) {
-        // Fetch the thread handle from the user defined thread structure
-        struct thread_desc* thrd = get_thread( this );
-
-        // First suspend, once the thread arrives here,
-        // the function pointer to main can be invalidated without risk
-        __finish_creation( thrd );
-
         // Officially start the thread by enabling preemption
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -108 +93 @@
         // The order of these 4 operations is very important
         //Final suspend, should never return
-        __leave_thread_monitor( thrd );
+        __leave_thread_monitor();
         __cabi_abort( "Resumed dead thread" );
 }
 
-
 void CtxStart(
         void (*main)(void *),
-        struct coroutine_desc *(*get_coroutine)(void *),
+        struct coroutine_desc * cor,
         void *this,
         void (*invoke)(void *)
 ) {
-        struct coroutine_desc * cor = get_coroutine( this );
         struct __stack_t * stack = cor->stack.storage;
 
@@ -138 +121 @@
 
         fs->dummyReturn = NULL;
-        fs->argument[0] = this;     // argument to invoke
+        fs->argument[0] = main;     // argument to invoke
+        fs->argument[1] = this;     // argument to invoke
         fs->rturn = invoke;
 
@@ -156 +140 @@
         fs->dummyReturn = NULL;
         fs->rturn = CtxInvokeStub;
-        fs->fixedRegisters[0] = this;
-        fs->fixedRegisters[1] = invoke;
+        fs->fixedRegisters[0] = main;
+        fs->fixedRegisters[1] = this;
+        fs->fixedRegisters[2] = invoke;
 
 #elif defined( __ARM_ARCH )
-
+#error ARM needs to be upgrade to use to parameters like X86/X64 (A.K.A. : I broke this and do not know how to fix it)
         struct FakeStack {
                 float fpRegs[16];                       // floating point registers

libcfa/src/concurrency/kernel.cfa

@@ -469 +469 @@
         );
 
-        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" ); 
+        Abort( pthread_attr_setstack( &attr, stack, stacksize ), "pthread_attr_setstack" );
 
         Abort( pthread_create( pthread, &attr, start, arg ), "pthread_create" );
@@ -490 +490 @@
         verify( ! kernelTLS.preemption_state.enabled );
 
+        kernelTLS.this_thread->curr_cor = dst;
         __stack_prepare( &dst->stack, 65000 );
-        CtxStart(&this->runner, CtxInvokeCoroutine);
+        CtxStart(main, dst, this->runner, CtxInvokeCoroutine);
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -505 +506 @@
         CtxSwitch( &src->context, &dst->context );
         // when CtxSwitch returns we are back in the src coroutine
+
+        mainThread->curr_cor = &mainThread->self_cor;
 
         // set state of new coroutine to active

libcfa/src/concurrency/kernel_private.hfa

@@ -88 +88 @@
 // Threads
 extern "C" {
-      forall(dtype T | is_thread(T))
-      void CtxInvokeThread(T * this);
+      void CtxInvokeThread(void (*main)(void *), void * this);
 }
 

libcfa/src/concurrency/monitor.cfa

@@ -243 +243 @@
         // last routine called by a thread.
         // Should never return
-        void __leave_thread_monitor( thread_desc * thrd ) {
+        void __leave_thread_monitor() {
+                thread_desc * thrd = TL_GET( this_thread );
                 monitor_desc * this = &thrd->self_mon;
 

libcfa/src/concurrency/thread.cfa

@@ -58 +58 @@
 void ?{}( scoped(T)& this ) with( this ) {
         handle{};
-        __thrd_start(handle);
+        __thrd_start(handle, main);
 }
 
@@ -64 +64 @@
 void ?{}( scoped(T)& this, P params ) with( this ) {
         handle{ params };
-        __thrd_start(handle);
+        __thrd_start(handle, main);
 }
 
@@ -75 +75 @@
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
-void __thrd_start( T& this ) {
+void __thrd_start( T & this, void (*main_p)(T &) ) {
         thread_desc * this_thrd = get_thread(this);
         thread_desc * curr_thrd = TL_GET( this_thread );
 
         disable_interrupts();
-        CtxStart(&this, CtxInvokeThread);
+        CtxStart(main_p, get_coroutine(this), this, CtxInvokeThread);
+
         this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
         verify( this_thrd->context.SP );
-        CtxSwitch( &curr_thrd->context, &this_thrd->context );
+        // CtxSwitch( &curr_thrd->context, &this_thrd->context );
 
         ScheduleThread(this_thrd);
         enable_interrupts( __cfaabi_dbg_ctx );
-}
-
-extern "C" {
-        // KERNEL ONLY
-        void __finish_creation(thread_desc * this) {
-                // set new coroutine that the processor is executing
-                // and context switch to it
-                verify( kernelTLS.this_thread != this );
-                verify( kernelTLS.this_thread->context.SP );
-                CtxSwitch( &this->context, &kernelTLS.this_thread->context );
-        }
 }
 

libcfa/src/concurrency/thread.hfa

@@ -54 +54 @@
 
 forall( dtype T | is_thread(T) )
-void __thrd_start( T & this );
+void __thrd_start( T & this, void (*)(T &) );
 
 //-----------------------------------------------------------------------------