Changes in libcfa/src/concurrency/kernel.cfa [ffe2fad:afc2427]

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -36 +36 @@
 #include "invoke.h"
 
-//-----------------------------------------------------------------------------
-// Some assembly required
-#if   defined( __i386 )
-        #define CtxGet( ctx )        \
-                __asm__ volatile (     \
-                        "movl %%esp,%0\n"\
-                        "movl %%ebp,%1\n"\
-                        : "=rm" (ctx.SP),\
-                                "=rm" (ctx.FP) \
-                )
-
-        // mxcr : SSE Status and Control bits (control bits are preserved across function calls)
-        // fcw  : X87 FPU control word (preserved across function calls)
-        #define __x87_store         \
-                uint32_t __mxcr;      \
-                uint16_t __fcw;       \
-                __asm__ volatile (    \
-                        "stmxcsr %0\n"  \
-                        "fnstcw  %1\n"  \
-                        : "=m" (__mxcr),\
-                                "=m" (__fcw)  \
-                )
-
-        #define __x87_load         \
-                __asm__ volatile (   \
-                        "fldcw  %1\n"  \
-                        "ldmxcsr %0\n" \
-                        ::"m" (__mxcr),\
-                                "m" (__fcw)  \
-                )
-
-#elif defined( __x86_64 )
-        #define CtxGet( ctx )        \
-                __asm__ volatile (     \
-                        "movq %%rsp,%0\n"\
-                        "movq %%rbp,%1\n"\
-                        : "=rm" (ctx.SP),\
-                                "=rm" (ctx.FP) \
-                )
-
-        #define __x87_store         \
-                uint32_t __mxcr;      \
-                uint16_t __fcw;       \
-                __asm__ volatile (    \
-                        "stmxcsr %0\n"  \
-                        "fnstcw  %1\n"  \
-                        : "=m" (__mxcr),\
-                                "=m" (__fcw)  \
-                )
-
-        #define __x87_load          \
-                __asm__ volatile (    \
-                        "fldcw  %1\n"   \
-                        "ldmxcsr %0\n"  \
-                        :: "m" (__mxcr),\
-                                "m" (__fcw)  \
-                )
-
-
-#elif defined( __ARM_ARCH )
-#define CtxGet( ctx ) __asm__ ( \
-                "mov %0,%%sp\n"   \
-                "mov %1,%%r11\n"   \
-        : "=rm" (ctx.SP), "=rm" (ctx.FP) )
-#else
-        #error unknown hardware architecture
-#endif
-
-//-----------------------------------------------------------------------------
 //Start and stop routine for the kernel, declared first to make sure they run first
 static void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
@@ -111 +42 @@
 //-----------------------------------------------------------------------------
 // Kernel storage
-KERNEL_STORAGE(cluster,         mainCluster);
-KERNEL_STORAGE(processor,       mainProcessor);
-KERNEL_STORAGE(thread_desc,     mainThread);
-KERNEL_STORAGE(__stack_t,       mainThreadCtx);
+KERNEL_STORAGE(cluster,           mainCluster);
+KERNEL_STORAGE(processor,         mainProcessor);
+KERNEL_STORAGE(thread_desc,       mainThread);
+KERNEL_STORAGE(machine_context_t, mainThreadCtx);
 
 cluster     * mainCluster;
@@ -123 +54 @@
 struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
 }
-
-size_t __page_size = 0;
 
 //-----------------------------------------------------------------------------
@@ -131 +60 @@
         NULL,
         NULL,
+        NULL,
         { 1, false, false }
 };
