Index: src/libcfa/concurrency/coroutine =================================================================== --- src/libcfa/concurrency/coroutine (revision ecc7752874f9978583bc6f0688400c001f2859ef) +++ src/libcfa/concurrency/coroutine (revision ecc7752874f9978583bc6f0688400c001f2859ef) @@ -0,0 +1,136 @@ +// - *- Mode: CFA - *- +// +// 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. +// +// coroutines -- +// +// 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 +// + +#ifndef COROUTINES_H +#define COROUTINES_H + +#include "assert" +#include "invoke.h" + +//----------------------------------------------------------------------------- +// Coroutine trait +// Anything that implements this trait can be resumed. +// Anything that is resumed is a coroutine. +trait is_coroutine(dtype T) { + void main(T * this); + coroutine * get_coroutine(T * this); +}; + +#define DECL_COROUTINE(X) static inline coroutine* get_coroutine(X* this) { return &this->c; } void main(X* this) + +//----------------------------------------------------------------------------- +// Ctors and dtors +void ?{}(coStack_t * this); +void ?{}(coroutine * this); +void ?{}(coroutine * this, const char * name); +void ^?{}(coStack_t * this); +void ^?{}(coroutine * this); + +//----------------------------------------------------------------------------- +// Public coroutine API +static inline void suspend(); + +forall(dtype T | is_coroutine(T)) +static inline void resume(T * cor); + +forall(dtype T | is_coroutine(T)) +void prime(T * cor); + +//----------------------------------------------------------------------------- +// PRIVATE exposed because of inline + +// Start coroutine routines +extern "C" { + forall(dtype T | is_coroutine(T)) + void CtxInvokeCoroutine(T * this); + + forall(dtype T | is_coroutine(T)) + void CtxStart(T * this, void ( *invoke)(T *)); +} + +// Get current coroutine +coroutine * this_coroutine(void); + +// Private wrappers for context switch and stack creation +extern void CoroutineCtxSwitch(coroutine * src, coroutine * dst); +extern void create_stack( coStack_t * this, unsigned int storageSize ); + +// Suspend implementation inlined for performance +static inline void suspend() { + coroutine * src = this_coroutine(); // optimization + + 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.", + src->name, src ); + assertf( src->last->state != Halted, + "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n" + "Possible cause is terminated coroutine's main routine has already returned.", + src->name, src, src->last->name, src->last ); + + CoroutineCtxSwitch( src, src->last ); +} + +// Resume implementation inlined for performance +forall(dtype T | is_coroutine(T)) +static inline void resume(T * cor) { + coroutine * src = this_coroutine(); // optimization + coroutine * dst = get_coroutine(cor); + + if( unlikely(!dst->stack.base) ) { + create_stack(&dst->stack, dst->stack.size); + CtxStart(cor, CtxInvokeCoroutine); + } + + // not resuming self ? + if ( src != dst ) { + assertf( dst->state != Halted , + "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n" + "Possible cause is terminated coroutine's main routine has already returned.", + src->name, src, dst->name, dst ); + + // set last resumer + dst->last = src; + } // if + + // always done for performance testing + CoroutineCtxSwitch( src, dst ); +} + +static inline void resume(coroutine * dst) { + coroutine * src = this_coroutine(); // optimization + + // not resuming self ? + if ( src != dst ) { + assertf( dst->state != Halted , + "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n" + "Possible cause is terminated coroutine's main routine has already returned.", + src->name, src, dst->name, dst ); + + // set last resumer + dst->last = src; + } // if + + // always done for performance testing + CoroutineCtxSwitch( src, dst ); +} + +#endif //COROUTINES_H + +// Local Variables: // +// mode: c // +// tab-width: 4 // +// End: // Index: src/libcfa/concurrency/coroutine.c =================================================================== --- src/libcfa/concurrency/coroutine.c (revision ecc7752874f9978583bc6f0688400c001f2859ef) +++ src/libcfa/concurrency/coroutine.c (revision ecc7752874f9978583bc6f0688400c001f2859ef) @@ -0,0 +1,178 @@ +// -*- Mode: CFA -*- +// +// 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. +// +// coroutines.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 +// + +#include "coroutines" + +extern "C" { +#include +#include +#include +#include +#include +#include +} + +#include "kernel" +#include "libhdr.h" + +#define __CFA_INVOKE_PRIVATE__ +#include "invoke.h" + +extern processor * get_this_processor(); + +//----------------------------------------------------------------------------- +// 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 + +//----------------------------------------------------------------------------- +// 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; +} + +void ?{}(coStack_t* this, size_t size) { + this{}; + this->size = size; + + create_stack(this, this->size); +} + +void ?{}(coroutine* this) { + this{ "Anonymous Coroutine" }; +} + +void ?{}(coroutine* this, const char * name) { + this->name = name; + this->errno_ = 0; + this->state = Start; + this->starter = NULL; + this->last = NULL; +} + +void ?{}(coroutine* this, size_t size) { + this{}; + (&this->stack){size}; +} + +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 ); + } +} + +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); +} + +// Wrapper for co +void CoroutineCtxSwitch(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 + get_this_processor()->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; +} + +// We need to call suspend from invoke.c, so we expose this wrapper that +// is not inline (We can't inline Cforall in C) +extern "C" { + void __suspend_internal(void) { + suspend(); + } +} + +// Local Variables: // +// mode: c // +// tab-width: 4 // +// End: // Index: c/libcfa/concurrency/coroutines =================================================================== --- src/libcfa/concurrency/coroutines (revision f841241a2a154a0a4c15d75fc2e630cfe658cc04) +++ (revision ) @@ -1,136 +1,0 @@ -// - *- Mode: CFA - *- -// -// 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. -// -// coroutines -- -// -// 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 -// - -#ifndef COROUTINES_H -#define COROUTINES_H - -#include "assert" -#include "invoke.h" - -//----------------------------------------------------------------------------- -// Coroutine trait -// Anything that implements this trait can be resumed. -// Anything that is resumed is a coroutine. -trait is_coroutine(dtype T) { - void main(T * this); - coroutine * get_coroutine(T * this); -}; - -#define DECL_COROUTINE(X) static inline coroutine* get_coroutine(X* this) { return &this->c; } void main(X* this) - -//----------------------------------------------------------------------------- -// Ctors and dtors -void ?{}(coStack_t * this); -void ?{}(coroutine * this); -void ?{}(coroutine * this, const char * name); -void ^?{}(coStack_t * this); -void ^?{}(coroutine * this); - -//----------------------------------------------------------------------------- -// Public coroutine API -static inline void suspend(); - -forall(dtype T | is_coroutine(T)) -static inline void resume(T * cor); - -forall(dtype T | is_coroutine(T)) -void prime(T * cor); - -//----------------------------------------------------------------------------- -// PRIVATE exposed because of inline - -// Start coroutine routines -extern "C" { - forall(dtype T | is_coroutine(T)) - void CtxInvokeCoroutine(T * this); - - forall(dtype T | is_coroutine(T)) - void CtxStart(T * this, void ( *invoke)(T *)); -} - -// Get current coroutine -coroutine * this_coroutine(void); - -// Private wrappers for context switch and stack creation -extern void CoroutineCtxSwitch(coroutine * src, coroutine * dst); -extern void create_stack( coStack_t * this, unsigned int storageSize ); - -// Suspend implementation inlined for performance -static inline void suspend() { - coroutine * src = this_coroutine(); // optimization - - 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.", - src->name, src ); - assertf( src->last->state != Halted, - "Attempt by coroutine \"%.256s\" (%p) to suspend back to terminated coroutine \"%.256s\" (%p).\n" - "Possible cause is terminated coroutine's main routine has already returned.", - src->name, src, src->last->name, src->last ); - - CoroutineCtxSwitch( src, src->last ); -} - -// Resume implementation inlined for performance -forall(dtype T | is_coroutine(T)) -static inline void resume(T * cor) { - coroutine * src = this_coroutine(); // optimization - coroutine * dst = get_coroutine(cor); - - if( unlikely(!dst->stack.base) ) { - create_stack(&dst->stack, dst->stack.size); - CtxStart(cor, CtxInvokeCoroutine); - } - - // not resuming self ? - if ( src != dst ) { - assertf( dst->state != Halted , - "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n" - "Possible cause is terminated coroutine's main routine has already returned.", - src->name, src, dst->name, dst ); - - // set last resumer - dst->last = src; - } // if - - // always done for performance testing - CoroutineCtxSwitch( src, dst ); -} - -static inline void resume(coroutine * dst) { - coroutine * src = this_coroutine(); // optimization - - // not resuming self ? - if ( src != dst ) { - assertf( dst->state != Halted , - "Attempt by coroutine %.256s (%p) to resume terminated coroutine %.256s (%p).\n" - "Possible cause is terminated coroutine's main routine has already returned.", - src->name, src, dst->name, dst ); - - // set last resumer - dst->last = src; - } // if - - // always done for performance testing - CoroutineCtxSwitch( src, dst ); -} - -#endif //COROUTINES_H - -// Local Variables: // -// mode: c // -// tab-width: 4 // -// End: // Index: c/libcfa/concurrency/coroutines.c =================================================================== --- src/libcfa/concurrency/coroutines.c (revision f841241a2a154a0a4c15d75fc2e630cfe658cc04) +++ (revision ) @@ -1,178 +1,0 @@ -// -*- Mode: CFA -*- -// -// 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. -// -// coroutines.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 -// - -#include "coroutines" - -extern "C" { -#include -#include -#include -#include -#include -#include -} - -#include "kernel" -#include "libhdr.h" - -#define __CFA_INVOKE_PRIVATE__ -#include "invoke.h" - -extern processor * get_this_processor(); - -//----------------------------------------------------------------------------- -// 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 - -//----------------------------------------------------------------------------- -// 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; -} - -void ?{}(coStack_t* this, size_t size) { - this{}; - this->size = size; - - create_stack(this, this->size); -} - -void ?{}(coroutine* this) { - this{ "Anonymous Coroutine" }; -} - -void ?{}(coroutine* this, const char * name) { - this->name = name; - this->errno_ = 0; - this->state = Start; - this->starter = NULL; - this->last = NULL; -} - -void ?{}(coroutine* this, size_t size) { - this{}; - (&this->stack){size}; -} - -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 ); - } -} - -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); -} - -// Wrapper for co -void CoroutineCtxSwitch(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 - get_this_processor()->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; -} - -// We need to call suspend from invoke.c, so we expose this wrapper that -// is not inline (We can't inline Cforall in C) -extern "C" { - void __suspend_internal(void) { - suspend(); - } -} - -// Local Variables: // -// mode: c // -// tab-width: 4 // -// End: // Index: src/libcfa/concurrency/thread =================================================================== --- src/libcfa/concurrency/thread (revision ecc7752874f9978583bc6f0688400c001f2859ef) +++ src/libcfa/concurrency/thread (revision ecc7752874f9978583bc6f0688400c001f2859ef) @@ -0,0 +1,76 @@ +// -*- Mode: CFA -*- +// +// 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 -- +// +// Author : Thierry Delisle +// Created On : Tue Jan 17 12:27:26 2017 +// Last Modified By : Thierry Delisle +// Last Modified On : -- +// Update Count : 0 +// + +#ifndef THREADS_H +#define THREADS_H + +#include "assert" +#include "invoke.h" + +#include "coroutines" + +//----------------------------------------------------------------------------- +// Coroutine trait +// Anything that implements this trait can be resumed. +// Anything that is resumed is a coroutine. +trait is_thread(dtype T) { + void main(T* this); + thread* get_thread(T* this); +}; + +#define DECL_THREAD(X) thread* get_thread(X* this) { return &this->t; } void main(X* this) + +forall( dtype T | is_thread(T) ) +static inline coroutine* get_coroutine(T* this) { + return &get_thread(this)->c; +} + +static inline coroutine* get_coroutine(thread* this) { + return &this->c; +} + +thread * this_thread(void); + +//----------------------------------------------------------------------------- +// Ctors and dtors +void ?{}(thread* this); +void ^?{}(thread* this); + +//----------------------------------------------------------------------------- +// thread runner +// Structure that actually start and stop threads +forall( dtype T | sized(T) | is_thread(T) ) +struct scoped { + T handle; +}; + +forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } ) +void ?{}( scoped(T)* this ); + +forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } ) +void ?{}( scoped(T)* this, P params ); + +forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } ) +void ^?{}( scoped(T)* this ); + +void yield(); + +#endif //THREADS_H + +// Local Variables: // +// mode: c // +// tab-width: 4 // +// End: // Index: src/libcfa/concurrency/thread.c =================================================================== --- src/libcfa/concurrency/thread.c (revision ecc7752874f9978583bc6f0688400c001f2859ef) +++ src/libcfa/concurrency/thread.c (revision ecc7752874f9978583bc6f0688400c001f2859ef) @@ -0,0 +1,131 @@ +// -*- Mode: CFA -*- +// +// 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 : Tue Jan 17 12:27:26 2017 +// Last Modified By : Thierry Delisle +// Last Modified On : -- +// Update Count : 0 +// + +#include "threads" + +#include "kernel_private.h" +#include "libhdr.h" + +#define __CFA_INVOKE_PRIVATE__ +#include "invoke.h" + +extern "C" { + #include + #include +} + +extern processor * get_this_processor(); + +//----------------------------------------------------------------------------- +// Forward declarations +forall( dtype T | is_thread(T) ) +void start( T* this ); + +forall( dtype T | is_thread(T) ) +void stop( T* this ); + +//----------------------------------------------------------------------------- +// Thread ctors and dtors + +void ?{}(thread* this) { + (&this->c){}; + this->c.name = "Anonymous Coroutine"; + (&this->terminated){}; + this->next = NULL; +} + +void ^?{}(thread* this) { + ^(&this->c){}; +} + +forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } ) +void ?{}( scoped(T)* this ) { + (&this->handle){}; + start(&this->handle); +} + +forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } ) +void ?{}( scoped(T)* this, P params ) { + (&this->handle){ params }; + start(&this->handle); +} + +forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } ) +void ^?{}( scoped(T)* this ) { + stop(&this->handle); + ^(&this->handle){}; +} + +//----------------------------------------------------------------------------- +// Starting and stopping threads +forall( dtype T | is_thread(T) ) +void start( T* this ) { + coroutine* thrd_c = get_coroutine(this); + thread* thrd_h = get_thread (this); + thrd_c->last = this_coroutine(); + get_this_processor()->current_coroutine = thrd_c; + + LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h); + + create_stack(&thrd_c->stack, thrd_c->stack.size); + CtxStart(this, CtxInvokeThread); + CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context ); + + ScheduleThread(thrd_h); +} + +forall( dtype T | is_thread(T) ) +void stop( T* this ) { + wait( & get_thread(this)->terminated ); +} + +void yield( void ) { + ScheduleInternal( get_this_processor()->current_thread ); +} + +void ThreadCtxSwitch(coroutine* src, coroutine* dst) { + // set state of current coroutine to inactive + src->state = Inactive; + dst->state = Active; + + //update the last resumer + dst->last = src; + + // set new coroutine that the processor is executing + // and context switch to it + get_this_processor()->current_coroutine = dst; + CtxSwitch( src->stack.context, dst->stack.context ); + get_this_processor()->current_coroutine = src; + + // set state of new coroutine to active + dst->state = Inactive; + src->state = Active; +} + +// C Helper to signal the termination of a thread +// Used in invoke.c +extern "C" { + void __thread_signal_termination( thread * this ) { + this->c.state = Halted; + LIB_DEBUG_PRINTF("Thread end : %p\n", this); + signal( &this->terminated ); + } +} + +// Local Variables: // +// mode: c // +// tab-width: 4 // +// End: // Index: c/libcfa/concurrency/threads =================================================================== --- src/libcfa/concurrency/threads (revision f841241a2a154a0a4c15d75fc2e630cfe658cc04) +++ (revision ) @@ -1,76 +1,0 @@ -// -*- Mode: CFA -*- -// -// 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 -- -// -// Author : Thierry Delisle -// Created On : Tue Jan 17 12:27:26 2017 -// Last Modified By : Thierry Delisle -// Last Modified On : -- -// Update Count : 0 -// - -#ifndef THREADS_H -#define THREADS_H - -#include "assert" -#include "invoke.h" - -#include "coroutines" - -//----------------------------------------------------------------------------- -// Coroutine trait -// Anything that implements this trait can be resumed. -// Anything that is resumed is a coroutine. -trait is_thread(dtype T) { - void main(T* this); - thread* get_thread(T* this); -}; - -#define DECL_THREAD(X) thread* get_thread(X* this) { return &this->t; } void main(X* this) - -forall( dtype T | is_thread(T) ) -static inline coroutine* get_coroutine(T* this) { - return &get_thread(this)->c; -} - -static inline coroutine* get_coroutine(thread* this) { - return &this->c; -} - -thread * this_thread(void); - -//----------------------------------------------------------------------------- -// Ctors and dtors -void ?{}(thread* this); -void ^?{}(thread* this); - -//----------------------------------------------------------------------------- -// thread runner -// Structure that actually start and stop threads -forall( dtype T | sized(T) | is_thread(T) ) -struct scoped { - T handle; -}; - -forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } ) -void ?{}( scoped(T)* this ); - -forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } ) -void ?{}( scoped(T)* this, P params ); - -forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } ) -void ^?{}( scoped(T)* this ); - -void yield(); - -#endif //THREADS_H - -// Local Variables: // -// mode: c // -// tab-width: 4 // -// End: // Index: c/libcfa/concurrency/threads.c =================================================================== --- src/libcfa/concurrency/threads.c (revision f841241a2a154a0a4c15d75fc2e630cfe658cc04) +++ (revision ) @@ -1,131 +1,0 @@ -// -*- Mode: CFA -*- -// -// 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 : Tue Jan 17 12:27:26 2017 -// Last Modified By : Thierry Delisle -// Last Modified On : -- -// Update Count : 0 -// - -#include "threads" - -#include "kernel_private.h" -#include "libhdr.h" - -#define __CFA_INVOKE_PRIVATE__ -#include "invoke.h" - -extern "C" { - #include - #include -} - -extern processor * get_this_processor(); - -//----------------------------------------------------------------------------- -// Forward declarations -forall( dtype T | is_thread(T) ) -void start( T* this ); - -forall( dtype T | is_thread(T) ) -void stop( T* this ); - -//----------------------------------------------------------------------------- -// Thread ctors and dtors - -void ?{}(thread* this) { - (&this->c){}; - this->c.name = "Anonymous Coroutine"; - (&this->terminated){}; - this->next = NULL; -} - -void ^?{}(thread* this) { - ^(&this->c){}; -} - -forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } ) -void ?{}( scoped(T)* this ) { - (&this->handle){}; - start(&this->handle); -} - -forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } ) -void ?{}( scoped(T)* this, P params ) { - (&this->handle){ params }; - start(&this->handle); -} - -forall( dtype T | sized(T) | is_thread(T) | { void ^?{}(T*); } ) -void ^?{}( scoped(T)* this ) { - stop(&this->handle); - ^(&this->handle){}; -} - -//----------------------------------------------------------------------------- -// Starting and stopping threads -forall( dtype T | is_thread(T) ) -void start( T* this ) { - coroutine* thrd_c = get_coroutine(this); - thread* thrd_h = get_thread (this); - thrd_c->last = this_coroutine(); - get_this_processor()->current_coroutine = thrd_c; - - LIB_DEBUG_PRINTF("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h); - - create_stack(&thrd_c->stack, thrd_c->stack.size); - CtxStart(this, CtxInvokeThread); - CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context ); - - ScheduleThread(thrd_h); -} - -forall( dtype T | is_thread(T) ) -void stop( T* this ) { - wait( & get_thread(this)->terminated ); -} - -void yield( void ) { - ScheduleInternal( get_this_processor()->current_thread ); -} - -void ThreadCtxSwitch(coroutine* src, coroutine* dst) { - // set state of current coroutine to inactive - src->state = Inactive; - dst->state = Active; - - //update the last resumer - dst->last = src; - - // set new coroutine that the processor is executing - // and context switch to it - get_this_processor()->current_coroutine = dst; - CtxSwitch( src->stack.context, dst->stack.context ); - get_this_processor()->current_coroutine = src; - - // set state of new coroutine to active - dst->state = Inactive; - src->state = Active; -} - -// C Helper to signal the termination of a thread -// Used in invoke.c -extern "C" { - void __thread_signal_termination( thread * this ) { - this->c.state = Halted; - LIB_DEBUG_PRINTF("Thread end : %p\n", this); - signal( &this->terminated ); - } -} - -// Local Variables: // -// mode: c // -// tab-width: 4 // -// End: //