Changes in / [cd4c605:c60e5094]

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_fd );
+                __io_uring_setup( this, cl.io.params, proc->idle );
                 __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);
@@ -229 +228 @@
                                 }
 
-                                idle_sleep( 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);
+
+                                {
+                                        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
 
                                 // We were woken up, remove self from idle
@@ -320 +349 @@
 
                                 __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);
+                                __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_fd, &val, sizeof(val) );
+                                        ssize_t ret = read( this->idle, &val, sizeof(val) );
                                         if(ret < 0) {
                                                 switch((int)errno) {
@@ -769 +798 @@
                 eventfd_t val;
                 val = 1;
-                eventfd_write( this->idle_fd, val );
+                eventfd_write( this->idle, 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
 }
 
@@ -815 +810 @@
                 insert_first(this.idles, proc);
 
-                __atomic_store_n(&this.fd, proc.idle_fd, __ATOMIC_SEQ_CST);
+                __atomic_store_n(&this.fd, proc.idle, __ATOMIC_SEQ_CST);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
@@ -832 +827 @@
                 {
                         int fd = 0;
-                        if(!this.idles`isEmpty) fd = this.idles`first.idle_fd;
+                        if(!this.idles`isEmpty) fd = this.idles`first.idle;
                         __atomic_store_n(&this.fd, fd, __ATOMIC_SEQ_CST);
                 }

libcfa/src/concurrency/kernel.hfa

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

libcfa/src/concurrency/kernel/startup.cfa

@@ -527 +527 @@
         this.local_data = 0p;
 
-        this.idle_fd = eventfd(0, 0);
-        if (idle_fd < 0) {
+        this.idle = eventfd(0, 0);
+        if (idle < 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_fd);
+        close(this.idle);
 }