@@ -137 +67 @@
 // Struct to steal stack
 struct current_stack_info_t {
-        __stack_t * storage;            // pointer to stack object
+        machine_context_t ctx;
+        unsigned int size;              // size of stack
         void *base;                             // base of stack
+        void *storage;                  // pointer to stack
         void *limit;                    // stack grows towards stack limit
         void *context;                  // address of cfa_context_t
+        void *top;                              // address of top of storage
 };
 
 void ?{}( current_stack_info_t & this ) {
-        __stack_context_t ctx;
-        CtxGet( ctx );
-        this.base = ctx.FP;
+        CtxGet( this.ctx );
+        this.base = this.ctx.FP;
+        this.storage = this.ctx.SP;
 
         rlimit r;
         getrlimit( RLIMIT_STACK, &r);
-        size_t size = r.rlim_cur;
-
-        this.limit = (void *)(((intptr_t)this.base) - size);
+        this.size = r.rlim_cur;
+
+        this.limit = (void *)(((intptr_t)this.base) - this.size);
         this.context = &storage_mainThreadCtx;
+        this.top = this.base;
 }
 
 //-----------------------------------------------------------------------------
 // Main thread construction
+void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
+        size      = info->size;
+        storage   = info->storage;
+        limit     = info->limit;
+        base      = info->base;
+        context   = info->context;
+        top       = info->top;
+        userStack = true;
+}
 
 void ?{}( coroutine_desc & this, current_stack_info_t * info) with( this ) {
-        stack.storage = info->storage;
-        with(*stack.storage) {
-                limit     = info->limit;
-                base      = info->base;
-        }
-        __attribute__((may_alias)) intptr_t * istorage = (intptr_t*) &stack.storage;
-        *istorage |= 0x1;
+        stack{ info };
         name = "Main Thread";
+        errno_ = 0;
         state = Start;
         starter = NULL;
-        last = NULL;
-        cancellation = NULL;
 }
 
 void ?{}( thread_desc & this, current_stack_info_t * info) with( this ) {
-        state = Start;
         self_cor{ info };
         curr_cor = &self_cor;
@@ -306 +241 @@
 }
 
-static int * __volatile_errno() __attribute__((noinline));
-static int * __volatile_errno() { asm(""); return &errno; }
-
 // KERNEL ONLY
 // runThread runs a thread by context switching
 // from the processor coroutine to the target thread
-static void runThread(processor * this, thread_desc * thrd_dst) {
+static void runThread(processor * this, thread_desc * dst) {
+        assert(dst->curr_cor);
         coroutine_desc * proc_cor = get_coroutine(this->runner);
+        coroutine_desc * thrd_cor = dst->curr_cor;
 
         // Reset the terminating actions here
@@ -319 +253 @@
 
         // Update global state
-        kernelTLS.this_thread = thrd_dst;
-
-        // set state of processor coroutine to inactive and the thread to active
-        proc_cor->state = proc_cor->state == Halted ? Halted : Inactive;
-        thrd_dst->state = Active;
-
-        // set context switch to the thread that the processor is executing
-        verify( thrd_dst->context.SP );
-        CtxSwitch( &proc_cor->context, &thrd_dst->context );
-        // when CtxSwitch returns we are back in the processor coroutine
-
-        // set state of processor coroutine to active and the thread to inactive
-        thrd_dst->state = thrd_dst->state == Halted ? Halted : Inactive;
-        proc_cor->state = Active;
+        kernelTLS.this_thread = dst;
+
+        // Context Switch to the thread
+        ThreadCtxSwitch(proc_cor, thrd_cor);
+        // when ThreadCtxSwitch returns we are back in the processor coroutine
 }
 
@@ -338 +263 @@
 static void returnToKernel() {
         coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
-        thread_desc * thrd_src = kernelTLS.this_thread;
-
-        // set state of current coroutine to inactive
-        thrd_src->state = thrd_src->state == Halted ? Halted : Inactive;
-        proc_cor->state = Active;
-        int local_errno = *__volatile_errno();
-        #if defined( __i386 ) || defined( __x86_64 )
-                __x87_store;
-        #endif
-
-        // set new coroutine that the processor is executing
-        // and context switch to it
-        verify( proc_cor->context.SP );
-        CtxSwitch( &thrd_src->context, &proc_cor->context );
-
-        // set state of new coroutine to active
-        proc_cor->state = proc_cor->state == Halted ? Halted : Inactive;
-        thrd_src->state = Active;
-
-        #if defined( __i386 ) || defined( __x86_64 )
-                __x87_load;
-        #endif
-        *__volatile_errno() = local_errno;
+        coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor = kernelTLS.this_coroutine;
+        ThreadCtxSwitch(thrd_cor, proc_cor);
 }
 
@@ -403 +307 @@
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
+        kernelTLS.this_coroutine = NULL;
         kernelTLS.this_thread    = NULL;
         kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
@@ -409 +314 @@
         // to waste the perfectly valid stack create by pthread.
         current_stack_info_t info;
-        __stack_t ctx;
-        info.storage = &ctx;
+        machine_context_t ctx;
+        info.context = &ctx;
         (proc->runner){ proc, &info };
 
-        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.storage);
+        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.base);
 
         //Set global state
