Changeset 295dd61

Timestamp:

Dec 6, 2021, 5:06:14 PM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

75873cf

Parents:

813dfd86 (diff), a83012bf (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• example/io/eventfds.c (added)
• example/range_parser.cfa (added)
• libcfa/src/Makefile.am (modified) (1 diff)
• libcfa/src/algorithms/range_iterator.cfa (added)
• libcfa/src/algorithms/range_iterator.hfa (added)
• libcfa/src/concurrency/io.cfa (modified) (8 diffs)
• libcfa/src/concurrency/io/setup.cfa (modified) (3 diffs)
• libcfa/src/concurrency/io/types.hfa (modified) (1 diff)
• libcfa/src/concurrency/kernel.cfa (modified) (15 diffs)
• libcfa/src/concurrency/kernel.hfa (modified) (1 diff)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (2 diffs)
• libcfa/src/concurrency/kernel_private.hfa (modified) (2 diffs)
• libcfa/src/device/cpu.cfa (modified) (6 diffs)
• libcfa/src/device/cpu.hfa (modified) (1 diff)
• src/AST/Decl.hpp (modified) (1 diff)
• src/AST/Expr.cpp (modified) (2 diffs)
• src/AST/Print.cpp (modified) (1 diff)
• src/AST/Print.hpp (modified) (2 diffs)
• src/Concurrency/Keywords.cc (modified) (1 diff)
• src/Concurrency/Keywords.h (modified) (3 diffs)
• src/Concurrency/KeywordsNew.cpp (added)
• src/Concurrency/module.mk (modified) (1 diff)
• src/InitTweak/InitTweak.cc (modified) (2 diffs)
• src/InitTweak/InitTweak.h (modified) (2 diffs)
• src/Validate/CompoundLiteral.cpp (added)
• src/Validate/CompoundLiteral.hpp (added)
• src/Validate/module.mk (modified) (1 diff)
• src/main.cc (modified) (6 diffs)
• tests/algorithms/.expect/range_test.txt (added)
• tests/algorithms/range_test.cfa (added)
• tests/concurrent/.expect/ctor-check.txt (added)
• tests/concurrent/ctor-check.cfa (added)
• tests/pybin/tools.py (modified) (1 diff)

libcfa/src/Makefile.am

@@ -84 +84 @@
         time.hfa \
         bits/weakso_locks.hfa \
+        algorithms/range_iterator.hfa \
         containers/maybe.hfa \
         containers/pair.hfa \

libcfa/src/concurrency/io.cfa

@@ -33 +33 @@
                 #include <sys/syscall.h>
                 #include <sys/eventfd.h>
+                #include <sys/uio.h>
 
                 #include <linux/io_uring.h>
@@ -133 +134 @@
         }
 
-        void __cfa_io_flush( processor * proc ) {
+        bool __cfa_io_flush( processor * proc, int min_comp ) {
                 /* paranoid */ verify( ! __preemption_enabled() );
                 /* paranoid */ verify( proc );
@@ -141 +142 @@
                 $io_context & ctx = *proc->io.ctx;
 
-                // for(i; 2) {
-                //      unsigned idx = proc->rdq.id + i;
-                //      cltr->ready_queue.lanes.tscs[idx].tv = -1ull;
-                // }
-
                 __ioarbiter_flush( ctx );
 
                 __STATS__( true, io.calls.flush++; )
-                int ret = syscall( __NR_io_uring_enter, ctx.fd, ctx.sq.to_submit, 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) {
@@ -157 +153 @@
                                 // Update statistics
                                 __STATS__( false, io.calls.errors.busy ++; )
-                                // for(i; 2) {
-                                //      unsigned idx = proc->rdq.id + i;
-                                //      cltr->ready_queue.lanes.tscs[idx].tv = rdtscl();
-                                // }
-                                return;
+                                return false;
                         default:
                                 abort( "KERNEL ERROR: IO_URING SYSCALL - (%d) %s\n", (int)errno, strerror(errno) );
@@ -182 +174 @@
 
                 ctx.proc->io.pending = false;
-
-                __cfa_io_drain( proc );
-                // for(i; 2) {
-                //      unsigned idx = proc->rdq.id + i;
-                //      cltr->ready_queue.lanes.tscs[idx].tv = rdtscl();
-                // }
+                ready_schedule_lock();
+                bool ret = __cfa_io_drain( proc );
+                ready_schedule_unlock();
+                return ret;
         }
 
@@ -291 +281 @@
         }
 
-
         //=============================================================================================
         // submission
@@ -314 +303 @@
                 ctx->proc->io.dirty   = true;
                 if(sq.to_submit > 30 || !lazy) {
-                        ready_schedule_lock();
-                        __cfa_io_flush( ctx->proc );
-                        ready_schedule_unlock();
+                        __cfa_io_flush( ctx->proc, 0 );
                 }
         }
