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

*** 4762,4774 ****
      size_t* surv_young_words = _par_scan_state->surviving_young_words();
      surv_young_words[young_index] += word_sz;
  
      if (obj->is_objArray() && arrayOop(obj)->length() >= ParGCArrayScanChunk) {
        // We keep track of the next start index in the length field of
!       // the from-space object. The actual length can be found in the
!       // length field of the to-space object.
!       arrayOop(old)->set_length(0);
        oop* old_p = set_partial_array_mask(old);
        _par_scan_state->push_on_queue(old_p);
      } else {
        // No point in using the slower heap_region_containing() method,
        // given that we know obj is in the heap.
--- 4762,4774 ----
      size_t* surv_young_words = _par_scan_state->surviving_young_words();
      surv_young_words[young_index] += word_sz;
  
      if (obj->is_objArray() && arrayOop(obj)->length() >= ParGCArrayScanChunk) {
        // We keep track of the next start index in the length field of
!       // the to-space object. The actual length can be found in the
!       // length field of the from-space object.
!       arrayOop(obj)->set_length(0);
        oop* old_p = set_partial_array_mask(old);
        _par_scan_state->push_on_queue(old_p);
      } else {
        // No point in using the slower heap_region_containing() method,
        // given that we know obj is in the heap.
*** 4838,4876 ****
    oop from_obj = clear_partial_array_mask(p);
  
    assert(Universe::heap()->is_in_reserved(from_obj), "must be in heap.");
    assert(from_obj->is_objArray(), "must be obj array");
    objArrayOop from_obj_array = objArrayOop(from_obj);
!   // We keep track of the next start index in the length field of the
!   // from-space object.
!   int next_index             = from_obj_array->length();
  
    assert(from_obj->is_forwarded(), "must be forwarded");
    oop to_obj                 = from_obj->forwardee();
    assert(from_obj != to_obj, "should not be chunking self-forwarded objects");
    objArrayOop to_obj_array   = objArrayOop(to_obj);
!    // The to-space object contains the real length.
!   int length                 = to_obj_array->length();
    assert(0 <= next_index && next_index < length,
           err_msg("invariant, next index: %d, length: %d", next_index, length));
  
    int start                  = next_index;
    int end                    = length;
    int remainder              = end - start;
    // We'll try not to push a range that's smaller than ParGCArrayScanChunk.
    if (remainder > 2 * ParGCArrayScanChunk) {
      end = start + ParGCArrayScanChunk;
!     from_obj_array->set_length(end);
      // Push the remainder before we process the range in case another
      // worker has run out of things to do and can steal it.
      oop* from_obj_p = set_partial_array_mask(from_obj);
      _par_scan_state->push_on_queue(from_obj_p);
    } else {
      assert(length == end, "sanity");
      // We'll process the final range for this object. Restore the length
      // so that the heap remains parsable in case of evacuation failure.
!     from_obj_array->set_length(end);
    }
    _scanner.set_region(_g1->heap_region_containing_raw(to_obj));
    // Process indexes [start,end). It will also process the header
    // along with the first chunk (i.e., the chunk with start == 0).
    // Note that at this point the length field of to_obj_array is not
--- 4838,4876 ----
    oop from_obj = clear_partial_array_mask(p);
  
    assert(Universe::heap()->is_in_reserved(from_obj), "must be in heap.");
    assert(from_obj->is_objArray(), "must be obj array");
    objArrayOop from_obj_array = objArrayOop(from_obj);
!   // The from-space object contains the real length.
!   int length                 = from_obj_array->length();
  
    assert(from_obj->is_forwarded(), "must be forwarded");
    oop to_obj                 = from_obj->forwardee();
    assert(from_obj != to_obj, "should not be chunking self-forwarded objects");
    objArrayOop to_obj_array   = objArrayOop(to_obj);
!   // We keep track of the next start index in the length field of the
!   // to-space object.
!   int next_index             = to_obj_array->length();
    assert(0 <= next_index && next_index < length,
           err_msg("invariant, next index: %d, length: %d", next_index, length));
  
    int start                  = next_index;
    int end                    = length;
    int remainder              = end - start;
    // We'll try not to push a range that's smaller than ParGCArrayScanChunk.
    if (remainder > 2 * ParGCArrayScanChunk) {
      end = start + ParGCArrayScanChunk;
!     to_obj_array->set_length(end);
      // Push the remainder before we process the range in case another
      // worker has run out of things to do and can steal it.
      oop* from_obj_p = set_partial_array_mask(from_obj);
      _par_scan_state->push_on_queue(from_obj_p);
    } else {
      assert(length == end, "sanity");
      // We'll process the final range for this object. Restore the length
      // so that the heap remains parsable in case of evacuation failure.
!     to_obj_array->set_length(end);
    }
    _scanner.set_region(_g1->heap_region_containing_raw(to_obj));
    // Process indexes [start,end). It will also process the header
    // along with the first chunk (i.e., the chunk with start == 0).
    // Note that at this point the length field of to_obj_array is not