Changes in src/libcfa/concurrency/threads.c [596f987b:c84e80a]

File:

• src/libcfa/concurrency/threads.c (modified) (3 diffs)

src/libcfa/concurrency/threads.c

@@ +1 @@
+//                              -*- Mode: CFA -*-
 //
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
@@ -8 +9 @@
 //
 // Author           : Thierry Delisle
-// Created On       : Mon Nov 28 12:27:26 2016
+// Created On       : Tue Jan 17 12:27:26 2016
 // Last Modified By : Thierry Delisle
-// Last Modified On : Mon Nov 28 12:27:26 2016
+// Last Modified On : --
 // Update Count     : 0
 //
 
-extern "C" {
-#include <stddef.h>
-#include <malloc.h>
-#include <errno.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/mman.h>
-}
+#include "threads"
 
-#include "threads"
+#include "kernel"
 #include "libhdr.h"
 
@@ -29 +23 @@
 #include "invoke.h"
 
-//-----------------------------------------------------------------------------
-// Global state variables
-
-// minimum feasible stack size in bytes
-#define MinStackSize 1000
-static size_t pageSize = 0;                             // architecture pagesize HACK, should go in proper runtime singleton
-
-//Extra private desctructor for the main
-//FIXME the main should not actually allocate a stack
-//Since the main is never resumed the extra stack does not cause 
-//any problem but it is wasted memory
-void ?{}(coStack_t* this, size_t size);
-void ?{}(coroutine* this, size_t size);
-
-//Main coroutine
-//FIXME do not construct a stack for the main
-coroutine main_coroutine = { 1000 };
-
-//Current coroutine
-//Will need to be in TLS when multi-threading is added
-coroutine* current_coroutine = &main_coroutine;
+#include <stdlib>
 
 //-----------------------------------------------------------------------------
-// Coroutine ctors and dtors
-void ?{}(coStack_t* this) {
-        this->size              = 10240;        // size of stack
-        this->storage   = NULL; // pointer to stack
-        this->limit             = NULL; // stack grows towards stack limit
-        this->base              = NULL; // base of stack
-        this->context   = NULL; // address of cfa_context_t
-        this->top               = NULL; // address of top of storage
-        this->userStack = false;        
+// Forward declarations
+forall(otype T | is_thread(T) )
+void start( thread(T)* this );
+
+forall(otype T | is_thread(T) )
+void stop( thread(T)* this );
+
+//-----------------------------------------------------------------------------
+// Thread ctors and dtors
+
+void ?{}(thread_h* this) {
+        (&this->c){};
 }
 
-void ?{}(coStack_t* this, size_t size) {
-        this{};
-        this->size = size;
-
-        create_stack(this, this->size);
+void ^?{}(thread_h* this) {
+        ^(&this->c){};
 }
 
-void ?{}(coroutine* this) {
-        this->name = "Anonymous Coroutine";
-        this->errno_ = 0;
-        this->state = Start;
-      this->notHalted = true;
-        this->starter = NULL;
-        this->last = NULL;
+forall(otype T | is_thread(T) )
+void ?{}( thread(T)* this ) {
+        printf("thread() ctor\n");
+        (&this->handle){};
+        start(this);
 }
 
-void ?{}(coroutine* this, size_t size) {
-        this{};
-        (&this->stack){size};
+forall(otype T, ttype P | is_thread(T) | { void ?{}(T*, P); } )
+void ?{}( thread(T)* this, P params ) {
+        (&this->handle){ params };
+        start(this);
 }
 
-void ^?{}(coStack_t* this) {
-        if ( ! this->userStack ) {
-                LIB_DEBUG_DO(
-                        if ( mprotect( this->storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
-                                abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", this, errno, strerror( errno ) );
-                        }
-                );
-                free( this->storage );
-        }
+forall(otype T | is_thread(T) )
+void ^?{}( thread(T)* this ) {
+        stop(this);
+        ^(&this->handle){};
 }
 
-void ^?{}(coroutine* this) {}
-
-// Part of the Public API
-// Not inline since only ever called once per coroutine
-forall(dtype T | is_coroutine(T))
-void prime(T* cor) {
-        coroutine* this = get_coroutine(cor);
-        assert(this->state == Start);
-
-        this->state = Primed;
-        resume(cor);
+//-----------------------------------------------------------------------------
+// Starting and stopping threads
+extern "C" {
+      forall(dtype T | is_thread(T))
+      void CtxInvokeThread(T * this);
 }
 
-// We need to call suspend from invoke.c, so we expose this wrapper that
-// is not inline (We can't inline Cforall in C)
-void suspend_no_inline(void) {
-        suspend();
+forall(otype T | is_thread(T))
+void start( thread(T)* this ) {
+        T* handle  = &this->handle;
+        coroutine* thrd_c = get_coroutine(handle);
+        thread_h*  thrd_h = get_thread   (handle);
+        thrd_c->last = this_coroutine();
+        current_coroutine = thrd_c;
+
+        // LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", handle, thrd_c, thrd_h);
+
+        create_stack(&thrd_c->stack, thrd_c->stack.size);
+        CtxStart(handle, CtxInvokeThread);
+        CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context );
+
+        scheduler_add(thrd_h);
 }
 
-void corCxtSw(coroutine* src, coroutine* dst) {
-        // THREAD_GETMEM( This )->disableInterrupts();
+forall(otype T | is_thread(T) )
+void stop( thread(T)* this ) {
 
-        // set state of current coroutine to inactive
-        src->state = Inactive;
-
-        // set new coroutine that task is executing
-        current_coroutine = dst;                        
-
-        // context switch to specified coroutine
-        CtxSwitch( src->stack.context, dst->stack.context );
-        // when CtxSwitch returns we are back in the src coroutine              
-
-        // set state of new coroutine to active
-        src->state = Active;
-
-        // THREAD_GETMEM( This )->enableInterrupts();
-} //ctxSwitchDirect
-
-void create_stack( coStack_t* this, unsigned int storageSize ) {
-        //TEMP HACK do this on proper kernel startup
-        if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
-
-        size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
-
-        if ( (intptr_t)this->storage == 0 ) {
-                this->userStack = false;
-                this->size = libCeiling( storageSize, 16 );
-                // use malloc/memalign because "new" raises an exception for out-of-memory
-                
-                // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment
-                LIB_DEBUG_DO( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );
-                LIB_NO_DEBUG_DO( this->storage = malloc( cxtSize + this->size + 8 ) );
-
-                LIB_DEBUG_DO(
-                        if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) {
-                                abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );
-                        } // if
-                );
-
-                if ( (intptr_t)this->storage == 0 ) {
-                        abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", this->size );
-                } // if
-
-                LIB_DEBUG_DO( this->limit = (char *)this->storage + pageSize );
-                LIB_NO_DEBUG_DO( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment
-
-        } else {
-                assertf( ((size_t)this->storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", this->storage, (int)libAlign() );
-                this->userStack = true;
-                this->size = storageSize - cxtSize;
-
-                if ( this->size % 16 != 0u ) this->size -= 8;
-
-                this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ); // minimum alignment
-        } // if
-        assertf( this->size >= MinStackSize, "Stack size %d provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
-
-        this->base = (char *)this->limit + this->size;
-        this->context = this->base;
-        this->top = (char *)this->context + cxtSize;
 }