Changes in libcfa/src/concurrency/kernel.cfa [28d73c1:efc171d1]

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -228 +228 @@
 static void * __invoke_processor(void * arg);
 
-static init(processor & this, const char name[], cluster & _cltr) with( this ) {
+void ?{}(processor & this, const char name[], cluster & _cltr) with( this ) {
         this.name = name;
         this.cltr = &_cltr;
         id = -1u;
+        terminated{ 0 };
         destroyer = 0p;
         do_terminate = false;
         preemption_alarm = 0p;
         pending_preemption = false;
+        runner.proc = &this;
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -242 +244 @@
         #endif
 
+        idle{};
+
+        __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
+
+        this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
         __atomic_fetch_add( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
 
-        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 );
-
-        // 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
-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();
-
-                // Adjust the ready queue size
-                ready_queue_shrink( this.cltr );
-
-                // Make sure we aren't on the idle queue
-                unsafe_remove( this.cltr->idles, &this );
-
-        // 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 ){ 0 };
-        ( this.runner ){};
-        init( this, name, _cltr );
-
-        __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
-
-        this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
-
 }
 
@@ -303 +269 @@
 
         free( this.stack );
-
-        deinit( this );
 
         __atomic_fetch_sub( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
@@ -354 +318 @@
 
         __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
-        #if !defined(__CFA_NO_STATISTICS__)
-                if( this->print_halts ) {
-                        __cfaabi_bits_print_safe( STDOUT_FILENO, "Processor : %d - %s (%p)\n", this->id, this->name, (void*)this);
-                }
-        #endif
+
+        // register the processor unless it's the main thread which is handled in the boot sequence
+        if(this != mainProcessor) {
+                this->id = doregister((__processor_id_t*)this);
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if( this->print_halts ) {
+                                __cfaabi_bits_print_safe( STDOUT_FILENO, "Processor : %d - %s (%p)\n", this->id, this->name, (void*)this);
+                        }
+                #endif
+
+                // 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( this->cltr );
+
+                // Unlock the RWlock
+                ready_mutate_unlock( last_size );
+        }
 
         {
@@ -397 +375 @@
         V( this->terminated );
 
-        if(this == mainProcessor) {
+        // unregister the processor unless it's the main thread which is handled in the boot sequence
+        if(this != mainProcessor) {
+                // 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 );
+
+                        // Make sure we aren't on the idle queue
+                        #if !defined(__CFA_NO_STATISTICS__)
+                                bool removed =
+                        #endif
+                        unsafe_remove( this->cltr->idles, this );
+
+                        #if !defined(__CFA_NO_STATISTICS__)
+                                if(removed) __tls_stats()->ready.sleep.exits++;
+                        #endif
+
+                // Unlock the RWlock
+                ready_mutate_unlock( last_size );
+
+                // Finally we don't need the read_lock any more
+                unregister((__processor_id_t*)this);
+        }
+        else {
                 // HACK : the coroutine context switch expects this_thread to be set
                 // and it make sense for it to be set in all other cases except here
@@ -857 +859 @@
 
         void ?{}(processor & this) with( this ) {
-                ( this.idle ){};
-                ( this.terminated ){ 0 };
-                ( this.runner ){};
-                init( this, "Main Processor", *mainCluster );
+                name = "Main Processor";
+                cltr = mainCluster;
+                terminated{ 0 };
+                do_terminate = false;
+                preemption_alarm = 0p;
+                pending_preemption = false;
                 kernel_thread = pthread_self();
+                id = -1u;
+
+                #if !defined(__CFA_NO_STATISTICS__)
+                        print_stats = false;
+                        print_halts = false;
+                #endif
 
                 runner{ &this };
                 __cfadbg_print_safe(runtime_core, "Kernel : constructed main processor context %p\n", &runner);
+
+                __atomic_fetch_add( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );
         }
 
@@ -871 +883 @@
         mainProcessor = (processor *)&storage_mainProcessor;
         (*mainProcessor){};
+
+        mainProcessor->id = doregister( (__processor_id_t*)mainProcessor);
 
         //initialize the global state variables
@@ -930 +944 @@
         kernel_stop_preemption();
 
+        unregister((__processor_id_t*)mainProcessor);
+
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
         void ^?{}(processor & this) with( this ){
-                deinit( this );
-
                 /* paranoid */ verify( this.do_terminate == true );
                 __atomic_fetch_sub( &cltr->nprocessors, 1u, __ATOMIC_SEQ_CST );