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

Timestamp:

Mar 21, 2022, 1:44:06 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

a76202d

Parents:

ef3c383 (diff), dbe2533 (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) (17 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -19 +19 @@
 // #define __CFA_DEBUG_PRINT_RUNTIME_CORE__
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
+
 //C Includes
 #include <errno.h>
@@ -25 +28 @@
 #include <signal.h>
 #include <unistd.h>
+
 extern "C" {
         #include <sys/eventfd.h>
@@ -31 +35 @@
 
 //CFA Includes
-#include "kernel_private.hfa"
+#include "kernel/private.hfa"
 #include "preemption.hfa"
 #include "strstream.hfa"
@@ -40 +44 @@
 #define __CFA_INVOKE_PRIVATE__
 #include "invoke.h"
+#pragma GCC diagnostic pop
 
 #if !defined(__CFA_NO_STATISTICS__)
@@ -131 +136 @@
 static void mark_awake(__cluster_proc_list & idles, processor & proc);
 
-extern void __cfa_io_start( processor * );
-extern bool __cfa_io_drain( processor * );
+extern bool __cfa_io_drain( $io_context * );
 extern bool __cfa_io_flush( processor *, int min_comp );
-extern void __cfa_io_stop ( processor * );
 static inline bool __maybe_io_drain( processor * );
 
@@ -159 +162 @@
         verify(this);
 
-        io_future_t future; // used for idle sleep when io_uring is present
-        future.self.ptr = 1p;  // mark it as already fulfilled so we know if there is a pending request or not
-        eventfd_t idle_val;
-        iovec idle_iovec = { &idle_val, sizeof(idle_val) };
-
-        __cfa_io_start( this );
+        /* paranoid */ verify( this->idle_wctx.ftr   != 0p );
+        /* paranoid */ verify( this->idle_wctx.rdbuf != 0p );
+
+        // used for idle sleep when io_uring is present
+        // mark it as already fulfilled so we know if there is a pending request or not
+        this->idle_wctx.ftr->self.ptr = 1p;
+        iovec idle_iovec = { this->idle_wctx.rdbuf, sizeof(eventfd_t) };
 
         __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
@@ -231 +235 @@
                                 }
 
-                                idle_sleep( this, future, idle_iovec );
+                                idle_sleep( this, *this->idle_wctx.ftr, idle_iovec );
 
                                 // We were woken up, remove self from idle
@@ -251 +255 @@
                         if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
 
-                        if(this->io.pending && !this->io.dirty) {
+                        if(__atomic_load_n(&this->io.pending, __ATOMIC_RELAXED) && !__atomic_load_n(&this->io.dirty, __ATOMIC_RELAXED)) {
                                 __IO_STATS__(true, io.flush.dirty++; )
                                 __cfa_io_flush( this, 0 );
@@ -259 +263 @@
                 __cfadbg_print_safe(runtime_core, "Kernel : core %p stopping\n", this);
         }
-
-        for(int i = 0; !available(future); i++) {
-                if(i > 1000) __cfaabi_dbg_write( "ERROR: kernel has bin spinning on a flush after exit loop.\n", 60);
-                __cfa_io_flush( this, 1 );
-        }
-
-        __cfa_io_stop( this );
 
         post( this->terminated );
@@ -634 +631 @@
 
         int fd = 1;
-        if( __atomic_load_n(&fdp->fd, __ATOMIC_SEQ_CST) != 1 ) {
-                fd = __atomic_exchange_n(&fdp->fd, 1, __ATOMIC_RELAXED);
+        if( __atomic_load_n(&fdp->sem, __ATOMIC_SEQ_CST) != 1 ) {
+                fd = __atomic_exchange_n(&fdp->sem, 1, __ATOMIC_RELAXED);
         }
 
@@ -677 +674 @@
         __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
 
-        this->idle_wctx.fd = 1;
+        this->idle_wctx.sem = 1;
 
         eventfd_t val;
         val = 1;
-        eventfd_write( this->idle_fd, val );
+        eventfd_write( this->idle_wctx.evfd, val );
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -689 +686 @@
         // Tell everyone we are ready to go do sleep
         for() {
-                int expected = this->idle_wctx.fd;
+                int expected = this->idle_wctx.sem;
 
                 // Someone already told us to wake-up! No time for a nap.
@@ -695 +692 @@
 
                 // Try to mark that we are going to sleep
-                if(__atomic_compare_exchange_n(&this->idle_wctx.fd, &expected, this->idle_fd, false,  __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ) {
+                if(__atomic_compare_exchange_n(&this->idle_wctx.sem, &expected, this->idle_wctx.evfd, false,  __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ) {
                         // Every one agreed, taking a nap
                         break;
@@ -713 +710 @@
                 {
                         eventfd_t val;
-                        ssize_t ret = read( this->idle_fd, &val, sizeof(val) );
+                        ssize_t ret = read( this->idle_wctx.evfd, &val, sizeof(val) );
                         if(ret < 0) {
                                 switch((int)errno) {
@@ -740 +737 @@
                         reset(future);
 
-                        __kernel_read(this, future, iov, this->idle_fd );
+                        __kernel_read(this, future, iov, this->idle_wctx.evfd );
                 }
 
@@ -750 +747 @@
         __STATS__(true, ready.sleep.halts++; )
 
-        proc.idle_wctx.fd = 0;
+        proc.idle_wctx.sem = 0;
 
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -842 +839 @@
                 if(head == tail) return false;
                 ready_schedule_lock();
-                ret = __cfa_io_drain( proc );
+                ret = __cfa_io_drain( ctx );
                 ready_schedule_unlock();
         #endif