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, 2011, 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_PSOLDGEN_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSOLDGEN_HPP
28 #include "gc_implementation/parallelScavenge/objectStartArray.hpp"
29 #include "gc_implementation/parallelScavenge/psGenerationCounters.hpp"
30 #include "gc_implementation/parallelScavenge/psVirtualspace.hpp"
31 #include "gc_implementation/shared/mutableSpace.hpp"
32 #include "gc_implementation/shared/spaceCounters.hpp"
33 #include "runtime/safepoint.hpp"
35 class PSMarkSweepDecorator;
37 class PSOldGen : public CHeapObj {
38 friend class VMStructs;
39 friend class PSPromotionManager; // Uses the cas_allocate methods
40 friend class ParallelScavengeHeap;
41 friend class AdjoiningGenerations;
43 protected:
44 MemRegion _reserved; // Used for simple containment tests
45 PSVirtualSpace* _virtual_space; // Controls mapping and unmapping of virtual mem
46 ObjectStartArray _start_array; // Keeps track of where objects start in a 512b block
47 MutableSpace* _object_space; // Where all the objects live
48 PSMarkSweepDecorator* _object_mark_sweep; // The mark sweep view of _object_space
49 const char* const _name; // Name of this generation.
51 // Performance Counters
52 PSGenerationCounters* _gen_counters;
53 SpaceCounters* _space_counters;
55 // Sizing information, in bytes, set in constructor
56 const size_t _init_gen_size;
57 const size_t _min_gen_size;
58 const size_t _max_gen_size;
60 // Used when initializing the _name field.
61 static inline const char* select_name();
63 HeapWord* allocate_noexpand(size_t word_size) {
64 // We assume the heap lock is held here.
65 assert_locked_or_safepoint(Heap_lock);
66 HeapWord* res = object_space()->allocate(word_size);
67 if (res != NULL) {
68 _start_array.allocate_block(res);
69 }
70 return res;
71 }
73 // Support for MT garbage collection. CAS allocation is lower overhead than grabbing
74 // and releasing the heap lock, which is held during gc's anyway. This method is not
75 // safe for use at the same time as allocate_noexpand()!
76 HeapWord* cas_allocate_noexpand(size_t word_size) {
77 assert(SafepointSynchronize::is_at_safepoint(), "Must only be called at safepoint");
78 HeapWord* res = object_space()->cas_allocate(word_size);
79 if (res != NULL) {
80 _start_array.allocate_block(res);
81 }
82 return res;
83 }
85 // Support for MT garbage collection. See above comment.
86 HeapWord* cas_allocate(size_t word_size) {
87 HeapWord* res = cas_allocate_noexpand(word_size);
88 return (res == NULL) ? expand_and_cas_allocate(word_size) : res;
89 }
91 HeapWord* expand_and_allocate(size_t word_size);
92 HeapWord* expand_and_cas_allocate(size_t word_size);
93 void expand(size_t bytes);
94 bool expand_by(size_t bytes);
95 bool expand_to_reserved();
97 void shrink(size_t bytes);
99 void post_resize();
101 public:
102 // Initialize the generation.
103 PSOldGen(ReservedSpace rs, size_t alignment,
104 size_t initial_size, size_t min_size, size_t max_size,
105 const char* perf_data_name, int level);
107 PSOldGen(size_t initial_size, size_t min_size, size_t max_size,
108 const char* perf_data_name, int level);
110 void initialize(ReservedSpace rs, size_t alignment,
111 const char* perf_data_name, int level);
112 void initialize_virtual_space(ReservedSpace rs, size_t alignment);
113 void initialize_work(const char* perf_data_name, int level);
115 MemRegion reserved() const { return _reserved; }
116 virtual size_t max_gen_size() { return _max_gen_size; }
117 size_t min_gen_size() { return _min_gen_size; }
119 // Returns limit on the maximum size of the generation. This
120 // is the same as _max_gen_size for PSOldGen but need not be
121 // for a derived class.
122 virtual size_t gen_size_limit();
124 bool is_in(const void* p) const {
125 return _virtual_space->contains((void *)p);
126 }
128 bool is_in_reserved(const void* p) const {
129 return reserved().contains(p);
130 }
132 MutableSpace* object_space() const { return _object_space; }
133 PSMarkSweepDecorator* object_mark_sweep() const { return _object_mark_sweep; }
134 ObjectStartArray* start_array() { return &_start_array; }
135 PSVirtualSpace* virtual_space() const { return _virtual_space;}
137 // Has the generation been successfully allocated?
138 bool is_allocated();
140 // MarkSweep methods
141 virtual void precompact();
142 void adjust_pointers();
143 void compact();
145 // Size info
146 size_t capacity_in_bytes() const { return object_space()->capacity_in_bytes(); }
147 size_t used_in_bytes() const { return object_space()->used_in_bytes(); }
148 size_t free_in_bytes() const { return object_space()->free_in_bytes(); }
150 size_t capacity_in_words() const { return object_space()->capacity_in_words(); }
151 size_t used_in_words() const { return object_space()->used_in_words(); }
152 size_t free_in_words() const { return object_space()->free_in_words(); }
154 // Includes uncommitted memory
155 size_t contiguous_available() const;
157 bool is_maximal_no_gc() const {
158 return virtual_space()->uncommitted_size() == 0;
159 }
161 // Calculating new sizes
162 void resize(size_t desired_free_space);
164 // Allocation. We report all successful allocations to the size policy
165 // Note that the perm gen does not use this method, and should not!
166 HeapWord* allocate(size_t word_size);
168 // Iteration.
169 void oop_iterate(OopClosure* cl) { object_space()->oop_iterate(cl); }
170 void object_iterate(ObjectClosure* cl) { object_space()->object_iterate(cl); }
172 // Debugging - do not use for time critical operations
173 virtual void print() const;
174 virtual void print_on(outputStream* st) const;
175 void print_used_change(size_t prev_used) const;
177 void verify(bool allow_dirty);
178 void verify_object_start_array();
180 // These should not used
181 virtual void reset_after_change();
183 // These should not used
184 virtual size_t available_for_expansion();
185 virtual size_t available_for_contraction();
187 void space_invariants() PRODUCT_RETURN;
189 // Performace Counter support
190 void update_counters();
192 // Printing support
193 virtual const char* name() const { return _name; }
195 // Debugging support
196 // Save the tops of all spaces for later use during mangling.
197 void record_spaces_top() PRODUCT_RETURN;
198 };
200 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSOLDGEN_HPP