Changeset 1716e1c for libcfa/src/concurrency/kernel.cfa
- Timestamp:
- May 4, 2021, 12:31:26 PM (3 years ago)
- Branches:
- ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
- Children:
- 0c4df43
- Parents:
- 8cd34e9 (diff), c0c940a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)links above to see all the changes relative to each parent. - File:
-
- 1 edited
-
libcfa/src/concurrency/kernel.cfa (modified) (2 diffs)
Legend:
- Unmodified
- Added
- Removed
-
libcfa/src/concurrency/kernel.cfa
r8cd34e9 r1716e1c 184 184 MAIN_LOOP: 185 185 for() { 186 #if 1 186 187 // Check if there is pending io 187 188 __maybe_io_drain( this ); … … 270 271 } 271 272 272 // SEARCH: { 273 // /* paranoid */ verify( ! __preemption_enabled() ); 274 // /* paranoid */ verify( kernelTLS().this_proc_id ); 275 276 // // First, lock the scheduler since we are searching for a thread 277 278 // // Try to get the next thread 279 // ready_schedule_lock(); 280 // readyThread = pop_fast( this->cltr ); 281 // ready_schedule_unlock(); 282 // if(readyThread) { break SEARCH; } 283 284 // // If we can't find a thread, might as well flush any outstanding I/O 285 // if(this->io.pending) { __cfa_io_flush( this ); } 286 287 // // Spin a little on I/O, just in case 288 // for(25) { 289 // __maybe_io_drain( this ); 290 // ready_schedule_lock(); 291 // readyThread = pop_fast( this->cltr ); 292 // ready_schedule_unlock(); 293 // if(readyThread) { break SEARCH; } 294 // } 295 296 // // no luck, try stealing a few times 297 // for(25) { 298 // if( __maybe_io_drain( this ) ) { 299 // ready_schedule_lock(); 300 // readyThread = pop_fast( this->cltr ); 301 // } else { 302 // ready_schedule_lock(); 303 // readyThread = pop_slow( this->cltr ); 304 // } 305 // ready_schedule_unlock(); 306 // if(readyThread) { break SEARCH; } 307 // } 308 309 // // still no luck, search for a thread 310 // ready_schedule_lock(); 311 // readyThread = pop_search( this->cltr ); 312 // ready_schedule_unlock(); 313 // if(readyThread) { break SEARCH; } 314 315 // // Don't block if we are done 316 // if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP; 317 318 // __STATS( __tls_stats()->ready.sleep.halts++; ) 319 320 // // Push self to idle stack 321 // mark_idle(this->cltr->procs, * this); 322 323 // // Confirm the ready-queue is empty 324 // __maybe_io_drain( this ); 325 // ready_schedule_lock(); 326 // readyThread = pop_search( this->cltr ); 327 // ready_schedule_unlock(); 328 329 // if( readyThread ) { 330 // // A thread was found, cancel the halt 331 // mark_awake(this->cltr->procs, * this); 332 333 // __STATS( __tls_stats()->ready.sleep.cancels++; ) 334 335 // // continue the main loop 336 // break SEARCH; 337 // } 338 339 // __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->id, rdtscl()); ) 340 // __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle); 341 342 // // __disable_interrupts_hard(); 343 // eventfd_t val; 344 // eventfd_read( this->idle, &val ); 345 // // __enable_interrupts_hard(); 346 347 // __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->id, rdtscl()); ) 348 349 // // We were woken up, remove self from idle 350 // mark_awake(this->cltr->procs, * this); 351 352 // // DON'T just proceed, start looking again 353 // continue MAIN_LOOP; 354 // } 355 356 // RUN_THREAD: 357 // /* paranoid */ verify( kernelTLS().this_proc_id ); 358 // /* paranoid */ verify( ! __preemption_enabled() ); 359 // /* paranoid */ verify( readyThread ); 360 361 // // Reset io dirty bit 362 // this->io.dirty = false; 363 364 // // We found a thread run it 365 // __run_thread(this, readyThread); 366 367 // // Are we done? 368 // if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP; 369 370 // #if !defined(__CFA_NO_STATISTICS__) 371 // unsigned long long curr = rdtscl(); 372 // if(curr > (last_tally + 500000000)) { 373 // __tally_stats(this->cltr->stats, __cfaabi_tls.this_stats); 374 // last_tally = curr; 375 // } 376 // #endif 377 378 // if(this->io.pending && !this->io.dirty) { 379 // __cfa_io_flush( this ); 380 // } 381 382 // // Check if there is pending io 383 // __maybe_io_drain( this ); 273 #else 274 275 SEARCH: { 276 /* paranoid */ verify( ! __preemption_enabled() ); 277 /* paranoid */ verify( kernelTLS().this_proc_id ); 278 279 // First, lock the scheduler since we are searching for a thread 280 ready_schedule_lock(); 281 282 // Try to get the next thread 283 readyThread = pop_fast( this->cltr ); 284 if(readyThread) { ready_schedule_unlock(); break SEARCH; } 285 286 // If we can't find a thread, might as well flush any outstanding I/O 287 if(this->io.pending) { __cfa_io_flush( this ); } 288 289 // Spin a little on I/O, just in case 290 for(25) { 291 __maybe_io_drain( this ); 292 readyThread = pop_fast( this->cltr ); 293 if(readyThread) { ready_schedule_unlock(); break SEARCH; } 294 } 295 296 // no luck, try stealing a few times 297 for(25) { 298 if( __maybe_io_drain( this ) ) { 299 readyThread = pop_fast( this->cltr ); 300 } else { 301 readyThread = pop_slow( this->cltr ); 302 } 303 if(readyThread) { ready_schedule_unlock(); break SEARCH; } 304 } 305 306 // still no luck, search for a thread 307 readyThread = pop_search( this->cltr ); 308 if(readyThread) { ready_schedule_unlock(); break SEARCH; } 309 310 // Don't block if we are done 311 if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP; 312 313 __STATS( __tls_stats()->ready.sleep.halts++; ) 314 315 // Push self to idle stack 316 ready_schedule_unlock(); 317 mark_idle(this->cltr->procs, * this); 318 ready_schedule_lock(); 319 320 // Confirm the ready-queue is empty 321 __maybe_io_drain( this ); 322 readyThread = pop_search( this->cltr ); 323 ready_schedule_unlock(); 324 325 if( readyThread ) { 326 // A thread was found, cancel the halt 327 mark_awake(this->cltr->procs, * this); 328 329 __STATS( __tls_stats()->ready.sleep.cancels++; ) 330 331 // continue the main loop 332 break SEARCH; 333 } 334 335 __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->id, rdtscl()); ) 336 __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle); 337 338 // __disable_interrupts_hard(); 339 eventfd_t val; 340 eventfd_read( this->idle, &val ); 341 // __enable_interrupts_hard(); 342 343 __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->id, rdtscl()); ) 344 345 // We were woken up, remove self from idle 346 mark_awake(this->cltr->procs, * this); 347 348 // DON'T just proceed, start looking again 349 continue MAIN_LOOP; 350 } 351 352 RUN_THREAD: 353 /* paranoid */ verify( kernelTLS().this_proc_id ); 354 /* paranoid */ verify( ! __preemption_enabled() ); 355 /* paranoid */ verify( readyThread ); 356 357 // Reset io dirty bit 358 this->io.dirty = false; 359 360 // We found a thread run it 361 __run_thread(this, readyThread); 362 363 // Are we done? 364 if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP; 365 366 #if !defined(__CFA_NO_STATISTICS__) 367 unsigned long long curr = rdtscl(); 368 if(curr > (last_tally + 500000000)) { 369 __tally_stats(this->cltr->stats, __cfaabi_tls.this_stats); 370 last_tally = curr; 371 } 372 #endif 373 374 if(this->io.pending && !this->io.dirty) { 375 __cfa_io_flush( this ); 376 } 377 378 ready_schedule_lock(); 379 __maybe_io_drain( this ); 380 ready_schedule_unlock(); 381 #endif 384 382 } 385 383
Note: See TracChangeset
for help on using the changeset viewer.
