Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/concurrency/kernel.cfa

    r34b2796 rc993b15  
    184184                MAIN_LOOP:
    185185                for() {
    186                         #if 1
    187186                        // Check if there is pending io
    188187                        __maybe_io_drain( this );
     
    271270                        }
    272271
    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
     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 );
    382384                }
    383385
Note: See TracChangeset for help on using the changeset viewer.