< prev index next >

src/share/vm/gc/g1/concurrentG1RefineThread.cpp

Print this page
rev 10297 : [mq]: webrev.01


  90   MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag);
  91   if (!is_primary()) {
  92     set_active(true);
  93   } else {
  94     DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
  95     dcqs.set_process_completed(true);
  96   }
  97   _monitor->notify();
  98 }
  99 
 100 void ConcurrentG1RefineThread::deactivate() {
 101   MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag);
 102   if (!is_primary()) {
 103     set_active(false);
 104   } else {
 105     DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
 106     dcqs.set_process_completed(false);
 107   }
 108 }
 109 
 110 void ConcurrentG1RefineThread::run() {
 111   initialize_in_thread();
 112   wait_for_universe_init();
 113 
 114   run_service();
 115 
 116   terminate();
 117 }
 118 
 119 void ConcurrentG1RefineThread::run_service() {
 120   _vtime_start = os::elapsedVTime();
 121 
 122   while (!_should_terminate) {
 123     // Wait for work
 124     wait_for_completed_buffers();
 125     if (_should_terminate) {
 126       break;
 127     }
 128 
 129     DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
 130     log_debug(gc, refine)("Activated %d, on threshold: %d, current: %d",
 131                           _worker_id, _threshold, dcqs.completed_buffers_num());
 132 
 133     {
 134       SuspendibleThreadSetJoiner sts_join;
 135 
 136       do {
 137         int curr_buffer_num = (int)dcqs.completed_buffers_num();
 138         // If the number of the buffers falls down into the yellow zone,


 147         }
 148       } while (dcqs.apply_closure_to_completed_buffer(_refine_closure,
 149                                                       _worker_id + _worker_id_offset,
 150                                                       _deactivation_threshold,
 151                                                       false /* during_pause */));
 152 
 153       deactivate();
 154       log_debug(gc, refine)("Deactivated %d, off threshold: %d, current: %d",
 155                             _worker_id, _deactivation_threshold,
 156                             dcqs.completed_buffers_num());
 157     }
 158 
 159     if (os::supports_vtime()) {
 160       _vtime_accum = (os::elapsedVTime() - _vtime_start);
 161     } else {
 162       _vtime_accum = 0.0;
 163     }
 164   }
 165 
 166   log_debug(gc, refine)("Stopping %d", _worker_id);
 167 }
 168 
 169 void ConcurrentG1RefineThread::stop() {
 170   // it is ok to take late safepoints here, if needed
 171   {
 172     MutexLockerEx mu(Terminator_lock);
 173     _should_terminate = true;
 174   }
 175 
 176   stop_service();
 177 
 178   {
 179     MutexLockerEx mu(Terminator_lock);
 180     while (!_has_terminated) {
 181       Terminator_lock->wait();
 182     }
 183   }
 184 }
 185 
 186 void ConcurrentG1RefineThread::stop_service() {
 187   MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag);
 188   _monitor->notify();
 189 }


  90   MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag);
  91   if (!is_primary()) {
  92     set_active(true);
  93   } else {
  94     DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
  95     dcqs.set_process_completed(true);
  96   }
  97   _monitor->notify();
  98 }
  99 
 100 void ConcurrentG1RefineThread::deactivate() {
 101   MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag);
 102   if (!is_primary()) {
 103     set_active(false);
 104   } else {
 105     DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
 106     dcqs.set_process_completed(false);
 107   }
 108 }
 109 









 110 void ConcurrentG1RefineThread::run_service() {
 111   _vtime_start = os::elapsedVTime();
 112 
 113   while (!_should_terminate) {
 114     // Wait for work
 115     wait_for_completed_buffers();
 116     if (_should_terminate) {
 117       break;
 118     }
 119 
 120     DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
 121     log_debug(gc, refine)("Activated %d, on threshold: %d, current: %d",
 122                           _worker_id, _threshold, dcqs.completed_buffers_num());
 123 
 124     {
 125       SuspendibleThreadSetJoiner sts_join;
 126 
 127       do {
 128         int curr_buffer_num = (int)dcqs.completed_buffers_num();
 129         // If the number of the buffers falls down into the yellow zone,


 138         }
 139       } while (dcqs.apply_closure_to_completed_buffer(_refine_closure,
 140                                                       _worker_id + _worker_id_offset,
 141                                                       _deactivation_threshold,
 142                                                       false /* during_pause */));
 143 
 144       deactivate();
 145       log_debug(gc, refine)("Deactivated %d, off threshold: %d, current: %d",
 146                             _worker_id, _deactivation_threshold,
 147                             dcqs.completed_buffers_num());
 148     }
 149 
 150     if (os::supports_vtime()) {
 151       _vtime_accum = (os::elapsedVTime() - _vtime_start);
 152     } else {
 153       _vtime_accum = 0.0;
 154     }
 155   }
 156 
 157   log_debug(gc, refine)("Stopping %d", _worker_id);

















 158 }
 159 
 160 void ConcurrentG1RefineThread::stop_service() {
 161   MutexLockerEx x(_monitor, Mutex::_no_safepoint_check_flag);
 162   _monitor->notify();
 163 }
< prev index next >