Changes in libcfa/src/concurrency/kernel.cfa [212c2187:deca0f5]

File:

• libcfa/src/concurrency/kernel.cfa (modified) (14 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 ) ));
@@ -42 +111 @@
 //-----------------------------------------------------------------------------
 // Kernel storage
-KERNEL_STORAGE(cluster,           mainCluster);
-KERNEL_STORAGE(processor,         mainProcessor);
-KERNEL_STORAGE(thread_desc,       mainThread);
-KERNEL_STORAGE(machine_context_t, mainThreadCtx);
+KERNEL_STORAGE(cluster,         mainCluster);
+KERNEL_STORAGE(processor,       mainProcessor);
+KERNEL_STORAGE(thread_desc,     mainThread);
+KERNEL_STORAGE(__stack_t,       mainThreadCtx);
 
 cluster     * mainCluster;
@@ -54 +123 @@
 struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
 }
+
+size_t __page_size = 0;
 
 //-----------------------------------------------------------------------------
@@ -66 +137 @@
 // Struct to steal stack
 struct current_stack_info_t {
-        machine_context_t ctx;
-        unsigned int size;              // size of stack
+        __stack_t * storage;            // pointer to stack object
         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 ) {
-        CtxGet( this.ctx );
-        this.base = this.ctx.FP;
-        this.storage = this.ctx.SP;
+        __stack_context_t ctx;
+        CtxGet( ctx );
+        this.base = ctx.FP;
 
         rlimit r;
         getrlimit( RLIMIT_STACK, &r);
-        this.size = r.rlim_cur;
-
-        this.limit = (void *)(((intptr_t)this.base) - this.size);
+        size_t size = r.rlim_cur;
+
+        this.limit = (void *)(((intptr_t)this.base) - 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{ info };
+        stack.storage = info->storage;
+        with(*stack.storage) {
+                limit     = info->limit;
+                base      = info->base;
+        }
+        *((intptr_t*)&stack.storage) |= 0x1;
         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;
@@ -240 +305 @@
 }
 
+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 * dst) {
-        assert(dst->curr_cor);
+static void runThread(processor * this, thread_desc * thrd_dst) {
         coroutine_desc * proc_cor = get_coroutine(this->runner);
-        coroutine_desc * thrd_cor = dst->curr_cor;
 
         // Reset the terminating actions here
@@ -252 +318 @@
 
         // Update global state
-        kernelTLS.this_thread = dst;
-
-        // Context Switch to the thread
-        ThreadCtxSwitch(proc_cor, thrd_cor);
-        // when ThreadCtxSwitch returns we are back in the processor coroutine
+        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;
 }
 
@@ -262 +337 @@
 static void returnToKernel() {
         coroutine_desc * proc_cor = get_coroutine(kernelTLS.this_processor->runner);
-        coroutine_desc * thrd_cor = kernelTLS.this_thread->curr_cor;
-        ThreadCtxSwitch(thrd_cor, proc_cor);
+        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;
 }
 
@@ -312 +408 @@
         // to waste the perfectly valid stack create by pthread.
         current_stack_info_t info;
-        machine_context_t ctx;
-        info.context = &ctx;
+        __stack_t ctx;
+        info.storage = &ctx;
         (proc->runner){ proc, &info };
 
-        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.base);
+        __cfaabi_dbg_print_safe("Coroutine : created stack %p\n", get_coroutine(proc->runner)->stack.storage);
 
         //Set global state
@@ -347 +443 @@
 
 // KERNEL_ONLY
-void kernel_first_resume(processor * this) {
-        coroutine_desc * src = mainThread->curr_cor;
+void kernel_first_resume( processor * this ) {
+        thread_desc * src = mainThread;
         coroutine_desc * dst = get_coroutine(this->runner);
 
         verify( ! kernelTLS.preemption_state.enabled );
 
-        create_stack(&dst->stack, dst->stack.size);
+        __stack_prepare( &dst->stack, 65000 );
         CtxStart(&this->runner, CtxInvokeCoroutine);
 
         verify( ! kernelTLS.preemption_state.enabled );
 
-        dst->last = src;
-        dst->starter = dst->starter ? dst->starter : src;
+        dst->last = &src->self_cor;
+        dst->starter = dst->starter ? dst->starter : &src->self_cor;
 
         // set state of current coroutine to inactive
         src->state = src->state == Halted ? Halted : Inactive;
 
-        // 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
-        assert( src->stack.context );
-        CtxSwitch( src->stack.context, dst->stack.context );
+        verify( dst->context.SP );
+        CtxSwitch( &src->context, &dst->context );
         // when CtxSwitch returns we are back in the src coroutine
 
@@ -380 +469 @@
 
         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 );
 }
 
@@ -388 +490 @@
 void ScheduleThread( thread_desc * thrd ) {
         verify( thrd );
-        verify( thrd->self_cor.state != Halted );
+        verify( thrd->state != Halted );
 
         verify( ! kernelTLS.preemption_state.enabled );
@@ -545 +647 @@
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 
+        __page_size = sysconf( _SC_PAGESIZE );
+
         __cfa_dbg_global_clusters.list{ __get };
         __cfa_dbg_global_clusters.lock{};
@@ -559 +663 @@
         mainThread = (thread_desc *)&storage_mainThread;
         current_stack_info_t info;
+        info.storage = (__stack_t*)&storage_mainThreadCtx;
         (*mainThread){ &info };
 
@@ -627 +732 @@
         // which is currently here
         __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
-        returnToKernel();
+        kernel_last_resume( kernelTLS.this_processor );
         mainThread->self_cor.state = Halted;