Changes in libcfa/src/concurrency/kernel.cfa [b4b63e8:6a77224]

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -252 +252 @@
                 /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
                 /* paranoid */ verify( thrd_dst->context.SP );
+                /* paranoid */ verify( thrd_dst->state != Halted );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor, "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, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
@@ -287 +288 @@
                 if(unlikely(thrd_dst->state == Halted)) {
                         // The thread has halted, it should never be scheduled/run again
-                        // We may need to wake someone up here since
-                        unpark( this->destroyer );
-                        this->destroyer = 0p;
+                        // finish the thread
+                        __thread_finish( thrd_dst );
                         break RUNNING;
                 }
@@ -299 +299 @@
                 int old_ticket = __atomic_fetch_sub(&thrd_dst->ticket, 1, __ATOMIC_SEQ_CST);
                 switch(old_ticket) {
-                        case 1:
+                        case TICKET_RUNNING:
                                 // This is case 1, the regular case, nothing more is needed
                                 break RUNNING;
-                        case 2:
+                        case TICKET_UNBLOCK:
                                 // This is case 2, the racy case, someone tried to run this thread before it finished blocking
                                 // In this case, just run it again.
@@ -410 +410 @@
         int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
         switch(old_ticket) {
-                case 1:
+                case TICKET_RUNNING:
                         // Wake won the race, the thread will reschedule/rerun itself
                         break;
-                case 0:
+                case TICKET_BLOCKED:
                         /* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
                         /* paranoid */ verify( thrd->state == Blocked );
@@ -422 +422 @@
                 default:
                         // This makes no sense, something is wrong abort
-                        abort();
+                        abort("Thread %p (%s) has mismatch park/unpark\n", thrd, thrd->self_cor.name);
         }
 }
@@ -448 +448 @@
 }
 
-// KERNEL ONLY
-void __leave_thread() {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        returnToKernel();
-        abort();
+extern "C" {
+        // Leave the thread monitor
+        // last routine called by a thread.
+        // Should never return
+        void __cfactx_thrd_leave() {
+                $thread * thrd = TL_GET( this_thread );
+                $monitor * this = &thrd->self_mon;
+
+                // Lock the monitor now
+                lock( this->lock __cfaabi_dbg_ctx2 );
+
+                disable_interrupts();
+
+                thrd->state = Halted;
+
+                if( thrd != this->owner || this->recursion != 1) { abort( "Thread internal monitor has unbalanced recursion" ); }
+
+                // Leave the thread
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                returnToKernel();
+                abort();
+
+                // Control flow should never reach here!
+        }
 }