1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
/*
* Copyright 2001-2006 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
*/
class PSMarkSweepDecorator;
class PSYoungGen : public CHeapObj {
friend class VMStructs;
friend class ParallelScavengeHeap;
friend class AdjoiningGenerations;
protected:
MemRegion _reserved;
PSVirtualSpace* _virtual_space;
// Spaces
MutableSpace* _eden_space;
MutableSpace* _from_space;
MutableSpace* _to_space;
// MarkSweep Decorators
PSMarkSweepDecorator* _eden_mark_sweep;
PSMarkSweepDecorator* _from_mark_sweep;
PSMarkSweepDecorator* _to_mark_sweep;
// Sizing information, in bytes, set in constructor
const size_t _init_gen_size;
const size_t _min_gen_size;
const size_t _max_gen_size;
// Performance counters
PSGenerationCounters* _gen_counters;
SpaceCounters* _eden_counters;
SpaceCounters* _from_counters;
SpaceCounters* _to_counters;
// Initialize the space boundaries
void compute_initial_space_boundaries();
// Space boundary helper
void set_space_boundaries(size_t eden_size, size_t survivor_size);
virtual bool resize_generation(size_t eden_size, size_t survivor_size);
virtual void resize_spaces(size_t eden_size, size_t survivor_size);
// Adjust the spaces to be consistent with the virtual space.
void post_resize();
// Return number of bytes that the generation can change.
// These should not be used by PSYoungGen
virtual size_t available_for_expansion();
virtual size_t available_for_contraction();
// Given a desired shrinkage in the size of the young generation,
// return the actual size available for shrinkage.
virtual size_t limit_gen_shrink(size_t desired_change);
// returns the number of bytes available from the current size
// down to the minimum generation size.
size_t available_to_min_gen();
// Return the number of bytes available for shrinkage considering
// the location the live data in the generation.
virtual size_t available_to_live();
public:
// Initialize the generation.
PSYoungGen(size_t initial_byte_size,
size_t minimum_byte_size,
size_t maximum_byte_size);
void initialize_work();
virtual void initialize(ReservedSpace rs, size_t alignment);
virtual void initialize_virtual_space(ReservedSpace rs, size_t alignment);
MemRegion reserved() const { return _reserved; }
bool is_in(const void* p) const {
return _virtual_space->contains((void *)p);
}
bool is_in_reserved(const void* p) const {
return reserved().contains((void *)p);
}
MutableSpace* eden_space() const { return _eden_space; }
MutableSpace* from_space() const { return _from_space; }
MutableSpace* to_space() const { return _to_space; }
PSVirtualSpace* virtual_space() const { return _virtual_space; }
// For Adaptive size policy
size_t min_gen_size() { return _min_gen_size; }
// MarkSweep support
PSMarkSweepDecorator* eden_mark_sweep() const { return _eden_mark_sweep; }
PSMarkSweepDecorator* from_mark_sweep() const { return _from_mark_sweep; }
PSMarkSweepDecorator* to_mark_sweep() const { return _to_mark_sweep; }
void precompact();
void adjust_pointers();
void compact();
// Parallel Old
void move_and_update(ParCompactionManager* cm);
// Called during/after gc
void swap_spaces();
// Resize generation using suggested free space size and survivor size
// NOTE: "eden_size" and "survivor_size" are suggestions only. Current
// heap layout (particularly, live objects in from space) might
// not allow us to use these values.
void resize(size_t eden_size, size_t survivor_size);
// Size info
size_t capacity_in_bytes() const;
size_t used_in_bytes() const;
size_t free_in_bytes() const;
size_t capacity_in_words() const;
size_t used_in_words() const;
size_t free_in_words() const;
// The max this generation can grow to
size_t max_size() const { return _reserved.byte_size(); }
// The max this generation can grow to if the boundary between
// the generations are allowed to move.
size_t gen_size_limit() const { return _max_gen_size; }
bool is_maximal_no_gc() const {
return true; // never expands except at a GC
}
// Allocation
HeapWord* allocate(size_t word_size, bool is_tlab) {
HeapWord* result = eden_space()->cas_allocate(word_size);
return result;
}
HeapWord** top_addr() const { return eden_space()->top_addr(); }
HeapWord** end_addr() const { return eden_space()->end_addr(); }
// Iteration.
void oop_iterate(OopClosure* cl);
void object_iterate(ObjectClosure* cl);
virtual void reset_after_change();
virtual void reset_survivors_after_shrink();
// Performance Counter support
void update_counters();
// Debugging - do not use for time critical operations
void print() const;
void print_on(outputStream* st) const;
void print_used_change(size_t prev_used) const;
virtual const char* name() const { return "PSYoungGen"; }
void verify(bool allow_dirty);
// Space boundary invariant checker
void space_invariants() PRODUCT_RETURN;
// Helper for mangling survivor spaces.
void mangle_survivors(MutableSpace* s1,
MemRegion s1MR,
MutableSpace* s2,
MemRegion s2MR) PRODUCT_RETURN;
void record_spaces_top() PRODUCT_RETURN;
};
|
