Changeset 8834751 for libcfa/src/concurrency/kernel.cfa

Timestamp:

Jun 16, 2020, 12:53:58 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

2073d207

Parents:

d29255c

Message:

Moved statistics to stats.cfa to combine ready Q stats and IO stats

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -130 +130 @@
 KERNEL_STORAGE(__stack_t,            mainThreadCtx);
 KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock);
+#if !defined(__CFA_NO_STATISTICS__)
+KERNEL_STORAGE(__stats_t, mainProcStats);
+#endif
 
 cluster              * mainCluster;
@@ -146 +149 @@
 thread_local struct KernelThreadData kernelTLS __attribute__ ((tls_model ( "initial-exec" ))) = {
         NULL,                                                                                           // cannot use 0p
+        NULL,
         NULL,
         { 1, false, false },
@@ -268 +272 @@
         #if !defined(__CFA_NO_STATISTICS__)
                 print_stats = false;
+                stats = alloc();
+                __init_stats( stats );
         #endif
 
@@ -281 +287 @@
 void ^?{}(cluster & this) {
         __kernel_io_shutdown( this, &this == mainCluster );
+
+        #if !defined(__CFA_NO_STATISTICS__)
+                if(this.print_stats) {
+                        __print_stats( this.stats );
+                }
+                free( this.stats );
+        #endif
 
         unregister(this);
@@ -357 +370 @@
 
         __cfadbg_print_safe(runtime_core, "Kernel : core %p terminated\n", this);
-
-        stats_tls_tally(this->cltr);
 }
 
@@ -479 +490 @@
 // It effectively constructs a coroutine by stealing the pthread stack
 static void * __invoke_processor(void * arg) {
+        #if !defined( __CFA_NO_STATISTICS__ )
+                __stats_t local_stats;
+                __init_stats( &local_stats );
+                kernelTLS.this_stats = &local_stats;
+        #endif
+
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
@@ -509 +526 @@
         // Main routine of the core returned, the core is now fully terminated
         __cfadbg_print_safe(runtime_core, "Kernel : core %p main ended (%p)\n", proc, &proc->runner);
+
+        #if !defined(__CFA_NO_STATISTICS__)
+                __tally_stats(proc->cltr->stats, &local_stats);
+        #endif
 
         return 0p;
@@ -794 +815 @@
         kernelTLS.this_thread    = mainThread;
 
+        #if !defined( __CFA_NO_STATISTICS__ )
+                kernelTLS.this_stats = (__stats_t *)& storage_mainProcStats;
+                __init_stats( kernelTLS.this_stats );
+        #endif
+
         // Enable preemption
         kernel_start_preemption();
@@ -874 +900 @@
 //=============================================================================================
 static $thread * __halt(processor * this) with( *this ) {
-        if( do_terminate ) return 0p;
-
-        // First, lock the cluster idle
-        lock( cltr->idle_lock __cfaabi_dbg_ctx2 );
-
-        // Check if we can find a thread
-        if( $thread * found = __next_thread( cltr ) ) {
-                unlock( cltr->idle_lock );
-                return found;
-        }
-
-        // Move this processor from the active list to the idle list
-        move_to_front(cltr->procs, cltr->idles, *this);
-
-        // Unlock the idle lock so we don't go to sleep with a lock
-        unlock    (cltr->idle_lock);
-
-        // We are ready to sleep
-        __cfadbg_print_safe(runtime_core, "Kernel : Processor %p ready to sleep\n", this);
-        wait( idle );
-
-        // We have woken up
-        __cfadbg_print_safe(runtime_core, "Kernel : Processor %p woke up and ready to run\n", this);
-
-        // Get ourself off the idle list
-        with( *cltr ) {
-                lock  (idle_lock __cfaabi_dbg_ctx2);
-                move_to_front(idles, procs, *this);
-                unlock(idle_lock);
-        }
+        // if( do_terminate ) return 0p;
+
+        // // First, lock the cluster idle
+        // lock( cltr->idle_lock __cfaabi_dbg_ctx2 );
+
+        // // Check if we can find a thread
+        // if( $thread * found = __next_thread( cltr ) ) {
+        //      unlock( cltr->idle_lock );
+        //      return found;
+        // }
+
+        // // Move this processor from the active list to the idle list
+        // move_to_front(cltr->procs, cltr->idles, *this);
+
+        // // Unlock the idle lock so we don't go to sleep with a lock
+        // unlock    (cltr->idle_lock);
+
+        // // We are ready to sleep
+        // __cfadbg_print_safe(runtime_core, "Kernel : Processor %p ready to sleep\n", this);
+        // wait( idle );
+
+        // // We have woken up
+        // __cfadbg_print_safe(runtime_core, "Kernel : Processor %p woke up and ready to run\n", this);
+
+        // // Get ourself off the idle list
+        // with( *cltr ) {
+        //      lock  (idle_lock __cfaabi_dbg_ctx2);
+        //      move_to_front(idles, procs, *this);
+        //      unlock(idle_lock);
+        // }
 
         // Don't check the ready queue again, we may not be in a position to run a thread
@@ -911 +937 @@
 // Wake a thread from the front if there are any
 static bool __wake_one(cluster * this) {
-        // First, lock the cluster idle
-        lock( this->idle_lock __cfaabi_dbg_ctx2 );
-
-        // Check if there is someone to wake up
-        if( !this->idles.head ) {
-                // Nope unlock and return false
-                unlock( this->idle_lock );
-                return false;
-        }
-
-        // Wake them up
-        __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this->idles.head);
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        post( this->idles.head->idle );
-
-        // Unlock and return true
-        unlock( this->idle_lock );
-        return true;
+        // // First, lock the cluster idle
+        // lock( this->idle_lock __cfaabi_dbg_ctx2 );
+
+        // // Check if there is someone to wake up
+        // if( !this->idles.head ) {
+        //      // Nope unlock and return false
+        //      unlock( this->idle_lock );
+        //      return false;
+        // }
+
+        // // Wake them up
+        // __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this->idles.head);
+        // /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        // post( this->idles.head->idle );
+
+        // // Unlock and return true
+        // unlock( this->idle_lock );
+        // return true;
+
+        return false;
 }
 
 // Unconditionnaly wake a thread
 static bool __wake_proc(processor * this) {
-        __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
-
-        disable_interrupts();
-                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-                bool ret = post( this->idle );
-        enable_interrupts( __cfaabi_dbg_ctx );
-
-        return ret;
+        // __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
+
+        // disable_interrupts();
+        //      /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        //      bool ret = post( this->idle );
+        // enable_interrupts( __cfaabi_dbg_ctx );
+
+        // return ret;
+
+        return false;
 }