|
0
|
1 /*
|
|
|
2 * Copyright 2001-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or
|
|
|
21 * have any questions.
|
|
|
22 *
|
|
|
23 */
|
|
|
24
|
|
|
25 class AdjoiningGenerations;
|
|
|
26 class GCTaskManager;
|
|
|
27 class PSAdaptiveSizePolicy;
|
|
|
28
|
|
|
29 class ParallelScavengeHeap : public CollectedHeap {
|
|
|
30 friend class VMStructs;
|
|
|
31 private:
|
|
|
32 static PSYoungGen* _young_gen;
|
|
|
33 static PSOldGen* _old_gen;
|
|
|
34 static PSPermGen* _perm_gen;
|
|
|
35
|
|
|
36 // Sizing policy for entire heap
|
|
|
37 static PSAdaptiveSizePolicy* _size_policy;
|
|
|
38 static PSGCAdaptivePolicyCounters* _gc_policy_counters;
|
|
|
39
|
|
|
40 static ParallelScavengeHeap* _psh;
|
|
|
41
|
|
|
42 size_t _perm_gen_alignment;
|
|
|
43 size_t _young_gen_alignment;
|
|
|
44 size_t _old_gen_alignment;
|
|
|
45
|
|
|
46 inline size_t set_alignment(size_t& var, size_t val);
|
|
|
47
|
|
|
48 // Collection of generations that are adjacent in the
|
|
|
49 // space reserved for the heap.
|
|
|
50 AdjoiningGenerations* _gens;
|
|
|
51
|
|
|
52 static GCTaskManager* _gc_task_manager; // The task manager.
|
|
|
53
|
|
|
54 protected:
|
|
|
55 static inline size_t total_invocations();
|
|
|
56 HeapWord* allocate_new_tlab(size_t size);
|
|
|
57 void fill_all_tlabs(bool retire);
|
|
|
58
|
|
|
59 public:
|
|
|
60 ParallelScavengeHeap() : CollectedHeap() {
|
|
|
61 set_alignment(_perm_gen_alignment, intra_generation_alignment());
|
|
|
62 set_alignment(_young_gen_alignment, intra_generation_alignment());
|
|
|
63 set_alignment(_old_gen_alignment, intra_generation_alignment());
|
|
|
64 }
|
|
|
65
|
|
|
66 // For use by VM operations
|
|
|
67 enum CollectionType {
|
|
|
68 Scavenge,
|
|
|
69 MarkSweep
|
|
|
70 };
|
|
|
71
|
|
|
72 ParallelScavengeHeap::Name kind() const {
|
|
|
73 return CollectedHeap::ParallelScavengeHeap;
|
|
|
74 }
|
|
|
75
|
|
|
76 static PSYoungGen* young_gen() { return _young_gen; }
|
|
|
77 static PSOldGen* old_gen() { return _old_gen; }
|
|
|
78 static PSPermGen* perm_gen() { return _perm_gen; }
|
|
|
79
|
|
|
80 virtual PSAdaptiveSizePolicy* size_policy() { return _size_policy; }
|
|
|
81
|
|
|
82 static PSGCAdaptivePolicyCounters* gc_policy_counters() { return _gc_policy_counters; }
|
|
|
83
|
|
|
84 static ParallelScavengeHeap* heap();
|
|
|
85
|
|
|
86 static GCTaskManager* const gc_task_manager() { return _gc_task_manager; }
|
|
|
87
|
|
|
88 AdjoiningGenerations* gens() { return _gens; }
|
|
|
89
|
|
|
90 // Returns JNI_OK on success
|
|
|
91 virtual jint initialize();
|
|
|
92
|
|
|
93 void post_initialize();
|
|
|
94 void update_counters();
|
|
|
95
|
|
|
96 // The alignment used for the various generations.
|
|
|
97 size_t perm_gen_alignment() const { return _perm_gen_alignment; }
|
|
|
98 size_t young_gen_alignment() const { return _young_gen_alignment; }
|
|
|
99 size_t old_gen_alignment() const { return _old_gen_alignment; }
|
|
|
100
|
|
|
101 // The alignment used for eden and survivors within the young gen.
|
|
|
102 size_t intra_generation_alignment() const { return 64 * K; }
|
|
|
103
|
|
|
104 size_t capacity() const;
|
|
|
105 size_t used() const;
|
|
|
106
|
|
|
107 // Return "true" if all generations (but perm) have reached the
|
|
|
108 // maximal committed limit that they can reach, without a garbage
|
|
|
109 // collection.
|
|
|
110 virtual bool is_maximal_no_gc() const;
|
|
|
111
|
|
|
112 // Does this heap support heap inspection? (+PrintClassHistogram)
|
|
|
113 bool supports_heap_inspection() const { return true; }
|
|
|
114
|
|
|
115 size_t permanent_capacity() const;
|
|
|
116 size_t permanent_used() const;
|
|
|
117
|
|
|
118 size_t max_capacity() const;
|
|
|
119
|
|
|
120 // Whether p is in the allocated part of the heap
|
|
|
121 bool is_in(const void* p) const;
|
|
|
122
|
|
|
123 bool is_in_reserved(const void* p) const;
|
|
|
124 bool is_in_permanent(const void *p) const { // reserved part
|
|
|
125 return perm_gen()->reserved().contains(p);
|
|
|
126 }
|
|
|
127
|
|
|
128 bool is_permanent(const void *p) const { // committed part
|
|
|
129 return perm_gen()->is_in(p);
|
|
|
130 }
|
|
|
131
|
|
|
132 static bool is_in_young(oop *p); // reserved part
|
|
|
133 static bool is_in_old_or_perm(oop *p); // reserved part
|
|
|
134
|
|
|
135 // Memory allocation. "gc_time_limit_was_exceeded" will
|
|
|
136 // be set to true if the adaptive size policy determine that
|
|
|
137 // an excessive amount of time is being spent doing collections
|
|
|
138 // and caused a NULL to be returned. If a NULL is not returned,
|
|
|
139 // "gc_time_limit_was_exceeded" has an undefined meaning.
|
|
|
140
|
|
|
141 HeapWord* mem_allocate(size_t size,
|
|
|
142 bool is_noref,
|
|
|
143 bool is_tlab,
|
|
|
144 bool* gc_overhead_limit_was_exceeded);
|
|
|
145 HeapWord* failed_mem_allocate(size_t size, bool is_tlab);
|
|
|
146
|
|
|
147 HeapWord* permanent_mem_allocate(size_t size);
|
|
|
148 HeapWord* failed_permanent_mem_allocate(size_t size);
|
|
|
149
|
|
|
150 // Support for System.gc()
|
|
|
151 void collect(GCCause::Cause cause);
|
|
|
152
|
|
|
153 // This interface assumes that it's being called by the
|
|
|
154 // vm thread. It collects the heap assuming that the
|
|
|
155 // heap lock is already held and that we are executing in
|
|
|
156 // the context of the vm thread.
|
|
|
157 void collect_as_vm_thread(GCCause::Cause cause);
|
|
|
158
|
|
|
159 // These also should be called by the vm thread at a safepoint (e.g., from a
|
|
|
160 // VM operation).
|
|
|
161 //
|
|
|
162 // The first collects the young generation only, unless the scavenge fails; it
|
|
|
163 // will then attempt a full gc. The second collects the entire heap; if
|
|
|
164 // maximum_compaction is true, it will compact everything and clear all soft
|
|
|
165 // references.
|
|
|
166 inline void invoke_scavenge();
|
|
|
167 inline void invoke_full_gc(bool maximum_compaction);
|
|
|
168
|
|
|
169 size_t large_typearray_limit() { return FastAllocateSizeLimit; }
|
|
|
170
|
|
|
171 bool supports_inline_contig_alloc() const { return !UseNUMA; }
|
|
|
172 HeapWord** top_addr() const { return !UseNUMA ? young_gen()->top_addr() : NULL; }
|
|
|
173 HeapWord** end_addr() const { return !UseNUMA ? young_gen()->end_addr() : NULL; }
|
|
|
174
|
|
|
175 void ensure_parsability(bool retire_tlabs);
|
|
|
176 void accumulate_statistics_all_tlabs();
|
|
|
177 void resize_all_tlabs();
|
|
|
178
|
|
|
179 size_t unsafe_max_alloc();
|
|
|
180
|
|
|
181 bool supports_tlab_allocation() const { return true; }
|
|
|
182
|
|
|
183 size_t tlab_capacity(Thread* thr) const;
|
|
|
184 size_t unsafe_max_tlab_alloc(Thread* thr) const;
|
|
|
185
|
|
|
186 void oop_iterate(OopClosure* cl);
|
|
|
187 void object_iterate(ObjectClosure* cl);
|
|
|
188 void permanent_oop_iterate(OopClosure* cl);
|
|
|
189 void permanent_object_iterate(ObjectClosure* cl);
|
|
|
190
|
|
|
191 HeapWord* block_start(const void* addr) const;
|
|
|
192 size_t block_size(const HeapWord* addr) const;
|
|
|
193 bool block_is_obj(const HeapWord* addr) const;
|
|
|
194
|
|
|
195 jlong millis_since_last_gc();
|
|
|
196
|
|
|
197 void prepare_for_verify();
|
|
|
198 void print() const;
|
|
|
199 void print_on(outputStream* st) const;
|
|
|
200 virtual void print_gc_threads_on(outputStream* st) const;
|
|
|
201 virtual void gc_threads_do(ThreadClosure* tc) const;
|
|
|
202 virtual void print_tracing_info() const;
|
|
|
203
|
|
|
204 void verify(bool allow_dirty, bool silent);
|
|
|
205
|
|
|
206 void print_heap_change(size_t prev_used);
|
|
|
207
|
|
|
208 // Resize the young generation. The reserved space for the
|
|
|
209 // generation may be expanded in preparation for the resize.
|
|
|
210 void resize_young_gen(size_t eden_size, size_t survivor_size);
|
|
|
211
|
|
|
212 // Resize the old generation. The reserved space for the
|
|
|
213 // generation may be expanded in preparation for the resize.
|
|
|
214 void resize_old_gen(size_t desired_free_space);
|
|
|
215 };
|
|
|
216
|
|
|
217 inline size_t ParallelScavengeHeap::set_alignment(size_t& var, size_t val)
|
|
|
218 {
|
|
|
219 assert(is_power_of_2((intptr_t)val), "must be a power of 2");
|
|
|
220 var = round_to(val, intra_generation_alignment());
|
|
|
221 return var;
|
|
|
222 }
|
