Changeset a0dbf20 for libcfa/src/concurrency

Timestamp:

Aug 30, 2022, 6:30:32 PM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

4858a88

Parents:

a8dd247 (diff), 01ba701 (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

Files:

• io/call.cfa.in (modified) (1 diff)
• io/setup.cfa (modified) (3 diffs)
• kernel/fwd.hfa (modified) (1 diff)
• kernel/private.hfa (modified) (1 diff)
• kernel/startup.cfa (modified) (2 diffs)
• preemption.cfa (modified) (2 diffs)

libcfa/src/concurrency/io/call.cfa.in

@@ -202 +202 @@
                 struct io_context$ * ctx = cfa_io_allocate( &sqe, &idx, 1 );
 
+                memset(sqe, 0, sizeof(*sqe));
                 sqe->opcode = IORING_OP_{op};
+                sqe->flags = sflags;
                 sqe->user_data = (uintptr_t)&future;
-                sqe->flags = sflags;
-                sqe->ioprio = 0;
-                sqe->fd = 0;
-                sqe->off = 0;
-                sqe->addr = 0;
-                sqe->len = 0;
-                sqe->fsync_flags = 0;
-                sqe->__pad2[0] = 0;
-                sqe->__pad2[1] = 0;
-                sqe->__pad2[2] = 0;{body}
+                {body}
 
                 asm volatile("": : :"memory");

libcfa/src/concurrency/io/setup.cfa

@@ -228 +228 @@
 
                 #if !defined(CFA_WITH_IO_URING_IDLE)
+                {
                         // Step 4 : eventfd
                         __cfadbg_print_safe(io_core, "Kernel I/O : registering %d for completion with ring %d\n", procfd, fd);
@@ -237 +238 @@
 
                         __cfadbg_print_safe(io_core, "Kernel I/O : registered %d for completion with ring %d\n", procfd, fd);
-                #endif
-
+                }
+                #endif
+
+                // TODO: implement a proper version of this.
+                // I have not found a better maximum that works in general but users should be able to configure it
+                // the same way they configure other I/O options
                 // #if defined(CFA_HAVE_IORING_REGISTER_IOWQ_MAX_WORKERS)
+                // {
                 //      // Step 5 : max worker count
                 //      __cfadbg_print_safe(io_core, "Kernel I/O : lmiting max workers for ring %d\n", fd);
@@ -252 +258 @@
 
                 //      __cfadbg_print_safe(io_core, "Kernel I/O : lmited max workers for ring %d\n", fd);
+                // }
                 // #endif
 

libcfa/src/concurrency/kernel/fwd.hfa

@@ -35 +35 @@
 extern "C" {
         extern "Cforall" {
-                extern __attribute__((aligned(64))) thread_local struct KernelThreadData {
+                extern __attribute__((aligned(64))) _Thread_local struct KernelThreadData {
                         struct thread$          * volatile this_thread;
                         struct processor        * volatile this_processor;

libcfa/src/concurrency/kernel/private.hfa

@@ -88 +88 @@
 #elif defined(CFA_HAVE_LINUX_RSEQ_H)
         extern "Cforall" {
-                extern __attribute__((aligned(64))) thread_local volatile struct rseq __cfaabi_rseq;
+                extern __attribute__((aligned(64))) _Thread_local volatile struct rseq __cfaabi_rseq;
         }
 #else

libcfa/src/concurrency/kernel/startup.cfa

@@ -133 +133 @@
 //-----------------------------------------------------------------------------
 // Global state
-thread_local struct KernelThreadData __cfaabi_tls __attribute__ ((tls_model ( "initial-exec" ))) @= {
+_Thread_local struct KernelThreadData __cfaabi_tls __attribute__ ((tls_model ( "initial-exec" ))) @= {
         NULL,                                                                                           // cannot use 0p
         NULL,
@@ -153 +153 @@
 #elif defined(CFA_HAVE_LINUX_RSEQ_H)
         extern "Cforall" {
-                __attribute__((aligned(64))) thread_local volatile struct rseq __cfaabi_rseq @= {
+                __attribute__((aligned(64))) _Thread_local volatile struct rseq __cfaabi_rseq @= {
                         .cpu_id : RSEQ_CPU_ID_UNINITIALIZED,
                 };

libcfa/src/concurrency/preemption.cfa

@@ -357 +357 @@
                         }
                 }
+        }
+
+        // Check whether or not there is pending preemption
+        // force_yield( __POLL_PREEMPTION ) if appropriate
+        // return true if the thread was in an interruptable state
+        // i.e. on a real processor and not in the kernel
+        // (can return true even if no preemption was pending)
+        bool poll_interrupts() libcfa_public {
+                // Cache the processor now since interrupts can start happening after the atomic store
+                processor   * proc = publicTLS_get( this_processor );
+                if ( ! proc ) return false;
+                if ( ! __preemption_enabled() ) return false;
+
+                with( __cfaabi_tls.preemption_state ){
+                        // Signal the compiler that a fence is needed but only for signal handlers
+                        __atomic_signal_fence(__ATOMIC_RELEASE);
+                        if( proc->pending_preemption ) {
+                                proc->pending_preemption = false;
+                                force_yield( __POLL_PREEMPTION );
+                        }
+                }
+
+                return true;
         }
 }
@@ -643 +666 @@
 // Kernel Signal Handlers
 //=============================================================================================
-__cfaabi_dbg_debug_do( static thread_local void * last_interrupt = 0; )
+__cfaabi_dbg_debug_do( static _Thread_local void * last_interrupt = 0; )
 
 // Context switch signal handler