Changeset 8e4aa05 for libcfa/src/concurrency/kernel.cfa

Timestamp:

Mar 4, 2021, 7:40:25 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

77d601f

Parents:

342af53 (diff), a5040fe (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -22 +22 @@
 #include <signal.h>
 #include <unistd.h>
+extern "C" {
+        #include <sys/eventfd.h>
+}
 
 //CFA Includes
@@ -114 +117 @@
 static [unsigned idle, unsigned total, * processor] query( & __cluster_idles idles );
 
+extern void __cfa_io_start( processor * );
+extern void __cfa_io_drain( processor * );
+extern void __cfa_io_flush( processor * );
+extern void __cfa_io_stop ( processor * );
+static inline void __maybe_io_drain( processor * );
+
+extern void __disable_interrupts_hard();
+extern void __enable_interrupts_hard();
 
 //=============================================================================================
@@ -129 +140 @@
         verify(this);
 
+        __cfa_io_start( this );
+
         __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
         #if !defined(__CFA_NO_STATISTICS__)
@@ -140 +153 @@
                 preemption_scope scope = { this };
 
+                #if !defined(__CFA_NO_STATISTICS__)
+                        unsigned long long last_tally = rdtscl();
+                #endif
+
+
                 __cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this);
 
@@ -145 +163 @@
                 MAIN_LOOP:
                 for() {
+                        // Check if there is pending io
+                        __maybe_io_drain( this );
+
                         // Try to get the next thread
                         readyThread = __next_thread( this->cltr );
 
                         if( !readyThread ) {
+                                __cfa_io_flush( this );
                                 readyThread = __next_thread_slow( this->cltr );
                         }
@@ -184 +206 @@
                                 #endif
 
-                                wait( this->idle );
+                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
+
+                                __disable_interrupts_hard();
+                                eventfd_t val;
+                                eventfd_read( this->idle, &val );
+                                __enable_interrupts_hard();
 
                                 #if !defined(__CFA_NO_STATISTICS__)
@@ -201 +228 @@
                         /* paranoid */ verify( readyThread );
 
+                        // Reset io dirty bit
+                        this->io.dirty = false;
+
                         // We found a thread run it
                         __run_thread(this, readyThread);
@@ -206 +236 @@
                         // Are we done?
                         if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
+
+                        #if !defined(__CFA_NO_STATISTICS__)
+                                unsigned long long curr = rdtscl();
+                                if(curr > (last_tally + 500000000)) {
+                                        __tally_stats(this->cltr->stats, __cfaabi_tls.this_stats);
+                                        last_tally = curr;
+                                }
+                        #endif
+
+                        if(this->io.pending && !this->io.dirty) {
+                                __cfa_io_flush( this );
+                        }
                 }
 
@@ -211 +253 @@
         }
 
