Changes in src/libcfa/concurrency/kernel.c [01963df:de94a60]

File:

• src/libcfa/concurrency/kernel.c (modified) (42 diffs)

src/libcfa/concurrency/kernel.c

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 30 18:26:11 2018
-// Update Count     : 23
+// Last Modified On : Mon Apr  9 16:11:46 2018
+// Update Count     : 24
 //
 
@@ -25 +25 @@
 
 //CFA Includes
+#include "time"
 #include "kernel_private.h"
 #include "preemption.h"
@@ -41 +42 @@
 KERNEL_STORAGE(cluster,           mainCluster);
 KERNEL_STORAGE(processor,         mainProcessor);
-KERNEL_STORAGE(processorCtx_t,    mainProcessorCtx);
 KERNEL_STORAGE(thread_desc,       mainThread);
 KERNEL_STORAGE(machine_context_t, mainThreadCtx);
 
-cluster *     mainCluster;
-processor *   mainProcessor;
+cluster     * mainCluster;
+processor   * mainProcessor;
 thread_desc * mainThread;
+
+struct { __dllist_t(thread_desc) list; __spinlock_t lock; } global_threads ;
+struct { __dllist_t(cluster    ) list; __spinlock_t lock; } global_clusters;
 
 //-----------------------------------------------------------------------------
@@ -56 +59 @@
 // volatile thread_local unsigned short disable_preempt_count = 1;
 
-thread_local struct KernelThreadData kernelThreadData = {
+thread_local struct KernelThreadData kernelTLS = {
         NULL,
         NULL,
@@ -64 +67 @@
 
 //-----------------------------------------------------------------------------
-// Main thread construction
+// Struct to steal stack
 struct current_stack_info_t {
         machine_context_t ctx;
@@ -89 +92 @@
 }
 
+//-----------------------------------------------------------------------------
+// Main thread construction
 void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
         size      = info->size;
@@ -110 +115 @@
         self_cor{ info };
         curr_cor = &self_cor;
+        curr_cluster = mainCluster;
         self_mon.owner = &this;
         self_mon.recursion = 1;
         self_mon_p = &self_mon;
         next = NULL;
-        __cfaabi_dbg_debug_do(
-                dbg_next = NULL;
-                dbg_prev = NULL;
-                __cfaabi_dbg_thread_register(&this);
-        )
+
+        node.next = NULL;
+        node.prev = NULL;
+        doregister(this);
 
         monitors{ &self_mon_p, 1, (fptr_t)0 };
@@ -125 +130 @@
 //-----------------------------------------------------------------------------
 // Processor coroutine
-void ?{}(processorCtx_t & this) {}
-
-// Construct the processor context of the main processor
-void ?{}(processorCtx_t & this, processor * proc) {
-        (this.__cor){ "Processor" };
-        this.__cor.starter = NULL;
-        this.proc = proc;
+void ?{}(processorCtx_t & this) {
+
 }
 
@@ -140 +140 @@
 }
 
-void ?{}(processor & this) {
-        this{ mainCluster };
-}
-
-void ?{}(processor & this, cluster * cltr) with( this ) {
-        this.cltr = cltr;
+void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
+        this.name = name;
+        this.cltr = &cltr;
         terminated{ 0 };
         do_terminate = false;
@@ -155 +152 @@
 }
 
-void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) with( this ) {
-        this.cltr = cltr;
-        terminated{ 0 };
-        do_terminate = false;
-        preemption_alarm = NULL;
-        pending_preemption = false;
-        kernel_thread = pthread_self();
-        runner.proc = &this;
-
-        __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
-        runner{ &this };
-}
-
 void ^?{}(processor & this) with( this ){
         if( ! do_terminate ) {
@@ -173 +157 @@
                 terminate(&this);
                 verify(this.do_terminate);
-                verify(TL_GET( this_processor ) != &this);
+                verify( kernelTLS.this_processor != &this);
                 P( terminated );
-                verify(TL_GET( this_processor ) != &this);
+                verify( kernelTLS.this_processor != &this);
                 pthread_join( kernel_thread, NULL );
         }
 }
 
-void ?{}(cluster & this) with( this ) {
+void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
+        this.name = name;
+        this.preemption_rate = preemption_rate;
         ready_queue{};
         ready_queue_lock{};
 
-        preemption_rate = default_preemption();
+        procs{ __get };
+        idles{ __get };
+
+        doregister(this);
 }
 
 void ^?{}(cluster & this) {
-
+        unregister(this);
 }
 
@@ -201 +190 @@
         __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
 
+        doregister(this->cltr, this);
+
         {
                 // Setup preemption data
@@ -214 +205 @@
                         if(readyThread)
                         {
-                                verify( ! TL_GET( preemption_state ).enabled );
+                                verify( ! kernelTLS.preemption_state.enabled );
 
                                 runThread(this, readyThread);
 
-                                verify( ! TL_GET( preemption_state ).enabled );
+                                verify( ! kernelTLS.preemption_state.enabled );
 
                                 //Some actions need to be taken from the kernel
@@ -234 +225 @@
         }
 
+        unregister(this->cltr, this);
+
         V( this->terminated );
 
@@ -239 +232 @@
 }
 
+// KERNEL ONLY
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
@@ -246 +240 @@
         coroutine_desc * thrd_cor = dst->curr_cor;
 
-        //Reset the terminating actions here
+        // Reset the terminating actions here
         this->finish.action_code = No_Action;
 
-        //Update global state
-        TL_SET( this_thread, dst );
+        // Update global state
+        kernelTLS.this_thread = dst;
 
         // Context Switch to the thread
@@ -257 +251 @@
 }
 
