Changeset 4479890 for libcfa/src/concurrency/io.cfa

Timestamp:

Mar 22, 2022, 4:59:53 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

1a567d0

Parents:

0521a1a

Message:

Implemented helping for io drain based on timestamps.

File:

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

libcfa/src/concurrency/io.cfa

@@ -94 +94 @@
         extern void __kernel_unpark( thread$ * thrd, unpark_hint );
 
-        bool __cfa_io_drain( $io_context * ctx, cluster * cltr ) {
+        static bool __cfa_do_drain( $io_context * ctx, cluster * cltr ) {
                 /* paranoid */ verify( ! __preemption_enabled() );
                 /* paranoid */ verify( ready_schedule_islocked() );
@@ -142 +142 @@
 
                 return true;
+        }
+
+        bool __cfa_io_drain( processor * proc ) {
+                bool local = false;
+                bool remote = false;
+
+                cluster * const cltr = proc->cltr;
+                $io_context * const ctx = proc->io.ctx;
+                /* paranoid */ verify( cltr );
+                /* paranoid */ verify( ctx );
+
+                with(cltr->sched) {
+                        const size_t ctxs_count = io.count;
+
+                        /* paranoid */ verify( ready_schedule_islocked() );
+                        /* paranoid */ verify( ! __preemption_enabled() );
+                        /* paranoid */ verify( active_processor() == proc );
+                        /* paranoid */ verify( __shard_factor.io > 0 );
+                        /* paranoid */ verify( ctxs_count > 0 );
+                        /* paranoid */ verify( ctx->cq.id < ctxs_count );
+
+                        const unsigned this_cache = cache_id(cltr, ctx->cq.id / __shard_factor.io);
+                        const unsigned long long ctsc = rdtscl();
+
+                        if(proc->io.target == MAX) {
+                                uint64_t chaos = __tls_rand();
+                                unsigned ext = chaos & 0xff;
+                                unsigned other  = (chaos >> 8) % (ctxs_count);
+
+                                if(ext < 3 || __atomic_load_n(&caches[other / __shard_factor.io].id, __ATOMIC_RELAXED) == this_cache) {
+                                        proc->io.target = other;
+                                }
+                        }
+                        else {
+                                const unsigned target = proc->io.target;
+                                /* paranoid */ verify( io.tscs[target].tv != MAX );
+                                if(target < ctxs_count) {
+                                        const unsigned long long cutoff = calc_cutoff(ctsc, ctx->cq.id, ctxs_count, io.data, io.tscs, __shard_factor.io);
+                                        const unsigned long long age = moving_average(ctsc, io.tscs[target].tv, io.tscs[target].ma);
+                                        // __cfadbg_print_safe(ready_queue, "Kernel : Help attempt on %u from %u, age %'llu vs cutoff %'llu, %s\n", target, this, age, cutoff, age > cutoff ? "yes" : "no");
+                                        if(age > cutoff) {
+                                                remote = __cfa_do_drain( io.data[target], cltr );
+                                        }
+                                }
+                                proc->io.target = MAX;
+                        }
+                }
+
+
+                // Drain the local queue
+                local = __cfa_do_drain( proc->io.ctx, cltr );
+
+                /* paranoid */ verify( ready_schedule_islocked() );
+                /* paranoid */ verify( ! __preemption_enabled() );
+                /* paranoid */ verify( active_processor() == proc );
+                return local || remote;
         }
 
@@ -189 +245 @@
 
                 ready_schedule_lock();
-                bool ret = __cfa_io_drain( &ctx, cltr );
+                bool ret = __cfa_io_drain( proc );
                 ready_schedule_unlock();
                 return ret;