@@ -515 +502 @@
                 }
         }
+
+        #if defined(CFA_WITH_IO_URING_IDLE)
+                bool __kernel_read(processor * proc, io_future_t & future, iovec & iov, int fd) {
+                        $io_context * ctx = proc->io.ctx;
+                        /* paranoid */ verify( ! __preemption_enabled() );
+                        /* paranoid */ verify( proc == __cfaabi_tls.this_processor );
+                        /* paranoid */ verify( ctx );
+
+                        __u32 idx;
+                        struct io_uring_sqe * sqe;
+
+                        // We can proceed to the fast path
+                        if( !__alloc(ctx, &idx, 1) ) return false;
+
+                        // Allocation was successful
+                        __fill( &sqe, 1, &idx, ctx );
+
+                        sqe->user_data = (uintptr_t)&future;
+                        sqe->flags = 0;
+                        sqe->fd = fd;
+                        sqe->off = 0;
+                        sqe->ioprio = 0;
+                        sqe->fsync_flags = 0;
+                        sqe->__pad2[0] = 0;
+                        sqe->__pad2[1] = 0;
+                        sqe->__pad2[2] = 0;
+
+                        #if defined(CFA_HAVE_IORING_OP_READ)
+                                sqe->opcode = IORING_OP_READ;
+                                sqe->addr = (uint64_t)iov.iov_base;
+                                sqe->len = iov.iov_len;
+                        #elif defined(CFA_HAVE_READV) && defined(CFA_HAVE_IORING_OP_READV)
+                                sqe->opcode = IORING_OP_READV;
+                                sqe->addr = (uintptr_t)&iov;
+                                sqe->len = 1;
+                        #else
+                                #error CFA_WITH_IO_URING_IDLE but none of CFA_HAVE_READV, CFA_HAVE_IORING_OP_READV or CFA_HAVE_IORING_OP_READ defined
+                        #endif
+
+                        asm volatile("": : :"memory");
+
+                        /* paranoid */ verify( sqe->user_data == (uintptr_t)&future );
+                        __submit( ctx, &idx, 1, true );
+
+                        /* paranoid */ verify( proc == __cfaabi_tls.this_processor );
+                        /* paranoid */ verify( ! __preemption_enabled() );
+                }
+        #endif
 #endif

libcfa/src/concurrency/io/setup.cfa

@@ -32 +32 @@
 
         void __cfa_io_start( processor * proc ) {}
-        void __cfa_io_flush( processor * proc ) {}
+        bool __cfa_io_flush( processor * proc, int ) {}
         void __cfa_io_stop ( processor * proc ) {}
 
@@ -111 +111 @@
                 this.ext_sq.empty = true;
                 (this.ext_sq.queue){};
-                __io_uring_setup( this, cl.io.params, proc->idle );
+                __io_uring_setup( this, cl.io.params, proc->idle_fd );
                 __cfadbg_print_safe(io_core, "Kernel I/O : Created ring for io_context %u (%p)\n", this.fd, &this);
         }
@@ -220 +220 @@
                 cq.cqes = (struct io_uring_cqe *)(((intptr_t)cq.ring_ptr) + params.cq_off.cqes);
 
-                // 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);
-
-                __disable_interrupts_hard();
-
-                int ret = syscall( __NR_io_uring_register, fd, IORING_REGISTER_EVENTFD, &procfd, 1);
-                if (ret < 0) {
-                        abort("KERNEL ERROR: IO_URING EVENTFD REGISTER - %s\n", strerror(errno));
-                }
-
-                __enable_interrupts_hard();
-
-                __cfadbg_print_safe(io_core, "Kernel I/O : registered %d for completion with ring %d\n", procfd, fd);
+                #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);
+
+                        __disable_interrupts_hard();
+
+                        int ret = syscall( __NR_io_uring_register, fd, IORING_REGISTER_EVENTFD, &procfd, 1);
+                        if (ret < 0) {
+                                abort("KERNEL ERROR: IO_URING EVENTFD REGISTER - %s\n", strerror(errno));
+                        }
+
+                        __enable_interrupts_hard();
+
+                        __cfadbg_print_safe(io_core, "Kernel I/O : registered %d for completion with ring %d\n", procfd, fd);
+                #endif
 
                 // some paranoid checks

