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 */
24
25 #include "precompiled.hpp"
26 #include "aot/aotLoader.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/stringTable.hpp"
29 #include "classfile/systemDictionary.hpp"
30 #include "classfile/vmSymbols.hpp"
31 #include "code/codeCache.hpp"
32 #include "code/icBuffer.hpp"
33 #include "gc/shared/cardTableRS.hpp"
34 #include "gc/shared/collectedHeap.inline.hpp"
35 #include "gc/shared/collectorCounters.hpp"
36 #include "gc/shared/gcId.hpp"
37 #include "gc/shared/gcLocker.inline.hpp"
38 #include "gc/shared/gcTrace.hpp"
39 #include "gc/shared/gcTraceTime.inline.hpp"
40 #include "gc/shared/genCollectedHeap.hpp"
41 #include "gc/shared/genOopClosures.inline.hpp"
42 #include "gc/shared/generationSpec.hpp"
43 #include "gc/shared/space.hpp"
44 #include "gc/shared/strongRootsScope.hpp"
45 #include "gc/shared/vmGCOperations.hpp"
46 #include "gc/shared/weakProcessor.hpp"
47 #include "gc/shared/workgroup.hpp"
48 #include "memory/filemap.hpp"
49 #include "memory/resourceArea.hpp"
50 #include "oops/oop.inline.hpp"
51 #include "runtime/biasedLocking.hpp"
52 #include "runtime/handles.hpp"
94 "Could not reserve enough space for object heap");
95 return JNI_ENOMEM;
96 }
97
98 initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
99
100 _rem_set = new CardTableRS(reserved_region());
101 set_barrier_set(rem_set()->bs());
102
103 ReservedSpace young_rs = heap_rs.first_part(gen_policy()->young_gen_spec()->max_size(), false, false);
104 _young_gen = gen_policy()->young_gen_spec()->init(young_rs, rem_set());
105 heap_rs = heap_rs.last_part(gen_policy()->young_gen_spec()->max_size());
106
107 ReservedSpace old_rs = heap_rs.first_part(gen_policy()->old_gen_spec()->max_size(), false, false);
108 _old_gen = gen_policy()->old_gen_spec()->init(old_rs, rem_set());
109 clear_incremental_collection_failed();
110
111 return JNI_OK;
112 }
113
114 char* GenCollectedHeap::allocate(size_t alignment,
115 ReservedSpace* heap_rs){
116 // Now figure out the total size.
117 const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size();
118 assert(alignment % pageSize == 0, "Must be");
119
120 GenerationSpec* young_spec = gen_policy()->young_gen_spec();
121 GenerationSpec* old_spec = gen_policy()->old_gen_spec();
122
123 // Check for overflow.
124 size_t total_reserved = young_spec->max_size() + old_spec->max_size();
125 if (total_reserved < young_spec->max_size()) {
126 vm_exit_during_initialization("The size of the object heap + VM data exceeds "
127 "the maximum representable size");
128 }
129 assert(total_reserved % alignment == 0,
130 "Gen size; total_reserved=" SIZE_FORMAT ", alignment="
131 SIZE_FORMAT, total_reserved, alignment);
132
133 *heap_rs = Universe::reserve_heap(total_reserved, alignment);
134
135 os::trace_page_sizes("Heap",
136 collector_policy()->min_heap_byte_size(),
137 total_reserved,
138 alignment,
139 heap_rs->base(),
140 heap_rs->size());
141
142 return heap_rs->base();
143 }
144
145 void GenCollectedHeap::post_initialize() {
146 CollectedHeap::post_initialize();
147 ref_processing_init();
148 check_gen_kinds();
149 DefNewGeneration* def_new_gen = (DefNewGeneration*)_young_gen;
150
151 _gen_policy->initialize_size_policy(def_new_gen->eden()->capacity(),
152 _old_gen->capacity(),
153 def_new_gen->from()->capacity());
154
155 _gen_policy->initialize_gc_policy_counters();
156 }
157
158 void GenCollectedHeap::ref_processing_init() {
159 _young_gen->ref_processor_init();
160 _old_gen->ref_processor_init();
161 }
162
163 size_t GenCollectedHeap::capacity() const {
164 return _young_gen->capacity() + _old_gen->capacity();
165 }
166
167 size_t GenCollectedHeap::used() const {
168 return _young_gen->used() + _old_gen->used();
169 }
170
171 void GenCollectedHeap::save_used_regions() {
315
316 // Read the gc count while the heap lock is held.
317 gc_count_before = total_collections();
318 }
319
320 VM_GenCollectForAllocation op(size, is_tlab, gc_count_before);
321 VMThread::execute(&op);
322 if (op.prologue_succeeded()) {
323 result = op.result();
324 if (op.gc_locked()) {
325 assert(result == NULL, "must be NULL if gc_locked() is true");
326 continue; // Retry and/or stall as necessary.
327 }
328
329 // Allocation has failed and a collection
330 // has been done. If the gc time limit was exceeded the
331 // this time, return NULL so that an out-of-memory
332 // will be thrown. Clear gc_overhead_limit_exceeded
333 // so that the overhead exceeded does not persist.
334
335 const bool limit_exceeded = gen_policy()->size_policy()->gc_overhead_limit_exceeded();
336 const bool softrefs_clear = soft_ref_policy()->all_soft_refs_clear();
337
338 if (limit_exceeded && softrefs_clear) {
339 *gc_overhead_limit_was_exceeded = true;
340 gen_policy()->size_policy()->set_gc_overhead_limit_exceeded(false);
341 if (op.result() != NULL) {
342 CollectedHeap::fill_with_object(op.result(), size);
343 }
344 return NULL;
345 }
346 assert(result == NULL || is_in_reserved(result),
347 "result not in heap");
348 return result;
349 }
350
351 // Give a warning if we seem to be looping forever.
352 if ((QueuedAllocationWarningCount > 0) &&
353 (try_count % QueuedAllocationWarningCount == 0)) {
354 log_warning(gc, ergo)("GenCollectedHeap::mem_allocate_work retries %d times,"
355 " size=" SIZE_FORMAT " %s", try_count, size, is_tlab ? "(TLAB)" : "");
356 }
357 }
358 }
359
360 #ifndef PRODUCT
|
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 */
24
25 #include "precompiled.hpp"
26 #include "aot/aotLoader.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/stringTable.hpp"
29 #include "classfile/systemDictionary.hpp"
30 #include "classfile/vmSymbols.hpp"
31 #include "code/codeCache.hpp"
32 #include "code/icBuffer.hpp"
33 #include "gc/shared/adaptiveSizePolicy.hpp"
34 #include "gc/shared/cardTableRS.hpp"
35 #include "gc/shared/collectedHeap.inline.hpp"
36 #include "gc/shared/collectorCounters.hpp"
37 #include "gc/shared/gcId.hpp"
38 #include "gc/shared/gcLocker.inline.hpp"
39 #include "gc/shared/gcTrace.hpp"
40 #include "gc/shared/gcTraceTime.inline.hpp"
41 #include "gc/shared/genCollectedHeap.hpp"
42 #include "gc/shared/genOopClosures.inline.hpp"
43 #include "gc/shared/generationSpec.hpp"
44 #include "gc/shared/space.hpp"
45 #include "gc/shared/strongRootsScope.hpp"
46 #include "gc/shared/vmGCOperations.hpp"
47 #include "gc/shared/weakProcessor.hpp"
48 #include "gc/shared/workgroup.hpp"
49 #include "memory/filemap.hpp"
50 #include "memory/resourceArea.hpp"
51 #include "oops/oop.inline.hpp"
52 #include "runtime/biasedLocking.hpp"
53 #include "runtime/handles.hpp"
95 "Could not reserve enough space for object heap");
96 return JNI_ENOMEM;
97 }
98
99 initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
100
101 _rem_set = new CardTableRS(reserved_region());
102 set_barrier_set(rem_set()->bs());
103
104 ReservedSpace young_rs = heap_rs.first_part(gen_policy()->young_gen_spec()->max_size(), false, false);
105 _young_gen = gen_policy()->young_gen_spec()->init(young_rs, rem_set());
106 heap_rs = heap_rs.last_part(gen_policy()->young_gen_spec()->max_size());
107
108 ReservedSpace old_rs = heap_rs.first_part(gen_policy()->old_gen_spec()->max_size(), false, false);
109 _old_gen = gen_policy()->old_gen_spec()->init(old_rs, rem_set());
110 clear_incremental_collection_failed();
111
112 return JNI_OK;
113 }
114
115 void GenCollectedHeap::initialize_size_policy(size_t init_eden_size,
116 size_t init_promo_size,
117 size_t init_survivor_size) {
118 const double max_gc_pause_sec = ((double) MaxGCPauseMillis) / 1000.0;
119 _size_policy = new AdaptiveSizePolicy(init_eden_size,
120 init_promo_size,
121 init_survivor_size,
122 max_gc_pause_sec,
123 GCTimeRatio);
124 }
125
126 char* GenCollectedHeap::allocate(size_t alignment,
127 ReservedSpace* heap_rs){
128 // Now figure out the total size.
129 const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size();
130 assert(alignment % pageSize == 0, "Must be");
131
132 GenerationSpec* young_spec = gen_policy()->young_gen_spec();
133 GenerationSpec* old_spec = gen_policy()->old_gen_spec();
134
135 // Check for overflow.
136 size_t total_reserved = young_spec->max_size() + old_spec->max_size();
137 if (total_reserved < young_spec->max_size()) {
138 vm_exit_during_initialization("The size of the object heap + VM data exceeds "
139 "the maximum representable size");
140 }
141 assert(total_reserved % alignment == 0,
142 "Gen size; total_reserved=" SIZE_FORMAT ", alignment="
143 SIZE_FORMAT, total_reserved, alignment);
144
145 *heap_rs = Universe::reserve_heap(total_reserved, alignment);
146
147 os::trace_page_sizes("Heap",
148 collector_policy()->min_heap_byte_size(),
149 total_reserved,
150 alignment,
151 heap_rs->base(),
152 heap_rs->size());
153
154 return heap_rs->base();
155 }
156
157 void GenCollectedHeap::post_initialize() {
158 CollectedHeap::post_initialize();
159 ref_processing_init();
160 check_gen_kinds();
161 DefNewGeneration* def_new_gen = (DefNewGeneration*)_young_gen;
162
163 initialize_size_policy(def_new_gen->eden()->capacity(),
164 _old_gen->capacity(),
165 def_new_gen->from()->capacity());
166
167 _gen_policy->initialize_gc_policy_counters();
168 }
169
170 void GenCollectedHeap::ref_processing_init() {
171 _young_gen->ref_processor_init();
172 _old_gen->ref_processor_init();
173 }
174
175 size_t GenCollectedHeap::capacity() const {
176 return _young_gen->capacity() + _old_gen->capacity();
177 }
178
179 size_t GenCollectedHeap::used() const {
180 return _young_gen->used() + _old_gen->used();
181 }
182
183 void GenCollectedHeap::save_used_regions() {
327
328 // Read the gc count while the heap lock is held.
329 gc_count_before = total_collections();
330 }
331
332 VM_GenCollectForAllocation op(size, is_tlab, gc_count_before);
333 VMThread::execute(&op);
334 if (op.prologue_succeeded()) {
335 result = op.result();
336 if (op.gc_locked()) {
337 assert(result == NULL, "must be NULL if gc_locked() is true");
338 continue; // Retry and/or stall as necessary.
339 }
340
341 // Allocation has failed and a collection
342 // has been done. If the gc time limit was exceeded the
343 // this time, return NULL so that an out-of-memory
344 // will be thrown. Clear gc_overhead_limit_exceeded
345 // so that the overhead exceeded does not persist.
346
347 const bool limit_exceeded = size_policy()->gc_overhead_limit_exceeded();
348 const bool softrefs_clear = soft_ref_policy()->all_soft_refs_clear();
349
350 if (limit_exceeded && softrefs_clear) {
351 *gc_overhead_limit_was_exceeded = true;
352 size_policy()->set_gc_overhead_limit_exceeded(false);
353 if (op.result() != NULL) {
354 CollectedHeap::fill_with_object(op.result(), size);
355 }
356 return NULL;
357 }
358 assert(result == NULL || is_in_reserved(result),
359 "result not in heap");
360 return result;
361 }
362
363 // Give a warning if we seem to be looping forever.
364 if ((QueuedAllocationWarningCount > 0) &&
365 (try_count % QueuedAllocationWarningCount == 0)) {
366 log_warning(gc, ergo)("GenCollectedHeap::mem_allocate_work retries %d times,"
367 " size=" SIZE_FORMAT " %s", try_count, size, is_tlab ? "(TLAB)" : "");
368 }
369 }
370 }
371
372 #ifndef PRODUCT
|