Changeset 1757f98

Timestamp:

Nov 19, 2021, 3:03:54 PM (2 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

cd4c605

Parents:

a633f6f

Message:

Refactoring idle sleep to try and help the change from idle on read to idle on io_uring_enter.

Location:

libcfa/src/concurrency

Files:

• io/setup.cfa (modified) (1 diff)
• kernel.cfa (modified) (6 diffs)
• kernel.hfa (modified) (1 diff)
• kernel/startup.cfa (modified) (2 diffs)

libcfa/src/concurrency/io/setup.cfa

@@ -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);
         }

libcfa/src/concurrency/kernel.cfa

@@ -124 +124 @@
 static void __wake_one(cluster * cltr);
 
+static void idle_sleep(processor * proc);
 static bool mark_idle (__cluster_proc_list & idles, processor & proc);
 static void mark_awake(__cluster_proc_list & idles, processor & proc);
@@ -228 +229 @@
                                 }
 
-                                #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);
-
-                                {
-                                        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 ) );
-                                                }
-                                        }
-                                }
-
-                                #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
+                                idle_sleep( this );
 
                                 // We were woken up, remove self from idle
@@ -349 +320 @@
 
                                 __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);
+                                __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) {
@@ -798 +769 @@
                 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) {
+        #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
 }
 
@@ -810 +815 @@
                 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 +832 @@
                 {
                         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);
 }