Changeset c7b2215 for libcfa/src

Timestamp:

Nov 29, 2021, 12:50:31 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

a1f3d93

Parents:

ddd2ec9

Message:

Fix implementation of io_uring_enter instead of eventfds.

Location:

libcfa/src/concurrency

Files:

• io.cfa (modified) (4 diffs)
• io/setup.cfa (modified) (1 diff)
• kernel.cfa (modified) (10 diffs)

libcfa/src/concurrency/io.cfa

@@ -133 +133 @@
         }
 
-        bool __cfa_io_flush( processor * proc, bool wait ) {
+        bool __cfa_io_flush( processor * proc, int min_comp ) {
                 /* paranoid */ verify( ! __preemption_enabled() );
                 /* paranoid */ verify( proc );
@@ -144 +144 @@
 
                 __STATS__( true, io.calls.flush++; )
-                int ret = syscall( __NR_io_uring_enter, ctx.fd, ctx.sq.to_submit, wait ? 1 : 0, 0, (sigset_t *)0p, _NSIG / 8);
+                int ret = syscall( __NR_io_uring_enter, ctx.fd, ctx.sq.to_submit, min_comp, min_comp > 0 ? IORING_ENTER_GETEVENTS : 0, (sigset_t *)0p, _NSIG / 8);
                 if( ret < 0 ) {
                         switch((int)errno) {
@@ -302 +302 @@
                 ctx->proc->io.dirty   = true;
                 if(sq.to_submit > 30 || !lazy) {
-                        __cfa_io_flush( ctx->proc, false );
+                        __cfa_io_flush( ctx->proc, 0 );
                 }
         }
@@ -521 +521 @@
                 sqe->flags = 0;
                 sqe->ioprio = 0;
-                sqe->fd = 0;
+                sqe->fd = fd;
                 sqe->off = 0;
                 sqe->fsync_flags = 0;

libcfa/src/concurrency/io/setup.cfa

@@ -32 +32 @@
 
         void __cfa_io_start( processor * proc ) {}
-        bool __cfa_io_flush( processor * proc, bool ) {}
+        bool __cfa_io_flush( processor * proc, int ) {}
         void __cfa_io_stop ( processor * proc ) {}
 

libcfa/src/concurrency/kernel.cfa

@@ -125 +125 @@
 static void __wake_one(cluster * cltr);
 
-static void idle_sleep(processor * proc, io_future_t & future, char buf[]);
+static void idle_sleep(processor * proc, io_future_t & future, eventfd_t & val);
 static bool mark_idle (__cluster_proc_list & idles, processor & proc);
 static void mark_awake(__cluster_proc_list & idles, processor & proc);
@@ -131 +131 @@
 extern void __cfa_io_start( processor * );
 extern bool __cfa_io_drain( processor * );
-extern bool __cfa_io_flush( processor *, bool wait );
+extern bool __cfa_io_flush( processor *, int min_comp );
 extern void __cfa_io_stop ( processor * );
 static inline bool __maybe_io_drain( processor * );
@@ -169 +169 @@
         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
-        char buf[sizeof(uint64_t)];
+        eventfd_t idle_val;
 
         __cfa_io_start( this );
@@ -204 +204 @@
 
                         if( !readyThread ) {
-                                __cfa_io_flush( this, false );
+                                __cfa_io_flush( this, 0 );
 
                                 readyThread = __next_thread_slow( this->cltr );
@@ -235 +235 @@
                                 }
 
-                                idle_sleep( this, future, buf );
+                                idle_sleep( this, future, idle_val );
 
                                 // We were woken up, remove self from idle
@@ -256 +256 @@
 
                         if(this->io.pending && !this->io.dirty) {
-                                __cfa_io_flush( this, false );
+                                __cfa_io_flush( this, 0 );
                         }
 
@@ -272 +272 @@
 
                                 // If we can't find a thread, might as well flush any outstanding I/O
-                                if(this->io.pending) { __cfa_io_flush( this, false ); }
+                                if(this->io.pending) { __cfa_io_flush( this, 0 ); }
 
                                 // Spin a little on I/O, just in case
@@ -367 +367 @@
 
                         if(this->io.pending && !this->io.dirty) {
-                                __cfa_io_flush( this, false );
+                                __cfa_io_flush( this, 0 );
                         }
 
@@ -777 +777 @@
 }
 
-static void idle_sleep(processor * this, io_future_t & future, char buf[]) {
+static void idle_sleep(processor * this, io_future_t & future, eventfd_t & val) {
         #if !defined(IO_URING_IDLE) || !defined(CFA_HAVE_LINUX_IO_URING_H)
                 #if !defined(__CFA_NO_STATISTICS__)
@@ -819 +819 @@
                         reset(future);
 
-                        __kernel_read(this, future, buf, this->idle_fd );
-                }
-
-                __cfa_io_flush( this, true );
+                        __kernel_read(this, future, (char *)&val, this->idle_fd );
+                }
+
+                __cfa_io_flush( this, 1 );
         #endif
 }