Changes in / [bb2e05e:2bb2efa9]

Location:

libcfa/src

Files:

• bits/containers.hfa (modified) (1 diff)
• bits/locks.hfa (modified) (2 diffs)
• concurrency/kernel.cfa (modified) (13 diffs)
• concurrency/kernel.hfa (modified) (3 diffs)
• concurrency/kernel_private.hfa (modified) (1 diff)

libcfa/src/bits/containers.hfa

@@ -274 +274 @@
                         return this.head != 0;
                 }
-
-                void move_to_front( __dllist(T) & src, __dllist(T) & dst, T & node ) {
-                        remove    (src, node);
-                        push_front(dst, node);
-                }
         }
         #undef next

libcfa/src/bits/locks.hfa

@@ -139 +139 @@
         }
 
-        static inline bool post(__bin_sem_t & this) with( this ) {
+        static inline void post(__bin_sem_t & this) with( this ) {
+                verify(__cfaabi_dbg_in_kernel());
+
                 pthread_mutex_lock(&lock);
                         bool needs_signal = !signaled;
@@ -145 +147 @@
                 pthread_mutex_unlock(&lock);
 
-                if (needs_signal) pthread_cond_signal(&cond);
-
-                return needs_signal;
+                if (needs_signal)
+                        pthread_cond_signal(&cond);
         }
 #endif

libcfa/src/concurrency/kernel.cfa

@@ -114 +114 @@
 
 //-----------------------------------------------------------------------------
-// Kernel Scheduling logic
-static $thread * __next_thread(cluster * this);
-static void __run_thread(processor * this, $thread * dst);
-static $thread * __halt(processor * this);
-static bool __wake_one(cluster * cltr, bool was_empty);
-static bool __wake_proc(processor *);
-
-//-----------------------------------------------------------------------------
 // Kernel storage
 KERNEL_STORAGE(cluster,         mainCluster);
@@ -228 +220 @@
         runner.proc = &this;
 
-        idle{};
+        idleLock{};
 
         __cfaabi_dbg_print_safe("Kernel : Starting core %p\n", &this);
@@ -242 +234 @@
 
                 __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
-                __wake_proc( &this );
+                wake( &this );
 
                 P( terminated );
@@ -272 +264 @@
 // Kernel Scheduling logic
 //=============================================================================================
+static $thread * __next_thread(cluster * this);
+static void __run_thread(processor * this, $thread * dst);
+static void __halt(processor * this);
+
 //Main of the processor contexts
 void main(processorCtx_t & runner) {
@@ -293 +289 @@
                 $thread * readyThread = 0p;
                 for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ ) {
-                        // Try to get the next thread
                         readyThread = __next_thread( this->cltr );
 
-                        // If no ready thread
-                        if( readyThread == 0p ) {
-                                // Block until a thread is ready
-                                readyThread = __halt(this);
-                        }
-
-                        // Check if we actually found a thread
-                        if( readyThread ) {
+                        if(readyThread) {
                                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-                                /* paranoid */ verifyf( readyThread->state == Ready || readyThread->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", readyThread->state, readyThread->preempted);
+                                /* paranoid */ verifyf( readyThread->state == Blocked || readyThread->state == Start || readyThread->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", readyThread->state, readyThread->preempted);
                                 /* paranoid */ verifyf( readyThread->next == 0p, "Expected null got %p", readyThread->next );
 
-                                // We found a thread run it
                                 __run_thread(this, readyThread);
 
                                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+                                spin_count = 0;
+                        } else {
+                                // spin(this, &spin_count);
+                                __halt(this);
                         }
                 }
@@ -320 +312 @@
         unregister(this->cltr, this);
 
-        V( this->terminated );
+        bool signalled = V( this->terminated );
+        if(signalled)
 
         __cfaabi_dbg_print_safe("Kernel : core %p terminated\n", this);
-
-        // 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
-        // fake it
-        if( this == mainProcessor ) kernelTLS.this_thread = mainThread;
 }
 
@@ -350 +338 @@
                 if(unlikely(thrd_dst->preempted)) {
                         thrd_dst->preempted = __NO_PREEMPTION;
-                        verify(thrd_dst->state == Active  || thrd_dst->state == Rerun);
+                        verify(thrd_dst->state == Active || thrd_dst->state == Rerun);
                 } else {
-                        verify(thrd_dst->state == Blocked || thrd_dst->state == Ready); // Ready means scheduled normally, blocked means rerun
+                        verify(thrd_dst->state == Start || thrd_dst->state == Primed || thrd_dst->state == Blocked);
                         thrd_dst->state = Active;
                 }
@@ -533 +521 @@
         dst->starter = dst->starter ? dst->starter : &src->self_cor;
 
-        // make sure the current state is still correct
-        /* paranoid */ verify(src->state == Ready);
+        // set state of current coroutine to inactive
+        src->state = src->state == Halted ? Halted : Blocked;
 
         // context switch to specified coroutine
@@ -543 +531 @@
         mainThread->curr_cor = &mainThread->self_cor;
 
-        // make sure the current state has been update
-        /* paranoid */ verify(src->state == Active);
+        // set state of new coroutine to active
+        src->state = Active;
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -582 +570 @@
         unlock( ready_queue_lock );
 
-        __wake_one(thrd->curr_cluster, was_empty);
+        if(was_empty) {
+                lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                if(idles) {
+                        wake_fast(idles.head);
+                }
+                unlock    (proc_list_lock);
+        }
+        else if( struct processor * idle = idles.head ) {
+                wake_fast(idle);
+        }
 
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -771 +768 @@
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
-        /* paranoid */ verify( TL_GET( preemption_state.enabled ) );
+        verify( TL_GET( preemption_state.enabled ) );
         disable_interrupts();
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
@@ -803 +800 @@
 
 //=============================================================================================
-// Kernel Idle Sleep
+// Kernel Quiescing
 //=============================================================================================
-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
+static void __halt(processor * this) with( *this ) {
+        // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+
+        with( *cltr ) {
+                lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                remove    (procs, *this);
+                push_front(idles, *this);
+                unlock    (proc_list_lock);
+        }
+
         __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
-        wait( idle );
-
-        // We have woken up
+
+        wait( idleLock );
+
         __cfaabi_dbg_print_safe("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
-        return 0p;
-}
-
-// Wake a thread from the front if there are any
-static bool __wake_one(cluster * this, __attribute__((unused)) bool force) {
-        // if we don't want to force check if we know it's false
-        if( !this->idles.head && !force ) return false;
-
-        // 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
-        post( this->idles.head->idle );
-
-        // Unlock and return true
-        unlock( this->idle_lock );
-        return true;
-}
-
-// Unconditionnaly wake a thread
-static bool __wake_proc(processor * this) {
-        return post( this->idle );
+                lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                remove    (idles, *this);
+                push_front(procs, *this);
+                unlock    (proc_list_lock);
+        }
 }
 
@@ -1010 +967 @@
 
 void doregister( cluster * cltr, processor * proc ) {
-        lock      (cltr->idle_lock __cfaabi_dbg_ctx2);
+        lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
         cltr->nprocessors += 1;
         push_front(cltr->procs, *proc);
-        unlock    (cltr->idle_lock);
+        unlock    (cltr->proc_list_lock);
 }
 
 void unregister( cluster * cltr, processor * proc ) {
-        lock  (cltr->idle_lock __cfaabi_dbg_ctx2);
+        lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
         remove(cltr->procs, *proc );
         cltr->nprocessors -= 1;
-        unlock(cltr->idle_lock);
+        unlock(cltr->proc_list_lock);
 }
 

libcfa/src/concurrency/kernel.hfa

@@ -76 +76 @@
         bool pending_preemption;
 
-        // Idle lock (kernel semaphore)
-        __bin_sem_t idle;
+        // Idle lock
+        __bin_sem_t idleLock;
 
         // Termination
@@ -83 +83 @@
         volatile bool do_terminate;
 
-        // Termination synchronisation (user semaphore)
+        // Termination synchronisation
         semaphore terminated;
 
@@ -126 +126 @@
 
         // List of processors
-        __spinlock_t idle_lock;
+        __spinlock_t proc_list_lock;
         __dllist_t(struct processor) procs;
         __dllist_t(struct processor) idles;

libcfa/src/concurrency/kernel_private.hfa

@@ -42 +42 @@
 void * __create_pthread( pthread_t *, void * (*)(void *), void * );
 
+static inline void wake_fast(processor * this) {
+        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
+        post( this->idleLock );
+}
 
+static inline void wake(processor * this) {
+        disable_interrupts();
+        wake_fast(this);
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
 
 struct event_kernel_t {