libcfa/src/concurrency/io/types.hfa

@@ -185 +185 @@
 
         // Wait for the future to be fulfilled
-        bool wait( io_future_t & this ) {
-                return wait(this.self);
-        }
-
-        void reset( io_future_t & this ) {
-                return reset(this.self);
-        }
+        bool wait     ( io_future_t & this ) { return wait     (this.self); }
+        void reset    ( io_future_t & this ) { return reset    (this.self); }
+        bool available( io_future_t & this ) { return available(this.self); }
 }

libcfa/src/concurrency/kernel.cfa

@@ -27 +27 @@
 extern "C" {
         #include <sys/eventfd.h>
+        #include <sys/uio.h>
 }
 
@@ -34 +35 @@
 #include "strstream.hfa"
 #include "device/cpu.hfa"
+#include "io/types.hfa"
 
 //Private includes
@@ -124 +126 @@
 static void __wake_one(cluster * cltr);
 
+static void idle_sleep(processor * proc, io_future_t & future, iovec & iov);
 static bool mark_idle (__cluster_proc_list & idles, processor & proc);
 static void mark_awake(__cluster_proc_list & idles, processor & proc);
@@ -129 +132 @@
 extern void __cfa_io_start( processor * );
 extern bool __cfa_io_drain( processor * );
-extern void __cfa_io_flush( processor * );
+extern bool __cfa_io_flush( processor *, int min_comp );
 extern void __cfa_io_stop ( processor * );
 static inline bool __maybe_io_drain( processor * );
+
+#if defined(CFA_WITH_IO_URING_IDLE)
+        extern bool __kernel_read(processor * proc, io_future_t & future, iovec &, int fd);
+#endif
 
 extern void __disable_interrupts_hard();
@@ -147 +154 @@
         /* paranoid */ verify( __preemption_enabled() );
 }
+
 
 //=============================================================================================
@@ -162 +170 @@
         verify(this);
 
+        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
+        eventfd_t idle_val;
+        iovec idle_iovec = { &idle_val, sizeof(idle_val) };
+
         __cfa_io_start( this );
 
@@ -195 +208 @@
 
                         if( !readyThread ) {
-                                ready_schedule_lock();
-                                __cfa_io_flush( this );
-                                ready_schedule_unlock();
+                                __cfa_io_flush( this, 0 );
 
                                 readyThread = __next_thread_slow( this->cltr );
@@ -228 +239 @@
                                 }
 
-                                #if !defined(__CFA_NO_STATISTICS__)
-                                        if(this->print_halts) {
-                                                __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl());
+                                idle_sleep( this, future, idle_iovec );
+
+                                // We were woken up, remove self from idle
+                                mark_awake(this->cltr->procs, * this);
+
+                                // DON'T just proceed, start looking again
+                                continue MAIN_LOOP;
+                        }
+
+                        /* paranoid */ verify( readyThread );
+
+                        // Reset io dirty bit
+                        this->io.dirty = false;
+
+                        // We found a thread run it
+                        __run_thread(this, readyThread);
+
+                        // Are we done?
+                        if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
+
+                        if(this->io.pending && !this->io.dirty) {
+                                __cfa_io_flush( this, 0 );
+                        }
+
+                        #else
+                                #warning new kernel loop
+                        SEARCH: {
+                                /* paranoid */ verify( ! __preemption_enabled() );
+
+                                // First, lock the scheduler since we are searching for a thread
+                                ready_schedule_lock();
+
+                                // Try to get the next thread
+                                readyThread = pop_fast( this->cltr );
+                                if(readyThread) { ready_schedule_unlock(); break SEARCH; }
+
+                                // If we can't find a thread, might as well flush any outstanding I/O
+                                if(this->io.pending) { __cfa_io_flush( this, 0 ); }
+
+                                // Spin a little on I/O, just in case
+                                for(5) {
+                                        __maybe_io_drain( this );
+                                        readyThread = pop_fast( this->cltr );
+                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
+                                }
+
+                                // no luck, try stealing a few times
+                                for(5) {
+                                        if( __maybe_io_drain( this ) ) {
+                                                readyThread = pop_fast( this->cltr );
+                                        } else {
+                                                readyThread = pop_slow( this->cltr );
                                         }
-                                #endif
-
-                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
+                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
+                                }
+
+                                // still no luck, search for a thread
+                                readyThread = pop_search( this->cltr );
+                                if(readyThread) { ready_schedule_unlock(); break SEARCH; }
+
+                                // Don't block if we are done
+                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) {
+                                        ready_schedule_unlock();
+                                        break MAIN_LOOP;
+                                }
+
+                                __STATS( __tls_stats()->ready.sleep.halts++; )
+
+                                // Push self to idle stack
+                                ready_schedule_unlock();
+                                if(!mark_idle(this->cltr->procs, * this)) goto SEARCH;
+                                ready_schedule_lock();
+
+                                // Confirm the ready-queue is empty
+                                __maybe_io_drain( this );
+                                readyThread = pop_search( this->cltr );
+                                ready_schedule_unlock();
+
+                                if( readyThread ) {
+                                        // A thread was found, cancel the halt
+                                        mark_awake(this->cltr->procs, * this);
+
+                                        __STATS( __tls_stats()->ready.sleep.cancels++; )
+
+                                        // continue the main loop
+                                        break SEARCH;
+                                }
+
+                                __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
+                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle_fd);
 
                                 {
                                         eventfd_t val;
-                                        ssize_t ret = read( this->idle, &val, sizeof(val) );
+                                        ssize_t ret = read( this->idle_fd, &val, sizeof(val) );
                                         if(ret < 0) {
                                                 switch((int)errno) {
@@ -254 +348 @@
                                 }
 
-                                #if !defined(__CFA_NO_STATISTICS__)
-                                        if(this->print_halts) {
-                                                __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl());
-                                        }
-                                #endif
+                                        __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
 
                                 // We were woken up, remove self from idle
@@ -267 +357 @@
                         }
 
