Changes in libcfa/src/concurrency/kernel/startup.cfa [89eff25:3e1a705]

File:

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

libcfa/src/concurrency/kernel/startup.cfa

@@ -77 +77 @@
 static void doregister( struct cluster & cltr );
 static void unregister( struct cluster & cltr );
+static void register_tls( processor * this );
+static void unregister_tls( processor * this );
 static void ?{}( $coroutine & this, current_stack_info_t * info);
 static void ?{}( $thread & this, current_stack_info_t * info);
@@ -123 +125 @@
         NULL,                                                                                           // cannot use 0p
         NULL,
+        false,
+        { 1, false, false },
+        0,
+        { 0, 0 },
         NULL,
-        NULL,
-        { 1, false, false },
+        #ifdef __CFA_WITH_VERIFY__
+                false,
+                0,
+        #endif
 };
 
@@ -210 +218 @@
         (*mainProcessor){};
 
+        register_tls( mainProcessor );
+
         //initialize the global state variables
         __cfaabi_tls.this_processor = mainProcessor;
-        __cfaabi_tls.this_proc_id   = (__processor_id_t*)mainProcessor;
         __cfaabi_tls.this_thread    = mainThread;
 
@@ -219 +228 @@
                 __init_stats( __cfaabi_tls.this_stats );
         #endif
+        mainProcessor->local_data = &__cfaabi_tls;
 
         // Enable preemption
@@ -225 +235 @@
         // 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
-        __schedule_thread(mainThread);
+        schedule_thread$(mainThread);
 
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
@@ -238 +248 @@
 
         /* paranoid */ verify( ! __preemption_enabled() );
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts();
         /* paranoid */ verify( __preemption_enabled() );
 
@@ -273 +283 @@
         #endif
 
+        mainProcessor->local_data = 0p;
+
+        unregister_tls( mainProcessor );
+
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
@@ -316 +330 @@
         processor * proc = (processor *) arg;
         __cfaabi_tls.this_processor = proc;
-        __cfaabi_tls.this_proc_id   = (__processor_id_t*)proc;
         __cfaabi_tls.this_thread    = 0p;
         __cfaabi_tls.preemption_state.[enabled, disable_count] = [false, 1];
+        proc->local_data = &__cfaabi_tls;
+
+        register_tls( proc );
+
         // SKULLDUGGERY: We want to create a context for the processor coroutine
         // which is needed for the 2-step context switch. However, there is no reason
@@ -355 +372 @@
                 #endif
         #endif
+
+        proc->local_data = 0p;
+
+        unregister_tls( proc );
 
         return 0p;
@@ -446 +467 @@
         self_mon_p = &self_mon;
         link.next = 0p;
-        link.prev = 0p;
-        link.preferred = -1u;
+        link.ts   = 0;
+        preferred = -1u;
         last_proc = 0p;
         #if defined( __CFA_WITH_VERIFY__ )
@@ -475 +496 @@
         this.rdq.id  = -1u;
         this.rdq.target = -1u;
-        this.rdq.cutoff = -1ull;
+        this.rdq.cutoff = 0ull;
         do_terminate = false;
         preemption_alarm = 0p;
@@ -485 +506 @@
 
         this.init.thrd = initT;
+
+        this.local_data = 0p;
 
         this.idle = eventfd(0, 0);
@@ -496 +519 @@
         #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);
-
-                // 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);
 }
@@ -512 +524 @@
 // 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_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);
 }
@@ -532 +533 @@
         disable_interrupts();
                 init( this, name, _cltr, initT );
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts();
 
         __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
@@ -559 +560 @@
         disable_interrupts();
                 deinit( this );
-        enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts();
 }
 
@@ -597 +598 @@
         // Unlock the RWlock
         ready_mutate_unlock( last_size );
-        enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+        enable_interrupts( false ); // Don't poll, could be in main cluster
 }
 
@@ -612 +613 @@
         // Unlock the RWlock
         ready_mutate_unlock( last_size );
-        enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+        enable_interrupts( false ); // Don't poll, could be in main cluster
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -656 +657 @@
         cltr->nthreads -= 1;
         unlock(cltr->thread_list_lock);
+}
+
+static void register_tls( processor * this ) {
+        // Register and Lock the RWlock so no-one pushes/pops while we are changing the queue
+        uint_fast32_t last_size;
+        [this->unique_id, last_size] = ready_mutate_register();
+
+                this->cltr->procs.total += 1u;
+                insert_last(this->cltr->procs.actives, *this);
+
+                // Adjust the ready queue size
+                ready_queue_grow( this->cltr );
+
+        // Unlock the RWlock
+        ready_mutate_unlock( last_size );
+}
+
+
+static void unregister_tls( 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);
+
+                // clear the cluster so nothing gets pushed to local queues
+                cluster * cltr = this->cltr;
+                this->cltr = 0p;
+
+                // Adjust the ready queue size
+                ready_queue_shrink( cltr );
+
+        // Unlock the RWlock and unregister: we don't need the read_lock any more
+        ready_mutate_unregister( this->unique_id, last_size );
 }