Changes in libcfa/src/concurrency/clib/cfathread.cfa [d27b6be:f03e11d]

File:

• libcfa/src/concurrency/clib/cfathread.cfa (modified) (4 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 {
@@ -74 +65 @@
 }
 
-//================================================================================
-// 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
+processor * procs = 0p;
+int proc_cnt = 1;
+
 extern "C" {
         int cfathread_cluster_create(cfathread_cluster_t * cl) __attribute__((nonnull(1))) {
@@ -142 +78 @@
         }
 
-        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) {
-                __cfainit * it = 0p;
-                if(init_routine) {
-                        it = alloc();
-                        (*it){init_routine, arg};
-                }
+                // processor * proc = new("C-processor", *cl, init_routine, arg);
                 processor * proc = alloc();
-                (*proc){ "C-processor", *cl, get_thread(*it) };
-
-                // Wait for the init thread to return before continuing
-                if(it) {
-                        ^(*it){};
-                        free(it);
-                }
-
+                (*proc){ "C-processor", *cl, init_routine, arg };
                 if(tid) *tid = proc->kernel_thread;
                 return 0;
@@ -245 +162 @@
         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_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;
-        }
+        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; }
 
         //--------------------