Changeset 78b3f52 for src/libcfa/concurrency/threads.c

Timestamp:

Dec 2, 2016, 5:10:22 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

d7bcbf5

Parents:

4cb935e

Message:

Ugly but working coroutines

File:

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

src/libcfa/concurrency/threads.c

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// threads.c --
+//
+// Author           : Thierry Delisle
+// Created On       : Mon Nov 28 12:27:26 2016
+// Last Modified By : Thierry Delisle
+// Last Modified On : Mon Nov 28 12:27:26 2016
+// 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 "assert"
+#include "libhdr.h"
 
-#include <stddef.h>
+extern "C" { extern void coInvokeStub( void ); }
 
-#include <fstream>
- 
+// minimum feasible stack size in bytes
+#define MinStackSize 1000
+
 static coroutine main_coroutine;
 static coroutine* current_coroutine = &main_coroutine;
 
-void ctxSwitchDirect(void* src, void* dst) {
-        current_coroutine = dst;
+extern "C" {
+        struct machine_context_t {
+                void *SP;
+                void *FP;
+                void *PC;
+        };
+}
+
+extern "C" { void CtxSwitch( void *from, void *to ) asm ("CtxSwitch"); }// assembler routine that performs the context switch
+
+static size_t pageSize = 0;                             // architecture pagesize
+
+void ctxSwitchDirect(coroutine* src, coroutine* dst) {
+        // THREAD_GETMEM( This )->disableInterrupts();
+
+        // 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 invokeCoroutine(coVtable* vtable, void* this);
+
+forall(dtype T | coroutine_t(T))
+void startCoroutine(T* this, void (*invoke)(coVtable*, void*));
+
+// used by all constructors
+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;
 }
 
@@ -17 +120 @@
 }
 
+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;        
+        create_stack(this, this->size);
+}
+
 void ?{}(coroutine* this)
 {
+        this->name = "Anonymous Coroutine";
+        this->errno_ = 0;
+        this->state = Start;
+      this->notHalted = true;
+        this->starter = NULL;
         this->last = NULL;
-      this->name = "A Coroutine";
-      this->notHalted = true;
+}
+
+forall(dtype T | coroutine_t(T))
+void start(T* this) {
+        startCoroutine(this, invokeCoroutine);
 }
 
@@ -27 +149 @@
       coroutine* src = this_coroutine();                // optimization
 
-        assertf( src->last == (coroutine*)0, 
+        assertf( src->last != 0, 
                 "Attempt to suspend coroutine %.256s (%p) that has never been resumed.\n"
                 "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",
@@ -44 +166 @@
         coroutine* dst = this_coroutine(cor);
 
+        fprintf(stderr, "Resuming %p from %p\n", dst, src);
         if ( src != dst ) {                             // not resuming self ?
                 assertf( dst->notHalted , 
@@ -49 +172 @@
                         "Possible cause is terminated coroutine's main routine has already returned.",
                         src->name, src, dst->name, dst );
+                fprintf(stderr, "Assigning last pointer\n");
                 dst->last = src;                                        // set last resumer
         } // if
         ctxSwitchDirect( src, dst );                            // always done for performance testing
 }
+
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //