Changes in libcfa/src/concurrency/kernel/startup.cfa [454f478:89eff25]

File:

• libcfa/src/concurrency/kernel/startup.cfa (modified) (20 diffs)

libcfa/src/concurrency/kernel/startup.cfa

@@ -22 +22 @@
 extern "C" {
       #include <limits.h>       // PTHREAD_STACK_MIN
+        #include <sys/eventfd.h>  // eventfd
       #include <sys/mman.h>     // mprotect
       #include <sys/resource.h> // getrlimit
@@ -72 +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);
+static void init(processor & this, const char name[], cluster & _cltr, $thread * initT);
 static void deinit(processor & this);
 static void doregister( struct cluster & cltr );
@@ -89 +90 @@
 extern void __kernel_alarm_startup(void);
 extern void __kernel_alarm_shutdown(void);
-extern void __kernel_io_startup (void);
-extern void __kernel_io_shutdown(void);
 
 //-----------------------------------------------------------------------------
@@ -102 +101 @@
 KERNEL_STORAGE($thread,              mainThread);
 KERNEL_STORAGE(__stack_t,            mainThreadCtx);
-KERNEL_STORAGE(io_context,           mainPollerThread);
 KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock);
 #if !defined(__CFA_NO_STATISTICS__)
@@ -198 +196 @@
 
         void ?{}(processor & this) with( this ) {
-                ( this.idle ){};
                 ( this.terminated ){};
                 ( this.runner ){};
-                init( this, "Main Processor", *mainCluster );
+                init( this, "Main Processor", *mainCluster, 0p );
                 kernel_thread = pthread_self();
 
@@ -226 +223 @@
         __kernel_alarm_startup();
 
-        // Start IO
-        __kernel_io_startup();
-
         // Add the main thread to the ready queue
         // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
@@ -241 +235 @@
         // THE SYSTEM IS NOW COMPLETELY RUNNING
 
-
-        // SKULLDUGGERY: The constructor for the mainCluster will call alloc with a dimension of 0
-        // malloc *can* return a non-null value, we should free it if that is the case
-        free( mainCluster->io.ctxs );
-
-        // Now that the system is up, finish creating systems that need threading
-        mainCluster->io.ctxs = (io_context *)&storage_mainPollerThread;
-        mainCluster->io.cnt  = 1;
-        (*mainCluster->io.ctxs){ *mainCluster };
-
         __cfadbg_print_safe(runtime_core, "Kernel : Started\n--------------------------------------------------\n\n");
 
@@ -260 +244 @@
 
 static void __kernel_shutdown(void) {
-        //Before we start shutting things down, wait for systems that need threading to shutdown
-        ^(*mainCluster->io.ctxs){};
-        mainCluster->io.cnt  = 0;
-        mainCluster->io.ctxs = 0p;
-
         /* paranoid */ verify( __preemption_enabled() );
         disable_interrupts();
@@ -283 +262 @@
         __kernel_alarm_shutdown();
 
-        // Stop IO
-        __kernel_io_shutdown();
+        #if !defined( __CFA_NO_STATISTICS__ )
+                __stats_t * st = (__stats_t *)& storage_mainProcStats;
+                __tally_stats(mainCluster->stats, st);
+                if( 0 != mainProcessor->print_stats ) {
+                        __print_stats( st, mainProcessor->print_stats, "Processor ", mainProcessor->name, (void*)mainProcessor );
+                }
+                #if defined(CFA_STATS_ARRAY)
+                        __flush_stat( st, "Processor", mainProcessor );
+                #endif
+        #endif
 
         // Destroy the main processor and its context in reverse order of construction
@@ -364 +351 @@
                         __print_stats( &local_stats, proc->print_stats, "Processor ", proc->name, (void*)proc );
                 }
+                #if defined(CFA_STATS_ARRAY)
+                        __flush_stat( &local_stats, "Processor", proc );
+                #endif
         #endif
 
@@ -457 +447 @@
         link.next = 0p;
         link.prev = 0p;
+        link.preferred = -1u;
+        last_proc = 0p;
         #if defined( __CFA_WITH_VERIFY__ )
                 canary = 0x0D15EA5E0D15EA5Ep;
@@ -476 +468 @@
 }
 