+        kernelTLS.this_coroutine = get_coroutine(proc->runner);
         kernelTLS.this_thread    = NULL;
 
@@ -444 +350 @@
 
 // KERNEL_ONLY
-void kernel_first_resume( processor * this ) {
-        thread_desc * src = mainThread;
+void kernel_first_resume(processor * this) {
+        coroutine_desc * src = kernelTLS.this_coroutine;
         coroutine_desc * dst = get_coroutine(this->runner);
 
         verify( ! kernelTLS.preemption_state.enabled );
 
-        __stack_prepare( &dst->stack, 65000 );
+        create_stack(&dst->stack, dst->stack.size);
         CtxStart(&this->runner, CtxInvokeCoroutine);
 
         verify( ! kernelTLS.preemption_state.enabled );
 
-        dst->last = &src->self_cor;
-        dst->starter = dst->starter ? dst->starter : &src->self_cor;
+        dst->last = src;
+        dst->starter = dst->starter ? dst->starter : src;
 
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Inactive;
 
+        // set new coroutine that task is executing
+        kernelTLS.this_coroutine = dst;
+
+        // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
+        // Therefore, when first creating a coroutine, interrupts are enable before calling the main.
+        // This is consistent with thread creation. However, when creating the main processor coroutine,
+        // we wan't interrupts to be disabled. Therefore, we double-disable interrupts here so they will
+        // stay disabled.
+        disable_interrupts();
+
         // context switch to specified coroutine
-        verify( dst->context.SP );
-        CtxSwitch( &src->context, &dst->context );
+        assert( src->stack.context );
+        CtxSwitch( src->stack.context, dst->stack.context );
         // when CtxSwitch returns we are back in the src coroutine
 
@@ -470 +386 @@
 
         verify( ! kernelTLS.preemption_state.enabled );
-}
-
-// KERNEL_ONLY
-void kernel_last_resume( processor * this ) {
-        coroutine_desc * src = &mainThread->self_cor;
-        coroutine_desc * dst = get_coroutine(this->runner);
-
-        verify( ! kernelTLS.preemption_state.enabled );
-        verify( dst->starter == src );
-        verify( dst->context.SP );
-
-        // context switch to the processor
-        CtxSwitch( &src->context, &dst->context );
 }
 
@@ -491 +394 @@
 void ScheduleThread( thread_desc * thrd ) {
         verify( thrd );
-        verify( thrd->state != Halted );
+        verify( thrd->self_cor.state != Halted );
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -648 +551 @@
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 
-        __page_size = sysconf( _SC_PAGESIZE );
-
         __cfa_dbg_global_clusters.list{ __get };
         __cfa_dbg_global_clusters.lock{};
@@ -664 +565 @@
         mainThread = (thread_desc *)&storage_mainThread;
         current_stack_info_t info;
-        info.storage = (__stack_t*)&storage_mainThreadCtx;
         (*mainThread){ &info };
 
@@ -699 +599 @@
         kernelTLS.this_processor = mainProcessor;
         kernelTLS.this_thread    = mainThread;
+        kernelTLS.this_coroutine = &mainThread->self_cor;
 
         // Enable preemption
@@ -733 +634 @@
         // which is currently here
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
-        kernel_last_resume( kernelTLS.this_processor );
+        returnToKernel();
         mainThread->self_cor.state = Halted;
 
@@ -819 +720 @@
                 __cfaabi_dbg_bits_write( abort_text, len );
 
-                if ( &thrd->self_cor != thrd->curr_cor ) {
-                        len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", thrd->curr_cor->name, thrd->curr_cor );
+                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 );
                 }