-                        /* paranoid */ verify( readyThread );
-
-                        // Reset io dirty bit
-                        this->io.dirty = false;
-
-                        // We found a thread run it
-                        __run_thread(this, readyThread);
-
-                        // Are we done?
-                        if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
-
-                        if(this->io.pending && !this->io.dirty) {
-                                ready_schedule_lock();
-                                __cfa_io_flush( this );
-                                ready_schedule_unlock();
-                        }
-
-                        #else
-                                #warning new kernel loop
-                        SEARCH: {
-                                /* paranoid */ verify( ! __preemption_enabled() );
-
-                                // First, lock the scheduler since we are searching for a thread
-                                ready_schedule_lock();
-
-                                // Try to get the next thread
-                                readyThread = pop_fast( this->cltr );
-                                if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-
-                                // If we can't find a thread, might as well flush any outstanding I/O
-                                if(this->io.pending) { __cfa_io_flush( this ); }
-
-                                // Spin a little on I/O, just in case
-                                for(5) {
-                                        __maybe_io_drain( this );
-                                        readyThread = pop_fast( this->cltr );
-                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-                                }
-
-                                // no luck, try stealing a few times
-                                for(5) {
-                                        if( __maybe_io_drain( this ) ) {
-                                                readyThread = pop_fast( this->cltr );
-                                        } else {
-                                                readyThread = pop_slow( this->cltr );
-                                        }
-                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-                                }
-
-                                // still no luck, search for a thread
-                                readyThread = pop_search( this->cltr );
-                                if(readyThread) { ready_schedule_unlock(); break SEARCH; }
-
-                                // Don't block if we are done
-                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) {
-                                        ready_schedule_unlock();
-                                        break MAIN_LOOP;
-                                }
-
-                                __STATS( __tls_stats()->ready.sleep.halts++; )
-
-                                // Push self to idle stack
-                                ready_schedule_unlock();
-                                if(!mark_idle(this->cltr->procs, * this)) goto SEARCH;
-                                ready_schedule_lock();
-
-                                // Confirm the ready-queue is empty
-                                __maybe_io_drain( this );
-                                readyThread = pop_search( this->cltr );
-                                ready_schedule_unlock();
-
-                                if( readyThread ) {
-                                        // A thread was found, cancel the halt
-                                        mark_awake(this->cltr->procs, * this);
-
-                                        __STATS( __tls_stats()->ready.sleep.cancels++; )
-
-                                        // continue the main loop
-                                        break SEARCH;
-                                }
-
-                                __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
-                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
-
-                                {
-                                        eventfd_t val;
-                                        ssize_t ret = read( this->idle, &val, sizeof(val) );
-                                        if(ret < 0) {
-                                                switch((int)errno) {
-                                                case EAGAIN:
-                                                #if EAGAIN != EWOULDBLOCK
-                                                        case EWOULDBLOCK:
-                                                #endif
-                                                case EINTR:
-                                                        // No need to do anything special here, just assume it's a legitimate wake-up
-                                                        break;
-                                                default:
-                                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
-                                                }
-                                        }
-                                }
-
-                                        __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
-
-                                // We were woken up, remove self from idle
-                                mark_awake(this->cltr->procs, * this);
-
-                                // DON'T just proceed, start looking again
-                                continue MAIN_LOOP;
-                        }
-
                 RUN_THREAD:
                         /* paranoid */ verify( ! __preemption_enabled() );
