Changeset 78da4ab for libcfa/src/concurrency/io/types.hfa

Timestamp:

Feb 19, 2021, 1:47:09 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

4f762d3

Parents:

b44959f

Message:

New implementation of io based on instance burrowing.
Trying to avoid the unbounded growth of the previous flat combining approach.

File:

• libcfa/src/concurrency/io/types.hfa (modified) (6 diffs)

libcfa/src/concurrency/io/types.hfa

@@ -25 +25 @@
 
 #if defined(CFA_HAVE_LINUX_IO_URING_H)
-        #define LEADER_LOCK
-        struct __leaderlock_t {
-                struct $thread * volatile value;        // ($thread) next_leader | (bool:1) is_locked
-        };
+        #include "bits/sequence.hfa"
+        #include "monitor.hfa"
 
-        static inline void ?{}( __leaderlock_t & this ) { this.value = 0p; }
+        struct processor;
+        monitor $io_arbiter;
 
         //-----------------------------------------------------------------------
         // Ring Data structure
-      struct __submition_data {
-                // Head and tail of the ring (associated with array)
-                volatile __u32 * head;
-                volatile __u32 * tail;
-                volatile __u32 prev_head;
+      struct __sub_ring_t {
+                struct {
+                        // Head and tail of the ring (associated with array)
+                        volatile __u32 * head;   // one passed last index consumed by the kernel
+                        volatile __u32 * tail;   // one passed last index visible to the kernel
+                        volatile __u32 ready;    // one passed last index added to array ()
+                        volatile __u32 released; // one passed last index released back to the free list
 
-                // The actual kernel ring which uses head/tail
-                // indexes into the sqes arrays
-                __u32 * array;
+                        // The actual kernel ring which uses head/tail
+                        // indexes into the sqes arrays
+                        __u32 * array;
+                } kring;
+
+                struct {
+                        volatile __u32 head;
+                        volatile __u32 tail;
+                        // The ring which contains free allocations
+                        // indexes into the sqes arrays
+                        __u32 * array;
+                } free_ring;
+
+                // number of sqes to submit on next system call.
+                __u32 to_submit;
 
                 // number of entries and mask to go with it
@@ -48 +61 @@
                 const __u32 * mask;
 
-                // Submission flags (Not sure what for)
+                // Submission flags, currently only IORING_SETUP_SQPOLL
                 __u32 * flags;
 
-                // number of sqes not submitted (whatever that means)
+                // number of sqes not submitted
+                // From documentation : [dropped] is incremented for each invalid submission queue entry encountered in the ring buffer.
                 __u32 * dropped;
 
-                // Like head/tail but not seen by the kernel
-                volatile __u32 * ready;
-                __u32 ready_cnt;
-                __u32 prev_ready;
-
-                #if defined(LEADER_LOCK)
-                        __leaderlock_t submit_lock;
-                #else
-                        __spinlock_t submit_lock;
-                #endif
-                __spinlock_t  release_lock;
-
                 // A buffer of sqes (not the actual ring)
-                volatile struct io_uring_sqe * sqes;
+                struct io_uring_sqe * sqes;
 
                 // The location and size of the mmaped area
@@ -74 +76 @@
         };
 
-        struct __completion_data {
+        struct __cmp_ring_t {
                 // Head and tail of the ring
                 volatile __u32 * head;
@@ -83 +85 @@
                 const __u32 * num;
 
-                // number of cqes not submitted (whatever that means)
+                // I don't know what this value is for
                 __u32 * overflow;
 
@@ -94 +96 @@
         };
 
-        struct __io_data {
-                struct __submition_data submit_q;
-                struct __completion_data completion_q;
+        struct __attribute__((aligned(128))) $io_context {
+                inline Seqable;
+
+                volatile bool revoked;
+                processor * proc;
+
+                $io_arbiter * arbiter;
+
+                struct {
+                        volatile bool empty;
+                        condition blocked;
+                } ext_sq;
+
+                struct __sub_ring_t sq;
+                struct __cmp_ring_t cq;
                 __u32 ring_flags;
                 int fd;
                 int efd;
-                bool eager_submits:1;
-                bool poller_submits:1;
+
+                single_sem sem;
+                $thread self;
+        };
+
+        void main( $io_context & this );
+        static inline $thread  * get_thread ( $io_context & this ) __attribute__((const)) { return &this.self; }
+        static inline $monitor * get_monitor( $io_context & this ) __attribute__((const)) { return &this.self.self_mon; }
+        static inline $io_context *& Back( $io_context * n ) { return ($io_context *)Back( (Seqable *)n ); }
+        static inline $io_context *& Next( $io_context * n ) { return ($io_context *)Next( (Colable *)n ); }
+        void ^?{}( $io_context & mutex this );
+
+        monitor __attribute__((aligned(128))) $io_arbiter {
+                struct {
+                        condition blocked;
+                        $io_context * ctx;
+                        volatile bool flag;
+                } pending;
+
+                Sequence($io_context) assigned;
+
+                Sequence($io_context) available;
         };
 
@@ -133 +167 @@
         #endif
 
-        struct $io_ctx_thread;
-        void __ioctx_register($io_ctx_thread & ctx);
-        void __ioctx_unregister($io_ctx_thread & ctx);
-        void __ioctx_prepare_block($io_ctx_thread & ctx);
-        void __sqe_clean( volatile struct io_uring_sqe * sqe );
+        void __ioctx_prepare_block($io_context & ctx);
 #endif