Index: benchmark/io/http/main.cfa =================================================================== --- benchmark/io/http/main.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ benchmark/io/http/main.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -125,5 +125,5 @@ workers[i].flags = 0; } - unpark( workers[i] __cfaabi_dbg_ctx2 ); + unpark( workers[i] ); } printf("%d workers started on %d processors\n", options.clopts.nworkers, options.clopts.nprocs); Index: benchmark/io/http/worker.cfa =================================================================== --- benchmark/io/http/worker.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ benchmark/io/http/worker.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -22,5 +22,5 @@ void main( Worker & this ) { - park( __cfaabi_dbg_ctx ); + park(); /* paranoid */ assert( this.pipe[0] != -1 ); /* paranoid */ assert( this.pipe[1] != -1 ); Index: benchmark/io/readv.cfa =================================================================== --- benchmark/io/readv.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ benchmark/io/readv.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -54,5 +54,5 @@ void main( Reader & ) { - park( __cfaabi_dbg_ctx ); + park(); /* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) ); @@ -151,5 +151,5 @@ for(i; nthreads) { - unpark( threads[i] __cfaabi_dbg_ctx2 ); + unpark( threads[i] ); } wait(duration, start, end, is_tty); Index: benchmark/readyQ/yield.cfa =================================================================== --- benchmark/readyQ/yield.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ benchmark/readyQ/yield.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -32,5 +32,5 @@ void main( Yielder & this ) { - park( __cfaabi_dbg_ctx ); + park(); /* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) ); @@ -70,5 +70,5 @@ for(i; nthreads) { - unpark( threads[i] __cfaabi_dbg_ctx2 ); + unpark( threads[i] ); } wait(duration, start, end, is_tty); Index: doc/theses/thierry_delisle_PhD/code/readQ_example/Makefile =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/Makefile (revision 615767bf8c2af44d97001895be6cbf190a69a365) +++ doc/theses/thierry_delisle_PhD/code/readQ_example/Makefile (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -0,0 +1,6 @@ +all: gui-proto + +CXXFLAGS = -fpic -g -O0 -I. + +gui-proto: proto-gui/main.o thrdlib/thread.o + $(CXX) -pthread -ldl -o ${@} ${^} -ftls-model=initial-exec Index: doc/theses/thierry_delisle_PhD/code/readQ_example/proto-gui/main.cpp =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/proto-gui/main.cpp (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ doc/theses/thierry_delisle_PhD/code/readQ_example/proto-gui/main.cpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -1,3 +1,3 @@ -#include "thrdlib/thread.h" +#include "thrdlib/thread.hpp" #include @@ -5,8 +5,33 @@ #include #include +#include #include #include #include +using thrdlib::thread_t; + + +extern __attribute__((aligned(128))) thread_local struct { + void * volatile this_thread; + void * volatile this_processor; + void * volatile this_stats; + + struct { + volatile unsigned short disable_count; + volatile bool enabled; + volatile bool in_progress; + } preemption_state; + + #if defined(__SIZEOF_INT128__) + __uint128_t rand_seed; + #else + uint64_t rand_seed; + #endif + struct { + uint64_t fwd_seed; + uint64_t bck_seed; + } ready_rng; +} kernelTLS __attribute__ ((tls_model ( "initial-exec" ))); //-------------------- @@ -36,5 +61,5 @@ assert( expected == reset ); if( std::atomic_compare_exchange_strong( &state, &expected, self) ) { - thrdlib_park( self ); + thrdlib::park( self ); ret = true; goto END; @@ -54,5 +79,5 @@ if( got == reset ) return false; - thrdlib_unpark( got ); + thrdlib::unpark( got ); return true; } @@ -109,5 +134,5 @@ the_stats_thread = self; fence(); - thrdlib_park( self ); + thrdlib::park( self ); std::vector seen; @@ -115,5 +140,5 @@ while(last_produced < nproduce) { - thrdlib_yield(); + thrdlib::yield(); thrd_stats.stats.ran++; if( last_produced > 0 ) seen.at(last_produced - 1) = true; @@ -147,5 +172,5 @@ void Renderer( thread_t self ) { - thrdlib_unpark( the_stats_thread ); + thrdlib::unpark( the_stats_thread ); for(unsigned i = 0; i < nproduce; i++) { auto & frame = frames[i % nframes]; @@ -178,4 +203,6 @@ fsize = 1000; nproduce = 60; + + const char * framework; for(;;) { @@ -196,4 +223,10 @@ case -1: /* paranoid */ assert(optind <= argc); + if( optind == argc ) { + std::cerr << "Must specify a framework" << std::endl; + goto usage; + + } + framework = argv[optind]; goto run; case 'b': @@ -228,5 +261,5 @@ std::cerr << opt << std::endl; usage: - std::cerr << "Usage: " << argv[0] << " [options]" << std::endl; + std::cerr << "Usage: " << argv[0] << " [options] framework" << std::endl; std::cerr << std::endl; std::cerr << " -b, --buff=COUNT Number of frames to buffer" << std::endl; @@ -237,4 +270,5 @@ } run: + assert( framework ); frames.reset(new Frame[nframes]); @@ -246,19 +280,21 @@ std::cout << "(Buffering " << nframes << ")" << std::endl; - thrdlib_setproccnt( 2 ); - - thread_t stats = thrdlib_create( Stats ); + thrdlib::init( framework, 2 ); + + thread_t stats = thrdlib::create( Stats ); std::cout << "Created Stats Thread" << std::endl; - while( the_stats_thread == nullptr ) thrdlib_yield(); + while( the_stats_thread == nullptr ) thrdlib::yield(); + std::cout << "Creating Main Threads" << std::endl; - thread_t renderer = thrdlib_create( Renderer ); - // while(true); - thread_t simulator = thrdlib_create( Simulator ); + thread_t renderer = thrdlib::create( Renderer ); + thread_t simulator = thrdlib::create( Simulator ); std::cout << "Running" << std::endl; - thrdlib_join( simulator ); - thrdlib_join( renderer ); - thrdlib_join( stats ); + thrdlib::join( simulator ); + thrdlib::join( renderer ); + thrdlib::join( stats ); + + thrdlib::clean(); std::cout << "----------" << std::endl; Index: doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/Makefile =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/Makefile (revision 615767bf8c2af44d97001895be6cbf190a69a365) +++ doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/Makefile (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -0,0 +1,19 @@ +all: fibre.so pthread.so cforall.so + +clean: + rm -rf fibre.so pthread.so + +CXXFLAGS=-Wall -Wextra -O3 -g -fpic -std=c++17 -pthread -ftls-model=initial-exec + +pthread.so: pthread.cpp Makefile + $(CXX) $(CXXFLAGS) -shared -o ${@} ${<} + +fibre.so: fibre.cpp Makefile + $(CXX) $(CXXFLAGS) -shared -o ${@} ${<} -lfibre + +CFAINC=${HOME}/local/include/cfa-dev +CFALIB=${HOME}/local/lib/cfa-dev/x64-debug +CFAFLAGS=-z execstack -I${CFAINC} -I${CFAINC}/concurrency -L${CFALIB} -Wl,-rpath,${CFALIB} + +cforall.so: cforall.cpp Makefile + $(CXX) $(CXXFLAGS) $(CFAFLAGS) -shared -o ${@} ${<} -lcfathread -lcfa -ldl -lm Index: doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/cforall.cpp =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/cforall.cpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) +++ doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/cforall.cpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -0,0 +1,43 @@ +#include +#include + +typedef cfathread_t thread_t; +static_assert(sizeof(thread_t) == sizeof(void*), "thread_t musst be of same size as void*"); + +#if !defined(__cplusplus) +#error no __cplusplus define! +#endif + +extern "C" { + //-------------------- + // Basic thread support + thread_t thrdlib_create( void (*the_main)( thread_t ) ) { + return cfathread_create( the_main ); + } + + void thrdlib_join( thread_t handle ) { + cfathread_join( handle ); + } + + void thrdlib_park( thread_t ) { + cfathread_park(); + } + + void thrdlib_unpark( thread_t handle ) { + cfathread_unpark( handle ); + } + + void thrdlib_yield( void ) { + cfathread_yield(); + } + + //-------------------- + // Basic kernel features + void thrdlib_init( int procs ) { + cfathread_setproccnt(procs); + } + + void thrdlib_clean( void ) { + cfathread_setproccnt(1); + } +} Index: doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/fibre.cpp =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/fibre.cpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) +++ doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/fibre.cpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -0,0 +1,48 @@ +#include +#include + +typedef cfibre_t thread_t; +static_assert(sizeof(thread_t) == sizeof(void*), "thread_t musst be of same size as void*"); + +void * fibre_runner(void * arg) { + auto the_main = (void (*)( thread_t ))arg; + the_main( cfibre_self() ); + return nullptr; +} + +extern "C" { + //-------------------- + // Basic thread support + thread_t thrdlib_create( void (*the_main)( thread_t ) ) { + thread_t fibre; + cfibre_create( &fibre, nullptr, fibre_runner, (void*)the_main ); + return fibre; + } + + void thrdlib_join( thread_t handle ) { + cfibre_join( handle, nullptr ); + } + + void thrdlib_park( thread_t handle ) { + assert( handle == cfibre_self() ); + cfibre_park(); + } + + void thrdlib_unpark( thread_t handle ) { + cfibre_unpark( handle ); + } + + void thrdlib_yield( void ) { + cfibre_yield(); + } + + //-------------------- + // Basic kernel features + void thrdlib_init( int procs ) { + cfibre_init_n(1, procs ); + } + + void thrdlib_clean( void ) { + + } +} Index: doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/pthread.cpp =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/pthread.cpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) +++ doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/pthread.cpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -0,0 +1,99 @@ +#include +#include +#include +#include +#include + +#define CHECKED(x) { int err = x; if( err != 0 ) { std::cerr << "KERNEL ERROR: Operation \"" #x "\" return error " << err << " - " << strerror(err) << std::endl; std::abort(); } } + +struct __bin_sem_t { + pthread_mutex_t lock; + pthread_cond_t cond; + int val; + + __bin_sem_t() { + // Create the mutex with error checking + pthread_mutexattr_t mattr; + pthread_mutexattr_init( &mattr ); + pthread_mutexattr_settype( &mattr, PTHREAD_MUTEX_ERRORCHECK_NP); + pthread_mutex_init(&lock, &mattr); + + pthread_cond_init (&cond, nullptr); + val = 0; + } + + ~__bin_sem_t() { + CHECKED( pthread_mutex_destroy(&lock) ); + CHECKED( pthread_cond_destroy (&cond) ); + } + + void wait() { + CHECKED( pthread_mutex_lock(&lock) ); + while(val < 1) { + pthread_cond_wait(&cond, &lock); + } + val -= 1; + CHECKED( pthread_mutex_unlock(&lock) ); + } + + bool post() { + bool needs_signal = false; + + CHECKED( pthread_mutex_lock(&lock) ); + if(val < 1) { + val += 1; + pthread_cond_signal(&cond); + needs_signal = true; + } + CHECKED( pthread_mutex_unlock(&lock) ); + + return needs_signal; + } +}; + +#undef CHECKED + +//-------------------- +// Basic types +struct pthread_runner_t { + pthread_t handle; + __bin_sem_t sem; +}; +typedef pthread_runner_t * thread_t; + +static_assert(sizeof(thread_t) == sizeof(void*), "thread_t musst be of same size as void*"); + +extern "C" { + //-------------------- + // Basic thread support + thread_t thrdlib_create( void (*main)( thread_t ) ) { + thread_t thrd = new pthread_runner_t(); + int r = pthread_create( &thrd->handle, nullptr, (void *(*)(void *))main, thrd ); + if( r != 0 ) std::abort(); + return thrd; + } + + void thrdlib_join( thread_t handle ) { + void * ret; + int r = pthread_join( handle->handle, &ret ); + if( r != 0 ) std::abort(); + delete handle; + } + + void thrdlib_park( thread_t handle ) { + handle->sem.wait(); + } + + void thrdlib_unpark( thread_t handle ) { + handle->sem.post(); + } + + void thrdlib_yield( void ) { + int r = pthread_yield(); + if( r != 0 ) std::abort(); + } + + //-------------------- + // Basic kernel features + void thrdlib_init( int ) {} +} Index: doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.cpp =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.cpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) +++ doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.cpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -0,0 +1,68 @@ +#include "thread.hpp" + +#include // va_start, va_end +#include +#include // strlen +extern "C" { + #include // _exit, getpid + #include + #include // dlopen, dlsym + #include // backtrace, messages +} + +#include +#include + +using thrdlib::thread_t; + +thread_t (*thrdlib::create)( void (*main)( thread_t ) ) = nullptr; +void (*thrdlib::join)( thread_t handle ) = nullptr; +void (*thrdlib::park)( thread_t handle ) = nullptr; +void (*thrdlib::unpark)( thread_t handle ) = nullptr; +void (*thrdlib::yield)( void ) = nullptr; +void (*lib_clean)(void) = nullptr; + +typedef void (*fptr_t)(); +static fptr_t open_symbol( void * library, const char * symbol, bool required ) { + void * ptr = dlsym( library, symbol ); + + const char * error = dlerror(); + if ( required && error ) { + std::cerr << "Fetching symbol '" << symbol << "' failed with error '" << error << "'\n"; + std::abort(); + } + + return (fptr_t)ptr; +} + +//-------------------- +// Basic kernel features +void thrdlib::init( const char * name, int procs ) { + std::string file = __FILE__; + std::size_t found = file.find_last_of("/"); + std::string libname = file.substr(0,found+1) + name + ".so"; + + std::cout << "Use framework " << name << "(" << libname << ")\n"; + + void * library = dlopen( libname.c_str(), RTLD_NOW ); + if ( const char * error = dlerror() ) { + std::cerr << "Could not open library '" << libname << "' from name '" << name <<"'\n"; + std::cerr << "Error was : '" << error << "'\n"; + std::abort(); + } + + void (*lib_init)( int ) = (void (*)( int ))open_symbol( library, "thrdlib_init", false ); + lib_clean = open_symbol( library, "thrdlib_clean" , false ); + + thrdlib::create = (typeof(thrdlib::create))open_symbol( library, "thrdlib_create", true ); + thrdlib::join = (typeof(thrdlib::join ))open_symbol( library, "thrdlib_join" , true ); + thrdlib::park = (typeof(thrdlib::park ))open_symbol( library, "thrdlib_park" , true ); + thrdlib::unpark = (typeof(thrdlib::unpark))open_symbol( library, "thrdlib_unpark", true ); + thrdlib::yield = (typeof(thrdlib::yield ))open_symbol( library, "thrdlib_yield" , true ); + + lib_init( procs ); +} + +void thrdlib::clean( void ) { + if(lib_clean) lib_clean(); +} Index: c/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.h =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.h (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ (revision ) @@ -1,2 +1,0 @@ - -#include "thread_pthread.h" Index: doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.hpp =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.hpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) +++ doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread.hpp (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -0,0 +1,18 @@ +#pragma once + +namespace thrdlib { + typedef void * thread_t; + + //-------------------- + // Basic thread support + extern thread_t (*create)( void (*main)( thread_t ) ); + extern void (*join)( thread_t handle ); + extern void (*park)( thread_t handle ); + extern void (*unpark)( thread_t handle ); + extern void (*yield)( void ) ; + + //-------------------- + // Basic kernel features + extern void init( const char * name, int procs ); + extern void clean( void ); +}; Index: c/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread_pthread.h =================================================================== --- doc/theses/thierry_delisle_PhD/code/readQ_example/thrdlib/thread_pthread.h (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ (revision ) @@ -1,107 +1,0 @@ -#pragma once - -#include -#include -#include -#include -#include - -#define CHECKED(x) { int err = x; if( err != 0 ) { std::cerr << "KERNEL ERROR: Operation \"" #x "\" return error " << err << " - " << strerror(err) << std::endl; std::abort(); } } - -struct __bin_sem_t { - pthread_mutex_t lock; - pthread_cond_t cond; - int val; - - __bin_sem_t() { - // Create the mutex with error checking - pthread_mutexattr_t mattr; - pthread_mutexattr_init( &mattr ); - pthread_mutexattr_settype( &mattr, PTHREAD_MUTEX_ERRORCHECK_NP); - pthread_mutex_init(&lock, &mattr); - - pthread_cond_init (&cond, nullptr); - val = 0; - } - - ~__bin_sem_t() { - CHECKED( pthread_mutex_destroy(&lock) ); - CHECKED( pthread_cond_destroy (&cond) ); - } - - void wait() { - CHECKED( pthread_mutex_lock(&lock) ); - while(val < 1) { - pthread_cond_wait(&cond, &lock); - } - val -= 1; - CHECKED( pthread_mutex_unlock(&lock) ); - } - - bool post() { - bool needs_signal = false; - - CHECKED( pthread_mutex_lock(&lock) ); - if(val < 1) { - val += 1; - pthread_cond_signal(&cond); - needs_signal = true; - } - CHECKED( pthread_mutex_unlock(&lock) ); - - return needs_signal; - } -}; - -#undef CHECKED - -#if defined(__cforall) || defined(__cpluplus) -extern "C" { -#endif - //-------------------- - // Basic types - struct pthread_runner_t { - pthread_t handle; - __bin_sem_t sem; - }; - typedef pthread_runner_t * thread_t; - - //-------------------- - // Basic thread support - thread_t thrdlib_create( void (*main)( thread_t ) ) { - thread_t thrd = new pthread_runner_t(); - int r = pthread_create( &thrd->handle, nullptr, (void *(*)(void *))main, thrd ); - if( r != 0 ) std::abort(); - return thrd; - } - - void thrdlib_join( thread_t handle ) { - void * ret; - int r = pthread_join( handle->handle, &ret ); - if( r != 0 ) std::abort(); - delete handle; - } - - void thrdlib_park( thread_t handle ) { - handle->sem.wait(); - } - - void thrdlib_unpark( thread_t handle ) { - handle->sem.post(); - } - - void thrdlib_yield( void ) { - int r = pthread_yield(); - if( r != 0 ) std::abort(); - } - - //-------------------- - // Basic kernel features - void thrdlib_setproccnt( int ) { - - } - - -#if defined(__cforall) || defined(__cpluplus) -} -#endif Index: libcfa/src/bits/locks.hfa =================================================================== --- libcfa/src/bits/locks.hfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/bits/locks.hfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -164,6 +164,6 @@ struct $thread; - extern void park( __cfaabi_dbg_ctx_param ); - extern void unpark( struct $thread * this __cfaabi_dbg_ctx_param2 ); + extern void park( void ); + extern void unpark( struct $thread * this ); static inline struct $thread * active_thread (); @@ -191,5 +191,5 @@ /* paranoid */ verify( expected == 0p ); if(__atomic_compare_exchange_n(&this.ptr, &expected, active_thread(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { - park( __cfaabi_dbg_ctx ); + park(); return true; } @@ -210,5 +210,5 @@ else { if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { - unpark( expected __cfaabi_dbg_ctx2 ); + unpark( expected ); return true; } @@ -244,5 +244,5 @@ /* paranoid */ verify( expected == 0p ); if(__atomic_compare_exchange_n(&this.ptr, &expected, active_thread(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { - park( __cfaabi_dbg_ctx ); + park(); /* paranoid */ verify( this.ptr == 1p ); return true; @@ -256,5 +256,5 @@ struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST); if( got == 0p ) return false; - unpark( got __cfaabi_dbg_ctx2 ); + unpark( got ); return true; } Index: libcfa/src/concurrency/alarm.cfa =================================================================== --- libcfa/src/concurrency/alarm.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/alarm.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -130,5 +130,5 @@ register_self( &node ); - park( __cfaabi_dbg_ctx ); + park(); /* paranoid */ verify( !node.set ); Index: libcfa/src/concurrency/clib/cfathread.cfa =================================================================== --- libcfa/src/concurrency/clib/cfathread.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/clib/cfathread.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -34,5 +34,5 @@ extern "C" { //-------------------- - // Basic thread managenemt + // Basic thread management CRunner * cfathread_create( void (*main)( CRunner * ) ) { return new( main ); @@ -44,9 +44,9 @@ void cfathread_park( void ) { - park( __cfaabi_dbg_ctx ); + park(); } void cfathread_unpark( CRunner * thrd ) { - unpark( *thrd __cfaabi_dbg_ctx2 ); + unpark( *thrd ); } Index: libcfa/src/concurrency/clib/cfathread.h =================================================================== --- libcfa/src/concurrency/clib/cfathread.h (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/clib/cfathread.h (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -17,5 +17,5 @@ #include "invoke.h" -#if defined(__cforall) || defined(__cpluplus) +#if defined(__cforall) || defined(__cplusplus) extern "C" { #endif @@ -39,5 +39,5 @@ -#if defined(__cforall) || defined(__cpluplus) +#if defined(__cforall) || defined(__cplusplus) } #endif Index: libcfa/src/concurrency/invoke.h =================================================================== --- libcfa/src/concurrency/invoke.h (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/invoke.h (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -93,4 +93,6 @@ }; + // Wrapper for gdb + struct cfathread_coroutine_t { struct $coroutine debug; }; static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { @@ -129,4 +131,6 @@ struct __condition_node_t * dtor_node; }; + // Wrapper for gdb + struct cfathread_monitor_t { struct $monitor debug; }; struct __monitor_group_t { @@ -186,16 +190,10 @@ } node; - #ifdef __CFA_DEBUG__ - // previous function to park/unpark the thread - const char * park_caller; - int park_result; - enum __Coroutine_State park_state; - bool park_stale; - const char * unpark_caller; - int unpark_result; - enum __Coroutine_State unpark_state; - bool unpark_stale; + #if defined( __CFA_WITH_VERIFY__ ) + unsigned long long canary; #endif }; + // Wrapper for gdb + struct cfathread_thread_t { struct $thread debug; }; #ifdef __CFA_DEBUG__ Index: libcfa/src/concurrency/io.cfa =================================================================== --- libcfa/src/concurrency/io.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/io.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -69,5 +69,5 @@ if( block ) { enable_interrupts( __cfaabi_dbg_ctx ); - park( __cfaabi_dbg_ctx ); + park(); disable_interrupts(); } @@ -97,5 +97,5 @@ if(nextt) { - unpark( nextt __cfaabi_dbg_ctx2 ); + unpark( nextt ); enable_interrupts( __cfaabi_dbg_ctx ); return true; Index: libcfa/src/concurrency/io/setup.cfa =================================================================== --- libcfa/src/concurrency/io/setup.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/io/setup.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -247,5 +247,4 @@ thrd.link.next = 0p; thrd.link.prev = 0p; - __cfaabi_dbg_debug_do( thrd.unpark_stale = true ); // Fixup the thread state Index: libcfa/src/concurrency/kernel.cfa =================================================================== --- libcfa/src/concurrency/kernel.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/kernel.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -246,8 +246,4 @@ thrd_dst->state = Active; - __cfaabi_dbg_debug_do( - thrd_dst->park_stale = true; - thrd_dst->unpark_stale = true; - ) // Update global state kernelTLS.this_thread = thrd_dst; @@ -255,15 +251,19 @@ /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); /* paranoid */ verify( kernelTLS.this_thread == thrd_dst ); + /* paranoid */ verify( thrd_dst->context.SP ); /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor + /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_dst->canary ); + // set context switch to the thread that the processor is executing - verify( thrd_dst->context.SP ); __cfactx_switch( &proc_cor->context, &thrd_dst->context ); // when __cfactx_switch returns we are back in the processor coroutine + /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_dst->canary ); /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ), "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); + /* paranoid */ verify( thrd_dst->context.SP ); /* paranoid */ verify( kernelTLS.this_thread == thrd_dst ); /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); @@ -288,5 +288,5 @@ // The thread has halted, it should never be scheduled/run again // We may need to wake someone up here since - unpark( this->destroyer __cfaabi_dbg_ctx2 ); + unpark( this->destroyer ); this->destroyer = 0p; break RUNNING; @@ -298,5 +298,4 @@ // set state of processor coroutine to active and the thread to inactive int old_ticket = __atomic_fetch_sub(&thrd_dst->ticket, 1, __ATOMIC_SEQ_CST); - __cfaabi_dbg_debug_do( thrd_dst->park_result = old_ticket; ) switch(old_ticket) { case 1: @@ -335,6 +334,8 @@ __x87_store; #endif - verify( proc_cor->context.SP ); + /* paranoid */ verify( proc_cor->context.SP ); + /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_src->canary ); __cfactx_switch( &thrd_src->context, &proc_cor->context ); + /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd_src->canary ); #if defined( __i386 ) || defined( __x86_64 ) __x87_load; @@ -368,4 +369,6 @@ /* paranoid */ #endif /* paranoid */ verifyf( thrd->link.next == 0p, "Expected null got %p", thrd->link.next ); + /* paranoid */ verify( 0x0D15EA5E0D15EA5E == thrd->canary ); + if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready; @@ -404,10 +407,6 @@ // KERNEL ONLY unpark with out disabling interrupts -void __unpark( struct __processor_id_t * id, $thread * thrd __cfaabi_dbg_ctx_param2 ) { - // record activity - __cfaabi_dbg_record_thrd( *thrd, false, caller ); - +void __unpark( struct __processor_id_t * id, $thread * thrd ) { int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST); - __cfaabi_dbg_debug_do( thrd->unpark_result = old_ticket; thrd->unpark_state = thrd->state; ) switch(old_ticket) { case 1: @@ -427,20 +426,17 @@ } -void unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) { +void unpark( $thread * thrd ) { if( !thrd ) return; disable_interrupts(); - __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd __cfaabi_dbg_ctx_fwd2 ); + __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd ); enable_interrupts( __cfaabi_dbg_ctx ); } -void park( __cfaabi_dbg_ctx_param ) { +void park( void ) { /* paranoid */ verify( kernelTLS.preemption_state.enabled ); disable_interrupts(); /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); /* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION ); - - // record activity - __cfaabi_dbg_record_thrd( *kernelTLS.this_thread, true, caller ); returnToKernel(); @@ -650,5 +646,5 @@ // atomically release spin lock and block unlock( lock ); - park( __cfaabi_dbg_ctx ); + park(); return true; } @@ -671,5 +667,5 @@ // make new owner - unpark( thrd __cfaabi_dbg_ctx2 ); + unpark( thrd ); return thrd != 0p; @@ -682,5 +678,5 @@ count += diff; for(release) { - unpark( pop_head( waiting ) __cfaabi_dbg_ctx2 ); + unpark( pop_head( waiting ) ); } @@ -698,15 +694,4 @@ this.prev_thrd = kernelTLS.this_thread; } - - void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]) { - if(park) { - this.park_caller = prev_name; - this.park_stale = false; - } - else { - this.unpark_caller = prev_name; - this.unpark_stale = false; - } - } } ) Index: libcfa/src/concurrency/kernel/fwd.hfa =================================================================== --- libcfa/src/concurrency/kernel/fwd.hfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/kernel/fwd.hfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -118,6 +118,6 @@ extern "Cforall" { - extern void park( __cfaabi_dbg_ctx_param ); - extern void unpark( struct $thread * this __cfaabi_dbg_ctx_param2 ); + extern void park( void ); + extern void unpark( struct $thread * this ); static inline struct $thread * active_thread () { return TL_GET( this_thread ); } Index: libcfa/src/concurrency/kernel/startup.cfa =================================================================== --- libcfa/src/concurrency/kernel/startup.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/kernel/startup.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -451,4 +451,7 @@ link.next = 0p; link.prev = 0p; + #if defined( __CFA_WITH_VERIFY__ ) + canary = 0x0D15EA5E0D15EA5E; + #endif node.next = 0p; Index: libcfa/src/concurrency/kernel_private.hfa =================================================================== --- libcfa/src/concurrency/kernel_private.hfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/kernel_private.hfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -64,5 +64,5 @@ // KERNEL ONLY unpark with out disabling interrupts -void __unpark( struct __processor_id_t *, $thread * thrd __cfaabi_dbg_ctx_param2 ); +void __unpark( struct __processor_id_t *, $thread * thrd ); static inline bool __post(single_sem & this, struct __processor_id_t * id) { @@ -77,5 +77,5 @@ else { if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { - __unpark( id, expected __cfaabi_dbg_ctx2 ); + __unpark( id, expected ); return true; } Index: libcfa/src/concurrency/monitor.cfa =================================================================== --- libcfa/src/concurrency/monitor.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/monitor.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -122,5 +122,5 @@ unlock( this->lock ); - park( __cfaabi_dbg_ctx ); + park(); __cfaabi_dbg_print_safe( "Kernel : %10p Entered mon %p\n", thrd, this); @@ -201,8 +201,8 @@ // Release the next thread /* paranoid */ verifyf( urgent->owner->waiting_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this ); - unpark( urgent->owner->waiting_thread __cfaabi_dbg_ctx2 ); + unpark( urgent->owner->waiting_thread ); // Park current thread waiting - park( __cfaabi_dbg_ctx ); + park(); // Some one was waiting for us, enter @@ -222,5 +222,5 @@ // Park current thread waiting - park( __cfaabi_dbg_ctx ); + park(); /* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this ); @@ -264,5 +264,5 @@ //We need to wake-up the thread /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this ); - unpark( new_owner __cfaabi_dbg_ctx2 ); + unpark( new_owner ); } @@ -493,9 +493,9 @@ // Wake the threads for(int i = 0; i < thread_count; i++) { - unpark( threads[i] __cfaabi_dbg_ctx2 ); + unpark( threads[i] ); } // Everything is ready to go to sleep - park( __cfaabi_dbg_ctx ); + park(); // We are back, restore the owners and recursions @@ -575,8 +575,8 @@ // unpark the thread we signalled - unpark( signallee __cfaabi_dbg_ctx2 ); + unpark( signallee ); //Everything is ready to go to sleep - park( __cfaabi_dbg_ctx ); + park(); @@ -679,8 +679,8 @@ // unpark the thread we signalled - unpark( next __cfaabi_dbg_ctx2 ); + unpark( next ); //Everything is ready to go to sleep - park( __cfaabi_dbg_ctx ); + park(); // We are back, restore the owners and recursions @@ -724,5 +724,5 @@ //Everything is ready to go to sleep - park( __cfaabi_dbg_ctx ); + park(); Index: libcfa/src/concurrency/mutex.cfa =================================================================== --- libcfa/src/concurrency/mutex.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/mutex.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -42,5 +42,5 @@ append( blocked_threads, kernelTLS.this_thread ); unlock( lock ); - park( __cfaabi_dbg_ctx ); + park(); } else { @@ -65,5 +65,5 @@ this.is_locked = (this.blocked_threads != 0); unpark( - pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2 + pop_head( this.blocked_threads ) ); unlock( this.lock ); @@ -97,5 +97,5 @@ append( blocked_threads, kernelTLS.this_thread ); unlock( lock ); - park( __cfaabi_dbg_ctx ); + park(); } } @@ -124,5 +124,5 @@ owner = thrd; recursion_count = (thrd ? 1 : 0); - unpark( thrd __cfaabi_dbg_ctx2 ); + unpark( thrd ); } unlock( lock ); @@ -142,5 +142,5 @@ lock( lock __cfaabi_dbg_ctx2 ); unpark( - pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2 + pop_head( this.blocked_threads ) ); unlock( lock ); @@ -151,5 +151,5 @@ while(this.blocked_threads) { unpark( - pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2 + pop_head( this.blocked_threads ) ); } @@ -161,5 +161,5 @@ append( this.blocked_threads, kernelTLS.this_thread ); unlock( this.lock ); - park( __cfaabi_dbg_ctx ); + park(); } @@ -170,5 +170,5 @@ unlock(l); unlock(this.lock); - park( __cfaabi_dbg_ctx ); + park(); lock(l); } Index: libcfa/src/concurrency/preemption.cfa =================================================================== --- libcfa/src/concurrency/preemption.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/preemption.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -274,5 +274,5 @@ kernelTLS.this_stats = this->curr_cluster->stats; #endif - __unpark( id, this __cfaabi_dbg_ctx2 ); + __unpark( id, this ); } Index: libcfa/src/concurrency/thread.cfa =================================================================== --- libcfa/src/concurrency/thread.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/thread.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -39,4 +39,7 @@ link.prev = 0p; link.preferred = -1; + #if defined( __CFA_WITH_VERIFY__ ) + canary = 0x0D15EA5E0D15EA5E; + #endif node.next = 0p; @@ -48,4 +51,7 @@ void ^?{}($thread& this) with( this ) { + #if defined( __CFA_WITH_VERIFY__ ) + canary = 0xDEADDEADDEADDEAD; + #endif unregister(curr_cluster, this); ^self_cor{}; Index: libcfa/src/concurrency/thread.hfa =================================================================== --- libcfa/src/concurrency/thread.hfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ libcfa/src/concurrency/thread.hfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -88,13 +88,13 @@ //---------- // Park thread: block until corresponding call to unpark, won't block if unpark is already called -void park( __cfaabi_dbg_ctx_param ); +void park( void ); //---------- // Unpark a thread, if the thread is already blocked, schedule it // if the thread is not yet block, signal that it should rerun immediately -void unpark( $thread * this __cfaabi_dbg_ctx_param2 ); +void unpark( $thread * this ); forall( dtype T | is_thread(T) ) -static inline void unpark( T & this __cfaabi_dbg_ctx_param2 ) { if(!&this) return; unpark( get_thread( this ) __cfaabi_dbg_ctx_fwd2 );} +static inline void unpark( T & this ) { if(!&this) return; unpark( get_thread( this ) );} //---------- Index: src/GenPoly/InstantiateGeneric.cc =================================================================== --- src/GenPoly/InstantiateGeneric.cc (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ src/GenPoly/InstantiateGeneric.cc (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -172,5 +172,5 @@ InstantiationMap< AggregateDecl, AggregateDecl > instantiations; /// Set of types which are dtype-only generic (and therefore have static layout) - ScopedSet< AggregateDecl* > dtypeStatics; + std::set dtypeStatics; /// Namer for concrete types UniqueName typeNamer; @@ -505,10 +505,8 @@ void GenericInstantiator::beginScope() { instantiations.beginScope(); - dtypeStatics.beginScope(); } void GenericInstantiator::endScope() { instantiations.endScope(); - dtypeStatics.endScope(); } Index: tests/concurrent/park/contention.cfa =================================================================== --- tests/concurrent/park/contention.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ tests/concurrent/park/contention.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -21,9 +21,9 @@ if(blocked[idx]) { Thread * thrd = __atomic_exchange_n(&blocked[idx], 0p, __ATOMIC_SEQ_CST); - unpark( *thrd __cfaabi_dbg_ctx2 ); + unpark( *thrd ); } else { Thread * thrd = __atomic_exchange_n(&blocked[idx], &this, __ATOMIC_SEQ_CST); - unpark( *thrd __cfaabi_dbg_ctx2 ); - park( __cfaabi_dbg_ctx ); + unpark( *thrd ); + park(); } } @@ -41,5 +41,5 @@ int idx = myrand() % blocked_size; Thread * thrd = __atomic_exchange_n(&blocked[idx], 0p, __ATOMIC_SEQ_CST); - unpark( *thrd __cfaabi_dbg_ctx2 ); + unpark( *thrd ); yield( myrand() % 20 ); } Index: tests/concurrent/park/force_preempt.cfa =================================================================== --- tests/concurrent/park/force_preempt.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ tests/concurrent/park/force_preempt.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -30,5 +30,5 @@ // Unpark this thread, don't force a yield - unpark( this __cfaabi_dbg_ctx2 ); + unpark( this ); assert(mask == 0xCAFEBABA); @@ -43,5 +43,5 @@ // Park this thread, assert(mask == (id_hash ^ 0xCAFEBABA)); - park( __cfaabi_dbg_ctx ); + park(); assert(mask == (id_hash ^ 0xCAFEBABA)); Index: tests/concurrent/park/start_parked.cfa =================================================================== --- tests/concurrent/park/start_parked.cfa (revision ebec8ed9e0a286db65262fb396a4ce6be64f2002) +++ tests/concurrent/park/start_parked.cfa (revision 615767bf8c2af44d97001895be6cbf190a69a365) @@ -3,5 +3,5 @@ thread Parker {}; void main( Parker & ) { - park( __cfaabi_dbg_ctx ); + park(); } @@ -9,5 +9,5 @@ for(1000) { Parker parker; - unpark( parker __cfaabi_dbg_ctx2 ); + unpark( parker ); } printf( "done\n" ); // non-empty .expect file