Changes in / [5527759:9d5fb67]
- Location:
- src
- Files:
-
- 14 edited
-
ResolvExpr/Resolver.cc (modified) (4 diffs)
-
SynTree/Statement.cc (modified) (1 diff)
-
libcfa/bits/locks.h (modified) (3 diffs)
-
libcfa/concurrency/coroutine (modified) (1 diff)
-
libcfa/concurrency/coroutine.c (modified) (3 diffs)
-
libcfa/concurrency/invoke.h (modified) (1 diff)
-
libcfa/concurrency/kernel (modified) (3 diffs)
-
libcfa/concurrency/kernel.c (modified) (19 diffs)
-
libcfa/concurrency/preemption.c (modified) (3 diffs)
-
libcfa/concurrency/thread (modified) (3 diffs)
-
libcfa/concurrency/thread.c (modified) (1 diff)
-
tests/concurrent/examples/.expect/boundedBufferEXT.txt (modified) (1 diff)
-
tests/concurrent/examples/boundedBufferEXT.c (modified) (4 diffs)
-
tests/concurrent/thread.c (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
src/ResolvExpr/Resolver.cc
r5527759 r9d5fb67 492 492 } 493 493 494 if(clause.target.arguments.empty()) {495 SemanticError( stmt->location, "Waitfor clause must have at least one mutex parameter");496 }497 498 494 // Find all alternatives for all arguments in canonical form 499 495 std::vector< AlternativeFinder > argAlternatives; … … 560 556 auto param_end = function->parameters.end(); 561 557 562 int n_mutex_arg = 0;563 564 558 // For every arguments of its set, check if it matches one of the parameter 565 559 // The order is important … … 570 564 // We ran out of parameters but still have arguments 571 565 // this function doesn't match 572 SemanticError( function, toString("candidate function not viable: too many mutex arguments, expected ", n_mutex_arg, "\n" ));566 SemanticError( function, "candidate function not viable: too many mutex arguments\n" ); 573 567 } 574 568 575 n_mutex_arg++;576 577 569 // Check if the argument matches the parameter type in the current scope 578 if( ! unify( arg.expr->get_result(), (*param)->get_type(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {570 if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) { 579 571 // Type doesn't match 580 572 stringstream ss; 581 573 ss << "candidate function not viable: no known convertion from '"; 574 arg.expr->get_result()->print( ss ); 575 ss << "' to '"; 582 576 (*param)->get_type()->print( ss ); 583 ss << "' to '";584 arg.expr->get_result()->print( ss );585 577 ss << "'\n"; 586 578 SemanticError( function, ss.str() ); … … 596 588 // We ran out of arguments but still have parameters left 597 589 // this function doesn't match 598 SemanticError( function, toString("candidate function not viable: too few mutex arguments, expected ", n_mutex_arg, "\n" ));590 SemanticError( function, "candidate function not viable: too few mutex arguments\n" ); 599 591 } 600 592 -
src/SynTree/Statement.cc
r5527759 r9d5fb67 453 453 void WaitForStmt::print( std::ostream &os, Indenter indent ) const { 454 454 os << "Waitfor Statement" << endl; 455 indent += 1; 456 for( auto & clause : clauses ) { 457 os << indent << "target function :"; 458 if(clause.target.function) { clause.target.function->print(os, indent + 1); } 459 os << endl << indent << "with arguments :" << endl; 460 for( auto & thing : clause.target.arguments) { 461 if(thing) { thing->print(os, indent + 1); } 462 } 463 os << indent << " with statment :" << endl; 464 if(clause.statement) { clause.statement->print(os, indent + 1); } 465 466 os << indent << " with condition :" << endl; 467 if(clause.condition) { clause.condition->print(os, indent + 1); } 468 } 469 470 os << indent << " timeout of :" << endl; 471 if(timeout.time) { timeout.time->print(os, indent + 1); } 472 473 os << indent << " with statment :" << endl; 474 if(timeout.statement) { timeout.statement->print(os, indent + 1); } 475 476 os << indent << " with condition :" << endl; 477 if(timeout.condition) { timeout.condition->print(os, indent + 1); } 478 479 480 os << indent << " else :" << endl; 481 if(orelse.statement) { orelse.statement->print(os, indent + 1); } 482 483 os << indent << " with condition :" << endl; 484 if(orelse.condition) { orelse.condition->print(os, indent + 1); } 455 os << indent << "... with block:" << endl << indent+1; 456 // block->print( os, indent + 4 ); 485 457 } 486 458 -
src/libcfa/bits/locks.h
r5527759 r9d5fb67 69 69 } 70 70 71 72 #ifdef __CFA_DEBUG__73 void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name);74 #else75 #define __cfaabi_dbg_record(x, y)76 #endif77 78 71 // Lock the spinlock, return false if already acquired 79 72 static inline _Bool try_lock ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) { … … 81 74 if( result ) { 82 75 disable_interrupts(); 83 __cfaabi_dbg_record( this, caller ); 76 // __cfaabi_dbg_debug_do( 77 // this.prev_name = caller; 78 // this.prev_thrd = TL_GET( this_thread ); 79 // ) 84 80 } 85 81 return result; … … 109 105 } 110 106 disable_interrupts(); 111 __cfaabi_dbg_record( this, caller ); 107 // __cfaabi_dbg_debug_do( 108 // this.prev_name = caller; 109 // this.prev_thrd = TL_GET( this_thread ); 110 // ) 112 111 } 113 112 -
src/libcfa/concurrency/coroutine
r5527759 r9d5fb67 32 32 //----------------------------------------------------------------------------- 33 33 // Ctors and dtors 34 // void ?{}( coStack_t & this ); 35 // void ^?{}( coStack_t & this ); 36 37 void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize ); 38 void ^?{}( coroutine_desc & this ); 39 40 static inline void ?{}( coroutine_desc & this) { this{ "Anonymous Coroutine", NULL, 0 }; } 41 static inline void ?{}( coroutine_desc & this, size_t stackSize) { this{ "Anonymous Coroutine", NULL, stackSize }; } 42 static inline void ?{}( coroutine_desc & this, void * storage, size_t storageSize ) { this{ "Anonymous Coroutine", storage, storageSize }; } 43 static inline void ?{}( coroutine_desc & this, const char * name) { this{ name, NULL, 0 }; } 44 static inline void ?{}( coroutine_desc & this, const char * name, size_t stackSize ) { this{ name, NULL, stackSize }; } 34 void ?{}(coStack_t & this); 35 void ?{}(coroutine_desc & this); 36 void ?{}(coroutine_desc & this, const char * name); 37 void ^?{}(coStack_t & this); 38 void ^?{}(coroutine_desc & this); 45 39 46 40 //----------------------------------------------------------------------------- -
src/libcfa/concurrency/coroutine.c
r5527759 r9d5fb67 39 39 //----------------------------------------------------------------------------- 40 40 // Coroutine ctors and dtors 41 void ?{}( coStack_t & this, void * storage, size_t storageSize ) with( this ) { 42 size = storageSize == 0 ? 65000 : storageSize; // size of stack 43 this.storage = storage; // pointer to stack 44 limit = NULL; // stack grows towards stack limit 45 base = NULL; // base of stack 46 context = NULL; // address of cfa_context_t 47 top = NULL; // address of top of storage 48 userStack = storage != NULL; 41 void ?{}(coStack_t& this) with( this ) { 42 size = 65000; // size of stack 43 storage = NULL; // pointer to stack 44 limit = NULL; // stack grows towards stack limit 45 base = NULL; // base of stack 46 context = NULL; // address of cfa_context_t 47 top = NULL; // address of top of storage 48 userStack = false; 49 } 50 51 void ?{}(coStack_t& this, size_t size) { 52 this{}; 53 this.size = size; 54 55 create_stack(&this, this.size); 56 } 57 58 void ?{}(coroutine_desc& this) { 59 this{ "Anonymous Coroutine" }; 60 } 61 62 void ?{}(coroutine_desc& this, const char * name) with( this ) { 63 this.name = name; 64 errno_ = 0; 65 state = Start; 66 starter = NULL; 67 last = NULL; 68 } 69 70 void ?{}(coroutine_desc& this, size_t size) { 71 this{}; 72 (this.stack){size}; 49 73 } 50 74 51 75 void ^?{}(coStack_t & this) { 52 if ( ! this.userStack && this.storage ) { 53 __cfaabi_dbg_debug_do( 54 if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) { 55 abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) ); 56 } 57 ); 58 free( this.storage ); 59 } 60 } 61 62 void ?{}( coroutine_desc & this, const char * name, void * storage, size_t storageSize ) with( this ) { 63 (this.stack){storage, storageSize}; 64 this.name = name; 65 errno_ = 0; 66 state = Start; 67 starter = NULL; 68 last = NULL; 76 if ( ! this.userStack && this.storage ) { 77 __cfaabi_dbg_debug_do( 78 if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) { 79 abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) ); 80 } 81 ); 82 free( this.storage ); 83 } 69 84 } 70 85 … … 75 90 forall(dtype T | is_coroutine(T)) 76 91 void prime(T& cor) { 77 78 92 coroutine_desc* this = get_coroutine(cor); 93 assert(this->state == Start); 79 94 80 81 95 this->state = Primed; 96 resume(cor); 82 97 } 83 98 84 99 // Wrapper for co 85 100 void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) { 86 87 101 verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate ); 102 disable_interrupts(); 88 103 89 90 104 // set state of current coroutine to inactive 105 src->state = src->state == Halted ? Halted : Inactive; 91 106 92 93 107 // set new coroutine that task is executing 108 TL_SET( this_coroutine, dst ); 94 109 95 96 97 98 110 // context switch to specified coroutine 111 assert( src->stack.context ); 112 CtxSwitch( src->stack.context, dst->stack.context ); 113 // when CtxSwitch returns we are back in the src coroutine 99 114 100 101 115 // set state of new coroutine to active 116 src->state = Active; 102 117 103 104 118 enable_interrupts( __cfaabi_dbg_ctx ); 119 verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate ); 105 120 } //ctxSwitchDirect 106 121 107 122 void create_stack( coStack_t* this, unsigned int storageSize ) with( *this ) { 108 109 123 //TEMP HACK do this on proper kernel startup 124 if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE ); 110 125 111 126 size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment 112 127 113 if ( !storage ) { 114 __cfaabi_dbg_print_safe("Kernel : Creating stack of size %zu for stack obj %p\n", cxtSize + size + 8, this); 128 if ( (intptr_t)storage == 0 ) { 129 userStack = false; 130 size = libCeiling( storageSize, 16 ); 131 // use malloc/memalign because "new" raises an exception for out-of-memory 115 132 116 userStack = false; 117 size = libCeiling( storageSize, 16);118 // use malloc/memalign because "new" raises an exception for out-of-memory 133 // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment 134 __cfaabi_dbg_debug_do( storage = memalign( pageSize, cxtSize + size + pageSize ) ); 135 __cfaabi_dbg_no_debug_do( storage = malloc( cxtSize + size + 8 ) ); 119 136 120 // assume malloc has 8 byte alignment so add 8 to allow rounding up to 16 byte alignment 121 __cfaabi_dbg_debug_do( storage = memalign( pageSize, cxtSize + size + pageSize ) ); 122 __cfaabi_dbg_no_debug_do( storage = malloc( cxtSize + size + 8 ) ); 137 __cfaabi_dbg_debug_do( 138 if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) { 139 abort( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) ); 140 } // if 141 ); 123 142 124 __cfaabi_dbg_debug_do( 125 if ( mprotect( storage, pageSize, PROT_NONE ) == -1 ) { 126 abort( "(uMachContext &)%p.createContext() : internal error, mprotect failure, error(%d) %s.", this, (int)errno, strerror( (int)errno ) ); 127 } // if 128 ); 143 if ( (intptr_t)storage == 0 ) { 144 abort( "Attempt to allocate %zd bytes of storage for coroutine or task execution-state but insufficient memory available.", size ); 145 } // if 129 146 130 if ( (intptr_t)storage == 0 ) { 131 abort( "Attempt to allocate %zd bytes of storage for coroutine or task execution-state but insufficient memory available.", size ); 132 } // if 147 __cfaabi_dbg_debug_do( limit = (char *)storage + pageSize ); 148 __cfaabi_dbg_no_debug_do( limit = (char *)libCeiling( (unsigned long)storage, 16 ) ); // minimum alignment 133 149 134 __cfaabi_dbg_debug_do( limit = (char *)storage + pageSize ); 135 __cfaabi_dbg_no_debug_do( limit = (char *)libCeiling( (unsigned long)storage, 16 ) ); // minimum alignment 150 } else { 151 assertf( ((size_t)storage & (libAlign() - 1)) != 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", storage, (int)libAlign() ); 152 userStack = true; 153 size = storageSize - cxtSize; 136 154 137 } else { 138 __cfaabi_dbg_print_safe("Kernel : stack obj %p using user stack %p(%u bytes)\n", this, storage, storageSize); 155 if ( size % 16 != 0u ) size -= 8; 139 156 140 assertf( ((size_t)storage & (libAlign() - 1)) == 0ul, "Stack storage %p for task/coroutine must be aligned on %d byte boundary.", storage, (int)libAlign() ); 141 userStack = true; 142 size = storageSize - cxtSize;157 limit = (char *)libCeiling( (unsigned long)storage, 16 ); // minimum alignment 158 } // if 159 assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize ); 143 160 144 if ( size % 16 != 0u ) size -= 8; 145 146 limit = (char *)libCeiling( (unsigned long)storage, 16 ); // minimum alignment 147 } // if 148 assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize ); 149 150 base = (char *)limit + size; 151 context = base; 152 top = (char *)context + cxtSize; 161 base = (char *)limit + size; 162 context = base; 163 top = (char *)context + cxtSize; 153 164 } 154 165 … … 156 167 // is not inline (We can't inline Cforall in C) 157 168 extern "C" { 158 159 160 169 void __suspend_internal(void) { 170 suspend(); 171 } 161 172 162 163 173 void __leave_coroutine(void) { 174 coroutine_desc * src = TL_GET( this_coroutine ); // optimization 164 175 165 166 167 168 169 170 171 172 176 assertf( src->starter != 0, 177 "Attempt to suspend/leave coroutine \"%.256s\" (%p) that has never been resumed.\n" 178 "Possible cause is a suspend executed in a member called by a coroutine user rather than by the coroutine main.", 179 src->name, src ); 180 assertf( src->starter->state != Halted, 181 "Attempt by coroutine \"%.256s\" (%p) to suspend/leave back to terminated coroutine \"%.256s\" (%p).\n" 182 "Possible cause is terminated coroutine's main routine has already returned.", 183 src->name, src, src->starter->name, src->starter ); 173 184 174 175 185 CoroutineCtxSwitch( src, src->starter ); 186 } 176 187 } 177 188 -
src/libcfa/concurrency/invoke.h
r5527759 r9d5fb67 125 125 // pointer to monitor with sufficient lifetime for current monitors 126 126 struct monitor_desc * self_mon_p; 127 128 // pointer to the cluster on which the thread is running129 struct cluster * curr_cluster;130 127 131 128 // monitors currently held by this thread -
src/libcfa/concurrency/kernel
r5527759 r9d5fb67 48 48 __queue_t(thread_desc) ready_queue; 49 49 50 // Name of the cluster51 const char * name;52 53 50 // Preemption rate on this cluster 54 51 Duration preemption_rate; 55 52 }; 56 53 57 extern struct cluster * mainCluster;58 54 extern Duration default_preemption(); 59 55 60 void ?{} (cluster & this , const char * name, Duration preemption_rate);56 void ?{} (cluster & this); 61 57 void ^?{}(cluster & this); 62 63 static inline void ?{} (cluster & this) { this{"Anonymous Cluster", default_preemption()}; }64 static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }65 static inline void ?{} (cluster & this, const char * name) { this{name, default_preemption()}; }66 58 67 59 //----------------------------------------------------------------------------- … … 100 92 cluster * cltr; 101 93 102 // Name of the processor103 const char * name;104 105 94 // Handle to pthreads 106 95 pthread_t kernel_thread; … … 130 119 }; 131 120 132 void ?{}(processor & this, const char * name, cluster & cltr); 121 void ?{}(processor & this); 122 void ?{}(processor & this, cluster * cltr); 133 123 void ^?{}(processor & this); 134 135 static inline void ?{}(processor & this) { this{ "Anonymous Processor", *mainCluster}; }136 static inline void ?{}(processor & this, cluster & cltr) { this{ "Anonymous Processor", cltr}; }137 static inline void ?{}(processor & this, const char * name) { this{name, *mainCluster }; }138 124 139 125 // Local Variables: // -
src/libcfa/concurrency/kernel.c
r5527759 r9d5fb67 42 42 KERNEL_STORAGE(cluster, mainCluster); 43 43 KERNEL_STORAGE(processor, mainProcessor); 44 KERNEL_STORAGE(processorCtx_t, mainProcessorCtx); 44 45 KERNEL_STORAGE(thread_desc, mainThread); 45 46 KERNEL_STORAGE(machine_context_t, mainThreadCtx); 46 47 47 cluster *mainCluster;48 processor *mainProcessor;48 cluster * mainCluster; 49 processor * mainProcessor; 49 50 thread_desc * mainThread; 50 51 … … 64 65 65 66 //----------------------------------------------------------------------------- 66 // Struct to steal stack67 // Main thread construction 67 68 struct current_stack_info_t { 68 69 machine_context_t ctx; … … 89 90 } 90 91 91 //-----------------------------------------------------------------------------92 // Main thread construction93 92 void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) { 94 93 size = info->size; … … 112 111 self_cor{ info }; 113 112 curr_cor = &self_cor; 114 curr_cluster = mainCluster;115 113 self_mon.owner = &this; 116 114 self_mon.recursion = 1; … … 128 126 //----------------------------------------------------------------------------- 129 127 // Processor coroutine 130 void ?{}(processorCtx_t & this) { 131 128 void ?{}(processorCtx_t & this) {} 129 130 // Construct the processor context of the main processor 131 void ?{}(processorCtx_t & this, processor * proc) { 132 (this.__cor){ "Processor" }; 133 this.__cor.starter = NULL; 134 this.proc = proc; 132 135 } 133 136 … … 138 141 } 139 142 140 void ?{}(processor & this, const char * name, cluster & cltr) with( this ) { 141 this.name = name; 142 this.cltr = &cltr; 143 void ?{}(processor & this) { 144 this{ mainCluster }; 145 } 146 147 void ?{}(processor & this, cluster * cltr) with( this ) { 148 this.cltr = cltr; 143 149 terminated{ 0 }; 144 150 do_terminate = false; … … 148 154 149 155 start( &this ); 156 } 157 158 void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) with( this ) { 159 this.cltr = cltr; 160 terminated{ 0 }; 161 do_terminate = false; 162 preemption_alarm = NULL; 163 pending_preemption = false; 164 kernel_thread = pthread_self(); 165 runner.proc = &this; 166 167 __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner); 168 runner{ &this }; 150 169 } 151 170 … … 162 181 } 163 182 164 void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) { 165 this.name = name; 166 this.preemption_rate = preemption_rate; 183 void ?{}(cluster & this) with( this ) { 167 184 ready_queue{}; 168 185 ready_queue_lock{}; 186 187 preemption_rate = default_preemption(); 169 188 } 170 189 … … 293 312 TL_SET( this_coroutine, NULL ); 294 313 TL_SET( this_thread, NULL ); 295 TL_GET( preemption_state ).[enabled, disable_count] = [false, 1]; 314 TL_GET( preemption_state ).enabled = false; 315 TL_GET( preemption_state ).disable_count = 1; 296 316 // SKULLDUGGERY: We want to create a context for the processor coroutine 297 317 // which is needed for the 2-step context switch. However, there is no reason … … 382 402 verifyf( thrd->next == NULL, "Expected null got %p", thrd->next ); 383 403 384 with( * thrd->curr_cluster ) {404 with( *TL_GET( this_processor )->cltr ) { 385 405 lock ( ready_queue_lock __cfaabi_dbg_ctx2 ); 386 406 append( ready_queue, thrd ); … … 410 430 void BlockInternal( __spinlock_t * lock ) { 411 431 disable_interrupts(); 412 with( *TL_GET( this_processor ) ) { 413 finish.action_code = Release; 414 finish.lock = lock; 415 } 432 TL_GET( this_processor )->finish.action_code = Release; 433 TL_GET( this_processor )->finish.lock = lock; 416 434 417 435 verify( ! TL_GET( preemption_state ).enabled ); … … 424 442 void BlockInternal( thread_desc * thrd ) { 425 443 disable_interrupts(); 426 with( *TL_GET( this_processor ) ) { 427 finish.action_code = Schedule; 428 finish.thrd = thrd; 429 } 444 TL_GET( this_processor )->finish.action_code = Schedule; 445 TL_GET( this_processor )->finish.thrd = thrd; 430 446 431 447 verify( ! TL_GET( preemption_state ).enabled ); … … 439 455 assert(thrd); 440 456 disable_interrupts(); 441 with( *TL_GET( this_processor ) ) { 442 finish.action_code = Release_Schedule; 443 finish.lock = lock; 444 finish.thrd = thrd; 445 } 457 TL_GET( this_processor )->finish.action_code = Release_Schedule; 458 TL_GET( this_processor )->finish.lock = lock; 459 TL_GET( this_processor )->finish.thrd = thrd; 446 460 447 461 verify( ! TL_GET( preemption_state ).enabled ); … … 454 468 void BlockInternal(__spinlock_t * locks [], unsigned short count) { 455 469 disable_interrupts(); 456 with( *TL_GET( this_processor ) ) { 457 finish.action_code = Release_Multi; 458 finish.locks = locks; 459 finish.lock_count = count; 460 } 470 TL_GET( this_processor )->finish.action_code = Release_Multi; 471 TL_GET( this_processor )->finish.locks = locks; 472 TL_GET( this_processor )->finish.lock_count = count; 461 473 462 474 verify( ! TL_GET( preemption_state ).enabled ); … … 469 481 void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) { 470 482 disable_interrupts(); 471 with( *TL_GET( this_processor ) ) { 472 finish.action_code = Release_Multi_Schedule; 473 finish.locks = locks; 474 finish.lock_count = lock_count; 475 finish.thrds = thrds; 476 finish.thrd_count = thrd_count; 477 } 483 TL_GET( this_processor )->finish.action_code = Release_Multi_Schedule; 484 TL_GET( this_processor )->finish.locks = locks; 485 TL_GET( this_processor )->finish.lock_count = lock_count; 486 TL_GET( this_processor )->finish.thrds = thrds; 487 TL_GET( this_processor )->finish.thrd_count = thrd_count; 478 488 479 489 verify( ! TL_GET( preemption_state ).enabled ); … … 486 496 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) { 487 497 verify( ! TL_GET( preemption_state ).enabled ); 488 with( *TL_GET( this_processor ) ) { 489 finish.action_code = thrd ? Release_Schedule : Release; 490 finish.lock = lock; 491 finish.thrd = thrd; 492 } 498 TL_GET( this_processor )->finish.action_code = thrd ? Release_Schedule : Release; 499 TL_GET( this_processor )->finish.lock = lock; 500 TL_GET( this_processor )->finish.thrd = thrd; 493 501 494 502 returnToKernel(); … … 504 512 __cfaabi_dbg_print_safe("Kernel : Starting\n"); 505 513 506 // Initialize the main cluster507 mainCluster = (cluster *)&storage_mainCluster;508 (*mainCluster){"Main Cluster"};509 510 __cfaabi_dbg_print_safe("Kernel : Main cluster ready\n");511 512 514 // Start by initializing the main thread 513 515 // SKULLDUGGERY: the mainThread steals the process main thread … … 519 521 __cfaabi_dbg_print_safe("Kernel : Main thread ready\n"); 520 522 521 522 523 // Construct the processor context of the main processor 524 void ?{}(processorCtx_t & this, processor * proc) { 525 (this.__cor){ "Processor" }; 526 this.__cor.starter = NULL; 527 this.proc = proc; 528 } 529 530 void ?{}(processor & this) with( this ) { 531 name = "Main Processor"; 532 cltr = mainCluster; 533 terminated{ 0 }; 534 do_terminate = false; 535 preemption_alarm = NULL; 536 pending_preemption = false; 537 kernel_thread = pthread_self(); 538 539 runner{ &this }; 540 __cfaabi_dbg_print_safe("Kernel : constructed main processor context %p\n", &runner); 541 } 523 // Initialize the main cluster 524 mainCluster = (cluster *)&storage_mainCluster; 525 (*mainCluster){}; 526 527 __cfaabi_dbg_print_safe("Kernel : main cluster ready\n"); 542 528 543 529 // Initialize the main processor and the main processor ctx 544 530 // (the coroutine that contains the processing control flow) 545 531 mainProcessor = (processor *)&storage_mainProcessor; 546 (*mainProcessor){ };532 (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx }; 547 533 548 534 //initialize the global state variables … … 739 725 thrd->dbg_next = NULL; 740 726 } 741 742 void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {743 this.prev_name = prev_name;744 this.prev_thrd = TL_GET( this_thread );745 }746 727 ) 747 728 // Local Variables: // -
src/libcfa/concurrency/preemption.c
r5527759 r9d5fb67 149 149 // Disable interrupts by incrementing the counter 150 150 void disable_interrupts() { 151 with( TL_GET( preemption_state ) ) { 152 enabled = false; 153 __attribute__((unused)) unsigned short new_val = disable_count + 1; 154 disable_count = new_val; 155 verify( new_val < 65_000u ); // If this triggers someone is disabling interrupts without enabling them 156 } 151 TL_GET( preemption_state ).enabled = false; 152 __attribute__((unused)) unsigned short new_val = TL_GET( preemption_state ).disable_count + 1; 153 TL_GET( preemption_state ).disable_count = new_val; 154 verify( new_val < 65_000u ); // If this triggers someone is disabling interrupts without enabling them 157 155 } 158 156 … … 163 161 thread_desc * thrd = TL_GET( this_thread ); // Cache the thread now since interrupts can start happening after the atomic add 164 162 165 with( TL_GET( preemption_state ) ){ 166 unsigned short prev = disable_count; 167 disable_count -= 1; 168 verify( prev != 0u ); // If this triggers someone is enabled already enabled interruptsverify( prev != 0u ); 169 170 // Check if we need to prempt the thread because an interrupt was missed 171 if( prev == 1 ) { 172 enabled = true; 173 if( proc->pending_preemption ) { 174 proc->pending_preemption = false; 175 BlockInternal( thrd ); 176 } 163 unsigned short prev = TL_GET( preemption_state ).disable_count; 164 TL_GET( preemption_state ).disable_count -= 1; 165 verify( prev != 0u ); // If this triggers someone is enabled already enabled interruptsverify( prev != 0u ); 166 167 // Check if we need to prempt the thread because an interrupt was missed 168 if( prev == 1 ) { 169 TL_GET( preemption_state ).enabled = true; 170 if( proc->pending_preemption ) { 171 proc->pending_preemption = false; 172 BlockInternal( thrd ); 177 173 } 178 174 } … … 332 328 if( !preemption_ready() ) { return; } 333 329 334 __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", TL_GET( this_processor ), TL_GET( this_thread ));330 __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread); 335 331 336 332 TL_GET( preemption_state ).in_progress = true; // Sync flag : prevent recursive calls to the signal handler -
src/libcfa/concurrency/thread
r5527759 r9d5fb67 23 23 24 24 //----------------------------------------------------------------------------- 25 // thread trait 25 // Coroutine trait 26 // Anything that implements this trait can be resumed. 27 // Anything that is resumed is a coroutine. 26 28 trait is_thread(dtype T) { 27 29 void ^?{}(T& mutex this); … … 50 52 } 51 53 52 extern struct cluster * mainCluster;54 //extern thread_local thread_desc * volatile this_thread; 53 55 54 56 forall( dtype T | is_thread(T) ) … … 57 59 //----------------------------------------------------------------------------- 58 60 // Ctors and dtors 59 void ?{}(thread_desc & this, const char * const name, struct cluster & cl, void * storage, size_t storageSize ); 60 void ^?{}(thread_desc & this); 61 62 static inline void ?{}(thread_desc & this) { this{ "Anonymous Thread", *mainCluster, NULL, 0 }; } 63 static inline void ?{}(thread_desc & this, size_t stackSize ) { this{ "Anonymous Thread", *mainCluster, NULL, stackSize }; } 64 static inline void ?{}(thread_desc & this, void * storage, size_t storageSize ) { this{ "Anonymous Thread", *mainCluster, storage, storageSize }; } 65 static inline void ?{}(thread_desc & this, struct cluster & cl ) { this{ "Anonymous Thread", cl, NULL, 0 }; } 66 static inline void ?{}(thread_desc & this, struct cluster & cl, size_t stackSize ) { this{ "Anonymous Thread", cl, 0, stackSize }; } 67 static inline void ?{}(thread_desc & this, struct cluster & cl, void * storage, size_t storageSize ) { this{ "Anonymous Thread", cl, storage, storageSize }; } 68 static inline void ?{}(thread_desc & this, const char * const name) { this{ name, *mainCluster, NULL, 0 }; } 69 static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl ) { this{ name, cl, NULL, 0 }; } 70 static inline void ?{}(thread_desc & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, NULL, stackSize }; } 61 void ?{}(thread_desc& this); 62 void ^?{}(thread_desc& this); 71 63 72 64 //----------------------------------------------------------------------------- -
src/libcfa/concurrency/thread.c
r5527759 r9d5fb67 30 30 //----------------------------------------------------------------------------- 31 31 // Thread ctors and dtors 32 void ?{}(thread_desc & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) { 33 self_cor{ name, storage, storageSize }; 34 verify(&self_cor); 32 33 void ?{}(thread_desc& this) with( this ) { 34 self_cor{}; 35 self_cor.name = "Anonymous Coroutine"; 35 36 curr_cor = &self_cor; 36 37 self_mon.owner = &this; 37 38 self_mon.recursion = 1; 38 39 self_mon_p = &self_mon; 39 curr_cluster = &cl;40 40 next = NULL; 41 41 __cfaabi_dbg_debug_do( -
src/tests/concurrent/examples/.expect/boundedBufferEXT.txt
r5527759 r9d5fb67 1 total:400000 1 concurrent/examples/boundedBufferEXT.c:39:1 error: No alternatives for function in call to waitfor 2 /u/pabuhr/software/cfa-cc/include/cfa/bits/containers.h:170:1 error: candidate function not viable: no mutex parameters 3 forall 4 _6573_20_T: sized object type 5 ... with assertions 6 get_next: pointer to function 7 ... with parameters 8 reference to instance of type _6573_20_T (not function type) 9 ... returning 10 _retval_get_next: reference to pointer to instance of type _6573_20_T (not function type) 11 ... with attributes: 12 Attribute with name: unused 13 14 15 16 lvalue function 17 ... with parameters 18 this: reference to instance of struct __queue with body 1 19 ... with parameters 20 instance of type _6573_20_T (not function type) 21 22 it: pointer to pointer to instance of type _6573_20_T (not function type) 23 ... returning 24 _retval_remove: pointer to instance of type _6573_20_T (not function type) 25 ... with attributes: 26 Attribute with name: unused 27 28 29 /usr/include/stdio.h:178:1 error: candidate function not viable: no mutex parameters 30 lvalue function 31 ... with parameters 32 __filename: C pointer to const char 33 ... returning 34 _retval_remove: signed int 35 ... with attributes: 36 Attribute with name: unused 37 38 39 concurrent/examples/boundedBufferEXT.c:47:1 error: No alternatives for function in call to waitfor 40 concurrent/examples/boundedBufferEXT.c:37:1 error: candidate function not viable: too few mutex arguments 41 forall 42 _6578_20_T: sized object type 43 ... with assertions 44 ?=?: pointer to function 45 ... with parameters 46 reference to instance of type _6578_20_T (not function type) 47 instance of type _6578_20_T (not function type) 48 ... returning 49 _retval__operator_assign: instance of type _6578_20_T (not function type) 50 ... with attributes: 51 Attribute with name: unused 52 53 54 ?{}: pointer to function 55 ... with parameters 56 reference to instance of type _6578_20_T (not function type) 57 ... returning nothing 58 59 ?{}: pointer to function 60 ... with parameters 61 reference to instance of type _6578_20_T (not function type) 62 instance of type _6578_20_T (not function type) 63 ... returning nothing 64 65 ^?{}: pointer to function 66 ... with parameters 67 reference to instance of type _6578_20_T (not function type) 68 ... returning nothing 69 70 71 lvalue function 72 ... with parameters 73 buffer: mutex reference to instance of struct Buffer with body 1 74 ... with parameters 75 instance of type _6578_20_T (not function type) 76 77 elem: instance of type _6578_20_T (not function type) 78 ... returning nothing 79 -
src/tests/concurrent/examples/boundedBufferEXT.c
r5527759 r9d5fb67 1 // 1 // 2 2 // The contents of this file are covered under the licence agreement in the 3 3 // file "LICENCE" distributed with Cforall. 4 // 5 // boundedBufferEXT.c -- 6 // 4 // 5 // boundedBufferEXT.c -- 6 // 7 7 // Author : Peter A. Buhr 8 8 // Created On : Wed Apr 18 22:52:12 2018 … … 10 10 // Last Modified On : Fri Apr 20 22:25:14 2018 11 11 // Update Count : 6 12 // 12 // 13 13 14 14 #include <stdlib> // random … … 39 39 forall( otype T ) 40 40 void insert( Buffer(T) & mutex buffer, T elem ) with( buffer ) { 41 if ( count == BufferSize ) waitfor( remove , buffer);41 if ( count == BufferSize ) waitfor( remove ); 42 42 elements[back] = elem; 43 43 back = ( back + 1 ) % BufferSize; … … 47 47 forall( otype T ) 48 48 T remove( Buffer(T) & mutex buffer ) with( buffer ) { 49 if ( count == 0 ) waitfor( insert , buffer);49 if ( count == 0 ) waitfor( insert ); 50 50 T elem = elements[front]; 51 51 front = ( front + 1 ) % BufferSize; -
src/tests/concurrent/thread.c
r5527759 r9d5fb67 7 7 thread Second { semaphore* lock; }; 8 8 9 void ?{}( First & this, semaphore & lock ) { ((thread&)this){"Thread 1"};this.lock = &lock; }10 void ?{}( Second & this, semaphore & lock ) { ((thread&)this){"Thread 2"};this.lock = &lock; }9 void ?{}( First & this, semaphore & lock ) { this.lock = &lock; } 10 void ?{}( Second & this, semaphore & lock ) { this.lock = &lock; } 11 11 12 12 void main(First& this) {
Note:
See TracChangeset
for help on using the changeset viewer.