-static void init(processor & this, const char name[], cluster & _cltr) with( this ) {
+static void init(processor & this, const char name[], cluster & _cltr, $thread * initT) with( this ) {
         this.name = name;
         this.cltr = &_cltr;
-        full_proc = true;
+        this.rdq.its = 0;
+        this.rdq.itr = 0;
+        this.rdq.id  = -1u;
+        this.rdq.target = -1u;
+        this.rdq.cutoff = -1ull;
         do_terminate = false;
         preemption_alarm = 0p;
         pending_preemption = false;
 
+        this.io.ctx = 0p;
+        this.io.pending = false;
+        this.io.dirty   = false;
+
+        this.init.thrd = initT;
+
+        this.idle = eventfd(0, 0);
+        if (idle < 0) {
+                abort("KERNEL ERROR: PROCESSOR EVENTFD - %s\n", strerror(errno));
+        }
+
         #if !defined(__CFA_NO_STATISTICS__)
                 print_stats = 0;
@@ -489 +496 @@
         #endif
 
-        lock( this.cltr->idles );
-                int target = this.cltr->idles.total += 1u;
-        unlock( this.cltr->idles );
-
-        id = doregister((__processor_id_t*)&this);
-
+        // Register and Lock the RWlock so no-one pushes/pops while we are changing the queue
+        uint_fast32_t last_size = ready_mutate_register((__processor_id_t*)&this);
+                this.cltr->procs.total += 1u;
+                insert_last(this.cltr->procs.actives, this);
+
+                // Adjust the ready queue size
+                ready_queue_grow( cltr );
+
+        // Unlock the RWlock
+        ready_mutate_unlock( last_size );
+
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this);
+}
+
+// Not a ctor, it just preps the destruction but should not destroy members
+static void deinit(processor & this) {
         // Lock the RWlock so no-one pushes/pops while we are changing the queue
         uint_fast32_t last_size = ready_mutate_lock();
+                this.cltr->procs.total -= 1u;
+                remove(this);
 
                 // Adjust the ready queue size
-                ready_queue_grow( cltr, target );
-
-        // Unlock the RWlock
-        ready_mutate_unlock( last_size );
-
-        __cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this);
-}
-
-// Not a ctor, it just preps the destruction but should not destroy members
-static void deinit(processor & this) {
-        lock( this.cltr->idles );
-                int target = this.cltr->idles.total -= 1u;
-        unlock( this.cltr->idles );
-
-        // Lock the RWlock so no-one pushes/pops while we are changing the queue
-        uint_fast32_t last_size = ready_mutate_lock();
-
-                // Adjust the ready queue size
-                ready_queue_shrink( this.cltr, target );
-
-        // Unlock the RWlock
-        ready_mutate_unlock( last_size );
-
-        // Finally we don't need the read_lock any more
-        unregister((__processor_id_t*)&this);
-}
-
-void ?{}(processor & this, const char name[], cluster & _cltr) {
-        ( this.idle ){};
+                ready_queue_shrink( this.cltr );
+
+        // Unlock the RWlock and unregister: we don't need the read_lock any more
+        ready_mutate_unregister((__processor_id_t*)&this, last_size );
+
+        close(this.idle);
+}
+
+void ?{}(processor & this, const char name[], cluster & _cltr, $thread * initT) {
         ( this.terminated ){};
         ( this.runner ){};
 
         disable_interrupts();
-                init( this, name, _cltr );
+                init( this, name, _cltr, initT );
         enable_interrupts( __cfaabi_dbg_ctx );
 
@@ -538 +537 @@
 
         this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
-
+}
+
+void ?{}(processor & this, const char name[], cluster & _cltr) {
+        (this){name, _cltr, 0p};
 }
 
@@ -562 +564 @@
 //-----------------------------------------------------------------------------
 // Cluster
-static void ?{}(__cluster_idles & this) {
+static void ?{}(__cluster_proc_list & this) {
         this.lock  = 0;
         this.idle  = 0;
         this.total = 0;
-        (this.list){};
 }
 
@@ -582 +583 @@
         threads{ __get };
 
+        io.arbiter = create();
+        io.params = io_params;
+
         doregister(this);
 
@@ -589 +593 @@
 
                 // Adjust the ready queue size
-                ready_queue_grow( &this, 0 );
+                ready_queue_grow( &this );
 
         // Unlock the RWlock
         ready_mutate_unlock( last_size );
         enable_interrupts_noPoll(); // Don't poll, could be in main cluster
-
-
-        this.io.cnt  = num_io;
-        this.io.ctxs = aalloc(num_io);
-        for(i; this.io.cnt) {
-                (this.io.ctxs[i]){ this, io_params };
-        }
 }
 
 void ^?{}(cluster & this) {
-        for(i; this.io.cnt) {
-                ^(this.io.ctxs[i]){ true };
-        }
-        free(this.io.ctxs);
+        destroy(this.io.arbiter);
 
         // Lock the RWlock so no-one pushes/pops while we are changing the queue
@@ -614 +608 @@
 
                 // Adjust the ready queue size
-                ready_queue_shrink( &this, 0 );
+                ready_queue_shrink( &this );
 
         // Unlock the RWlock
@@ -624 +618 @@
                         __print_stats( this.stats, this.print_stats, "Cluster", this.name, (void*)&this );
                 }
+                #if defined(CFA_STATS_ARRAY)
+                        __flush_stat( this.stats, "Cluster", &this );
+                #endif
                 free( this.stats );
         #endif
@@ -736 +733 @@
 }
 
-
 #if defined(__CFA_WITH_VERIFY__)
 static bool verify_fwd_bck_rng(void) {