Changes in / [3eab0ef6:66b8773]
- Location:
- src
- Files:
-
- 1 deleted
- 9 edited
-
Concurrency/Keywords.cc (modified) (7 diffs)
-
libcfa/concurrency/invoke.h (modified) (3 diffs)
-
libcfa/concurrency/kernel.c (modified) (3 diffs)
-
libcfa/concurrency/monitor (modified) (4 diffs)
-
libcfa/concurrency/monitor.c (modified) (19 diffs)
-
libcfa/concurrency/preemption.c (modified) (2 diffs)
-
tests/preempt_longrun/stack.c (modified) (1 diff)
-
tests/sched-ext.c (deleted)
-
tests/sched-int-disjoint.c (modified) (2 diffs)
-
tests/sched-int-wait.c (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/Concurrency/Keywords.cc
r3eab0ef6 r66b8773 200 200 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* ); 201 201 void validate( DeclarationWithType * ); 202 void addStatments( FunctionDecl* func,CompoundStmt *, const std::list<DeclarationWithType * > &);202 void addStatments( CompoundStmt *, const std::list<DeclarationWithType * > &); 203 203 204 204 static void implement( std::list< Declaration * > & translationUnit ) { … … 210 210 StructDecl* monitor_decl = nullptr; 211 211 StructDecl* guard_decl = nullptr; 212 213 static std::unique_ptr< Type > generic_func;214 212 }; 215 216 std::unique_ptr< Type > MutexKeyword::generic_func = std::unique_ptr< Type >(217 new FunctionType(218 noQualifiers,219 true220 )221 );222 213 223 214 //----------------------------------------------------------------------------- … … 403 394 // Mutex keyword implementation 404 395 //============================================================================================= 405 406 396 void MutexKeyword::visit(FunctionDecl* decl) { 407 397 Visitor::visit(decl); … … 420 410 if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl ); 421 411 422 addStatments( decl,body, mutexArgs );412 addStatments( body, mutexArgs ); 423 413 } 424 414 … … 466 456 } 467 457 468 void MutexKeyword::addStatments( FunctionDecl* func,CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {458 void MutexKeyword::addStatments( CompoundStmt * body, const std::list<DeclarationWithType * > & args ) { 469 459 ObjectDecl * monitors = new ObjectDecl( 470 460 "__monitors", … … 497 487 ); 498 488 499 assert(generic_func);500 501 489 //in reverse order : 502 // monitor_guard_t __guard = { __monitors, # , func};490 // monitor_guard_t __guard = { __monitors, # }; 503 491 body->push_front( 504 492 new DeclStmt( noLabels, new ObjectDecl( … … 514 502 { 515 503 new SingleInit( new VariableExpr( monitors ) ), 516 new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ), 517 new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) ) 504 new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ) 518 505 }, 519 506 noDesignators, -
src/libcfa/concurrency/invoke.h
r3eab0ef6 r66b8773 28 28 #define thread_local _Thread_local 29 29 30 typedef void (*fptr_t)();31 32 30 struct spinlock { 33 31 volatile int lock; … … 52 50 void append( struct __thread_queue_t *, struct thread_desc * ); 53 51 struct thread_desc * pop_head( struct __thread_queue_t * ); 54 struct thread_desc * remove( struct __thread_queue_t *, struct thread_desc ** );55 52 56 53 void ?{}( struct __condition_stack_t * ); … … 90 87 struct __condition_stack_t signal_stack; // stack of conditions to run next once we exit the monitor 91 88 unsigned int recursion; // monitor routines can be called recursively, we need to keep track of that 92 93 struct __acceptable_t * acceptables; // list of acceptable functions, null if any 94 unsigned short acceptable_count; // number of acceptable functions 95 short accepted_index; // the index of the accepted function, -1 if none 96 }; 89 }; 97 90 98 91 struct thread_desc { 99 // Core threading fields100 92 struct coroutine_desc cor; // coroutine body used to store context 101 93 struct monitor_desc mon; // monitor body used for mutual exclusion 102 103 // Link lists fields104 94 struct thread_desc * next; // instrusive link field for threads 105 106 // Current status related to monitors107 95 struct monitor_desc ** current_monitors; // currently held monitors 108 96 unsigned short current_monitor_count; // number of currently held monitors 109 fptr_t current_monitor_func; // last function that acquired monitors 110 }; 97 }; 111 98 112 99 #endif //_INVOKE_H_ -
src/libcfa/concurrency/kernel.c
r3eab0ef6 r66b8773 366 366 367 367 void BlockInternal( thread_desc * thrd ) { 368 assert(thrd);369 368 disable_interrupts(); 370 369 assert( thrd->cor.state != Halted ); … … 380 379 381 380 void BlockInternal( spinlock * lock, thread_desc * thrd ) { 382 assert(thrd);383 381 disable_interrupts(); 384 382 this_processor->finish.action_code = Release_Schedule; … … 668 666 } 669 667 670 thread_desc * remove( __thread_queue_t * this, thread_desc ** it ) {671 thread_desc * thrd = *it;672 verify( thrd );673 674 (*it) = thrd->next;675 676 if( this->tail == &thrd->next ) {677 this->tail = it;678 }679 680 thrd->next = NULL;681 682 verify( (this->head == NULL) == (&this->head == this->tail) );683 verify( *this->tail == NULL );684 return thrd;685 }686 687 688 689 668 void ?{}( __condition_stack_t * this ) { 690 669 this->top = NULL; -
src/libcfa/concurrency/monitor
r3eab0ef6 r66b8773 23 23 24 24 static inline void ?{}(monitor_desc * this) { 25 (&this->lock){};26 25 this->owner = NULL; 27 (&this->entry_queue){};28 (&this->signal_stack){};29 26 this->recursion = 0; 30 this->acceptables = NULL;31 this->acceptable_count = 0;32 this->accepted_index = -1;33 27 } 34 28 … … 38 32 monitor_desc ** prev_mntrs; 39 33 unsigned short prev_count; 40 fptr_t prev_func;41 34 }; 42 35 … … 45 38 } 46 39 47 void ?{}( monitor_guard_t * this, monitor_desc ** m, int count , void (*func)());40 void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ); 48 41 void ^?{}( monitor_guard_t * this ); 49 42 … … 96 89 uintptr_t front( condition * this ); 97 90 98 //-----------------------------------------------------------------------------99 // External scheduling100 101 91 struct __acceptable_t { 102 fptr_t func;92 void (*func)(void); 103 93 unsigned short count; 104 monitor_desc * * monitors;94 monitor_desc * monitors[1]; 105 95 }; 106 96 107 int __accept_internal( unsigned short count, __acceptable_t * acceptables);97 void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) ); 108 98 109 99 // Local Variables: // -
src/libcfa/concurrency/monitor.c
r3eab0ef6 r66b8773 25 25 static inline void set_owner( monitor_desc * this, thread_desc * owner ); 26 26 static inline thread_desc * next_thread( monitor_desc * this ); 27 static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() );28 27 29 28 static inline void lock_all( spinlock ** locks, unsigned short count ); … … 35 34 static inline void restore_recursion( monitor_desc ** ctx, unsigned int * /*in */ recursions, unsigned short count ); 36 35 37 static inline void init ( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );38 static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );39 40 36 static inline thread_desc * check_condition( __condition_criterion_t * ); 41 37 static inline void brand_condition( condition * ); 42 38 static inline unsigned short insert_unique( thread_desc ** thrds, unsigned short end, thread_desc * val ); 43 39 44 static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count );45 46 //-----------------------------------------------------------------------------47 // Useful defines48 #define wait_ctx(thrd, user_info) /* Create the necessary information to use the signaller stack */ \49 __condition_node_t waiter = { thrd, count, user_info }; /* Create the node specific to this wait operation */ \50 __condition_criterion_t criteria[count]; /* Create the creteria this wait operation needs to wake up */ \51 init( count, monitors, &waiter, criteria ); /* Link everything together */ \52 53 #define wait_ctx_primed(thrd, user_info) /* Create the necessary information to use the signaller stack */ \54 __condition_node_t waiter = { thrd, count, user_info }; /* Create the node specific to this wait operation */ \55 __condition_criterion_t criteria[count]; /* Create the creteria this wait operation needs to wake up */ \56 init_push( count, monitors, &waiter, criteria ); /* Link everything together and push it to the AS-Stack */ \57 58 #define monitor_ctx( mons, cnt ) /* Define that create the necessary struct for internal/external scheduling operations */ \59 monitor_desc ** monitors = mons; /* Save the targeted monitors */ \60 unsigned short count = cnt; /* Save the count to a local variable */ \61 unsigned int recursions[ count ]; /* Save the current recursion levels to restore them later */ \62 spinlock * locks [ count ]; /* We need to pass-in an array of locks to BlockInternal */ \63 64 40 //----------------------------------------------------------------------------- 65 41 // Enter/Leave routines … … 67 43 68 44 extern "C" { 69 // Enter single monitor 70 static void __enter_monitor_desc( monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) { 71 // Lock the monitor spinlock, lock_yield to reduce contention 45 void __enter_monitor_desc( monitor_desc * this ) { 72 46 lock_yield( &this->lock DEBUG_CTX2 ); 73 47 thread_desc * thrd = this_thread; 74 48 75 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner); 76 77 this->accepted_index = -1; 49 // LIB_DEBUG_PRINT_SAFE("%p Entering %p (o: %p, r: %i)\n", thrd, this, this->owner, this->recursion); 50 78 51 if( !this->owner ) { 79 // 52 //No one has the monitor, just take it 80 53 set_owner( this, thrd ); 81 82 LIB_DEBUG_PRINT_SAFE("Kernel : mon is free \n");83 54 } 84 55 else if( this->owner == thrd) { 85 // 56 //We already have the monitor, just not how many times we took it 86 57 verify( this->recursion > 0 ); 87 58 this->recursion += 1; 88 89 LIB_DEBUG_PRINT_SAFE("Kernel : mon already owned \n");90 }91 else if( (this->accepted_index = is_accepted( thrd, this, group, group_cnt, func)) >= 0 ) {92 // Some one was waiting for us, enter93 set_owner( this, thrd );94 95 LIB_DEBUG_PRINT_SAFE("Kernel : mon accepts \n");96 59 } 97 60 else { 98 LIB_DEBUG_PRINT_SAFE("Kernel : blocking \n"); 99 100 // Some one else has the monitor, wait in line for it 61 //Some one else has the monitor, wait in line for it 101 62 append( &this->entry_queue, thrd ); 63 // LIB_DEBUG_PRINT_SAFE("%p Blocking on entry\n", thrd); 102 64 BlockInternal( &this->lock ); 103 65 104 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered mon %p\n", thrd, this); 105 106 // BlockInternal will unlock spinlock, no need to unlock ourselves 66 //BlockInternal will unlock spinlock, no need to unlock ourselves 107 67 return; 108 68 } 109 69 110 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entered mon %p\n", thrd, this);111 112 // Release the lock and leave113 70 unlock( &this->lock ); 114 71 return; 115 72 } 116 73 117 // Leave single monitor 74 // leave pseudo code : 75 // TODO 118 76 void __leave_monitor_desc( monitor_desc * this ) { 119 // Lock the monitor spinlock, lock_yield to reduce contention120 77 lock_yield( &this->lock DEBUG_CTX2 ); 121 78 79 // LIB_DEBUG_PRINT_SAFE("%p Leaving %p (o: %p, r: %i). ", this_thread, this, this->owner, this->recursion); 122 80 verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i)", this_thread, this->owner, this->recursion ); 123 81 124 // 82 //Leaving a recursion level, decrement the counter 125 83 this->recursion -= 1; 126 84 127 // 128 // 85 //If we haven't left the last level of recursion 86 //it means we don't need to do anything 129 87 if( this->recursion != 0) { 130 88 unlock( &this->lock ); … … 132 90 } 133 91 134 // Get the next thread, will be null on low contention monitor135 92 thread_desc * new_owner = next_thread( this ); 136 93 137 // 94 //We can now let other threads in safely 138 95 unlock( &this->lock ); 96 97 // LIB_DEBUG_PRINT_SAFE("Next owner is %p\n", new_owner); 139 98 140 99 //We need to wake-up the thread … … 142 101 } 143 102 144 // Leave the thread monitor145 // last routine called by a thread.146 // Should never return147 103 void __leave_thread_monitor( thread_desc * thrd ) { 148 104 monitor_desc * this = &thrd->mon; 149 150 // Lock the monitor now151 105 lock_yield( &this->lock DEBUG_CTX2 ); 152 106 … … 157 111 verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i)", thrd, this->owner, this->recursion ); 158 112 159 // 113 //Leaving a recursion level, decrement the counter 160 114 this->recursion -= 1; 161 115 162 // If we haven't left the last level of recursion 163 // it must mean there is an error 164 if( this->recursion != 0) { abortf("Thread internal monitor has unbalanced recursion"); } 165 166 // Fetch the next thread, can be null 116 //If we haven't left the last level of recursion 117 //it means we don't need to do anything 118 if( this->recursion != 0) { 119 unlock( &this->lock ); 120 return; 121 } 122 167 123 thread_desc * new_owner = next_thread( this ); 168 124 169 // Leave the thread, this will unlock the spinlock170 // Use leave thread instead of BlockInternal which is171 // specialized for this case and supports null new_owner172 125 LeaveThread( &this->lock, new_owner ); 173 174 // Control flow should never reach here! 175 } 176 } 177 178 // Enter multiple monitor 179 // relies on the monitor array being sorted 180 static inline void enter(monitor_desc ** monitors, int count, void (*func)() ) { 126 } 127 } 128 129 static inline void enter(monitor_desc ** monitors, int count) { 181 130 for(int i = 0; i < count; i++) { 182 __enter_monitor_desc( monitors[i], monitors, count, func ); 183 } 184 } 185 186 // Leave multiple monitor 187 // relies on the monitor array being sorted 131 __enter_monitor_desc( monitors[i] ); 132 } 133 } 134 188 135 static inline void leave(monitor_desc ** monitors, int count) { 189 136 for(int i = count - 1; i >= 0; i--) { … … 192 139 } 193 140 194 // Ctor for monitor guard 195 // Sorts monitors before entering 196 void ?{}( monitor_guard_t * this, monitor_desc ** m, int count, void (*func)() ) { 197 // Store current array 141 void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ) { 198 142 this->m = m; 199 143 this->count = count; 200 201 // Sort monitors based on address -> TODO use a sort specialized for small numbers202 144 qsort(this->m, count); 203 204 // Save previous thread context 145 enter( this->m, this->count ); 146 205 147 this->prev_mntrs = this_thread->current_monitors; 206 148 this->prev_count = this_thread->current_monitor_count; 207 this->prev_func = this_thread->current_monitor_func; 208 209 // Update thread context (needed for conditions) 149 210 150 this_thread->current_monitors = m; 211 151 this_thread->current_monitor_count = count; 212 this_thread->current_monitor_func = func; 213 214 // Enter the monitors in order 215 enter( this->m, this->count, func ); 216 } 217 218 // Dtor for monitor guard 152 } 153 219 154 void ^?{}( monitor_guard_t * this ) { 220 // Leave the monitors in order221 155 leave( this->m, this->count ); 222 156 223 // Restore thread context224 157 this_thread->current_monitors = this->prev_mntrs; 225 158 this_thread->current_monitor_count = this->prev_count; 226 this_thread->current_monitor_func = this->prev_func; 227 } 228 229 //----------------------------------------------------------------------------- 230 // Internal scheduling types 159 } 231 160 232 161 void ?{}(__condition_node_t * this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) { … … 254 183 // Internal scheduling 255 184 void wait( condition * this, uintptr_t user_info = 0 ) { 185 // LIB_DEBUG_PRINT_SAFE("Waiting\n"); 186 256 187 brand_condition( this ); 257 188 258 // 189 //Check that everything is as expected 259 190 assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors ); 260 191 verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count ); 261 192 verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count ); 262 193 263 // Create storage for monitor context 264 monitor_ctx( this->monitors, this->monitor_count ); 265 266 // Create the node specific to this wait operation 267 wait_ctx( this_thread, user_info ); 268 269 // Append the current wait operation to the ones already queued on the condition 270 // We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion 194 unsigned short count = this->monitor_count; 195 unsigned int recursions[ count ]; //Save the current recursion levels to restore them later 196 spinlock * locks [ count ]; //We need to pass-in an array of locks to BlockInternal 197 198 // LIB_DEBUG_PRINT_SAFE("count %i\n", count); 199 200 __condition_node_t waiter = { (thread_desc*)this_thread, count, user_info }; 201 202 __condition_criterion_t criteria[count]; 203 for(int i = 0; i < count; i++) { 204 (&criteria[i]){ this->monitors[i], &waiter }; 205 // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] ); 206 } 207 208 waiter.criteria = criteria; 271 209 append( &this->blocked, &waiter ); 272 210 273 // Lock all monitors (aggregates the lock them as well) 274 lock_all( monitors, locks, count ); 275 276 // DON'T unlock, ask the kernel to do it 277 278 // Save monitor state 279 save_recursion( monitors, recursions, count ); 280 281 // Find the next thread(s) to run 211 lock_all( this->monitors, locks, count ); 212 save_recursion( this->monitors, recursions, count ); 213 //DON'T unlock, ask the kernel to do it 214 215 //Find the next thread(s) to run 282 216 unsigned short thread_count = 0; 283 217 thread_desc * threads[ count ]; … … 286 220 } 287 221 288 // Remove any duplicate threads289 222 for( int i = 0; i < count; i++) { 290 thread_desc * new_owner = next_thread( monitors[i] );223 thread_desc * new_owner = next_thread( this->monitors[i] ); 291 224 thread_count = insert_unique( threads, thread_count, new_owner ); 292 225 } 226 227 // LIB_DEBUG_PRINT_SAFE("Will unblock: "); 228 for(int i = 0; i < thread_count; i++) { 229 // LIB_DEBUG_PRINT_SAFE("%p ", threads[i]); 230 } 231 // LIB_DEBUG_PRINT_SAFE("\n"); 293 232 294 233 // Everything is ready to go to sleep … … 296 235 297 236 298 // 299 300 301 // 237 //WE WOKE UP 238 239 240 //We are back, restore the owners and recursions 302 241 lock_all( locks, count ); 303 restore_recursion( monitors, recursions, count );242 restore_recursion( this->monitors, recursions, count ); 304 243 unlock_all( locks, count ); 305 244 } 306 245 307 246 bool signal( condition * this ) { 308 if( is_empty( this ) ) { return false; } 247 if( is_empty( this ) ) { 248 // LIB_DEBUG_PRINT_SAFE("Nothing to signal\n"); 249 return false; 250 } 309 251 310 252 //Check that everything is as expected 311 253 verify( this->monitors ); 312 254 verify( this->monitor_count != 0 ); 255 256 unsigned short count = this->monitor_count; 313 257 314 258 //Some more checking in debug … … 317 261 if ( this->monitor_count != this_thrd->current_monitor_count ) { 318 262 abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->current_monitor_count ); 319 } 263 } // if 320 264 321 265 for(int i = 0; i < this->monitor_count; i++) { 322 266 if ( this->monitors[i] != this_thrd->current_monitors[i] ) { 323 267 abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->current_monitors[i] ); 324 } 268 } // if 325 269 } 326 270 ); 327 271 328 unsigned short count = this->monitor_count; 329 330 // Lock all monitors 272 //Lock all the monitors 331 273 lock_all( this->monitors, NULL, count ); 274 // LIB_DEBUG_PRINT_SAFE("Signalling"); 332 275 333 276 //Pop the head of the waiting queue … … 337 280 for(int i = 0; i < count; i++) { 338 281 __condition_criterion_t * crit = &node->criteria[i]; 282 // LIB_DEBUG_PRINT_SAFE(" %p", crit->target); 339 283 assert( !crit->ready ); 340 284 push( &crit->target->signal_stack, crit ); 341 285 } 342 286 287 // LIB_DEBUG_PRINT_SAFE("\n"); 288 343 289 //Release 344 290 unlock_all( this->monitors, count ); … … 348 294 349 295 bool signal_block( condition * this ) { 350 if( !this->blocked.head ) { return false; } 296 if( !this->blocked.head ) { 297 LIB_DEBUG_PRINT_SAFE("Nothing to signal\n"); 298 return false; 299 } 351 300 352 301 //Check that everything is as expected … … 354 303 verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count ); 355 304 356 // Create storage for monitor context 357 monitor_ctx( this->monitors, this->monitor_count ); 358 359 // Lock all monitors (aggregates the locks them as well) 360 lock_all( monitors, locks, count ); 361 362 // Create the node specific to this wait operation 363 wait_ctx_primed( this_thread, 0 ) 305 unsigned short count = this->monitor_count; 306 unsigned int recursions[ count ]; //Save the current recursion levels to restore them later 307 spinlock * locks [ count ]; //We need to pass-in an array of locks to BlockInternal 308 309 lock_all( this->monitors, locks, count ); 310 311 //create creteria 312 __condition_node_t waiter = { (thread_desc*)this_thread, count, 0 }; 313 314 __condition_criterion_t criteria[count]; 315 for(int i = 0; i < count; i++) { 316 (&criteria[i]){ this->monitors[i], &waiter }; 317 // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] ); 318 push( &criteria[i].target->signal_stack, &criteria[i] ); 319 } 320 321 waiter.criteria = criteria; 364 322 365 323 //save contexts 366 save_recursion( monitors, recursions, count );324 save_recursion( this->monitors, recursions, count ); 367 325 368 326 //Find the thread to run 369 327 thread_desc * signallee = pop_head( &this->blocked )->waiting_thread; 370 328 for(int i = 0; i < count; i++) { 371 set_owner( monitors[i], signallee ); 372 } 329 set_owner( this->monitors[i], signallee ); 330 } 331 332 LIB_DEBUG_PRINT_SAFE( "Waiting on signal block\n" ); 373 333 374 334 //Everything is ready to go to sleep … … 376 336 377 337 378 // WE WOKE UP 379 338 339 340 LIB_DEBUG_PRINT_SAFE( "Back from signal block\n" ); 380 341 381 342 //We are back, restore the owners and recursions 382 343 lock_all( locks, count ); 383 restore_recursion( monitors, recursions, count );344 restore_recursion( this->monitors, recursions, count ); 384 345 unlock_all( locks, count ); 385 346 … … 387 348 } 388 349 389 // Access the user_info of the thread waiting at the front of the queue390 350 uintptr_t front( condition * this ) { 391 351 verifyf( !is_empty(this), … … 398 358 //----------------------------------------------------------------------------- 399 359 // Internal scheduling 400 int __accept_internal( unsigned short acc_count, __acceptable_t * acceptables ) { 401 thread_desc * thrd = this_thread; 402 403 // Create storage for monitor context 404 monitor_ctx( acceptables->monitors, acceptables->count ); 405 406 // Lock all monitors (aggregates the lock them as well) 407 lock_all( monitors, locks, count ); 408 409 // Create the node specific to this wait operation 410 wait_ctx_primed( thrd, 0 ); 411 412 // Check if the entry queue 413 thread_desc * next = search_entry_queue( acceptables, acc_count, monitors, count ); 414 415 LIB_DEBUG_PRINT_SAFE("Owner(s) :"); 416 for(int i = 0; i < count; i++) { 417 LIB_DEBUG_PRINT_SAFE(" %p", monitors[i]->owner ); 418 } 419 LIB_DEBUG_PRINT_SAFE("\n"); 420 421 LIB_DEBUG_PRINT_SAFE("Passing mon to %p\n", next); 422 423 if( !next ) { 424 // Update acceptables on the current monitors 425 for(int i = 0; i < count; i++) { 426 monitors[i]->acceptables = acceptables; 427 monitors[i]->acceptable_count = acc_count; 428 } 429 } 430 else { 431 for(int i = 0; i < count; i++) { 432 set_owner( monitors[i], next ); 433 } 434 } 435 436 437 save_recursion( monitors, recursions, count ); 438 439 440 // Everything is ready to go to sleep 441 BlockInternal( locks, count, &next, next ? 1 : 0 ); 442 443 444 //WE WOKE UP 445 446 447 //We are back, restore the owners and recursions 448 lock_all( locks, count ); 449 restore_recursion( monitors, recursions, count ); 450 int acc_idx = monitors[0]->accepted_index; 451 unlock_all( locks, count ); 452 453 return acc_idx; 360 void __accept_internal( unsigned short count, __acceptable_t * acceptables, void (*func)(void) ) { 361 // thread_desc * this = this_thread; 362 363 // unsigned short count = this->current_monitor_count; 364 // unsigned int recursions[ count ]; //Save the current recursion levels to restore them later 365 // spinlock * locks [ count ]; //We need to pass-in an array of locks to BlockInternal 366 367 // lock_all( this->current_monitors, locks, count ); 368 369 370 371 372 373 // // // Everything is ready to go to sleep 374 // // BlockInternal( locks, count, threads, thread_count ); 375 376 377 // //WE WOKE UP 378 379 380 // //We are back, restore the owners and recursions 381 // lock_all( locks, count ); 382 // restore_recursion( this->monitors, recursions, count ); 383 // unlock_all( locks, count ); 454 384 } 455 385 … … 485 415 } 486 416 487 static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) {488 __acceptable_t* accs = this->acceptables; // Optim489 int acc_cnt = this->acceptable_count;490 491 // Check if there are any acceptable functions492 if( !accs ) return -1;493 494 // If this isn't the first monitor to test this, there is no reason to repeat the test.495 if( this != group[0] ) return group[0]->accepted_index;496 497 // For all acceptable functions check if this is the current function.498 OUT_LOOP:499 for( int i = 0; i < acc_cnt; i++ ) {500 __acceptable_t * acc = &accs[i];501 502 // if function matches, check the monitors503 if( acc->func == func ) {504 505 // If the group count is different then it can't be a match506 if( acc->count != group_cnt ) return -1;507 508 // Check that all the monitors match509 for( int j = 0; j < group_cnt; j++ ) {510 // If not a match, check next function511 if( acc->monitors[j] != group[j] ) continue OUT_LOOP;512 }513 514 // It's a complete match, accept the call515 return i;516 }517 }518 519 // No function matched520 return -1;521 }522 523 static inline void init( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {524 for(int i = 0; i < count; i++) {525 (&criteria[i]){ monitors[i], waiter };526 }527 528 waiter->criteria = criteria;529 }530 531 static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {532 for(int i = 0; i < count; i++) {533 (&criteria[i]){ monitors[i], waiter };534 push( &criteria[i].target->signal_stack, &criteria[i] );535 }536 537 waiter->criteria = criteria;538 }539 540 417 static inline void lock_all( spinlock ** locks, unsigned short count ) { 541 418 for( int i = 0; i < count; i++ ) { … … 628 505 } 629 506 630 static inline bool match( __acceptable_t * acc, thread_desc * thrd ) {631 verify( thrd );632 verify( acc );633 if( acc->func != thrd->current_monitor_func ) return false;634 635 return true;636 }637 638 static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count ) {639 640 __thread_queue_t * entry_queue = &monitors[0]->entry_queue;641 642 // For each thread in the entry-queue643 for( thread_desc ** thrd_it = &entry_queue->head;644 *thrd_it;645 thrd_it = &(*thrd_it)->next)646 {647 // For each acceptable check if it matches648 __acceptable_t * acc_end = acceptables + acc_count;649 for( __acceptable_t * acc_it = acceptables; acc_it != acc_end; acc_it++ ) {650 // Check if we have a match651 if( match( acc_it, *thrd_it ) ) {652 653 // If we have a match return it654 // after removeing it from the entry queue655 return remove( entry_queue, thrd_it );656 }657 }658 }659 660 return NULL;661 }662 663 507 void ?{}( __condition_blocked_queue_t * this ) { 664 508 this->head = NULL; -
src/libcfa/concurrency/preemption.c
r3eab0ef6 r66b8773 332 332 assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int); 333 333 334 //LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );334 LIB_DEBUG_PRINT_SAFE("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int ); 335 335 // Switch on the code (a.k.a. the sender) to 336 336 switch( info.si_code ) … … 340 340 case SI_TIMER: 341 341 case SI_KERNEL: 342 //LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n");342 LIB_DEBUG_PRINT_SAFE("Kernel : Preemption thread tick\n"); 343 343 lock( &event_kernel->lock DEBUG_CTX2 ); 344 344 tick_preemption(); -
src/tests/preempt_longrun/stack.c
r3eab0ef6 r66b8773 15 15 16 16 void main(worker_t * this) { 17 volatile long longp = 5_021_609ul;18 volatile long longa = 326_417ul;19 volatile long longn = 1l;20 for (volatile long longi = 0; i < p; i++) {17 volatile long p = 5_021_609ul; 18 volatile long a = 326_417ul; 19 volatile long n = 1l; 20 for (volatile long i = 0; i < p; i++) { 21 21 n *= a; 22 22 n %= p; -
src/tests/sched-int-disjoint.c
r3eab0ef6 r66b8773 3 3 #include <monitor> 4 4 #include <thread> 5 6 #include <time.h>7 5 8 6 static const unsigned long N = 10_000ul; … … 109 107 // Main loop 110 108 int main(int argc, char* argv[]) { 111 rand48seed( time( NULL ) );112 109 all_done = false; 113 110 processor p; -
src/tests/sched-int-wait.c
r3eab0ef6 r66b8773 5 5 #include <thread> 6 6 7 #include <time.h> 8 9 static const unsigned long N = 2_500ul; 7 static const unsigned long N = 10_000ul; 10 8 11 9 #ifndef PREEMPTION_RATE … … 121 119 // Main 122 120 int main(int argc, char* argv[]) { 123 rand48seed( time( NULL ) );124 121 waiter_left = 4; 125 122 processor p[2];
Note:
See TracChangeset
for help on using the changeset viewer.