@@ -392 +371 @@
 
                         if(this->io.pending && !this->io.dirty) {
-                                __cfa_io_flush( this );
+                                __cfa_io_flush( this, 0 );
                         }
 
@@ -402 +381 @@
 
                 __cfadbg_print_safe(runtime_core, "Kernel : core %p stopping\n", this);
+        }
+
+        for(int i = 0; !available(future); i++) {
+                if(i > 1000) __cfaabi_dbg_write( "ERROR: kernel has bin spinning on a flush after exit loop.\n", 60);
+                __cfa_io_flush( this, 1 );
         }
 
@@ -798 +782 @@
                 eventfd_t val;
                 val = 1;
-                eventfd_write( this->idle, val );
+                eventfd_write( this->idle_fd, val );
         __enable_interrupts_checked();
+}
+
+static void idle_sleep(processor * this, io_future_t & future, iovec & iov) {
+        #if !defined(CFA_WITH_IO_URING_IDLE)
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if(this->print_halts) {
+                                __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl());
+                        }
+                #endif
+
+                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle_fd);
+
+                {
+                        eventfd_t val;
+                        ssize_t ret = read( this->idle_fd, &val, sizeof(val) );
+                        if(ret < 0) {
+                                switch((int)errno) {
+                                case EAGAIN:
+                                #if EAGAIN != EWOULDBLOCK
+                                        case EWOULDBLOCK:
+                                #endif
+                                case EINTR:
+                                        // No need to do anything special here, just assume it's a legitimate wake-up
+                                        break;
+                                default:
+                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
+                                }
+                        }
+                }
+
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if(this->print_halts) {
+                                __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl());
+                        }
+                #endif
+        #else
+                // Do we already have a pending read
+                if(available(future)) {
+                        // There is no pending read, we need to add one
+                        reset(future);
+
+                        __kernel_read(this, future, iov, this->idle_fd );
+                }
+
+                __cfa_io_flush( this, 1 );
+        #endif
 }
 
@@ -810 +840 @@
                 insert_first(this.idles, proc);
 
-                __atomic_store_n(&this.fd, proc.idle, __ATOMIC_SEQ_CST);
+                __atomic_store_n(&this.fd, proc.idle_fd, __ATOMIC_SEQ_CST);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -827 +857 @@
                 {
                         int fd = 0;
-                        if(!this.idles`isEmpty) fd = this.idles`first.idle;
+                        if(!this.idles`isEmpty) fd = this.idles`first.idle_fd;
                         __atomic_store_n(&this.fd, fd, __ATOMIC_SEQ_CST);
                 }

libcfa/src/concurrency/kernel.hfa

@@ -100 +100 @@
 
         // Idle lock (kernel semaphore)
-        int idle;
+        int idle_fd;
 
         // Termination synchronisation (user semaphore)

libcfa/src/concurrency/kernel/startup.cfa

@@ -527 +527 @@
         this.local_data = 0p;
 
-        this.idle = eventfd(0, 0);
-        if (idle < 0) {
+        this.idle_fd = eventfd(0, 0);
+        if (idle_fd < 0) {
                 abort("KERNEL ERROR: PROCESSOR EVENTFD - %s\n", strerror(errno));
         }
@@ -542 +542 @@
 // Not a ctor, it just preps the destruction but should not destroy members
 static void deinit(processor & this) {
-        close(this.idle);
+        close(this.idle_fd);
 }
 

libcfa/src/concurrency/kernel_private.hfa

@@ -39 +39 @@
 }
 
+// Defines whether or not we *want* to use io_uring_enter as the idle_sleep blocking call
+#define CFA_WANT_IO_URING_IDLE
+
+// Defines whether or not we *can* use io_uring_enter as the idle_sleep blocking call
+#if defined(CFA_WANT_IO_URING_IDLE) && defined(CFA_HAVE_LINUX_IO_URING_H)
+        #if defined(CFA_HAVE_IORING_OP_READ) || (defined(CFA_HAVE_READV) && defined(CFA_HAVE_IORING_OP_READV))
+                #define CFA_WITH_IO_URING_IDLE
+        #endif
+#endif
+
 //-----------------------------------------------------------------------------
 // Scheduler
@@ -149 +159 @@
         __atomic_store_n(ll, (bool)false, __ATOMIC_RELEASE);
 }
-
-
-
-
 
 //-----------------------------------------------------------------------

libcfa/src/device/cpu.cfa

@@ -135 +135 @@
                 count++;
         }
