Changes in src/libcfa/concurrency/kernel.c [4e6fb8e:4aa2fb2]
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
src/libcfa/concurrency/kernel.c
r4e6fb8e r4aa2fb2 59 59 // Global state 60 60 61 volatile thread_local processor * this_processor; 62 volatile thread_local unsigned short disable_preempt_count; 61 thread_local processor * this_processor; 63 62 64 63 coroutine_desc * this_coroutine(void) { … … 143 142 this->preemption_alarm = NULL; 144 143 this->preemption = default_preemption(); 144 this->disable_preempt_count = 1; //Start with interrupts disabled 145 145 this->pending_preemption = false; 146 146 … … 154 154 (&this->terminated){}; 155 155 this->is_terminated = false; 156 this->preemption_alarm = NULL; 157 this->preemption = default_preemption(); 156 this->disable_preempt_count = 0; 158 157 this->pending_preemption = false; 159 this->kernel_thread = pthread_self();160 158 161 159 this->runner = runner; 162 LIB_DEBUG_PRINT_SAFE("Kernel : constructing systemprocessor context %p\n", runner);160 LIB_DEBUG_PRINT_SAFE("Kernel : constructing processor context %p\n", runner); 163 161 runner{ this }; 164 162 } 165 166 LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )167 163 168 164 void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) { … … 172 168 173 169 (&this->proc){ cltr, runner }; 174 175 LIB_DEBUG_DO( assert( validate( &this->alarms ) ) );176 170 } 177 171 … … 215 209 if(readyThread) 216 210 { 217 assert( disable_preempt_count > 0 );218 219 211 runThread(this, readyThread); 220 221 assert( disable_preempt_count > 0 );222 212 223 213 //Some actions need to be taken from the kernel … … 299 289 processor * proc = (processor *) arg; 300 290 this_processor = proc; 301 disable_preempt_count = 1;302 291 // SKULLDUGGERY: We want to create a context for the processor coroutine 303 292 // which is needed for the 2-step context switch. However, there is no reason … … 322 311 // appropriate stack. 323 312 proc_cor_storage.__cor.state = Active; 324 325 313 main( &proc_cor_storage ); 314 proc_cor_storage.__cor.state = Halted; 326 315 327 316 // Main routine of the core returned, the core is now fully terminated … … 333 322 void start(processor * this) { 334 323 LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this); 335 336 // SIGALRM must only be caught by the system processor 337 sigset_t old_mask; 338 bool is_system_proc = this_processor == &systemProcessor->proc; 339 if ( is_system_proc ) { 340 // Child kernel-thread inherits the signal mask from the parent kernel-thread. So one special case for the 341 // system processor creating the user processor => toggle the blocking SIGALRM on system processor, create user 342 // processor, and toggle back (below) previous signal mask of the system processor. 343 344 sigset_t new_mask; 345 sigemptyset( &new_mask ); 346 sigemptyset( &old_mask ); 347 sigaddset( &new_mask, SIGALRM ); 348 349 if ( sigprocmask( SIG_BLOCK, &new_mask, &old_mask ) == -1 ) { 350 abortf( "internal error, sigprocmask" ); 351 } 352 353 assert( ! sigismember( &old_mask, SIGALRM ) ); 354 } 355 324 356 325 pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this ); 357 358 // Toggle back previous signal mask of system processor.359 if ( is_system_proc ) {360 if ( sigprocmask( SIG_SETMASK, &old_mask, NULL ) == -1 ) {361 abortf( "internal error, sigprocmask" );362 } // if363 } // if364 326 365 327 LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this); … … 371 333 if( !thrd ) return; 372 334 373 assertf( thrd->next == NULL, "Expected null got %p", thrd->next );335 verifyf( thrd->next == NULL, "Expected null got %p", thrd->next ); 374 336 375 337 lock( &systemProcessor->proc.cltr->lock ); … … 385 347 } 386 348 387 void BlockInternal() { 388 disable_interrupts(); 389 assert( disable_preempt_count > 0 ); 349 void ScheduleInternal() { 390 350 suspend(); 391 assert( disable_preempt_count > 0 ); 392 enable_interrupts( __PRETTY_FUNCTION__ ); 393 } 394 395 void BlockInternal( spinlock * lock ) { 396 disable_interrupts(); 351 } 352 353 void ScheduleInternal( spinlock * lock ) { 397 354 this_processor->finish.action_code = Release; 398 355 this_processor->finish.lock = lock; 399 assert( disable_preempt_count > 0 );400 356 suspend(); 401 assert( disable_preempt_count > 0 ); 402 enable_interrupts( __PRETTY_FUNCTION__ ); 403 } 404 405 void BlockInternal( thread_desc * thrd ) { 406 disable_interrupts(); 357 } 358 359 void ScheduleInternal( thread_desc * thrd ) { 407 360 this_processor->finish.action_code = Schedule; 408 361 this_processor->finish.thrd = thrd; 409 assert( disable_preempt_count > 0 );410 362 suspend(); 411 assert( disable_preempt_count > 0 ); 412 enable_interrupts( __PRETTY_FUNCTION__ ); 413 } 414 415 void BlockInternal( spinlock * lock, thread_desc * thrd ) { 416 disable_interrupts(); 363 } 364 365 void ScheduleInternal( spinlock * lock, thread_desc * thrd ) { 417 366 this_processor->finish.action_code = Release_Schedule; 418 367 this_processor->finish.lock = lock; 419 368 this_processor->finish.thrd = thrd; 420 assert( disable_preempt_count > 0 );421 369 suspend(); 422 assert( disable_preempt_count > 0 ); 423 enable_interrupts( __PRETTY_FUNCTION__ ); 424 } 425 426 void BlockInternal(spinlock ** locks, unsigned short count) { 427 disable_interrupts(); 370 } 371 372 void ScheduleInternal(spinlock ** locks, unsigned short count) { 428 373 this_processor->finish.action_code = Release_Multi; 429 374 this_processor->finish.locks = locks; 430 375 this_processor->finish.lock_count = count; 431 assert( disable_preempt_count > 0 );432 376 suspend(); 433 assert( disable_preempt_count > 0 ); 434 enable_interrupts( __PRETTY_FUNCTION__ ); 435 } 436 437 void BlockInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) { 438 disable_interrupts(); 377 } 378 379 void ScheduleInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) { 439 380 this_processor->finish.action_code = Release_Multi_Schedule; 440 381 this_processor->finish.locks = locks; … … 442 383 this_processor->finish.thrds = thrds; 443 384 this_processor->finish.thrd_count = thrd_count; 444 assert( disable_preempt_count > 0 );445 385 suspend(); 446 assert( disable_preempt_count > 0 );447 enable_interrupts( __PRETTY_FUNCTION__ );448 386 } 449 387 … … 465 403 LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n"); 466 404 405 // Enable preemption 406 kernel_start_preemption(); 407 467 408 // Initialize the system cluster 468 409 systemCluster = (cluster *)&systemCluster_storage; … … 484 425 this_processor->current_thread = mainThread; 485 426 this_processor->current_coroutine = &mainThread->cor; 486 disable_preempt_count = 1;487 488 // Enable preemption489 kernel_start_preemption();490 427 491 428 // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX … … 498 435 // THE SYSTEM IS NOW COMPLETELY RUNNING 499 436 LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n"); 500 501 enable_interrupts( __PRETTY_FUNCTION__ );502 437 } 503 438 504 439 void kernel_shutdown(void) { 505 440 LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n"); 506 507 disable_interrupts();508 441 509 442 // SKULLDUGGERY: Notify the systemProcessor it needs to terminates. … … 514 447 515 448 // THE SYSTEM IS NOW COMPLETELY STOPPED 516 517 // Disable preemption518 kernel_stop_preemption();519 449 520 450 // Destroy the system processor and its context in reverse order of construction … … 620 550 if( !this->cond ) { 621 551 append( &this->blocked, this_thread() ); 622 BlockInternal( &this->lock ); 623 } 624 else { 625 unlock( &this->lock ); 626 } 552 ScheduleInternal( &this->lock ); 553 lock( &this->lock ); 554 } 555 unlock( &this->lock ); 627 556 } 628 557 … … 632 561 this->cond = true; 633 562 634 disable_interrupts();635 563 thread_desc * it; 636 564 while( it = pop_head( &this->blocked) ) { 637 565 ScheduleThread( it ); 638 566 } 639 enable_interrupts( __PRETTY_FUNCTION__ );640 567 } 641 568 unlock( &this->lock ); … … 650 577 651 578 void append( __thread_queue_t * this, thread_desc * t ) { 652 assert(this->tail != NULL);579 verify(this->tail != NULL); 653 580 *this->tail = t; 654 581 this->tail = &t->next; … … 672 599 673 600 void push( __condition_stack_t * this, __condition_criterion_t * t ) { 674 assert( !t->next );601 verify( !t->next ); 675 602 t->next = this->top; 676 603 this->top = t;
Note: See TracChangeset
for help on using the changeset viewer.