Changes in libcfa/src/concurrency/kernel/startup.cfa [dddb3dd0:da3963a]

File:

• libcfa/src/concurrency/kernel/startup.cfa (modified) (14 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
@@ -81 +80 @@
 static void ?{}(processorCtx_t & this) {}
 static void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info);
+static void ?{}(__bin_sem_t & this);
+static void ^?{}(__bin_sem_t & this);
 
 #if defined(__CFA_WITH_VERIFY__)
@@ -90 +91 @@
 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 +104 @@
 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 +200 @@
 
         void ?{}(processor & this) with( this ) {
+                ( this.idle ){};
                 ( this.terminated ){};
                 ( this.runner ){};
@@ -223 +228 @@
         __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 +243 @@
         // 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 +262 @@
 
 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();
@@ -261 +284 @@
         // Disable preemption
         __kernel_alarm_shutdown();
+
+        // Stop IO
+        __kernel_io_shutdown();
 
         // Destroy the main processor and its context in reverse order of construction
@@ -460 +486 @@
         pending_preemption = false;
 
-        this.io.ctx = 0p;
-        this.io.pending = false;
-        this.io.dirty   = false;
-
-        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;
@@ -509 +526 @@
         // Finally we don't need the read_lock any more
         unregister((__processor_id_t*)&this);
-
-        close(this.idle);
 }
 
 void ?{}(processor & this, const char name[], cluster & _cltr) {
+        ( this.idle ){};
         ( this.terminated ){};
         ( this.runner ){};
@@ -568 +584 @@
         threads{ __get };
 
-        io.arbiter = create();
-        io.params = io_params;
-
         doregister(this);
 
@@ -583 +596 @@
         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
@@ -715 +738 @@
 }
 
+extern "C" {
+        char * strerror(int);
+}
+#define CHECKED(x) { int err = x; if( err != 0 ) abort("KERNEL ERROR: Operation \"" #x "\" return error %d - %s\n", err, strerror(err)); }
+
+static void ?{}(__bin_sem_t & this) with( this ) {
+        // Create the mutex with error checking
+        pthread_mutexattr_t mattr;
+        pthread_mutexattr_init( &mattr );
+        pthread_mutexattr_settype( &mattr, PTHREAD_MUTEX_ERRORCHECK_NP);
+        pthread_mutex_init(&lock, &mattr);
+
+        pthread_cond_init (&cond, (const pthread_condattr_t *)0p);  // workaround trac#208: cast should not be required
+        val = 0;
+}
+
+static void ^?{}(__bin_sem_t & this) with( this ) {
+        CHECKED( pthread_mutex_destroy(&lock) );
+        CHECKED( pthread_cond_destroy (&cond) );
+}
+
+#undef CHECKED
+
 #if defined(__CFA_WITH_VERIFY__)
 static bool verify_fwd_bck_rng(void) {