-        iterate_dir(path, lambda);
+        int ret = iterate_dir(path, lambda);
+        if(ret == ENOTDIR) return 0;
 
         /* paranoid */ verifyf(count == max + 1, "Inconsistent %s count, counted %d, but max %s was %d", prefix, count, prefix, (int)max);
@@ -159 +160 @@
 
         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, &_);;
 }
 
@@ -226 +225 @@
 
 struct raw_cache_instance {
-        idx_range_t range;
-        unsigned width;
-        unsigned char level;
+        idx_range_t range;      // A text description of the cpus covered
+        unsigned width;         // The number of cpus covered
+        unsigned char level;    // the cache level
         // FIXME add at least size and type
 };
@@ -235 +234 @@
 static void ^?{}(raw_cache_instance & this) { free(this.range);}
 
+// Returns a 2D array of instances of size [cpu count][cache levels]
+// where cache level doesn't include instruction caches
 raw_cache_instance ** build_raw_cache_table(unsigned cpus, unsigned idxs, unsigned cache_levels)
 {
         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);
-                void addcache(unsigned fidx, unsigned char level, idx_range_t range, size_t len) {
-                        /* paranoid */ verifyf(level <= cache_levels, "Unexpected cache level %d on cpu %u index %u", (int)level, i, fidx);
-
-                        unsigned idx = cache_levels - level;
-                        raw_cache_instance & r = raw[i][idx];
-                        r.range = strndup(range, len);
-                        r.level = level;
-                        const char * end;
-                        r.width = read_width(range, len, &end);
-                }
-                foreach_cacheidx(i, idxs, addcache);
+                if (cache_levels > 0) {
+                        raw[i] = alloc(cache_levels);
+                        void addcache(unsigned fidx, unsigned char level, idx_range_t range, size_t len) {
+                                /* paranoid */ verifyf(level <= cache_levels, "Unexpected cache level %d on cpu %u index %u", (int)level, i, fidx);
+
+                                unsigned idx = cache_levels - level;
+                                raw_cache_instance & r = raw[i][idx];
+                                r.range = strndup(range, len);
+                                r.level = level;
+                                const char * end;
+                                r.width = read_width(range, len, &end);
+                        }
+                        foreach_cacheidx(i, idxs, addcache);
+                }
+                else {
+                        char buf[128];
+                        snprintf(buf, 128, "0-%u", cpus);
+                        raw[i] = alloc();
+                        raw[i]->range = strndup(buf, 128);
+                        raw[i]->level = 0;
+                        raw[i]->width = cpus;
+                }
         }
 
@@ -333 +346 @@
                 unsigned cache_levels = 0;
                 unsigned llc = 0;
