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

File:

• libcfa/src/concurrency/kernel/startup.cfa (modified) (21 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
@@ -73 +72 @@
 static void __kernel_first_resume( processor * this );
 static void __kernel_last_resume ( processor * this );
-static void init(processor & this, const char name[], cluster & _cltr, $thread * initT);
+static void init(processor & this, const char name[], cluster & _cltr);
 static void deinit(processor & this);
 static void doregister( struct cluster & cltr );
@@ -90 +89 @@
 extern void __kernel_alarm_startup(void);
 extern void __kernel_alarm_shutdown(void);
+extern void __kernel_io_startup (void);
+extern void __kernel_io_shutdown(void);
 
 //-----------------------------------------------------------------------------
@@ -101 +102 @@
 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__)
@@ -196 +198 @@
 
         void ?{}(processor & this) with( this ) {
+                ( this.idle ){};
                 ( this.terminated ){};
                 ( this.runner ){};
-                init( this, "Main Processor", *mainCluster, 0p );
+                init( this, "Main Processor", *mainCluster );
                 kernel_thread = pthread_self();
 
@@ -223 +226 @@
         __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
@@ -235 +241 @@
         // 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");
 
@@ -244 +260 @@
 
 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();
@@ -262 +283 @@
         __kernel_alarm_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
+        // Stop IO
+        __kernel_io_shutdown();
 
         // Destroy the main processor and its context in reverse order of construction
@@ -351 +364 @@
                         __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
 
@@ -447 +457 @@
         link.next = 0p;
         link.prev = 0p;
-        link.preferred = -1u;
-        last_proc = 0p;
         #if defined( __CFA_WITH_VERIFY__ )
                 canary = 0x0D15EA5E0D15EA5Ep;
@@ -468 +476 @@
 }
 
-static void init(processor & this, const char name[], cluster & _cltr, $thread * initT) with( this ) {
+static void init(processor & this, const char name[], cluster & _cltr) with( this ) {
         this.name = name;
         this.cltr = &_cltr;
-        this.rdq.its = 0;
-        this.rdq.itr = 0;
-        this.rdq.id  = -1u;
-        this.rdq.target = -1u;
-        this.rdq.cutoff = -1ull;
+        full_proc = true;
         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;
@@ -496 +489 @@
         #endif
 
-        // 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);
+        lock( this.cltr->idles );
+                int target = this.cltr->idles.total += 1u;
+        unlock( this.cltr->idles );
+
+        id = doregister((__processor_id_t*)&this);
+
+        // 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_grow( cltr );
+                ready_queue_grow( cltr, target );
 
         // Unlock the RWlock
@@ -512 +509 @@
 // 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();
-                this.cltr->procs.total -= 1u;
-                remove(this);
 
                 // Adjust the ready queue size
-                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) {
+                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 ){};
         ( this.terminated ){};
         ( this.runner ){};
 
         disable_interrupts();
-                init( this, name, _cltr, initT );
+                init( this, name, _cltr );
         enable_interrupts( __cfaabi_dbg_ctx );
 
@@ -537 +538 @@
 
         this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
-}
-
-void ?{}(processor & this, const char name[], cluster & _cltr) {
-        (this){name, _cltr, 0p};
+
 }
 
@@ -564 +562 @@
 //-----------------------------------------------------------------------------
 // Cluster
-static void ?{}(__cluster_proc_list & this) {
+static void ?{}(__cluster_idles & this) {
         this.lock  = 0;
         this.idle  = 0;
         this.total = 0;
+        (this.list){};
 }
 
@@ -583 +582 @@
         threads{ __get };
 
-        io.arbiter = create();
-        io.params = io_params;
-
         doregister(this);
 
@@ -593 +589 @@
 
                 // Adjust the ready queue size
-                ready_queue_grow( &this );
+                ready_queue_grow( &this, 0 );
 
         // 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) {
-        destroy(this.io.arbiter);
+        for(i; this.io.cnt) {
+                ^(this.io.ctxs[i]){ true };
+        }
+        free(this.io.ctxs);
 
         // Lock the RWlock so no-one pushes/pops while we are changing the queue
@@ -608 +614 @@
 
                 // Adjust the ready queue size
-                ready_queue_shrink( &this );
+                ready_queue_shrink( &this, 0 );
 
         // Unlock the RWlock
@@ -618 +624 @@
                         __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
@@ -733 +736 @@
 }
 
+
 #if defined(__CFA_WITH_VERIFY__)
 static bool verify_fwd_bck_rng(void) {