Changeset 63be3387 for libcfa/src/concurrency/kernel.cfa

Timestamp:

Nov 14, 2022, 11:52:44 AM (3 years ago)

Author:

caparson <caparson@…>

Branches:

ADT, ast-experimental, master

Children:

7d9598d8

Parents:

b77f0e1 (diff), 19a8c40 (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

File:

• libcfa/src/concurrency/kernel.cfa (modified) (11 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -138 +138 @@
 extern bool __cfa_io_drain( processor * proc ) __attribute__((nonnull (1)));
 extern bool __cfa_io_flush( processor * ) __attribute__((nonnull (1)));
-extern void __cfa_io_idle( processor * ) __attribute__((nonnull (1)));
-
-#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();
@@ -162 +158 @@
         verify(this);
 
-        /* paranoid */ verify( this->idle_wctx.ftr   != 0p );
-        /* paranoid */ verify( this->idle_wctx.rdbuf != 0p );
-
-        // used for idle sleep when io_uring is present
-        // mark it as already fulfilled so we know if there is a pending request or not
-        this->idle_wctx.ftr->self.ptr = 1p;
-
         __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
         #if !defined(__CFA_NO_STATISTICS__)
@@ -291 +280 @@
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verifyf( thrd_dst->state == Ready || thrd_dst->preempted != __NO_PREEMPTION, "state : %d, preempted %d\n", thrd_dst->state, thrd_dst->preempted);
-        /* paranoid */ verifyf( thrd_dst->link.next == 0p, "Expected null got %p", thrd_dst->link.next );
+        /* paranoid */ verifyf( thrd_dst->rdy_link.next == 0p, "Expected null got %p", thrd_dst->rdy_link.next );
         __builtin_prefetch( thrd_dst->context.SP );
 
@@ -321 +310 @@
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
+                /* paranoid */ verify( __atomic_exchange_n( &thrd_dst->executing, this, __ATOMIC_SEQ_CST) == 0p );
                 /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
 
@@ -332 +322 @@
 
                 /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd_dst->canary );
+                /* paranoid */ verify( __atomic_exchange_n( &thrd_dst->executing, 0p, __ATOMIC_SEQ_CST) == this );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too large.\n", thrd_dst );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->corctx_flag, "ERROR : Destination thread$ %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
+                /* paranoid */ verify( thrd_dst->state != Halted );
                 /* paranoid */ verify( thrd_dst->context.SP );
-                /* paranoid */ verify( thrd_dst->curr_cluster == this->cltr );
                 /* paranoid */ verify( kernelTLS().this_thread == thrd_dst );
                 /* paranoid */ verify( ! __preemption_enabled() );
@@ -452 +443 @@
                                         "Error preempted thread marked as not currently running, state %d, preemption %d\n", thrd->state, thrd->preempted );
         /* paranoid */ #endif
-        /* paranoid */ verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next );
+        /* paranoid */ verifyf( thrd->rdy_link.next == 0p, "Expected null got %p", thrd->rdy_link.next );
         /* paranoid */ verify( 0x0D15EA5E0D15EA5Ep == thrd->canary );
 
@@ -600 +591 @@
                 /* paranoid */ verifyf( ((uintptr_t)thrd->context.SP) < ((uintptr_t)__get_stack(thrd->curr_cor)->base ), "ERROR : thread$ %p has been corrupted.\n StackPointer too small.\n", thrd );
 
-                thrd->state = Halting;
                 if( TICKET_RUNNING != thrd->ticket ) { abort( "Thread terminated with pending unpark" ); }
                 if( thrd != this->owner ) { abort( "Thread internal monitor has incorrect owner" ); }
                 if( this->recursion != 1) { abort( "Thread internal monitor has unbalanced recursion" ); }
+
+                thrd->state = Halting;
+                thrd->ticket = TICKET_DEAD;
 
                 // Leave the thread
@@ -624 +617 @@
                 // If that is the case, abandon the preemption.
                 bool preempted = false;
-                if(thrd->link.next == 0p) {
+                if(thrd->rdy_link.next == 0p) {
                         preempted = true;
                         thrd->preempted = reason;
@@ -726 +719 @@
 
 
-        #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());
+        #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_wctx.evfd, &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 ) );
                         }
-                #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_wctx.evfd, &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
-                __cfa_io_idle( this );
+                }
+        }
+
+        #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
 }
@@ -775 +764 @@
                 insert_first(this.idles, proc);
 
+                // update the pointer to the head wait context, which should now point to this proc.
                 __atomic_store_n(&this.fdw, &proc.idle_wctx, __ATOMIC_SEQ_CST);
         unlock( this );
@@ -791 +781 @@
 
                 {
+                        // update the pointer to the head wait context
                         struct __fd_waitctx * wctx = 0;
                         if(!this.idles`isEmpty) wctx = &this.idles`first.idle_wctx;