Changeset 6b33e89 for libcfa/src/concurrency/io.cfa

Timestamp:

Apr 25, 2025, 7:39:09 AM (5 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

65bd3c2

Parents:

b195498

Message:

change backquote call to regular call

File:

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

libcfa/src/concurrency/io.cfa

@@ -95 +95 @@
         static inline void __post(oneshot & this, bool kernel, unpark_hint hint) {
                 thread$ * t = post( this, false );
-                if(kernel) __kernel_unpark( t, hint );
+                if (kernel) __kernel_unpark( t, hint );
                 else unpark( t, hint );
         }
@@ -108 +108 @@
                         // do the system call in a loop, repeat on interrupts
                         ret = syscall( __NR_io_uring_enter, ctx.fd, ctx.sq.to_submit, min_comp, flags, (sigset_t *)0p, _NSIG / 8);
-                        if( ret < 0 ) {
+                        if ( ret < 0 ) {
                                 switch((int)errno) {
                                 case EINTR:
@@ -154 +154 @@
                         const __u32 tail = *ctx->cq.tail;
 
-                        if(head == tail) return false;
+                        if (head == tail) return false;
                 }
 
                 // try a simple spinlock acquire, it's likely there are completions to drain
-                if(!__atomic_try_acquire(&ctx->cq.try_lock)) {
+                if ( ! __atomic_try_acquire(&ctx->cq.try_lock)) {
                         // some other processor already has it
                         __STATS__( false, io.calls.locked++; )
@@ -214 +214 @@
 
                         // we finished draining the completions... unless the ring buffer was full and there are more secret completions in the kernel.
-                        if(likely(count < num)) break;
+                        if (likely(count < num)) break;
 
                         // the ring buffer was full, there could be more stuff in the kernel.
@@ -243 +243 @@
 
                 // if submitting must be submitted, do the system call
-                if(ctx.sq.to_submit != 0) {
+                if (ctx.sq.to_submit != 0) {
                         ioring_syscsll(ctx, 0, 0);
                 }
@@ -278 +278 @@
                         // only help once every other time
                         // pick a target when not helping
-                        if(proc->io.target == UINT_MAX) {
+                        if (proc->io.target == UINT_MAX) {
                                 uint64_t chaos = __tls_rand();
                                 // choose who to help and whether to accept helping far processors 
@@ -285 +285 @@
 
                                 // if the processor is on the same cache line or is lucky ( 3 out of 256 odds ) help it
-                                if(ext < 3 || __atomic_load_n(&caches[other / __shard_factor.io].id, __ATOMIC_RELAXED) == this_cache) {
+                                if (ext < 3 || __atomic_load_n(&caches[other / __shard_factor.io].id, __ATOMIC_RELAXED) == this_cache) {
                                         proc->io.target = other;
                                 }
@@ -294 +294 @@
                                 /* paranoid */ verify( io.tscs[target].t.tv != ULLONG_MAX );
                                 // make sure the target hasn't stopped existing since last time
-                                HELP: if(target < ctxs_count) {
+                                HELP: if (target < ctxs_count) {
                                         // calculate it's age and how young it could be before we give up on helping
                                         const __readyQ_avg_t cutoff = calc_cutoff(ctsc, ctx->cq.id, ctxs_count, io.data, io.tscs, __shard_factor.io, false);
@@ -300 +300 @@
                                         __cfadbg_print_safe(io, "Kernel I/O: Help attempt on %u from %u, age %'llu vs cutoff %'llu, %s\n", target, ctx->cq.id, age, cutoff, age > cutoff ? "yes" : "no");
                                         // is the target older than the cutoff, recall 0 is oldest and bigger ints are younger
-                                        if(age <= cutoff) break HELP;
+                                        if (age <= cutoff) break HELP;
 
                                         // attempt to help the submission side
@@ -306 +306 @@
 
                                         // attempt to help the completion side
-                                        if(!try_acquire(io.data[target])) break HELP; // already acquire no help needed
+                                        if ( ! try_acquire(io.data[target])) break HELP; // already acquire no help needed
 
                                         // actually help
-                                        if(!__cfa_do_drain( io.data[target], cltr )) break HELP;
+                                        if ( ! __cfa_do_drain( io.data[target], cltr )) break HELP;
 
                                         // track we did help someone
@@ -322 +322 @@
 
                 // Drain the local queue
-                if(try_acquire( proc->io.ctx )) {
+                if (try_acquire( proc->io.ctx )) {
                         local = __cfa_do_drain( proc->io.ctx, cltr );
                 }
@@ -390 +390 @@
 
                 // If we don't have enough sqes, fail
-                if((ftail - fhead) < want) { return false; }
+                if ((ftail - fhead) < want) { return false; }
 
                 // copy all the indexes we want from the available list
@@ -422 +422 @@
 
                 // We can proceed to the fast path
-                if( __alloc(ctx, idxs, want) ) {
+                if ( __alloc(ctx, idxs, want) ) {
                         // Allocation was successful
                         __STATS__( true, io.alloc.fast += 1; )
@@ -456 +456 @@
         // barebones logic to submit a group of sqes
         static inline void __submit_only( struct io_context$ * ctx, __u32 idxs[], __u32 have, bool lock) {
-                if(!lock) 
+                if ( ! lock) 
                         lock( ctx->ext_sq.lock __cfaabi_dbg_ctx2 );
                 // We can proceed to the fast path
@@ -478 +478 @@
                 __atomic_store_n(&ctx->proc->io.dirty  , true, __ATOMIC_RELAXED);
 
-                if(!lock) 
+                if ( ! lock) 
                         unlock( ctx->ext_sq.lock );
         }
@@ -487 +487 @@
                 __submit_only(ctx, idxs, have, false);
 
-                if(sq.to_submit > 30) {
+                if (sq.to_submit > 30) {
                         __tls_stats()->io.flush.full++;
                         __cfa_io_flush( ctx->proc );
                 }
-                if(!lazy) {
+                if ( ! lazy ) {
                         __tls_stats()->io.flush.eager++;
                         __cfa_io_flush( ctx->proc );
@@ -503 +503 @@
 
                 disable_interrupts();
-                __STATS__( true, if(!lazy) io.submit.eagr += 1; )
+                __STATS__( true, if ( ! lazy ) io.submit.eagr += 1; )
                 struct processor * proc = __cfaabi_tls.this_processor;
                 io_context$ * ctx = proc->io.ctx;
@@ -510 +510 @@
 
                 // Can we proceed to the fast path
-                if( ctx == inctx )              // We have the right instance?
+                if ( ctx == inctx )             // We have the right instance?
                 {
                         // yes! fast submit
@@ -564 +564 @@
                 __u32 count = chead - phead;
 
-                if(count == 0) {
+                if (count == 0) {
                         return 0;
                 }
@@ -594 +594 @@
                 lock( queue.lock __cfaabi_dbg_ctx2 );
                 {
-                        was_empty = queue.queue`isEmpty;
+                        was_empty = isEmpty( queue.queue );
 
                         // Add our request to the list
@@ -632 +632 @@
         // notify the arbiter that new allocations are available
         static void __ioarbiter_notify( io_arbiter$ & this, io_context$ * ctx ) {
-                /* paranoid */ verify( !this.pending.queue`isEmpty );
+                /* paranoid */ verify( ! isEmpty( this.pending.queue ) );
                 /* paranoid */ verify( __preemption_enabled() );
 
@@ -642 +642 @@
                         // as long as there are pending allocations try to satisfy them
                         // for simplicity do it in FIFO order
-                        while( !this.pending.queue`isEmpty ) {
+                        while( ! isEmpty( this.pending.queue ) ) {
                                 // get first pending allocs
                                 __u32 have = ctx->sq.free_ring.tail - ctx->sq.free_ring.head;
-                                __pending_alloc & pa = (__pending_alloc&)(this.pending.queue`first);
+                                __pending_alloc & pa = (__pending_alloc&)( first( this.pending.queue ));
 
                                 // check if we have enough to satisfy the request
-                                if( have > pa.want ) goto DONE;
+                                if ( have > pa.want ) goto DONE;
 
                                 // if there are enough allocations it means we can drop the request
-                                try_pop_front( this.pending.queue );
+                                remove_first( this.pending.queue );
 
                                 /* paranoid */__attribute__((unused)) bool ret =
@@ -676 +676 @@
         // short hand to avoid the mutual exclusion of the pending is empty regardless
         static void __ioarbiter_notify( io_context$ & ctx ) {
-                if(empty( ctx.arbiter->pending )) return;
+                if (empty( ctx.arbiter->pending )) return;
                 __ioarbiter_notify( *ctx.arbiter, &ctx );
         }
@@ -700 +700 @@
                 // if this is the first to be enqueued, signal the processor in an attempt to speed up flushing
                 // if it's not the first enqueue, a signal is already in transit
-                if( we ) {
+                if ( we ) {
                         sigval_t value = { PREEMPT_IO };
                         __cfaabi_pthread_sigqueue(ctx->proc->kernel_thread, SIGUSR1, value);
@@ -716 +716 @@
         static void __ioarbiter_flush( io_context$ & ctx, bool kernel ) {
                 // if there are no external operations just return
-                if(empty( ctx.ext_sq )) return;
+                if ( empty( ctx.ext_sq ) ) return;
 
                 // stats and logs
@@ -727 +727 @@
                         // pop each operation one at a time.
                         // There is no wait morphing because of the io sq ring
-                        while( !ctx.ext_sq.queue`isEmpty ) {
+                        while( ! isEmpty( ctx.ext_sq.queue ) ) {
                                 // drop the element from the queue
-                                __external_io & ei = (__external_io&)try_pop_front( ctx.ext_sq.queue );
+                                __external_io & ei = (__external_io&)remove_first( ctx.ext_sq.queue );
 
                                 // submit it