Changeset 68e6031 for src/libcfa/concurrency
- Timestamp:
- Jan 18, 2017, 9:24:12 PM (7 years ago)
- 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:
- 6acb935, e9e4e9ee
- Parents:
- 1ab7d3fe (diff), c84e80a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- src/libcfa/concurrency
- Files:
-
- 4 added
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
src/libcfa/concurrency/invoke.c
r1ab7d3fe r68e6031 14 14 15 15 extern void __suspend_no_inline__F___1(void); 16 extern void __scheduler_remove__F_P9sthread_h__1(struct thread_h*); 16 17 17 18 void CtxInvokeCoroutine( … … 20 21 void *this 21 22 ) { 22 LIB_DEBUG_PRINTF("Invoke : Received %p (main %p, get_c %p)\n", this, main, get_coroutine);23 // LIB_DEBUG_PRINTF("Invoke Coroutine : Received %p (main %p, get_c %p)\n", this, main, get_coroutine); 23 24 24 25 struct coroutine* cor = get_coroutine( this ); … … 31 32 32 33 main( this ); 34 35 //Final suspend, should never return 36 __suspend_no_inline__F___1(); 37 assertf(false, "Resumed dead coroutine"); 38 } 39 40 void CtxInvokeThread( 41 void (*main)(void *), 42 struct thread_h *(*get_thread)(void *), 43 void *this 44 ) { 45 // LIB_DEBUG_PRINTF("Invoke Thread : Received %p (main %p, get_t %p)\n", this, main, get_thread); 46 47 __suspend_no_inline__F___1(); 48 49 struct thread_h* thrd = get_thread( this ); 50 struct coroutine* cor = &thrd->c; 51 cor->state = Active; 52 53 // LIB_DEBUG_PRINTF("Invoke Thread : invoking main %p (args %p)\n", main, this); 54 main( this ); 55 56 __scheduler_remove__F_P9sthread_h__1(thrd); 57 58 //Final suspend, should never return 59 __suspend_no_inline__F___1(); 60 assertf(false, "Resumed dead thread"); 33 61 } 34 62 … … 40 68 void (*invoke)(void *) 41 69 ) { 42 LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (main %p, get_c %p) to %p\n", this, main, get_coroutine, invoke);70 // LIB_DEBUG_PRINTF("StartCoroutine : Passing in %p (main %p) to invoke (%p) from start (%p)\n", this, main, invoke, CtxStart); 43 71 44 72 struct coStack_t* stack = &get_coroutine( this )->stack; -
src/libcfa/concurrency/invoke.h
r1ab7d3fe r68e6031 35 35 }; 36 36 37 struct thread_h { 38 struct coroutine c; 39 }; 40 37 41 #endif //_INVOKE_H_ 38 42 #else //! defined(__CFA_INVOKE_PRIVATE__) -
src/libcfa/concurrency/threads
r1ab7d3fe r68e6031 9 9 // 10 10 // Author : Thierry Delisle 11 // Created On : Mon Nov 2812:27:26 201611 // Created On : Tue Jan 17 12:27:26 2016 12 12 // Last Modified By : Thierry Delisle 13 // Last Modified On : Mon Nov 28 12:27:26 201613 // Last Modified On : -- 14 14 // Update Count : 0 15 15 // … … 18 18 #define THREADS_H 19 19 20 #include "assert" //20 #include "assert" 21 21 #include "invoke.h" 22 23 #include "coroutines" 22 24 23 25 //----------------------------------------------------------------------------- … … 25 27 // Anything that implements this trait can be resumed. 26 28 // Anything that is resumed is a coroutine. 27 trait is_coroutine(dtype T) { 28 void co_main(T* this); 29 coroutine* get_coroutine(T* this); 29 trait is_thread(dtype T /*| sized(T)*/) { 30 void main(T* this); 31 thread_h* get_thread(T* this); 32 /*void ?{}(T*); 33 void ^?{}(T*);*/ 30 34 }; 35 36 forall(otype T | is_thread(T) ) 37 static inline coroutine* get_coroutine(T* this) { 38 return &get_thread(this)->c; 39 } 40 41 static inline coroutine* get_coroutine(thread_h* this) { 42 return &this->c; 43 } 31 44 32 45 //----------------------------------------------------------------------------- 33 46 // Ctors and dtors 34 void ?{}(coStack_t* this); 35 void ?{}(coroutine* this); 36 void ^?{}(coStack_t* this); 37 void ^?{}(coroutine* this); 47 void ?{}(thread_h* this); 48 void ^?{}(thread_h* this); 38 49 39 50 //----------------------------------------------------------------------------- 40 // Public coroutine API 41 static inline void suspend(); 51 // thread runner 52 // Structure that actually start and stop threads 53 forall(otype T | is_thread(T) ) 54 struct thread { 55 T handle; 56 }; 42 57 43 forall( dtype T | is_coroutine(T))44 static inline void resume(T* cor);58 forall(otype T | is_thread(T) ) 59 void ?{}( thread(T)* this ); 45 60 46 forall(dtype T | is_coroutine(T)) 47 void prime(T* cor); 61 forall(otype T, ttype P | is_thread(T) | { void ?{}(T*, P); } ) 62 void ?{}( thread(T)* this, P params ); 63 64 forall(otype T | is_thread(T) ) 65 void ^?{}( thread(T)* this ); 48 66 49 67 //----------------------------------------------------------------------------- 50 68 // PRIVATE exposed because of inline 51 52 // Start coroutine routines53 extern "C" {54 forall(dtype T | is_coroutine(T))55 void CtxInvokeCoroutine(T* this);56 57 forall(dtype T | is_coroutine(T))58 void CtxStart(T* this, void (*invoke)(T*));59 }60 61 // Get current coroutine62 extern coroutine* current_coroutine; //PRIVATE, never use directly63 static inline coroutine* this_coroutine(void) {64 return current_coroutine;65 }66 67 // Private wrappers for context switch and stack creation68 extern void corCxtSw(coroutine* src, coroutine* dst);69 extern void create_stack( coStack_t* this, unsigned int storageSize );70 71 // Suspend implementation inlined for performance72 static inline void suspend() {73 coroutine* src = this_coroutine(); // optimization74 75 assertf( src->last != 0,76 "Attempt to suspend coroutine %.256s (%p) that has never been resumed.\n"77 "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.",78 src->name, src );79 assertf( src->last->notHalted,80 "Attempt by coroutine %.256s (%p) to suspend back to terminated coroutine %.256s (%p).\n"81 "Possible cause is terminated coroutine's main routine has already returned.",82 src->name, src, src->last->name, src->last );83 84 corCxtSw( src, src->last );85 }86 87 // Resume implementation inlined for performance88 forall(dtype T | is_coroutine(T))89 static inline void resume(T* cor) {90 coroutine* src = this_coroutine(); // optimization91 coroutine* dst = get_coroutine(cor);92 93 if( unlikely(!dst->stack.base) ) {94 create_stack(&dst->stack, dst->stack.size);95 CtxStart(cor, CtxInvokeCoroutine);96 }97 98 // not resuming self ?99 if ( src != dst ) {100 assertf( dst->notHalted ,101 "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n"102 "Possible cause is terminated coroutine's main routine has already returned.",103 src->name, src, dst->name, dst );104 105 // set last resumer106 dst->last = src;107 } // if108 109 // always done for performance testing110 corCxtSw( src, dst );111 }112 69 113 70 #endif //THREADS_H -
src/libcfa/concurrency/threads.c
r1ab7d3fe r68e6031 1 // -*- Mode: CFA -*- 1 2 // 2 3 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo … … 8 9 // 9 10 // Author : Thierry Delisle 10 // Created On : Mon Nov 2812:27:26 201611 // Created On : Tue Jan 17 12:27:26 2016 11 12 // Last Modified By : Thierry Delisle 12 // Last Modified On : Mon Nov 28 12:27:26 201613 // Last Modified On : -- 13 14 // Update Count : 0 14 15 // 15 16 16 extern "C" { 17 #include <stddef.h> 18 #include <malloc.h> 19 #include <errno.h> 20 #include <string.h> 21 #include <unistd.h> 22 #include <sys/mman.h> 23 } 17 #include "threads" 24 18 25 #include " threads"19 #include "kernel" 26 20 #include "libhdr.h" 27 21 … … 29 23 #include "invoke.h" 30 24 31 //----------------------------------------------------------------------------- 32 // Global state variables 33 34 // minimum feasible stack size in bytes 35 #define MinStackSize 1000 36 static size_t pageSize = 0; // architecture pagesize HACK, should go in proper runtime singleton 37 38 //Extra private desctructor for the main 39 //FIXME the main should not actually allocate a stack 40 //Since the main is never resumed the extra stack does not cause 41 //any problem but it is wasted memory 42 void ?{}(coStack_t* this, size_t size); 43 void ?{}(coroutine* this, size_t size); 44 45 //Main coroutine 46 //FIXME do not construct a stack for the main 47 coroutine main_coroutine = { 1000 }; 48 49 //Current coroutine 50 //Will need to be in TLS when multi-threading is added 51 coroutine* current_coroutine = &main_coroutine; 25 #include <stdlib> 52 26 53 27 //----------------------------------------------------------------------------- 54 // Coroutine ctors and dtors 55 void ?{}(coStack_t* this) { 56 this->size = 10240; // size of stack 57 this->storage = NULL; // pointer to stack 58 this->limit = NULL; // stack grows towards stack limit 59 this->base = NULL; // base of stack 60 this->context = NULL; // address of cfa_context_t 61 this->top = NULL; // address of top of storage 62 this->userStack = false; 28 // Forward declarations 29 forall(otype T | is_thread(T) ) 30 void start( thread(T)* this ); 31 32 forall(otype T | is_thread(T) ) 33 void stop( thread(T)* this ); 34 35 //----------------------------------------------------------------------------- 36 // Thread ctors and dtors 37 38 void ?{}(thread_h* this) { 39 (&this->c){}; 63 40 } 64 41 65 void ?{}(coStack_t* this, size_t size) { 66 this{}; 67 this->size = size; 68 69 create_stack(this, this->size); 42 void ^?{}(thread_h* this) { 43 ^(&this->c){}; 70 44 } 71 45 72 void ?{}(coroutine* this) { 73 this->name = "Anonymous Coroutine"; 74 this->errno_ = 0; 75 this->state = Start; 76 this->notHalted = true; 77 this->starter = NULL; 78 this->last = NULL; 46 forall(otype T | is_thread(T) ) 47 void ?{}( thread(T)* this ) { 48 printf("thread() ctor\n"); 49 (&this->handle){}; 50 start(this); 79 51 } 80 52 81 void ?{}(coroutine* this, size_t size) { 82 this{}; 83 (&this->stack){size}; 53 forall(otype T, ttype P | is_thread(T) | { void ?{}(T*, P); } ) 54 void ?{}( thread(T)* this, P params ) { 55 (&this->handle){ params }; 56 start(this); 84 57 } 85 58 86 void ^?{}(coStack_t* this) { 87 if ( ! this->userStack ) { 88 LIB_DEBUG_DO( 89 if ( mprotect( this->storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) { 90 abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", this, errno, strerror( errno ) ); 91 } 92 ); 93 free( this->storage ); 94 } 59 forall(otype T | is_thread(T) ) 60 void ^?{}( thread(T)* this ) { 61 stop(this); 62 ^(&this->handle){}; 95 63 } 96 64 97 void ^?{}(coroutine* this) {} 98 99 // Part of the Public API 100 // Not inline since only ever called once per coroutine 101 forall(dtype T | is_coroutine(T)) 102 void prime(T* cor) { 103 coroutine* this = get_coroutine(cor); 104 assert(this->state == Start); 105 106 this->state = Primed; 107 resume(cor); 65 //----------------------------------------------------------------------------- 66 // Starting and stopping threads 67 extern "C" { 68 forall(dtype T | is_thread(T)) 69 void CtxInvokeThread(T * this); 108 70 } 109 71 110 // We need to call suspend from invoke.c, so we expose this wrapper that 111 // is not inline (We can't inline Cforall in C) 112 void suspend_no_inline(void) { 113 suspend(); 72 forall(otype T | is_thread(T)) 73 void start( thread(T)* this ) { 74 T* handle = &this->handle; 75 coroutine* thrd_c = get_coroutine(handle); 76 thread_h* thrd_h = get_thread (handle); 77 thrd_c->last = this_coroutine(); 78 current_coroutine = thrd_c; 79 80 // LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", handle, thrd_c, thrd_h); 81 82 create_stack(&thrd_c->stack, thrd_c->stack.size); 83 CtxStart(handle, CtxInvokeThread); 84 CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context ); 85 86 scheduler_add(thrd_h); 114 87 } 115 88 116 void corCxtSw(coroutine* src, coroutine* dst) { 117 // THREAD_GETMEM( This )->disableInterrupts(); 89 forall(otype T | is_thread(T) ) 90 void stop( thread(T)* this ) { 118 91 119 // set state of current coroutine to inactive120 src->state = Inactive;121 122 // set new coroutine that task is executing123 current_coroutine = dst;124 125 // context switch to specified coroutine126 CtxSwitch( src->stack.context, dst->stack.context );127 // when CtxSwitch returns we are back in the src coroutine128 129 // set state of new coroutine to active130 src->state = Active;131 132 // THREAD_GETMEM( This )->enableInterrupts();133 } //ctxSwitchDirect134 135 void create_stack( coStack_t* this, unsigned int storageSize ) {136 //TEMP HACK do this on proper kernel startup137 if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );138 139 size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment140 141 if ( (intptr_t)this->storage == 0 ) {142 this->userStack = false;143 this->size = libCeiling( storageSize, 16 );144 // use malloc/memalign because "new" raises an exception for out-of-memory145 146 // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment147 LIB_DEBUG_DO( this->storage = memalign( pageSize, cxtSize + this->size + pageSize ) );148 LIB_NO_DEBUG_DO( this->storage = malloc( cxtSize + this->size + 8 ) );149 150 LIB_DEBUG_DO(151 if ( mprotect( this->storage, pageSize, PROT_NONE ) == -1 ) {152 abortf( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) );153 } // if154 );155 156 if ( (intptr_t)this->storage == 0 ) {157 abortf( "Attempt to allocate %d bytes of storage for coroutine or task execution-state but insufficient memory available.", this->size );158 } // if159 160 LIB_DEBUG_DO( this->limit = (char *)this->storage + pageSize );161 LIB_NO_DEBUG_DO( this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ) ); // minimum alignment162 163 } else {164 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() );165 this->userStack = true;166 this->size = storageSize - cxtSize;167 168 if ( this->size % 16 != 0u ) this->size -= 8;169 170 this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ); // minimum alignment171 } // if172 assertf( this->size >= MinStackSize, "Stack size %d provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );173 174 this->base = (char *)this->limit + this->size;175 this->context = this->base;176 this->top = (char *)this->context + cxtSize;177 92 } 178 93
Note: See TracChangeset
for help on using the changeset viewer.