+// KERNEL_ONLY
 void returnToKernel() {
-        coroutine_desc * proc_cor = get_coroutine(TL_GET( this_processor )->runner);
-        coroutine_desc * thrd_cor = TL_GET( this_thread )->curr_cor = TL_GET( this_coroutine );
+        coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
+        coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor = kernelTLS.this_coroutine;
         ThreadCtxSwitch(thrd_cor, proc_cor);
 }
 
+// KERNEL_ONLY
 // Once a thread has finished running, some of
 // its final actions must be executed from the kernel
 void finishRunning(processor * this) with( this->finish ) {
         if( action_code == Release ) {
-                verify( ! TL_GET( preemption_state ).enabled );
+                verify( ! kernelTLS.preemption_state.enabled );
                 unlock( *lock );
         }
@@ -274 +270 @@
         }
         else if( action_code == Release_Schedule ) {
-                verify( ! TL_GET( preemption_state ).enabled );
+                verify( ! kernelTLS.preemption_state.enabled );
                 unlock( *lock );
                 ScheduleThread( thrd );
         }
         else if( action_code == Release_Multi ) {
-                verify( ! TL_GET( preemption_state ).enabled );
+                verify( ! kernelTLS.preemption_state.enabled );
                 for(int i = 0; i < lock_count; i++) {
                         unlock( *locks[i] );
@@ -303 +299 @@
 }
 
+// KERNEL_ONLY
 // Context invoker for processors
 // This is the entry point for processors (kernel threads)
@@ -308 +305 @@
 void * CtxInvokeProcessor(void * arg) {
         processor * proc = (processor *) arg;
-        TL_SET( this_processor, proc );
-        TL_SET( this_coroutine, NULL );
-        TL_SET( this_thread, NULL );
-        TL_GET( preemption_state ).enabled = false;
-        TL_GET( preemption_state ).disable_count = 1;
+        kernelTLS.this_processor = proc;
+        kernelTLS.this_coroutine = NULL;
+        kernelTLS.this_thread    = NULL;
+        kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
         // SKULLDUGGERY: We want to create a context for the processor coroutine
         // which is needed for the 2-step context switch. However, there is no reason
@@ -324 +320 @@
 
         //Set global state
-        TL_SET( this_coroutine, get_coroutine(proc->runner) );
-        TL_SET( this_thread, NULL );
+        kernelTLS.this_coroutine = get_coroutine(proc->runner);
+        kernelTLS.this_thread    = NULL;
 
         //We now have a proper context from which to schedule threads
@@ -352 +348 @@
 }
 
+// KERNEL_ONLY
 void kernel_first_resume(processor * this) {
-        coroutine_desc * src = TL_GET( this_coroutine );
+        coroutine_desc * src = kernelTLS.this_coroutine;
         coroutine_desc * dst = get_coroutine(this->runner);
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         create_stack(&dst->stack, dst->stack.size);
         CtxStart(&this->runner, CtxInvokeCoroutine);
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         dst->last = src;
@@ -370 +367 @@
 
         // set new coroutine that task is executing
-        TL_SET( this_coroutine, dst );
+        kernelTLS.this_coroutine = dst;
 
         // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
@@ -387 +384 @@
         src->state = Active;
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 }
 
 //-----------------------------------------------------------------------------
 // Scheduler routines
+
+// KERNEL ONLY
 void ScheduleThread( thread_desc * thrd ) {
-        // if( ! thrd ) return;
         verify( thrd );
         verify( thrd->self_cor.state != Halted );
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        with( *TL_GET( this_processor )->cltr ) {
+        with( *thrd->curr_cluster ) {
                 lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
                 append( ready_queue, thrd );
@@ -407 +405 @@
         }
 
-        verify( ! TL_GET( preemption_state ).enabled );
-}
-
+        verify( ! kernelTLS.preemption_state.enabled );
+}
+
+// KERNEL ONLY
 thread_desc * nextThread(cluster * this) with( *this ) {
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
         thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         return head;
 }
@@ -421 +420 @@
 void BlockInternal() {
         disable_interrupts();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
@@ -429 +428 @@
 void BlockInternal( __spinlock_t * lock ) {
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Release;
-        TL_GET( this_processor )->finish.lock        = lock;
-
-        verify( ! TL_GET( preemption_state ).enabled );
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Release;
+                finish.lock        = lock;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -441 +442 @@
 void BlockInternal( thread_desc * thrd ) {
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Schedule;
-        TL_GET( this_processor )->finish.thrd        = thrd;
-
-        verify( ! TL_GET( preemption_state ).enabled );
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = Schedule;
+                finish.thrd        = thrd;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -454 +457 @@
         assert(thrd);
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Release_Schedule;
-        TL_GET( this_processor )->finish.lock        = lock;
-        TL_GET( this_processor )->finish.thrd        = thrd;
-
-        verify( ! TL_GET( preemption_state ).enabled );
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = Release_Schedule;
+                finish.lock        = lock;
+                finish.thrd        = thrd;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -467 +472 @@
 void BlockInternal(__spinlock_t * locks [], unsigned short count) {
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Release_Multi;
-        TL_GET( this_processor )->finish.locks       = locks;
-        TL_GET( this_processor )->finish.lock_count  = count;
-
-        verify( ! TL_GET( preemption_state ).enabled );
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = Release_Multi;
+                finish.locks       = locks;
+                finish.lock_count  = count;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -480 +487 @@
 void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Release_Multi_Schedule;
-        TL_GET( this_processor )->finish.locks       = locks;
-        TL_GET( this_processor )->finish.lock_count  = lock_count;
-        TL_GET( this_processor )->finish.thrds       = thrds;
-        TL_GET( this_processor )->finish.thrd_count  = thrd_count;
-
-        verify( ! TL_GET( preemption_state ).enabled );
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Release_Multi_Schedule;
+                finish.locks       = locks;
+                finish.lock_count  = lock_count;
+                finish.thrds       = thrds;
+                finish.thrd_count  = thrd_count;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
         returnToKernel();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
 }
 
+// KERNEL ONLY
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
-        verify( ! TL_GET( preemption_state ).enabled );
-        TL_GET( this_processor )->finish.action_code = thrd ? Release_Schedule : Release;
-        TL_GET( this_processor )->finish.lock        = lock;
-        TL_GET( this_processor )->finish.thrd        = thrd;
+        verify( ! kernelTLS.preemption_state.enabled );
+        with( * kernelTLS.this_processor ) {
+                finish.action_code = thrd ? Release_Schedule : Release;
+                finish.lock        = lock;
+                finish.thrd        = thrd;
+        }
 
         returnToKernel();
@@ -508 +520 @@
 // Kernel boot procedures
 void kernel_startup(void) {
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
+
+        global_threads. list{ __get };
+        global_threads. lock{};
+        global_clusters.list{ __get };
+        global_clusters.lock{};
+
+        // Initialize the main cluster
+        mainCluster = (cluster *)&storage_mainCluster;
+        (*mainCluster){"Main Cluster"};
+
+        __cfaabi_dbg_print_safe("Kernel : Main cluster ready\n");
 
         // Start by initializing the main thread
@@ -520 +543 @@
         __cfaabi_dbg_print_safe("Kernel : Main thread ready\n");
 
-        // Initialize the main cluster
-        mainCluster = (cluster *)&storage_mainCluster;
-        (*mainCluster){};
-
-        __cfaabi_dbg_print_safe("Kernel : main cluster ready\n");
+
+
+        // Construct the processor context of the main processor
+        void ?{}(processorCtx_t & this, processor * proc) {
+                (this.__cor){ "Processor" };
+                this.__cor.starter = NULL;
+                this.proc = proc;
+        }
+
+        void ?{}(processor & this) with( this ) {
+                name = "Main Processor";
+                cltr = mainCluster;
+                terminated{ 0 };
+                do_terminate = false;
+                preemption_alarm = NULL;
+                pending_preemption = false;
+                kernel_thread = pthread_self();
+
+                runner{ &this };
+                __cfaabi_dbg_print_safe("Kernel : constructed main processor context %p\n", &runner);
+        }
 
         // Initialize the main processor and the main processor ctx
         // (the coroutine that contains the processing control flow)
         mainProcessor = (processor *)&storage_mainProcessor;
-        (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx };
+        (*mainProcessor){};
 
         //initialize the global state variables
-        TL_SET( this_processor, mainProcessor );
-        TL_SET( this_thread, mainThread );
-        TL_SET( this_coroutine, &mainThread->self_cor );
+        kernelTLS.this_processor = mainProcessor;
+        kernelTLS.this_thread    = mainThread;
+        kernelTLS.this_coroutine = &mainThread->self_cor;
 
         // Enable preemption
@@ -546 +585 @@
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
-        kernel_first_resume( TL_GET( this_processor ) );
+        kernel_first_resume( kernelTLS.this_processor );
 
 
@@ -553 +592 @@
         __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
 
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
-        verify( TL_GET( preemption_state ).enabled );
+        verify( TL_GET( preemption_state.enabled ) );
 }
 
@@ -561 +600 @@
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
-        verify( TL_GET( preemption_state ).enabled );
+        verify( TL_GET( preemption_state.enabled ) );
         disable_interrupts();
-        verify( ! TL_GET( preemption_state ).enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
 
         // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
@@ -589 +628 @@
 
 //=============================================================================================
+// Kernel Quiescing
+//=============================================================================================
+
+// void halt(processor * this) with( this ) {
+//      pthread_mutex_lock( &idle.lock );
+
+
+
+//      // SKULLDUGGERY: Even if spurious wake-up is a thing
+//      // spuriously waking up a kernel thread is not a big deal
+//      // if it is very rare.
+//      pthread_cond_wait( &idle.cond, &idle.lock);
+//      pthread_mutex_unlock( &idle.lock );
+// }
+
+// void wake(processor * this) with( this ) {
+//      pthread_mutex_lock  (&idle.lock);
+//      pthread_cond_signal (&idle.cond);
+//      pthread_mutex_unlock(&idle.lock);
+// }
+
+//=============================================================================================
 // Unexpected Terminating logic
 //=============================================================================================
@@ -594 +655 @@
 
 static __spinlock_t kernel_abort_lock;
-static __spinlock_t kernel_debug_lock;
 static bool kernel_abort_called = false;
 
-void * kernel_abort    (void) __attribute__ ((__nothrow__)) {
+void * kernel_abort(void) __attribute__ ((__nothrow__)) {
         // abort cannot be recursively entered by the same or different processors because all signal handlers return when
         // the globalAbort flag is true.
@@ -603 +663 @@
 
         // first task to abort ?
-        if ( ! kernel_abort_called ) {                  // not first task to abort ?
+        if ( kernel_abort_called ) {                    // not first task to abort ?
+                unlock( kernel_abort_lock );
+
+                sigset_t mask;
+                sigemptyset( &mask );
+                sigaddset( &mask, SIGALRM );            // block SIGALRM signals
+                sigsuspend( &mask );                    // block the processor to prevent further damage during abort
+                _exit( EXIT_FAILURE );                  // if processor unblocks before it is killed, terminate it
+        }
+        else {
                 kernel_abort_called = true;
                 unlock( kernel_abort_lock );
         }
-        else {
-                unlock( kernel_abort_lock );
-
-                sigset_t mask;
-                sigemptyset( &mask );
-                sigaddset( &mask, SIGALRM );                    // block SIGALRM signals
-                sigaddset( &mask, SIGUSR1 );                    // block SIGUSR1 signals
-                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
-                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
-        }
-
-        return TL_GET( this_thread );
+
+        return kernelTLS.this_thread;
 }
 
@@ -624 +683 @@
         thread_desc * thrd = kernel_data;
 
-        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
-        __cfaabi_dbg_bits_write( abort_text, len );
-
-        if ( get_coroutine(thrd) != TL_GET( this_coroutine ) ) {
-                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", TL_GET( this_coroutine )->name, TL_GET( this_coroutine ) );
+        if(thrd) {
+                int len = snprintf( abort_text, abort_text_size, "Error occurred while executing thread %.256s (%p)", thrd->self_cor.name, thrd );
                 __cfaabi_dbg_bits_write( abort_text, len );
+
+                if ( get_coroutine(thrd) != kernelTLS.this_coroutine ) {
+                        len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", kernelTLS.this_coroutine->name, kernelTLS.this_coroutine );
+                        __cfaabi_dbg_bits_write( abort_text, len );
+                }
+                else {
+                        __cfaabi_dbg_bits_write( ".\n", 2 );
+                }
         }
         else {
-                __cfaabi_dbg_bits_write( ".\n", 2 );
+                int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
         }
 }
 
 int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
-        return get_coroutine(TL_GET( this_thread )) == get_coroutine(mainThread) ? 4 : 2;
-}
+        return get_coroutine(kernelTLS.this_thread) == get_coroutine(mainThread) ? 4 : 2;
+}
+
+static __spinlock_t kernel_debug_lock;
 
 extern "C" {
@@ -667 +733 @@
         if ( count < 0 ) {
                 // queue current task
-                append( waiting, (thread_desc *)TL_GET( this_thread ) );
+                append( waiting, kernelTLS.this_thread );
 
                 // atomically release spin lock and block
@@ -693 +759 @@
 
 //-----------------------------------------------------------------------------
+// Global Queues
+void doregister( thread_desc & thrd ) {
+        // lock      ( global_thread.lock );
+        // push_front( global_thread.list, thrd );
+        // unlock    ( global_thread.lock );
+}
+
+void unregister( thread_desc & thrd ) {
+        // lock  ( global_thread.lock );
+        // remove( global_thread.list, thrd );
+        // unlock( global_thread.lock );
+}
+
+void doregister( cluster     & cltr ) {
+        // lock      ( global_cluster.lock );
+        // push_front( global_cluster.list, cltr );
+        // unlock    ( global_cluster.lock );
+}
+
+void unregister( cluster     & cltr ) {
+        // lock  ( global_cluster.lock );
+        // remove( global_cluster.list, cltr );
+        // unlock( global_cluster.lock );
+}
+
+
+void doregister( cluster * cltr, processor * proc ) {
+        // lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        // push_front(cltr->procs, *proc);
+        // unlock    (cltr->proc_list_lock);
+}
+
+void unregister( cluster * cltr, processor * proc ) {
+        // lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        // remove(cltr->procs, *proc );
+        // unlock(cltr->proc_list_lock);
+}
+
+//-----------------------------------------------------------------------------
 // Debug
 __cfaabi_dbg_debug_do(
-        struct {
-                thread_desc * tail;
-        } __cfaabi_dbg_thread_list = { NULL };
-
-        void __cfaabi_dbg_thread_register( thread_desc * thrd ) {
-                if( !__cfaabi_dbg_thread_list.tail ) {
-                        __cfaabi_dbg_thread_list.tail = thrd;
-                        return;
-                }
-                __cfaabi_dbg_thread_list.tail->dbg_next = thrd;
-                thrd->dbg_prev = __cfaabi_dbg_thread_list.tail;
-                __cfaabi_dbg_thread_list.tail = thrd;
-        }
-
-        void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) {
-                thread_desc * prev = thrd->dbg_prev;
-                thread_desc * next = thrd->dbg_next;
-
-                if( next ) { next->dbg_prev = prev; }
-                else       {
-                        assert( __cfaabi_dbg_thread_list.tail == thrd );
-                        __cfaabi_dbg_thread_list.tail = prev;
-                }
-
-                if( prev ) { prev->dbg_next = next; }
-
-                thrd->dbg_prev = NULL;
-                thrd->dbg_next = NULL;
+        void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
+                this.prev_name = prev_name;
+                this.prev_thrd = kernelTLS.this_thread;
         }
 )