Changes in libcfa/src/concurrency/io/setup.cfa [bf0263c:19cb0cb]

File:

• libcfa/src/concurrency/io/setup.cfa (modified) (13 diffs)

libcfa/src/concurrency/io/setup.cfa

@@ -26 +26 @@
 
 #if !defined(CFA_HAVE_LINUX_IO_URING_H)
-        void ?{}(io_context_params & this) {}
-
-        void  ?{}($io_context & this, struct cluster & cl) {}
-        void ^?{}($io_context & this) {}
+        void ?{}(io_context_params & this) libcfa_public {}
+
+        void  ?{}(io_context$ & this, struct cluster & cl) {}
+        void ^?{}(io_context$ & this) {}
 
         void __cfa_io_start( processor * proc ) {}
@@ -37 +37 @@
         void __cfa_io_stop ( processor * proc ) {}
 
-        $io_arbiter * create(void) { return 0p; }
-        void destroy($io_arbiter *) {}
+        io_arbiter$ * create(void) { return 0p; }
+        void destroy(io_arbiter$ *) {}
 
 #else
@@ -66 +66 @@
 #pragma GCC diagnostic pop
 
-        void ?{}(io_context_params & this) {
+        void ?{}(io_context_params & this) libcfa_public {
                 this.num_entries = 256;
         }
@@ -105 +105 @@
 
 
-        static void __io_uring_setup ( $io_context & this, const io_context_params & params_in, int procfd );
-        static void __io_uring_teardown( $io_context & this );
-        static void __epoll_register($io_context & ctx);
-        static void __epoll_unregister($io_context & ctx);
-        void __ioarbiter_register( $io_arbiter & mutex, $io_context & ctx );
-        void __ioarbiter_unregister( $io_arbiter & mutex, $io_context & ctx );
-
-        void ?{}($io_context & this, processor * proc, struct cluster & cl) {
+        static void __io_uring_setup ( io_context$ & this, const io_context_params & params_in, int procfd );
+        static void __io_uring_teardown( io_context$ & this );
+        static void __epoll_register(io_context$ & ctx);
+        static void __epoll_unregister(io_context$ & ctx);
+        void __ioarbiter_register( io_arbiter$ & mutex, io_context$ & ctx );
+        void __ioarbiter_unregister( io_arbiter$ & mutex, io_context$ & ctx );
+
+        void ?{}(io_context$ & this, processor * proc, struct cluster & cl) {
                 /* paranoid */ verify( cl.io.arbiter );
                 this.proc = proc;
@@ -122 +122 @@
         }
 
-        void ^?{}($io_context & this) {
+        void ^?{}(io_context$ & this) {
                 __cfadbg_print_safe(io_core, "Kernel I/O : tearing down io_context %u\n", this.fd);
 
@@ -129 +129 @@
         }
 
-        static void __io_uring_setup( $io_context & this, const io_context_params & params_in, int procfd ) {
+        static void __io_uring_setup( io_context$ & this, const io_context_params & params_in, int procfd ) {
                 // Step 1 : call to setup
                 struct io_uring_params params;
@@ -228 +228 @@
 
                 #if !defined(CFA_WITH_IO_URING_IDLE)
+                {
                         // Step 4 : eventfd
-                        // io_uring_register is so f*cking slow on some machine that it
-                        // will never succeed if preemption isn't hard blocked
                         __cfadbg_print_safe(io_core, "Kernel I/O : registering %d for completion with ring %d\n", procfd, fd);
 
@@ -239 +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);
+
+                //      unsigned int maxes[2];
+                //      maxes[0] = 64; // max number of bounded workers (Regular files / block)
+                //      maxes[1] = 64;  // max number of unbounded workers (IOSQE_ASYNC)
+                //      int ret = syscall( __NR_io_uring_register, fd, IORING_REGISTER_IOWQ_MAX_WORKERS, maxes, 2);
+                //      if (ret < 0) {
+                //              abort("KERNEL ERROR: IO_URING MAX WORKER REGISTER - %s\n", strerror(errno));
+                //      }
+
+                //      __cfadbg_print_safe(io_core, "Kernel I/O : lmited max workers for ring %d\n", fd);
+                // }
+                // #endif
 
                 // some paranoid checks
@@ -257 +277 @@
         }
 
-        static void __io_uring_teardown( $io_context & this ) {
+        static void __io_uring_teardown( io_context$ & this ) {
                 // Shutdown the io rings
                 struct __sub_ring_t & sq = this.sq;
@@ -300 +320 @@
 // I/O Context Sleep
 //=============================================================================================
-        // static inline void __epoll_ctl($io_context & ctx, int op, const char * error) {
+        // static inline void __epoll_ctl(io_context$ & ctx, int op, const char * error) {
         //      struct epoll_event ev;
         //      ev.events = EPOLLIN | EPOLLONESHOT;
@@ -310 +330 @@
         // }
 
-        // static void __epoll_register($io_context & ctx) {
+        // static void __epoll_register(io_context$ & ctx) {
         //      __epoll_ctl(ctx, EPOLL_CTL_ADD, "ADD");
         // }
 
-        // static void __epoll_unregister($io_context & ctx) {
+        // static void __epoll_unregister(io_context$ & ctx) {
         //      // Read the current epoch so we know when to stop
         //      size_t curr = __atomic_load_n(&iopoll.epoch, __ATOMIC_SEQ_CST);
@@ -333 +353 @@
         // }
 
-        // void __ioctx_prepare_block($io_context & ctx) {
+        // void __ioctx_prepare_block(io_context$ & ctx) {
         //      __cfadbg_print_safe(io_core, "Kernel I/O - epoll : Re-arming io poller %d (%p)\n", ctx.fd, &ctx);
         //      __epoll_ctl(ctx, EPOLL_CTL_MOD, "REARM");
@@ -342 +362 @@
 // I/O Context Misc Setup
 //=============================================================================================
-        void ?{}( $io_arbiter & this ) {
+        void ?{}( io_arbiter$ & this ) {
                 this.pending.empty = true;
         }
 
-        void ^?{}( $io_arbiter & this ) {}
-
-        $io_arbiter * create(void) {
+        void ^?{}( io_arbiter$ & mutex this ) {}
+
+        io_arbiter$ * create(void) {
                 return new();
         }
-        void destroy($io_arbiter * arbiter) {
+        void destroy(io_arbiter$ * arbiter) {
                 delete(arbiter);
         }