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

*** 36,56 ****
                                     size_t worker_i) {
    bool res = true;
    if (_buf != NULL) {
      res = apply_closure_to_buffer(cl, _buf, _index, _sz,
                                    consume,
!                                   (int) worker_i);
      if (res && consume) _index = _sz;
    }
    return res;
  }
  
  bool DirtyCardQueue::apply_closure_to_buffer(CardTableEntryClosure* cl,
                                               void** buf,
                                               size_t index, size_t sz,
                                               bool consume,
!                                              int worker_i) {
    if (cl == NULL) return true;
    for (size_t i = index; i < sz; i += oopSize) {
      int ind = byte_index_to_index((int)i);
      jbyte* card_ptr = (jbyte*)buf[ind];
      if (card_ptr != NULL) {
--- 36,56 ----
                                     size_t worker_i) {
    bool res = true;
    if (_buf != NULL) {
      res = apply_closure_to_buffer(cl, _buf, _index, _sz,
                                    consume,
!                                   (uint) worker_i);
      if (res && consume) _index = _sz;
    }
    return res;
  }
  
  bool DirtyCardQueue::apply_closure_to_buffer(CardTableEntryClosure* cl,
                                               void** buf,
                                               size_t index, size_t sz,
                                               bool consume,
!                                              uint worker_i) {
    if (cl == NULL) return true;
    for (size_t i = index; i < sz; i += oopSize) {
      int ind = byte_index_to_index((int)i);
      jbyte* card_ptr = (jbyte*)buf[ind];
      if (card_ptr != NULL) {
*** 123,137 ****
    // We grab the current JavaThread.
    JavaThread* thread = JavaThread::current();
  
    // We get the the number of any par_id that this thread
    // might have already claimed.
!   int worker_i = thread->get_claimed_par_id();
  
    // If worker_i is not -1 then the thread has already claimed
    // a par_id. We make note of it using the already_claimed value
!   if (worker_i != -1) {
      already_claimed = true;
    } else {
  
      // Otherwise we need to claim a par id
      worker_i = _free_ids->claim_par_id();
--- 123,137 ----
    // We grab the current JavaThread.
    JavaThread* thread = JavaThread::current();
  
    // We get the the number of any par_id that this thread
    // might have already claimed.
!   uint worker_i = thread->get_claimed_par_id();
  
    // If worker_i is not -1 then the thread has already claimed
    // a par_id. We make note of it using the already_claimed value
!   if (worker_i != UINT_MAX) {
      already_claimed = true;
    } else {
  
      // Otherwise we need to claim a par id
      worker_i = _free_ids->claim_par_id();
*** 139,149 ****
      // And store the par_id value in the thread
      thread->set_claimed_par_id(worker_i);
    }
  
    bool b = false;
!   if (worker_i != -1) {
      b = DirtyCardQueue::apply_closure_to_buffer(_closure, buf, 0,
                                                  _sz, true, worker_i);
      if (b) Atomic::inc(&_processed_buffers_mut);
  
      // If we had not claimed an id before entering the method
--- 139,149 ----
      // And store the par_id value in the thread
      thread->set_claimed_par_id(worker_i);
    }
  
    bool b = false;
!   if (worker_i != UINT_MAX) {
      b = DirtyCardQueue::apply_closure_to_buffer(_closure, buf, 0,
                                                  _sz, true, worker_i);
      if (b) Atomic::inc(&_processed_buffers_mut);
  
      // If we had not claimed an id before entering the method
*** 152,162 ****
  
        // we release the id
        _free_ids->release_par_id(worker_i);
  
        // and set the claimed_id in the thread to -1
!       thread->set_claimed_par_id(-1);
      }
    }
    return b;
  }
  
--- 152,162 ----
  
        // we release the id
        _free_ids->release_par_id(worker_i);
  
        // and set the claimed_id in the thread to -1
!       thread->set_claimed_par_id(UINT_MAX);
      }
    }
    return b;
  }
  
*** 183,193 ****
    return nd;
  }
  
  bool DirtyCardQueueSet::
  apply_closure_to_completed_buffer_helper(CardTableEntryClosure* cl,
!                                          int worker_i,
                                           BufferNode* nd) {
    if (nd != NULL) {
      void **buf = BufferNode::make_buffer_from_node(nd);
      size_t index = nd->index();
      bool b =
--- 183,193 ----
    return nd;
  }
  
  bool DirtyCardQueueSet::
  apply_closure_to_completed_buffer_helper(CardTableEntryClosure* cl,
!                                          uint worker_i,
                                           BufferNode* nd) {
    if (nd != NULL) {
      void **buf = BufferNode::make_buffer_from_node(nd);
      size_t index = nd->index();
      bool b =
*** 205,225 ****
      return false;
    }
  }
  
  bool DirtyCardQueueSet::apply_closure_to_completed_buffer(CardTableEntryClosure* cl,
!                                                           int worker_i,
                                                            int stop_at,
                                                            bool during_pause) {
    assert(!during_pause || stop_at == 0, "Should not leave any completed buffers during a pause");
    BufferNode* nd = get_completed_buffer(stop_at);
    bool res = apply_closure_to_completed_buffer_helper(cl, worker_i, nd);
    if (res) Atomic::inc(&_processed_buffers_rs_thread);
    return res;
  }
  
! bool DirtyCardQueueSet::apply_closure_to_completed_buffer(int worker_i,
                                                            int stop_at,
                                                            bool during_pause) {
    return apply_closure_to_completed_buffer(_closure, worker_i,
                                             stop_at, during_pause);
  }
--- 205,225 ----
      return false;
    }
  }
  
  bool DirtyCardQueueSet::apply_closure_to_completed_buffer(CardTableEntryClosure* cl,
!                                                           uint worker_i,
                                                            int stop_at,
                                                            bool during_pause) {
    assert(!during_pause || stop_at == 0, "Should not leave any completed buffers during a pause");
    BufferNode* nd = get_completed_buffer(stop_at);
    bool res = apply_closure_to_completed_buffer_helper(cl, worker_i, nd);
    if (res) Atomic::inc(&_processed_buffers_rs_thread);
    return res;
  }
  
! bool DirtyCardQueueSet::apply_closure_to_completed_buffer(uint worker_i,
                                                            int stop_at,
                                                            bool during_pause) {
    return apply_closure_to_completed_buffer(_closure, worker_i,
                                             stop_at, during_pause);
  }