Changes in / [0351e9f:a1f3d93]

Location:

libcfa/src

Files:

• concurrency/io.cfa (modified) (4 diffs)
• concurrency/io/setup.cfa (modified) (1 diff)
• concurrency/kernel.cfa (modified) (10 diffs)
• device/cpu.cfa (modified) (2 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 );
                 }
         }
@@ -522 +522 @@
                         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 * );
@@ -171 +171 @@
         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 );
@@ -206 +206 @@
 
                         if( !readyThread ) {
-                                __cfa_io_flush( this, false );
+                                __cfa_io_flush( this, 0 );
 
                                 readyThread = __next_thread_slow( this->cltr );
@@ -237 +237 @@
                                 }
 
-                                idle_sleep( this, future, buf );
+                                idle_sleep( this, future, idle_val );
 
                                 // We were woken up, remove self from idle
@@ -258 +258 @@
 
                         if(this->io.pending && !this->io.dirty) {
-                                __cfa_io_flush( this, false );
+                                __cfa_io_flush( this, 0 );
                         }
 
@@ -274 +274 @@
 
                                 // 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
@@ -369 +369 @@
 
                         if(this->io.pending && !this->io.dirty) {
-                                __cfa_io_flush( this, false );
+                                __cfa_io_flush( this, 0 );
                         }
 
@@ -779 +779 @@
 }
 
-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__)
@@ -821 +821 @@
                         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
 }

libcfa/src/device/cpu.cfa

@@ -159 +159 @@
 
         const char * _;
-        int cnt = read_width(buff, r - 1, &_);
-        /* paranoid */ verify(cnt == count_prefix_dirs("/sys/devices/system/cpu", "cpu"));
-        return cnt;
+        return read_width(buff, r - 1, &_);;
 }
 
@@ -238 +236 @@
 {
         raw_cache_instance ** raw = alloc(cpus);
+
+        // TODO: this loop is broken, it only works if the present cpu start at 0 and are contiguous which is not guaranteed.
         for(i; cpus) {
                 raw[i] = alloc(cache_levels);