-                {
+                if (idxs != 0) {
                         unsigned char prev = -1u;
                         void first(unsigned idx, unsigned char level, const char * map, size_t len) {
@@ -416 +429 @@
                 cpu_info.llc_map = entries;
                 cpu_info.hthrd_count = cpus;
+                cpu_info.llc_count = map_cnt;
         }
 

libcfa/src/device/cpu.hfa

@@ -23 +23 @@
 
 struct cpu_info_t {
-         // array of size [hthrd_count]
+        // Array of size [hthrd_count]
         const cpu_map_entry_t * llc_map;
 
-         // Number of _hardware_ threads present in the system
+        // Number of _hardware_ threads present in the system
         size_t hthrd_count;
+
+        // Number of distinct last level caches
+        size_t llc_count;
 };
 

src/AST/Decl.hpp

@@ -270 +270 @@
         : AggregateDecl( loc, name, std::move(attrs), linkage ), kind( kind ) {}
 
-        bool is_coroutine() { return kind == Coroutine; }
-        bool is_generator() { return kind == Generator; }
-        bool is_monitor  () { return kind == Monitor  ; }
-        bool is_thread   () { return kind == Thread   ; }
+        bool is_coroutine() const { return kind == Coroutine; }
+        bool is_generator() const { return kind == Generator; }
+        bool is_monitor  () const { return kind == Monitor  ; }
+        bool is_thread   () const { return kind == Thread   ; }
 
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Expr.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May 15 17:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Created On       : Thr Jun 13 13:38:00 2019
-// Update Count     : 6
+// Last Modified By : Andrew Beach
+// Created On       : Tue Nov 30 14:23:00 2021
+// Update Count     : 7
 //
 
@@ -141 +141 @@
         /// The type of the address of a type.
         /// Caller is responsible for managing returned memory
-        Type * addrType( const Type * type ) {
-                if ( const ReferenceType * refType = dynamic_cast< const ReferenceType * >( type ) ) {
-                        return new ReferenceType{ addrType( refType->base ), refType->qualifiers };
+        Type * addrType( const ptr<Type> & type ) {
+                if ( auto refType = type.as< ReferenceType >() ) {
+                        return new ReferenceType( addrType( refType->base ), refType->qualifiers );
                 } else {
-                        return new PointerType{ type };
+                        return new PointerType( type );
                 }
         }
-}
-
-AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) : Expr( loc ), arg( a ) {
-        if ( arg->result ) {
-                if ( arg->get_lvalue() ) {
-                        // lvalue, retains all levels of reference, and gains a pointer inside the references
-                        Type * res = addrType( arg->result );
-                        result = res;
+
+        /// The type of the address of an expression.
+        /// Caller is responsible for managing returned memory
+        Type * addrExprType( const CodeLocation & loc, const Expr * arg ) {
+                assert( arg );
+                // If the expression's type is unknown, the address type is unknown.
+                if ( nullptr == arg->result ) {
+                        return nullptr;
+                // An lvalue is transformed directly.
+                } else if ( arg->get_lvalue() ) {
+                        return addrType( arg->result );
+                // Strip a layer of reference to "create" an lvalue expression.
+                } else if ( auto refType = arg->result.as< ReferenceType >() ) {
+                        return addrType( refType->base );
                 } else {
-                        // taking address of non-lvalue, must be a reference, loses one layer of reference
-                        if ( const ReferenceType * refType =
-                                        dynamic_cast< const ReferenceType * >( arg->result.get() ) ) {
-                                Type * res = addrType( refType->base );
-                                result = res;
-                        } else {
-                                SemanticError( loc, arg->result.get(),
-                                        "Attempt to take address of non-lvalue expression: " );
-                        }
+                        SemanticError( loc, arg->result.get(),
+                                "Attempt to take address of non-lvalue expression: " );
                 }
         }
 }
+
+AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) :
+        Expr( loc, addrExprType( loc, a ) ), arg( a )
+{}
 
 // --- LabelAddressExpr

src/AST/Print.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Print.cpp --
+// Print.cpp -- Print an AST (or sub-tree) to a stream.
 //
 // Author           : Thierry Delisle

src/AST/Print.hpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Print.hpp --
+// Print.hpp -- Print an AST (or sub-tree) to a stream.
 //
 // Author           : Thierry Delisle
@@ -35 +35 @@
 template< typename Coll >
 void printAll( std::ostream & os, const Coll & c, Indenter indent = {} ) {
-    for ( const auto & i : c ) {
-        if ( ! i ) continue;
-        
-        os << indent;
-        print( os, i, indent );
-        os << std::endl;
-    }
+        for ( const auto & i : c ) {
+                if ( ! i ) continue;
+
+                os << indent;
+                print( os, i, indent );
+                os << std::endl;
+        }
 }
 

src/Concurrency/Keywords.cc

@@ -979 +979 @@
                         // If this is the destructor for a monitor it must be mutex
                         if(isDtor) {
+                                // This reflects MutexKeyword::validate, except does not produce an error.
                                 Type* ty = decl->get_functionType()->get_parameters().front()->get_type();
 

src/Concurrency/Keywords.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Keywords.h --
+// Keywords.h -- Implement concurrency constructs from their keywords.
 //
 // Author           : Thierry Delisle
@@ -19 +19 @@
 
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 
 namespace Concurrency {
@@ -24 +27 @@
         void implementMutexFuncs( std::list< Declaration * > & translationUnit );
         void implementThreadStarter( std::list< Declaration * > & translationUnit );
+
+/// Implement the sue-like keywords and the suspend keyword.
+void implementKeywords( ast::TranslationUnit & translationUnit );
+/// Implement the mutex parameters and mutex statement.
+void implementMutex( ast::TranslationUnit & translationUnit );
+/// Add the thread starter code to constructors.
+void implementThreadStarter( ast::TranslationUnit & translationUnit );
 };
 

src/Concurrency/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += Concurrency/Keywords.cc Concurrency/Keywords.h Concurrency/Waitfor.cc Concurrency/Waitfor.h
-SRCDEMANGLE += Concurrency/Keywords.cc
+SRC_CONCURRENCY = \
+        Concurrency/KeywordsNew.cpp \
+        Concurrency/Keywords.cc
 
+SRC += $(SRC_CONCURRENCY) \
+        Concurrency/Keywords.h \
+        Concurrency/Waitfor.cc \
+        Concurrency/Waitfor.h
+
+SRCDEMANGLE += $(SRC_CONCURRENCY)
+

src/InitTweak/InitTweak.cc

@@ -9 +9 @@
 // Author           : Rob Schluntz
 // Created On       : Fri May 13 11:26:36 2016
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 16 20:57:22 2021
-// Update Count     : 18
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Nov 19 19:22:00 2021
+// Update Count     : 19
 //
 
@@ -540 +540 @@
         }
 
+        const ast::Type * getTypeofThis( const ast::FunctionType * ftype ) {
+                assertf( ftype, "getTypeofThis: nullptr ftype" );
+                const std::vector<ast::ptr<ast::Type>> & params = ftype->params;
+                assertf( !params.empty(), "getTypeofThis: ftype with 0 parameters: %s",
+                                toString( ftype ).c_str() );
+                const ast::ReferenceType * refType =
+                        params.front().strict_as<ast::ReferenceType>();
+                return refType->base;
+        }
+
         ObjectDecl * getParamThis( FunctionType * ftype ) {
                 assertf( ftype, "getParamThis: nullptr ftype" );

src/InitTweak/InitTweak.h

@@ -10 +10 @@
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Jul 19 14:18:00 2019
-// Update Count     : 6
+// Last Modified On : Fri Nov 19 14:18:00 2021
+// Update Count     : 7
 //
 
@@ -35 +35 @@
         /// returns the base type of the first parameter to a constructor/destructor/assignment function
         Type * getTypeofThis( FunctionType * ftype );
+        const ast::Type * getTypeofThis( const ast::FunctionType * ftype );
 
         /// returns the first parameter of a constructor/destructor/assignment function

src/Validate/module.mk

@@ -16 +16 @@
 
 SRC_VALIDATE = \
+        Validate/CompoundLiteral.cpp \
+        Validate/CompoundLiteral.hpp \
         Validate/HandleAttributes.cc \
         Validate/HandleAttributes.h \

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Nov 12 11:06:00 2021
-// Update Count     : 658
+// Last Modified On : Tue Nov 30 10:25:00 2021
+// Update Count     : 659
 //
 
@@ -50 +50 @@
 #include "Common/UnimplementedError.h"      // for UnimplementedError
 #include "Common/utility.h"                 // for deleteAll, filter, printAll
+#include "Concurrency/Keywords.h"           // for implementMutex, implement...
 #include "Concurrency/Waitfor.h"            // for generateWaitfor
 #include "ControlStruct/ExceptDecl.h"       // for translateExcept
@@ -73 +74 @@
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
 #include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
+#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
 #include "Validate/InitializerLength.hpp"   // for setLengthFromInitializer
 #include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
@@ -325 +327 @@
                 PASS( "Validate-C", SymTab::validate_C( translationUnit ) );
                 PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
-                PASS( "Validate-E", SymTab::validate_E( translationUnit ) );
 
                 CodeTools::fillLocations( translationUnit );
@@ -338 +339 @@
                         forceFillCodeLocations( transUnit );
 
+                        PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
+                        PASS( "Implement Thread Start", Concurrency::implementThreadStarter( transUnit ) );
+                        PASS( "Compound Literal", Validate::handleCompoundLiterals( transUnit ) );
                         PASS( "Set Length From Initializer", Validate::setLengthFromInitializer( transUnit ) );
                         PASS( "Find Global Decls", Validate::findGlobalDecls( transUnit ) );
@@ -402 +406 @@
                         translationUnit = convert( move( transUnit ) );
                 } else {
+                        PASS( "Validate-E", SymTab::validate_E( translationUnit ) );
                         PASS( "Validate-F", SymTab::validate_F( translationUnit ) );
 

tests/pybin/tools.py

@@ -374 +374 @@
 
         if not os.path.isfile(core):
-                return 1, "ERR No core dump"
+                return 1, "ERR No core dump (limit soft: {} hard: {})".format(*resource.getrlimit(resource.RLIMIT_CORE))
 
         try: