Changeset d672350 for libcfa/src/concurrency/kernel

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

Location:

libcfa/src/concurrency/kernel

Files:

• cluster.cfa (added)
• cluster.hfa (added)
• fwd.hfa (modified) (1 diff)
• private.hfa (moved) (moved from libcfa/src/concurrency/kernel_private.hfa ) (5 diffs)
• startup.cfa (modified) (13 diffs)

libcfa/src/concurrency/kernel/fwd.hfa

@@ -347 +347 @@
                                         struct oneshot * want = expected == 0p ? 1p : 2p;
                                         if(__atomic_compare_exchange_n(&this.ptr, &expected, want, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                                if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return 0p; }
+                                                if( expected == 0p ) { return 0p; }
                                                 thread$ * ret = post( *expected, do_unpark );
                                                 __atomic_store_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);

libcfa/src/concurrency/kernel/private.hfa

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// kernel_private.hfa --
+// kernel/private.hfa --
 //
 // Author           : Thierry Delisle
@@ -17 +17 @@
 
 #if !defined(__cforall_thread__)
-        #error kernel_private.hfa should only be included in libcfathread source
+        #error kernel/private.hfa should only be included in libcfathread source
 #endif
 
@@ -33 +33 @@
 #else
         #ifndef _GNU_SOURCE
-        #error kernel_private requires gnu_source
+        #error kernel/private requires gnu_source
         #endif
         #include <sched.h>
@@ -59 +59 @@
 
 extern bool __preemption_enabled();
+
+enum {
+        PREEMPT_NORMAL    = 0,
+        PREEMPT_TERMINATE = 1,
+        PREEMPT_IO = 2,
+};
 
 static inline void __disable_interrupts_checked() {
@@ -359 +365 @@
 void ready_queue_shrink(struct cluster * cltr);
 
+//-----------------------------------------------------------------------
+// Decrease the width of the ready queue (number of lanes) by 4
+void ready_queue_close(struct cluster * cltr);
 
 // Local Variables: //

libcfa/src/concurrency/kernel/startup.cfa

@@ -18 +18 @@
 
 // C Includes
-#include <errno.h>                                                                              // errno
+#include <errno.h>                                      // errno
 #include <signal.h>
-#include <string.h>                                                                             // strerror
-#include <unistd.h>                                                                             // sysconf
+#include <string.h>                                     // strerror
+#include <unistd.h>                                     // sysconf
 
 extern "C" {
-        #include <limits.h>                                                                     // PTHREAD_STACK_MIN
-        #include <unistd.h>                                                                     // syscall
-        #include <sys/eventfd.h>                                                        // eventfd
-        #include <sys/mman.h>                                                           // mprotect
-        #include <sys/resource.h>                                                       // getrlimit
+        #include <limits.h>                             // PTHREAD_STACK_MIN
+        #include <unistd.h>                             // syscall
+        #include <sys/eventfd.h>                        // eventfd
+        #include <sys/mman.h>                           // mprotect
+        #include <sys/resource.h>                       // getrlimit
 }
 
 // CFA Includes
-#include "kernel_private.hfa"
-#include "startup.hfa"                                                                  // STARTUP_PRIORITY_XXX
+#include "kernel/private.hfa"
+#include "iofwd.hfa"
+#include "startup.hfa"                                  // STARTUP_PRIORITY_XXX
 #include "limits.hfa"
 #include "math.hfa"
@@ -97 +98 @@
 extern void __kernel_alarm_startup(void);
 extern void __kernel_alarm_shutdown(void);
+extern void __cfa_io_start( processor * );
+extern void __cfa_io_stop ( processor * );
 
 //-----------------------------------------------------------------------------
@@ -111 +114 @@
 KERNEL_STORAGE(__stack_t,            mainThreadCtx);
 KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock);
+KERNEL_STORAGE(eventfd_t,            mainIdleEventFd);
+KERNEL_STORAGE(io_future_t,          mainIdleFuture);
 #if !defined(__CFA_NO_STATISTICS__)
 KERNEL_STORAGE(__stats_t, mainProcStats);
@@ -224 +229 @@
         (*mainProcessor){};
 
+        mainProcessor->idle_wctx.rdbuf = &storage_mainIdleEventFd;
+        mainProcessor->idle_wctx.ftr   = (io_future_t*)&storage_mainIdleFuture;
+        /* paranoid */ verify( sizeof(storage_mainIdleEventFd) == sizeof(eventfd_t) );
+
         register_tls( mainProcessor );
+        __cfa_io_start( mainProcessor );
 
         // Start by initializing the main thread
@@ -304 +314 @@
         mainProcessor->local_data = 0p;
 
+        __cfa_io_stop( mainProcessor );
         unregister_tls( mainProcessor );
 
@@ -355 +366 @@
         register_tls( proc );
 
+        __cfa_io_start( proc );
+
+        // used for idle sleep when io_uring is present
+        io_future_t future;
+        eventfd_t idle_buf;
+        proc->idle_wctx.ftr = &future;
+        proc->idle_wctx.rdbuf = &idle_buf;
+
+
         // 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
@@ -381 +401 @@
         // 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);
+
+        __cfa_io_stop( proc );
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -515 +537 @@
         this.rdq.its = 0;
         this.rdq.itr = 0;
-        this.rdq.id  = MAX;
+        this.rdq.id  = 0;
         this.rdq.target = MAX;
         this.rdq.last = MAX;
@@ -532 +554 @@
         this.local_data = 0p;
 
-        this.idle_fd = eventfd(0, 0);
-        if (idle_fd < 0) {
+        idle_wctx.evfd = eventfd(0, 0);
+        if (idle_wctx.evfd < 0) {
                 abort("KERNEL ERROR: PROCESSOR EVENTFD - %s\n", strerror(errno));
         }
 
-        this.idle_wctx.fd = 0;
+        idle_wctx.sem = 0;
 
         // I'm assuming these two are reserved for standard input and output
         // so I'm using them as sentinels with idle_wctx.
-        /* paranoid */ verify( this.idle_fd != 0 );
-        /* paranoid */ verify( this.idle_fd != 1 );
+        /* paranoid */ verify( idle_wctx.evfd != 0 );
+        /* paranoid */ verify( idle_wctx.evfd != 1 );
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -554 +576 @@
 // Not a ctor, it just preps the destruction but should not destroy members
 static void deinit(processor & this) {
-        close(this.idle_fd);
+        close(this.idle_wctx.evfd);
 }
 
@@ -605 +627 @@
         this.name = name;
         this.preemption_rate = preemption_rate;
-        ready_queue{};
+        this.sched.readyQ.data = 0p;
+        this.sched.readyQ.tscs = 0p;
+        this.sched.readyQ.count = 0;
+        this.sched.io.tscs = 0p;
+        this.sched.caches = 0p;
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -644 +670 @@
         // Unlock the RWlock
         ready_mutate_unlock( last_size );
+
+        ready_queue_close( &this );
+        /* paranoid */ verify( this.sched.readyQ.data == 0p );
+        /* paranoid */ verify( this.sched.readyQ.tscs == 0p );
+        /* paranoid */ verify( this.sched.readyQ.count == 0 );
+        /* paranoid */ verify( this.sched.io.tscs == 0p );
+        /* paranoid */ verify( this.sched.caches == 0p );
+
         enable_interrupts( false ); // Don't poll, could be in main cluster
+
 
         #if !defined(__CFA_NO_STATISTICS__)
@@ -736 +771 @@
         check( pthread_attr_init( &attr ), "pthread_attr_init" ); // initialize attribute
 
-        size_t stacksize = DEFAULT_STACK_SIZE;
+        size_t stacksize = max( PTHREAD_STACK_MIN, DEFAULT_STACK_SIZE );
 
         void * stack;