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

rev 10537 : [mq]: yield

*** 153,198 ****
  bool DirtyCardQueueSet::apply_closure_to_buffer(CardTableEntryClosure* cl,
                                                  BufferNode* node,
                                                  bool consume,
                                                  uint worker_i) {
    if (cl == NULL) return true;
    void** buf = BufferNode::make_buffer_from_node(node);
    size_t limit = DirtyCardQueue::byte_index_to_index(buffer_size());
!   size_t start = DirtyCardQueue::byte_index_to_index(node->index());
!   for (size_t i = start; i < limit; ++i) {
      jbyte* card_ptr = static_cast<jbyte*>(buf[i]);
      assert(card_ptr != NULL, "invariant");
      if (!cl->do_card_ptr(card_ptr, worker_i)) {
!       if (consume) {
!         size_t new_index = DirtyCardQueue::index_to_byte_index(i + 1);
!         assert(new_index <= buffer_size(), "invariant");
!         node->set_index(new_index);
!       }
!       return false;
      }
    }
    if (consume) {
!     node->set_index(buffer_size());
    }
!   return true;
  }
  
  bool DirtyCardQueueSet::mut_process_buffer(BufferNode* node) {
    guarantee(_free_ids != NULL, "must be");
  
!   // claim a par id
!   uint worker_i = _free_ids->claim_par_id();
  
!   bool b = apply_closure_to_buffer(_mut_process_closure, node, true, worker_i);
!   if (b) {
      Atomic::inc(&_processed_buffers_mut);
    }
! 
!   // release the id
!   _free_ids->release_par_id(worker_i);
! 
!   return b;
  }
  
  
  BufferNode* DirtyCardQueueSet::get_completed_buffer(size_t stop_at) {
    BufferNode* nd = NULL;
--- 153,194 ----
  bool DirtyCardQueueSet::apply_closure_to_buffer(CardTableEntryClosure* cl,
                                                  BufferNode* node,
                                                  bool consume,
                                                  uint worker_i) {
    if (cl == NULL) return true;
+   bool result = true;
    void** buf = BufferNode::make_buffer_from_node(node);
    size_t limit = DirtyCardQueue::byte_index_to_index(buffer_size());
!   size_t i = DirtyCardQueue::byte_index_to_index(node->index());
!   for ( ; i < limit; ++i) {
      jbyte* card_ptr = static_cast<jbyte*>(buf[i]);
      assert(card_ptr != NULL, "invariant");
      if (!cl->do_card_ptr(card_ptr, worker_i)) {
!       result = false;           // Incomplete processing.
!       break;
      }
    }
    if (consume) {
!     size_t new_index = DirtyCardQueue::index_to_byte_index(i);
!     assert(new_index <= buffer_size(), "invariant");
!     node->set_index(new_index);
    }
!   return result;
  }
  
  bool DirtyCardQueueSet::mut_process_buffer(BufferNode* node) {
    guarantee(_free_ids != NULL, "must be");
  
!   uint worker_i = _free_ids->claim_par_id(); // temporarily claim an id
!   bool result = apply_closure_to_buffer(_mut_process_closure, node, true, worker_i);
!   _free_ids->release_par_id(worker_i); // release the id
  
!   if (result) {
!     assert(node->index() == buffer_size(), "apply said fully consumed");
      Atomic::inc(&_processed_buffers_mut);
    }
!   return result;
  }
  
  
  BufferNode* DirtyCardQueueSet::get_completed_buffer(size_t stop_at) {
    BufferNode* nd = NULL;
*** 225,243 ****
    BufferNode* nd = get_completed_buffer(stop_at);
    if (nd == NULL) {
      return false;
    } else {
      if (apply_closure_to_buffer(cl, nd, true, worker_i)) {
        // Done with fully processed buffer.
        deallocate_buffer(nd);
        Atomic::inc(&_processed_buffers_rs_thread);
-       return true;
      } else {
        // Return partially processed buffer to the queue.
        enqueue_complete_buffer(nd);
-       return false;
      }
    }
  }
  
  void DirtyCardQueueSet::par_apply_closure_to_all_completed_buffers(CardTableEntryClosure* cl) {
    BufferNode* nd = _cur_par_buffer_node;
--- 221,240 ----
    BufferNode* nd = get_completed_buffer(stop_at);
    if (nd == NULL) {
      return false;
    } else {
      if (apply_closure_to_buffer(cl, nd, true, worker_i)) {
+       assert(nd->index() == buffer_size(), "apply said fully consumed");
        // Done with fully processed buffer.
        deallocate_buffer(nd);
        Atomic::inc(&_processed_buffers_rs_thread);
      } else {
        // Return partially processed buffer to the queue.
+       guarantee(!during_pause, "Should never stop early");
        enqueue_complete_buffer(nd);
      }
+     return true;
    }
  }
  
  void DirtyCardQueueSet::par_apply_closure_to_all_completed_buffers(CardTableEntryClosure* cl) {
    BufferNode* nd = _cur_par_buffer_node;