jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp@631f79e71e90 (annotated)

src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp@631f79e71e90 (annotated)

src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp

Tue, 24 Aug 2010 17:24:33 -0400

author: tonyp
date: Tue, 24 Aug 2010 17:24:33 -0400
changeset 2315: 631f79e71e90
parent 2314: f95d63e2154a
child 2333: 016a3628c885
permissions: -rw-r--r--

6974966: G1: unnecessary direct-to-old allocations
Summary: This change revamps the slow allocation path of G1. Improvements include the following: a) Allocations directly to old regions are now totally banned. G1 now only allows allocations out of young regions (with the only exception being humongous regions). b) The thread that allocates a new region (which is now guaranteed to be young) does not dirty all its cards. Each thread that successfully allocates out of a young region is now responsible for dirtying the cards that corresponding to the "block" that just got allocated. c) allocate_new_tlab() and mem_allocate() are now implemented differently and TLAB allocations are only done by allocate_new_tlab(). d) If a thread schedules an evacuation pause in order to satisfy an allocation request, it will perform the allocation at the end of the safepoint so that the thread that initiated the GC also gets "first pick" of any space made available by the GC. e) If a thread is unable to allocate a humongous object it will schedule an evacuation pause in case it reclaims enough regions so that the humongous allocation can be satisfied aftewards. f) The G1 policy is more careful to set the young list target length to be the survivor number +1. g) Lots of code tidy up, removal, refactoring to make future changes easier.
Reviewed-by: johnc, ysr

 /*
  * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_INLINE_HPP
 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_INLINE_HPP
 #include "gc_implementation/g1/concurrentMark.hpp"
 #include "gc_implementation/g1/g1CollectedHeap.hpp"
 #include "gc_implementation/g1/g1CollectorPolicy.hpp"
 #include "gc_implementation/g1/heapRegionSeq.hpp"
 #include "utilities/taskqueue.hpp"
 // Inline functions for G1CollectedHeap
 inline HeapRegion*
 G1CollectedHeap::heap_region_containing(const void* addr) const {
   HeapRegion* hr = _hrs->addr_to_region(addr);
   // hr can be null if addr in perm_gen
   if (hr != NULL && hr->continuesHumongous()) {
     hr = hr->humongous_start_region();
   }
   return hr;
 }
 inline HeapRegion*
 G1CollectedHeap::heap_region_containing_raw(const void* addr) const {
   assert(_g1_reserved.contains(addr), "invariant");
   size_t index = pointer_delta(addr, _g1_reserved.start(), 1)
                                         >> HeapRegion::LogOfHRGrainBytes;
   HeapRegion* res = _hrs->at(index);
   assert(res == _hrs->addr_to_region(addr), "sanity");
   return res;
 }
 inline bool G1CollectedHeap::obj_in_cs(oop obj) {
   HeapRegion* r = _hrs->addr_to_region(obj);
   return r != NULL && r->in_collection_set();
 }
 // See the comment in the .hpp file about the locking protocol and
 // assumptions of this method (and other related ones).
 inline HeapWord*
 G1CollectedHeap::allocate_from_cur_alloc_region(HeapRegion* cur_alloc_region,
                                                 size_t word_size) {
   assert_heap_locked_and_not_at_safepoint();
   assert(cur_alloc_region != NULL, "pre-condition of the method");
   assert(cur_alloc_region == _cur_alloc_region, "pre-condition of the method");
   assert(cur_alloc_region->is_young(),
          "we only support young current alloc regions");
   assert(!isHumongous(word_size), "allocate_from_cur_alloc_region() "
          "should not be used for humongous allocations");
   assert(!cur_alloc_region->isHumongous(), "Catch a regression of this bug.");
   assert(!cur_alloc_region->is_empty(),
          err_msg("region ["PTR_FORMAT","PTR_FORMAT"] should not be empty",
                  cur_alloc_region->bottom(), cur_alloc_region->end()));
   // This allocate method does BOT updates and we don't need them in
   // the young generation. This will be fixed in the near future by
   // CR 6994297.
   HeapWord* result = cur_alloc_region->allocate(word_size);
   if (result != NULL) {
     assert(is_in(result), "result should be in the heap");
     Heap_lock->unlock();
     // Do the dirtying after we release the Heap_lock.
     dirty_young_block(result, word_size);
     return result;
   }
   assert_heap_locked();
   return NULL;
 }
 // See the comment in the .hpp file about the locking protocol and
 // assumptions of this method (and other related ones).
 inline HeapWord*
 G1CollectedHeap::attempt_allocation(size_t word_size) {
   assert_heap_locked_and_not_at_safepoint();
   assert(!isHumongous(word_size), "attempt_allocation() should not be called "
          "for humongous allocation requests");
   HeapRegion* cur_alloc_region = _cur_alloc_region;
   if (cur_alloc_region != NULL) {
     HeapWord* result = allocate_from_cur_alloc_region(cur_alloc_region,
                                                       word_size);
     if (result != NULL) {
       assert_heap_not_locked();
       return result;
     }
     assert_heap_locked();
     // Since we couldn't successfully allocate into it, retire the
     // current alloc region.
     retire_cur_alloc_region(cur_alloc_region);
   }
   // Try to get a new region and allocate out of it
   HeapWord* result = replace_cur_alloc_region_and_allocate(word_size,
                                                       false, /* at safepoint */
                                                       true   /* do_dirtying */);
   if (result != NULL) {
     assert_heap_not_locked();
     return result;
   }
   assert_heap_locked();
   return NULL;
 }
 inline void
 G1CollectedHeap::retire_cur_alloc_region_common(HeapRegion* cur_alloc_region) {
   assert_heap_locked_or_at_safepoint();
   assert(cur_alloc_region != NULL && cur_alloc_region == _cur_alloc_region,
          "pre-condition of the call");
   assert(cur_alloc_region->is_young(),
          "we only support young current alloc regions");
   // The region is guaranteed to be young
   g1_policy()->add_region_to_incremental_cset_lhs(cur_alloc_region);
   _summary_bytes_used += cur_alloc_region->used();
   _cur_alloc_region = NULL;
 }
 // It dirties the cards that cover the block so that so that the post
 // write barrier never queues anything when updating objects on this
 // block. It is assumed (and in fact we assert) that the block
 // belongs to a young region.
 inline void
 G1CollectedHeap::dirty_young_block(HeapWord* start, size_t word_size) {
   assert_heap_not_locked();
   // Assign the containing region to containing_hr so that we don't
   // have to keep calling heap_region_containing_raw() in the
   // asserts below.
   DEBUG_ONLY(HeapRegion* containing_hr = heap_region_containing_raw(start);)
   assert(containing_hr != NULL && start != NULL && word_size > 0,
          "pre-condition");
   assert(containing_hr->is_in(start), "it should contain start");
   assert(containing_hr->is_young(), "it should be young");
   assert(!containing_hr->isHumongous(), "it should not be humongous");
   HeapWord* end = start + word_size;
   assert(containing_hr->is_in(end - 1), "it should also contain end - 1");
   MemRegion mr(start, end);
   ((CardTableModRefBS*)_g1h->barrier_set())->dirty(mr);
 }
 inline RefToScanQueue* G1CollectedHeap::task_queue(int i) const {
   return _task_queues->queue(i);
 }
 inline  bool G1CollectedHeap::isMarkedPrev(oop obj) const {
   return _cm->prevMarkBitMap()->isMarked((HeapWord *)obj);
 }
 inline bool G1CollectedHeap::isMarkedNext(oop obj) const {
   return _cm->nextMarkBitMap()->isMarked((HeapWord *)obj);
 }
 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_INLINE_HPP

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp@631f79e71e90 (annotated)

src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp