Changeset a5e7233

Timestamp:

Mar 17, 2021, 1:56:12 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

c407434e

Parents:

e0c072c

Message:

C interface now runs worker init routine in dedicated thread.
Also added test for this case.

Files:

• libcfa/src/concurrency/clib/cfathread.cfa (modified) (3 diffs)
• libcfa/src/concurrency/kernel.cfa (modified) (2 diffs)
• libcfa/src/concurrency/kernel.hfa (modified) (2 diffs)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (6 diffs)
• tests/concurrent/.expect/clib_tls.txt (added)
• tests/concurrent/clib.c (modified) (2 diffs)
• tests/concurrent/clib_tls.c (added)

libcfa/src/concurrency/clib/cfathread.cfa

@@ -21 +21 @@
 
 #include "cfathread.h"
+
+extern void ?{}(processor &, const char[], cluster &, $thread *);
+extern "C" {
+      extern void __cfactx_invoke_thread(void (*main)(void *), void * this);
+}
+
+//================================================================================
+// Thread run y the C Interface
 
 struct cfathread_object {
@@ -65 +73 @@
 }
 
-processor * procs = 0p;
-int proc_cnt = 1;
-
+//================================================================================
+// Special Init Thread responsible for the initialization or processors
+struct __cfainit {
+        $thread self;
+        void (*init)( void * );
+        void * arg;
+};
+void main(__cfainit & this);
+void ^?{}(__cfainit & mutex this);
+
+static inline $thread * get_thread( __cfainit & this ) { return &this.self; }
+
+typedef ThreadCancelled(__cfainit) __cfainit_exception;
+typedef ThreadCancelled_vtable(__cfainit) __cfainit_vtable;
+
+void defaultResumptionHandler(ThreadCancelled(__cfainit) & except) {
+        abort | "The init thread was cancelled";
+}
+
+__cfainit_vtable ___cfainit_vtable_instance;
+
+__cfainit_vtable const & get_exception_vtable(__cfainit_exception *) {
+        return ___cfainit_vtable_instance;
+}
+
+static void ?{}( __cfainit & this, void (*init)( void * ), void * arg ) {
+        this.init = init;
+        this.arg = arg;
+        ((thread&)this){"Processir Init"};
+
+        // Don't use __thrd_start! just prep the context manually
+        $thread * this_thrd = get_thread(this);
+        void (*main_p)(__cfainit &) = main;
+
+        disable_interrupts();
+        __cfactx_start(main_p, get_coroutine(this), this, __cfactx_invoke_thread);
+
+        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
+        /* paranoid */ verify( this_thrd->context.SP );
+
+        this_thrd->state = Ready;
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
+void ^?{}(__cfainit & mutex this) {
+        ^(this.self){};
+}
+
+void main( __cfainit & this ) {
+        __attribute__((unused)) void * const thrd_obj = (void*)&this;
+        __attribute__((unused)) void * const thrd_hdl = (void*)active_thread();
+        /* paranoid */ verify( thrd_obj == thrd_hdl );
+
+        this.init( this.arg );
+}
+
+//================================================================================
+// Main Api
 extern "C" {
         int cfathread_cluster_create(cfathread_cluster_t * cl) __attribute__((nonnull(1))) {
@@ -79 +142 @@
 
         int cfathread_cluster_add_worker(cfathread_cluster_t cl, pthread_t* tid, void (*init_routine) (void *), void * arg) {
-                // processor * proc = new("C-processor", *cl, init_routine, arg);
+                __cfainit * it = 0p;
+                if(init_routine) {
+                        it = alloc();
+                        (*it){init_routine, arg};
+                }
                 processor * proc = alloc();
-                (*proc){ "C-processor", *cl, init_routine, arg };
+                (*proc){ "C-processor", *cl, get_thread(*it) };
+
+                // Wait for the init thread to return before continuing
+                if(it) {
+                        ^(*it){};
+                        free(it);
+                }
+
                 if(tid) *tid = proc->kernel_thread;
                 return 0;

libcfa/src/concurrency/kernel.cfa

@@ -149 +149 @@
         #endif
 
-        // if we need to run some special setup, now is the time to do it.
-        if(this->init.fnc) {
-                this->init.fnc(this->init.arg);
-        }
-
         {
                 // Setup preemption data
@@ -162 +157 @@
                 #endif
 
+                // if we need to run some special setup, now is the time to do it.
+                if(this->init.thrd) {
+                        this->init.thrd->curr_cluster = this->cltr;
+                        __run_thread(this, this->init.thrd);
+                }
 
                 __cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this);

libcfa/src/concurrency/kernel.hfa

@@ -112 +112 @@
         // it is not a particularly safe scheme as it can make processors less homogeneous
         struct {
-                void (*fnc) (void *);
-                void * arg;
+                $thread * thrd;
         } init;
 
@@ -127 +126 @@
 };
 
-void  ?{}(processor & this, const char name[], struct cluster & cltr, void (*init) (void *), void * arg);
+void  ?{}(processor & this, const char name[], struct cluster & cltr);
 void ^?{}(processor & this);
 
-static inline void  ?{}(processor & this)                        { this{ "Anonymous Processor", *mainCluster, 0p, 0p}; }
-static inline void  ?{}(processor & this, struct cluster & cltr) { this{ "Anonymous Processor", cltr, 0p, 0p}; }
-static inline void  ?{}(processor & this, const char name[])     { this{name, *mainCluster, 0p, 0p }; }
+static inline void  ?{}(processor & this)                        { this{ "Anonymous Processor", *mainCluster}; }
+static inline void  ?{}(processor & this, struct cluster & cltr) { this{ "Anonymous Processor", cltr}; }
+static inline void  ?{}(processor & this, const char name[])     { this{name, *mainCluster}; }
 
 DLISTED_MGD_IMPL_OUT(processor)

libcfa/src/concurrency/kernel/startup.cfa

@@ -73 +73 @@
 static void __kernel_first_resume( processor * this );
 static void __kernel_last_resume ( processor * this );
-static void init(processor & this, const char name[], cluster & _cltr, void (*fnc) (void *), void * arg);
+static void init(processor & this, const char name[], cluster & _cltr, $thread * initT);
 static void deinit(processor & this);
 static void doregister( struct cluster & cltr );
@@ -198 +198 @@
                 ( this.terminated ){};
                 ( this.runner ){};
-                init( this, "Main Processor", *mainCluster, 0p, 0p );
+                init( this, "Main Processor", *mainCluster, 0p );
                 kernel_thread = pthread_self();
 
@@ -452 +452 @@
 }
 
-static void init(processor & this, const char name[], cluster & _cltr, void (*fnc) (void *), void * arg) with( this ) {
+static void init(processor & this, const char name[], cluster & _cltr, $thread * initT) with( this ) {
         this.name = name;
         this.cltr = &_cltr;
@@ -464 +464 @@
         this.io.dirty   = false;
 
-        this.init.fnc = fnc;
-        this.init.arg = arg;
+        this.init.thrd = initT;
 
         this.idle = eventfd(0, 0);
@@ -516 +515 @@
 }
 
-void ?{}(processor & this, const char name[], cluster & _cltr, void (*fnc) (void *), void * arg) {
+void ?{}(processor & this, const char name[], cluster & _cltr, $thread * initT) {
         ( this.terminated ){};
         ( this.runner ){};
 
         disable_interrupts();
-                init( this, name, _cltr, fnc, arg );
+                init( this, name, _cltr, initT );
         enable_interrupts( __cfaabi_dbg_ctx );
 
@@ -527 +526 @@
 
         this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
-
+}
+
+void ?{}(processor & this, const char name[], cluster & _cltr) {
+        (this){name, _cltr, 0p};
 }
 

tests/concurrent/clib.c

@@ -62 +62 @@
         cfathread_cluster_add_worker( cl, NULL, NULL, NULL );
         cfathread_cluster_add_worker( cl, NULL, NULL, NULL );
+
+        cfathread_attr_t attr;
+        cfathread_attr_init(&attr);
+        cfathread_attr_setcluster(&attr, cl);
+
         cfathread_t u;
-        cfathread_create( &u, NULL, Unparker, NULL );
+        cfathread_create( &u, &attr, Unparker, NULL );
         {
                 cfathread_t t[20];
                 for(int i = 0; i < 20; i++) {
-                        cfathread_create( &t[i], NULL, Worker, NULL );
+                        cfathread_create( &t[i], &attr, Worker, NULL );
                 }
                 for(int i = 0; i < 20; i++) {
@@ -75 +80 @@
         stop = true;
         cfathread_join(u, NULL);
+        cfathread_attr_destroy(&attr);
         fflush(stdout);
         _exit(0);