Thu, 22 Sep 2011 10:57:37 -0700
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
1 /*
2 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_CARDTABLEEXTENSION_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_CARDTABLEEXTENSION_HPP
28 #include "memory/cardTableModRefBS.hpp"
30 class MutableSpace;
31 class ObjectStartArray;
32 class PSPromotionManager;
33 class GCTaskQueue;
35 class CardTableExtension : public CardTableModRefBS {
36 private:
37 // Support methods for resizing the card table.
38 // resize_commit_uncommit() returns true if the pages were committed or
39 // uncommitted
40 bool resize_commit_uncommit(int changed_region, MemRegion new_region);
41 void resize_update_card_table_entries(int changed_region,
42 MemRegion new_region);
43 void resize_update_committed_table(int changed_region, MemRegion new_region);
44 void resize_update_covered_table(int changed_region, MemRegion new_region);
46 protected:
48 static void verify_all_young_refs_precise_helper(MemRegion mr);
50 public:
51 enum ExtendedCardValue {
52 youngergen_card = CardTableModRefBS::CT_MR_BS_last_reserved + 1,
53 verify_card = CardTableModRefBS::CT_MR_BS_last_reserved + 5
54 };
56 CardTableExtension(MemRegion whole_heap, int max_covered_regions) :
57 CardTableModRefBS(whole_heap, max_covered_regions) { }
59 // Too risky for the 4/10/02 putback
60 // BarrierSet::Name kind() { return BarrierSet::CardTableExtension; }
62 // Scavenge support
63 void scavenge_contents(ObjectStartArray* start_array,
64 MutableSpace* sp,
65 HeapWord* space_top,
66 PSPromotionManager* pm);
68 void scavenge_contents_parallel(ObjectStartArray* start_array,
69 MutableSpace* sp,
70 HeapWord* space_top,
71 PSPromotionManager* pm,
72 uint stripe_number);
74 // Verification
75 static void verify_all_young_refs_imprecise();
76 static void verify_all_young_refs_precise();
78 bool addr_is_marked_imprecise(void *addr);
79 bool addr_is_marked_precise(void *addr);
81 void set_card_newgen(void* addr) { jbyte* p = byte_for(addr); *p = verify_card; }
83 // Testers for entries
84 static bool card_is_dirty(int value) { return value == dirty_card; }
85 static bool card_is_newgen(int value) { return value == youngergen_card; }
86 static bool card_is_clean(int value) { return value == clean_card; }
87 static bool card_is_verify(int value) { return value == verify_card; }
89 // Card marking
90 void inline_write_ref_field_gc(void* field, oop new_val) {
91 jbyte* byte = byte_for(field);
92 *byte = youngergen_card;
93 }
95 // Adaptive size policy support
96 // Allows adjustment of the base and size of the covered regions
97 void resize_covered_region(MemRegion new_region);
98 // Finds the covered region to resize based on the start address
99 // of the covered regions.
100 void resize_covered_region_by_start(MemRegion new_region);
101 // Finds the covered region to resize based on the end address
102 // of the covered regions.
103 void resize_covered_region_by_end(int changed_region, MemRegion new_region);
104 // Finds the lowest start address of a covered region that is
105 // previous (i.e., lower index) to the covered region with index "ind".
106 HeapWord* lowest_prev_committed_start(int ind) const;
108 #ifdef ASSERT
110 bool is_valid_card_address(jbyte* addr) {
111 return (addr >= _byte_map) && (addr < _byte_map + _byte_map_size);
112 }
114 #endif // ASSERT
115 };
117 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_CARDTABLEEXTENSION_HPP