-        V( this->terminated );
+        __cfa_io_stop( this );
+
+        post( this->terminated );
+
 
         if(this == mainProcessor) {
@@ -234 +279 @@
         /* paranoid */ verifyf( thrd_dst->link.next == 0p, "Expected null got %p", thrd_dst->link.next );
         __builtin_prefetch( thrd_dst->context.SP );
+
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p running thread %p (%s)\n", this, thrd_dst, thrd_dst->self_cor.name);
 
         $coroutine * proc_cor = get_coroutine(this->runner);
@@ -316 +363 @@
         // Just before returning to the processor, set the processor coroutine to active
         proc_cor->state = Active;
+
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p finished running thread %p\n", this, thrd_dst);
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -550 +599 @@
 
         // We found a processor, wake it up
-        post( p->idle );
+        eventfd_t val;
+        val = 1;
+        eventfd_write( p->idle, val );
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -568 +619 @@
         disable_interrupts();
                 /* paranoid */ verify( ! __preemption_enabled() );
-                post( this->idle );
+                eventfd_t val;
+                val = 1;
+                eventfd_write( this->idle, val );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
@@ -611 +664 @@
 // Unexpected Terminating logic
 //=============================================================================================
-static __spinlock_t kernel_abort_lock;
-static bool kernel_abort_called = false;
-
-void * kernel_abort(void) __attribute__ ((__nothrow__)) {
-        // abort cannot be recursively entered by the same or different processors because all signal handlers return when
-        // the globalAbort flag is true.
-        lock( kernel_abort_lock __cfaabi_dbg_ctx2 );
-
-        // disable interrupts, it no longer makes sense to try to interrupt this processor
-        disable_interrupts();
-
-        // first task to abort ?
-        if ( kernel_abort_called ) {                    // not first task to abort ?
-                unlock( kernel_abort_lock );
-
-                sigset_t mask;
-                sigemptyset( &mask );
-                sigaddset( &mask, SIGALRM );            // block SIGALRM signals
-                sigaddset( &mask, SIGUSR1 );            // block SIGALRM signals
-                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
-                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
-        }
-        else {
-                kernel_abort_called = true;
-                unlock( kernel_abort_lock );
-        }
-
-        return __cfaabi_tls.this_thread;
-}
-
-void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
-        $thread * thrd = ( $thread * ) kernel_data;
+void __kernel_abort_msg( char * abort_text, int abort_text_size ) {
+        $thread * thrd = __cfaabi_tls.this_thread;
 
         if(thrd) {
@@ -662 +685 @@
 }
 
-int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
-        return get_coroutine(kernelTLS().this_thread) == get_coroutine(mainThread) ? 4 : 2;
+int __kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
+        return get_coroutine(__cfaabi_tls.this_thread) == get_coroutine(mainThread) ? 4 : 2;
 }
 
@@ -681 +704 @@
 // Kernel Utilities
 //=============================================================================================
-//-----------------------------------------------------------------------------
-// Locks
-void  ?{}( semaphore & this, int count = 1 ) {
-        (this.lock){};
-        this.count = count;
-        (this.waiting){};
-}
-void ^?{}(semaphore & this) {}
-
-bool P(semaphore & this) with( this ){
-        lock( lock __cfaabi_dbg_ctx2 );
-        count -= 1;
-        if ( count < 0 ) {
-                // queue current task
-                append( waiting, active_thread() );
-
-                // atomically release spin lock and block
-                unlock( lock );
-                park();
-                return true;
-        }
-        else {
-            unlock( lock );
-            return false;
-        }
-}
-
-bool V(semaphore & this) with( this ) {
-        $thread * thrd = 0p;
-        lock( lock __cfaabi_dbg_ctx2 );
-        count += 1;
-        if ( count <= 0 ) {
-                // remove task at head of waiting list
-                thrd = pop_head( waiting );
-        }
-
-        unlock( lock );
-
-        // make new owner
-        unpark( thrd );
-
-        return thrd != 0p;
-}
-
-bool V(semaphore & this, unsigned diff) with( this ) {
-        $thread * thrd = 0p;
-        lock( lock __cfaabi_dbg_ctx2 );
-        int release = max(-count, (int)diff);
-        count += diff;
-        for(release) {
-                unpark( pop_head( waiting ) );
-        }
-
-        unlock( lock );
-
-        return thrd != 0p;
+#if defined(CFA_HAVE_LINUX_IO_URING_H)
+#include "io/types.hfa"
+#endif
+
+static inline void __maybe_io_drain( processor * proc ) {
+        #if defined(CFA_HAVE_LINUX_IO_URING_H)
+                __cfadbg_print_safe(runtime_core, "Kernel : core %p checking io for ring %d\n", proc, proc->io.ctx->fd);
+
+                // Check if we should drain the queue
+                $io_context * ctx = proc->io.ctx;
+                unsigned head = *ctx->cq.head;
+                unsigned tail = *ctx->cq.tail;
+                if(head != tail) __cfa_io_drain( proc );
+        #endif
 }