Changeset 1f55a75 for libcfa/src/concurrency/clib

Timestamp:

Mar 23, 2021, 9:19:47 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

98d9ce9

Parents:

f9c3100 (diff), e825c9d (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/clib

Files:

• cfathread.cfa (modified) (4 diffs)
• cfathread.h (modified) (2 diffs)

libcfa/src/concurrency/clib/cfathread.cfa

@@ -17 +17 @@
 #include "locks.hfa"
 #include "kernel.hfa"
+#include "stats.hfa"
 #include "thread.hfa"
 #include "time.hfa"
 
 #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 +74 @@
 }
 
-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))) {
@@ -78 +142 @@
         }
 
+        int cfathread_cluster_print_stats( cfathread_cluster_t cl ) {
+                #if !defined(__CFA_NO_STATISTICS__)
+                        print_stats_at_exit( *cl, CFA_STATS_READY_Q | CFA_STATS_IO );
+                        print_stats_now( *cl, CFA_STATS_READY_Q | CFA_STATS_IO );
+                #endif
+                return 0;
+        }
+
         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;
@@ -162 +245 @@
         int cfathread_mutex_init(cfathread_mutex_t *restrict mut, const cfathread_mutexattr_t *restrict) __attribute__((nonnull (1))) { *mut = new(); return 0; }
         int cfathread_mutex_destroy(cfathread_mutex_t *mut) __attribute__((nonnull (1))) { delete( *mut ); return 0; }
-        int cfathread_mutex_lock   (cfathread_mutex_t *mut) __attribute__((nonnull (1))) { lock    ( (*mut)->impl ); return 0; }
-        int cfathread_mutex_trylock(cfathread_mutex_t *mut) __attribute__((nonnull (1))) { try_lock( (*mut)->impl ); return 0; }
-        int cfathread_mutex_unlock (cfathread_mutex_t *mut) __attribute__((nonnull (1))) { unlock  ( (*mut)->impl ); return 0; }
+        int cfathread_mutex_lock   (cfathread_mutex_t *mut) __attribute__((nonnull (1))) { lock( (*mut)->impl ); return 0; }
+        int cfathread_mutex_unlock (cfathread_mutex_t *mut) __attribute__((nonnull (1))) { unlock( (*mut)->impl ); return 0; }
+        int cfathread_mutex_trylock(cfathread_mutex_t *mut) __attribute__((nonnull (1))) {
+                bool ret = try_lock( (*mut)->impl );
+                if( ret ) return 0;
+                else return EBUSY;
+        }
 
         //--------------------

libcfa/src/concurrency/clib/cfathread.h

@@ -13 +13 @@
 // Update Count     :
 //
-
-#include "stddef.h"
-#include "invoke.h"
 
 #if defined(__cforall) || defined(__cplusplus)
@@ -32 +29 @@
         int cfathread_cluster_create(cfathread_cluster_t * cluster);
         cfathread_cluster_t cfathread_cluster_self(void);
+        int cfathread_cluster_print_stats(cfathread_cluster_t cluster);
         int cfathread_cluster_add_worker(cfathread_cluster_t cluster, pthread_t* tid, void (*init_routine) (void *), void * arg);
         int cfathread_cluster_pause (cfathread_cluster_t cluster);