Mercurial > hg > truffle
diff src/share/vm/gc_implementation/g1/concurrentMark.hpp @ 4787:2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
Summary: This change simplifies the interaction between GC and concurrent marking. By disabling survivor spaces during the initial-mark pause we don't need to propagate marks of objects we copy during each GC (since we never need to copy an explicitly marked object).
Reviewed-by: johnc, brutisso
author | tonyp |
---|---|
date | Tue, 10 Jan 2012 18:58:13 -0500 |
parents | 441e946dc1af |
children | 2e966d967c5c |
line wrap: on
line diff
--- a/src/share/vm/gc_implementation/g1/concurrentMark.hpp Tue Jan 10 20:02:41 2012 +0100 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.hpp Tue Jan 10 18:58:13 2012 -0500 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2012, 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 @@ -166,10 +166,10 @@ // Ideally this should be GrowableArray<> just like MSC's marking stack(s). class CMMarkStack VALUE_OBJ_CLASS_SPEC { ConcurrentMark* _cm; - oop* _base; // bottom of stack - jint _index; // one more than last occupied index - jint _capacity; // max #elements - jint _oops_do_bound; // Number of elements to include in next iteration. + oop* _base; // bottom of stack + jint _index; // one more than last occupied index + jint _capacity; // max #elements + jint _saved_index; // value of _index saved at start of GC NOT_PRODUCT(jint _max_depth;) // max depth plumbed during run bool _overflow; @@ -247,16 +247,12 @@ void setEmpty() { _index = 0; clear_overflow(); } - // Record the current size; a subsequent "oops_do" will iterate only over - // indices valid at the time of this call. - void set_oops_do_bound(jint bound = -1) { - if (bound == -1) { - _oops_do_bound = _index; - } else { - _oops_do_bound = bound; - } - } - jint oops_do_bound() { return _oops_do_bound; } + // Record the current index. + void note_start_of_gc(); + + // Make sure that we have not added any entries to the stack during GC. + void note_end_of_gc(); + // iterate over the oops in the mark stack, up to the bound recorded via // the call above. void oops_do(OopClosure* f); @@ -724,10 +720,9 @@ // G1CollectedHeap // This notifies CM that a root during initial-mark needs to be - // grayed and it's MT-safe. Currently, we just mark it. But, in the - // future, we can experiment with pushing it on the stack and we can - // do this without changing G1CollectedHeap. - void grayRoot(oop p); + // grayed. It is MT-safe. + inline void grayRoot(oop obj, size_t word_size); + // It's used during evacuation pauses to gray a region, if // necessary, and it's MT-safe. It assumes that the caller has // marked any objects on that region. If _should_gray_objects is @@ -735,6 +730,7 @@ // pushed on the region stack, if it is located below the global // finger, otherwise we do nothing. void grayRegionIfNecessary(MemRegion mr); + // It's used during evacuation pauses to mark and, if necessary, // gray a single object and it's MT-safe. It assumes the caller did // not mark the object. If _should_gray_objects is true and we're @@ -791,24 +787,40 @@ // Mark in the previous bitmap. NB: this is usually read-only, so use // this carefully! - void markPrev(oop p); + inline void markPrev(oop p); + inline void markNext(oop p); void clear(oop p); - // Clears marks for all objects in the given range, for both prev and - // next bitmaps. NB: the previous bitmap is usually read-only, so use - // this carefully! - void clearRangeBothMaps(MemRegion mr); + // Clears marks for all objects in the given range, for the prev, + // next, or both bitmaps. NB: the previous bitmap is usually + // read-only, so use this carefully! + void clearRangePrevBitmap(MemRegion mr); + void clearRangeNextBitmap(MemRegion mr); + void clearRangeBothBitmaps(MemRegion mr); - // Record the current top of the mark and region stacks; a - // subsequent oops_do() on the mark stack and - // invalidate_entries_into_cset() on the region stack will iterate - // only over indices valid at the time of this call. - void set_oops_do_bound() { - _markStack.set_oops_do_bound(); - _regionStack.set_oops_do_bound(); + // Notify data structures that a GC has started. + void note_start_of_gc() { + _markStack.note_start_of_gc(); } + + // Notify data structures that a GC is finished. + void note_end_of_gc() { + _markStack.note_end_of_gc(); + } + // Iterate over the oops in the mark stack and all local queues. It // also calls invalidate_entries_into_cset() on the region stack. void oops_do(OopClosure* f); + + // Verify that there are no CSet oops on the stacks (taskqueues / + // global mark stack), enqueued SATB buffers, per-thread SATB + // buffers, and fingers (global / per-task). The boolean parameters + // decide which of the above data structures to verify. If marking + // is not in progress, it's a no-op. + void verify_no_cset_oops(bool verify_stacks, + bool verify_enqueued_buffers, + bool verify_thread_buffers, + bool verify_fingers) PRODUCT_RETURN; + // It is called at the end of an evacuation pause during marking so // that CM is notified of where the new end of the heap is. It // doesn't do anything if concurrent_marking_in_progress() is false, @@ -1166,6 +1178,7 @@ // It keeps picking SATB buffers and processing them until no SATB // buffers are available. void drain_satb_buffers(); + // It keeps popping regions from the region stack and processing // them until the region stack is empty. void drain_region_stack(BitMapClosure* closure);