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

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -237 +237 @@
         $coroutine * proc_cor = get_coroutine(this->runner);
 
-        // Update global state
-        kernelTLS.this_thread = thrd_dst;
-
         // set state of processor coroutine to inactive
         verify(proc_cor->state == Active);
@@ -249 +246 @@
                 thrd_dst->state = Active;
 
-                __cfaabi_dbg_debug_do(
-                        thrd_dst->park_stale   = true;
-                        thrd_dst->unpark_stale = true;
-                )
+                // Update global state
+                kernelTLS.this_thread = thrd_dst;
 
                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
                 /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
+                /* paranoid */ verify( thrd_dst->context.SP );
                 /* 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
+                /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_dst->canary );
+
+
 
                 // set context switch to the thread that the processor is executing
-                verify( thrd_dst->context.SP );
                 __cfactx_switch( &proc_cor->context, &thrd_dst->context );
                 // when __cfactx_switch returns we are back in the processor coroutine
 
+                /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_dst->canary );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit), "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 ), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst );
+                /* paranoid */ verify( thrd_dst->context.SP );
                 /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
+                // Reset global state
+                kernelTLS.this_thread = 0p;
 
                 // We just finished running a thread, there are a few things that could have happened.
@@ -286 +288 @@
                         // The thread has halted, it should never be scheduled/run again
                         // We may need to wake someone up here since
-                        unpark( this->destroyer __cfaabi_dbg_ctx2 );
+                        unpark( this->destroyer );
                         this->destroyer = 0p;
                         break RUNNING;
@@ -296 +298 @@
                 // set state of processor coroutine to active and the thread to inactive
                 int old_ticket = __atomic_fetch_sub(&thrd_dst->ticket, 1, __ATOMIC_SEQ_CST);
-                __cfaabi_dbg_debug_do( thrd_dst->park_result = old_ticket; )
                 switch(old_ticket) {
                         case 1:
@@ -313 +314 @@
         // Just before returning to the processor, set the processor coroutine to active
         proc_cor->state = Active;
-        kernelTLS.this_thread = 0p;
 
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -334 +334 @@
                         __x87_store;
                 #endif
-                verify( proc_cor->context.SP );
+                /* paranoid */ verify( proc_cor->context.SP );
+                /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_src->canary );
                 __cfactx_switch( &thrd_src->context, &proc_cor->context );
+                /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_src->canary );
                 #if defined( __i386 ) || defined( __x86_64 )
                         __x87_load;
@@ -367 +369 @@
         /* paranoid */ #endif
         /* paranoid */ verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next );
+        /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd->canary );
+
 
         if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
@@ -403 +407 @@
 
 // KERNEL ONLY unpark with out disabling interrupts
-void __unpark(  struct __processor_id_t * id, $thread * thrd __cfaabi_dbg_ctx_param2 ) {
-        // record activity
-        __cfaabi_dbg_record_thrd( *thrd, false, caller );
-
+void __unpark(  struct __processor_id_t * id, $thread * thrd ) {
         int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
-        __cfaabi_dbg_debug_do( thrd->unpark_result = old_ticket; thrd->unpark_state = thrd->state; )
         switch(old_ticket) {
                 case 1:
@@ -426 +426 @@
 }
 
-void unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) {
+void unpark( $thread * thrd ) {
         if( !thrd ) return;
 
         disable_interrupts();
-        __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd __cfaabi_dbg_ctx_fwd2 );
+        __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
 
-void park( __cfaabi_dbg_ctx_param ) {
+void park( void ) {
         /* paranoid */ verify( kernelTLS.preemption_state.enabled );
         disable_interrupts();
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         /* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION );
-
-        // record activity
-        __cfaabi_dbg_record_thrd( *kernelTLS.this_thread, true, caller );
 
         returnToKernel();
@@ -521 +518 @@
         disable_interrupts();
                 /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-                bool ret = post( this->idle );
+                post( this->idle );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
@@ -649 +646 @@
                 // atomically release spin lock and block
                 unlock( lock );
-                park( __cfaabi_dbg_ctx );
+                park();
                 return true;
         }
@@ -670 +667 @@
 
         // make new owner
-        unpark( thrd __cfaabi_dbg_ctx2 );
+        unpark( thrd );
 
         return thrd != 0p;
@@ -681 +678 @@
         count += diff;
         for(release) {
-                unpark( pop_head( waiting ) __cfaabi_dbg_ctx2 );
+                unpark( pop_head( waiting ) );
         }
 
@@ -697 +694 @@
                         this.prev_thrd = kernelTLS.this_thread;
                 }
-
-                void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]) {
-                        if(park) {
-                                this.park_caller   = prev_name;
-                                this.park_stale    = false;
-                        }
-                        else {
-                                this.unpark_caller = prev_name;
-                                this.unpark_stale  = false;
-                        }
-                }
         }
 )