src/share/vm/gc/g1/dirtyCardQueue.cpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/gc/g1

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

Print this page




 190 
 191 bool DirtyCardQueueSet::mut_process_buffer(void** buf) {
 192   guarantee(_free_ids != NULL, "must be");
 193 
 194   // claim a par id
 195   uint worker_i = _free_ids->claim_par_id();
 196 
 197   bool b = DirtyCardQueue::apply_closure_to_buffer(_mut_process_closure, buf, 0,
 198                                                    _sz, true, worker_i);
 199   if (b) {
 200     Atomic::inc(&_processed_buffers_mut);
 201   }
 202 
 203   // release the id
 204   _free_ids->release_par_id(worker_i);
 205 
 206   return b;
 207 }
 208 
 209 
 210 BufferNode* DirtyCardQueueSet::get_completed_buffer(int stop_at) {
 211   BufferNode* nd = NULL;
 212   MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
 213 
 214   if ((int)_n_completed_buffers <= stop_at) {
 215     _process_completed = false;
 216     return NULL;
 217   }
 218 
 219   if (_completed_buffers_head != NULL) {
 220     nd = _completed_buffers_head;

 221     _completed_buffers_head = nd->next();
 222     if (_completed_buffers_head == NULL)
 223       _completed_buffers_tail = NULL;
 224     _n_completed_buffers--;
 225     assert(_n_completed_buffers >= 0, "Invariant");



 226   }
 227   DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked());
 228   return nd;
 229 }
 230 
 231 bool DirtyCardQueueSet::apply_closure_to_completed_buffer(CardTableEntryClosure* cl,
 232                                                           uint worker_i,
 233                                                           int stop_at,
 234                                                           bool during_pause) {
 235   assert(!during_pause || stop_at == 0, "Should not leave any completed buffers during a pause");
 236   BufferNode* nd = get_completed_buffer(stop_at);
 237   if (nd == NULL) {
 238     return false;
 239   } else {
 240     void** buf = BufferNode::make_buffer_from_node(nd);
 241     size_t index = nd->index();
 242     if (DirtyCardQueue::apply_closure_to_buffer(cl,
 243                                                 buf, index, _sz,
 244                                                 true, worker_i)) {
 245       // Done with fully processed buffer.
 246       deallocate_buffer(buf);
 247       Atomic::inc(&_processed_buffers_rs_thread);
 248       return true;
 249     } else {
 250       // Return partially processed buffer to the queue.
 251       enqueue_complete_buffer(buf, index);
 252       return false;
 253     }




 190 
 191 bool DirtyCardQueueSet::mut_process_buffer(void** buf) {
 192   guarantee(_free_ids != NULL, "must be");
 193 
 194   // claim a par id
 195   uint worker_i = _free_ids->claim_par_id();
 196 
 197   bool b = DirtyCardQueue::apply_closure_to_buffer(_mut_process_closure, buf, 0,
 198                                                    _sz, true, worker_i);
 199   if (b) {
 200     Atomic::inc(&_processed_buffers_mut);
 201   }
 202 
 203   // release the id
 204   _free_ids->release_par_id(worker_i);
 205 
 206   return b;
 207 }
 208 
 209 
 210 BufferNode* DirtyCardQueueSet::get_completed_buffer(size_t stop_at) {
 211   BufferNode* nd = NULL;
 212   MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
 213 
 214   if (_n_completed_buffers <= stop_at) {
 215     _process_completed = false;
 216     return NULL;
 217   }
 218 
 219   if (_completed_buffers_head != NULL) {
 220     nd = _completed_buffers_head;
 221     assert(_n_completed_buffers > 0, "Invariant");
 222     _completed_buffers_head = nd->next();


 223     _n_completed_buffers--;
 224     if (_completed_buffers_head == NULL) {
 225       assert(_n_completed_buffers == 0, "Invariant");
 226       _completed_buffers_tail = NULL;
 227     }
 228   }
 229   DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked());
 230   return nd;
 231 }
 232 
 233 bool DirtyCardQueueSet::apply_closure_to_completed_buffer(CardTableEntryClosure* cl,
 234                                                           uint worker_i,
 235                                                           size_t stop_at,
 236                                                           bool during_pause) {
 237   assert(!during_pause || stop_at == 0, "Should not leave any completed buffers during a pause");
 238   BufferNode* nd = get_completed_buffer(stop_at);
 239   if (nd == NULL) {
 240     return false;
 241   } else {
 242     void** buf = BufferNode::make_buffer_from_node(nd);
 243     size_t index = nd->index();
 244     if (DirtyCardQueue::apply_closure_to_buffer(cl,
 245                                                 buf, index, _sz,
 246                                                 true, worker_i)) {
 247       // Done with fully processed buffer.
 248       deallocate_buffer(buf);
 249       Atomic::inc(&_processed_buffers_rs_thread);
 250       return true;
 251     } else {
 252       // Return partially processed buffer to the queue.
 253       enqueue_complete_buffer(buf, index);
 254       return false;
 255     }


src/share/vm/gc/g1/dirtyCardQueue.cpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File