41 #include "memory/resourceArea.hpp"
42 #include "memory/strongRootsScope.hpp"
43 #include "memory/space.hpp"
44 #include "oops/oop.inline.hpp"
45 #include "runtime/biasedLocking.hpp"
46 #include "runtime/fprofiler.hpp"
47 #include "runtime/handles.hpp"
48 #include "runtime/handles.inline.hpp"
49 #include "runtime/java.hpp"
50 #include "runtime/vmThread.hpp"
51 #include "services/management.hpp"
52 #include "services/memoryService.hpp"
53 #include "utilities/vmError.hpp"
54 #include "utilities/workgroup.hpp"
55 #include "utilities/macros.hpp"
56 #if INCLUDE_ALL_GCS
57 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
58 #include "gc_implementation/concurrentMarkSweep/vmCMSOperations.hpp"
59 #endif // INCLUDE_ALL_GCS
60
61 GenCollectedHeap* GenCollectedHeap::_gch;
62 NOT_PRODUCT(size_t GenCollectedHeap::_skip_header_HeapWords = 0;)
63
64 // The set of potentially parallel tasks in root scanning.
65 enum GCH_strong_roots_tasks {
66 GCH_PS_Universe_oops_do,
67 GCH_PS_JNIHandles_oops_do,
68 GCH_PS_ObjectSynchronizer_oops_do,
69 GCH_PS_FlatProfiler_oops_do,
70 GCH_PS_Management_oops_do,
71 GCH_PS_SystemDictionary_oops_do,
72 GCH_PS_ClassLoaderDataGraph_oops_do,
73 GCH_PS_jvmti_oops_do,
74 GCH_PS_CodeCache_oops_do,
75 GCH_PS_younger_gens,
76 // Leave this one last.
77 GCH_PS_NumElements
78 };
79
80 GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) :
81 CollectedHeap(),
109 // Allocate space for the heap.
110
111 char* heap_address;
112 ReservedSpace heap_rs;
113
114 size_t heap_alignment = collector_policy()->heap_alignment();
115
116 heap_address = allocate(heap_alignment, &heap_rs);
117
118 if (!heap_rs.is_reserved()) {
119 vm_shutdown_during_initialization(
120 "Could not reserve enough space for object heap");
121 return JNI_ENOMEM;
122 }
123
124 initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
125
126 _rem_set = collector_policy()->create_rem_set(reserved_region());
127 set_barrier_set(rem_set()->bs());
128
129 _gch = this;
130
131 ReservedSpace young_rs = heap_rs.first_part(gen_policy()->young_gen_spec()->max_size(), false, false);
132 _young_gen = gen_policy()->young_gen_spec()->init(young_rs, 0, rem_set());
133 heap_rs = heap_rs.last_part(gen_policy()->young_gen_spec()->max_size());
134
135 ReservedSpace old_rs = heap_rs.first_part(gen_policy()->old_gen_spec()->max_size(), false, false);
136 _old_gen = gen_policy()->old_gen_spec()->init(old_rs, 1, rem_set());
137 clear_incremental_collection_failed();
138
139 #if INCLUDE_ALL_GCS
140 // If we are running CMS, create the collector responsible
141 // for collecting the CMS generations.
142 if (collector_policy()->is_concurrent_mark_sweep_policy()) {
143 bool success = create_cms_collector();
144 if (!success) return JNI_ENOMEM;
145 }
146 #endif // INCLUDE_ALL_GCS
147
148 return JNI_OK;
149 }
150
1096 bool old_to_young) {
1097 if (old_to_young) {
1098 cl->do_generation(_old_gen);
1099 cl->do_generation(_young_gen);
1100 } else {
1101 cl->do_generation(_young_gen);
1102 cl->do_generation(_old_gen);
1103 }
1104 }
1105
1106 bool GenCollectedHeap::is_maximal_no_gc() const {
1107 return _young_gen->is_maximal_no_gc() && _old_gen->is_maximal_no_gc();
1108 }
1109
1110 void GenCollectedHeap::save_marks() {
1111 _young_gen->save_marks();
1112 _old_gen->save_marks();
1113 }
1114
1115 GenCollectedHeap* GenCollectedHeap::heap() {
1116 assert(_gch != NULL, "Uninitialized access to GenCollectedHeap::heap()");
1117 assert(_gch->kind() == CollectedHeap::GenCollectedHeap, "not a generational heap");
1118 return _gch;
1119 }
1120
1121 void GenCollectedHeap::prepare_for_compaction() {
1122 // Start by compacting into same gen.
1123 CompactPoint cp(_old_gen);
1124 _old_gen->prepare_for_compaction(&cp);
1125 _young_gen->prepare_for_compaction(&cp);
1126 }
1127
1128 GCStats* GenCollectedHeap::gc_stats(int level) const {
1129 if (level == 0) {
1130 return _young_gen->gc_stats();
1131 } else {
1132 return _old_gen->gc_stats();
1133 }
1134 }
1135
1136 void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) {
1137 if (!silent) {
1138 gclog_or_tty->print("%s", _old_gen->name());
|
41 #include "memory/resourceArea.hpp"
42 #include "memory/strongRootsScope.hpp"
43 #include "memory/space.hpp"
44 #include "oops/oop.inline.hpp"
45 #include "runtime/biasedLocking.hpp"
46 #include "runtime/fprofiler.hpp"
47 #include "runtime/handles.hpp"
48 #include "runtime/handles.inline.hpp"
49 #include "runtime/java.hpp"
50 #include "runtime/vmThread.hpp"
51 #include "services/management.hpp"
52 #include "services/memoryService.hpp"
53 #include "utilities/vmError.hpp"
54 #include "utilities/workgroup.hpp"
55 #include "utilities/macros.hpp"
56 #if INCLUDE_ALL_GCS
57 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
58 #include "gc_implementation/concurrentMarkSweep/vmCMSOperations.hpp"
59 #endif // INCLUDE_ALL_GCS
60
61 NOT_PRODUCT(size_t GenCollectedHeap::_skip_header_HeapWords = 0;)
62
63 // The set of potentially parallel tasks in root scanning.
64 enum GCH_strong_roots_tasks {
65 GCH_PS_Universe_oops_do,
66 GCH_PS_JNIHandles_oops_do,
67 GCH_PS_ObjectSynchronizer_oops_do,
68 GCH_PS_FlatProfiler_oops_do,
69 GCH_PS_Management_oops_do,
70 GCH_PS_SystemDictionary_oops_do,
71 GCH_PS_ClassLoaderDataGraph_oops_do,
72 GCH_PS_jvmti_oops_do,
73 GCH_PS_CodeCache_oops_do,
74 GCH_PS_younger_gens,
75 // Leave this one last.
76 GCH_PS_NumElements
77 };
78
79 GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) :
80 CollectedHeap(),
108 // Allocate space for the heap.
109
110 char* heap_address;
111 ReservedSpace heap_rs;
112
113 size_t heap_alignment = collector_policy()->heap_alignment();
114
115 heap_address = allocate(heap_alignment, &heap_rs);
116
117 if (!heap_rs.is_reserved()) {
118 vm_shutdown_during_initialization(
119 "Could not reserve enough space for object heap");
120 return JNI_ENOMEM;
121 }
122
123 initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
124
125 _rem_set = collector_policy()->create_rem_set(reserved_region());
126 set_barrier_set(rem_set()->bs());
127
128 ReservedSpace young_rs = heap_rs.first_part(gen_policy()->young_gen_spec()->max_size(), false, false);
129 _young_gen = gen_policy()->young_gen_spec()->init(young_rs, 0, rem_set());
130 heap_rs = heap_rs.last_part(gen_policy()->young_gen_spec()->max_size());
131
132 ReservedSpace old_rs = heap_rs.first_part(gen_policy()->old_gen_spec()->max_size(), false, false);
133 _old_gen = gen_policy()->old_gen_spec()->init(old_rs, 1, rem_set());
134 clear_incremental_collection_failed();
135
136 #if INCLUDE_ALL_GCS
137 // If we are running CMS, create the collector responsible
138 // for collecting the CMS generations.
139 if (collector_policy()->is_concurrent_mark_sweep_policy()) {
140 bool success = create_cms_collector();
141 if (!success) return JNI_ENOMEM;
142 }
143 #endif // INCLUDE_ALL_GCS
144
145 return JNI_OK;
146 }
147
1093 bool old_to_young) {
1094 if (old_to_young) {
1095 cl->do_generation(_old_gen);
1096 cl->do_generation(_young_gen);
1097 } else {
1098 cl->do_generation(_young_gen);
1099 cl->do_generation(_old_gen);
1100 }
1101 }
1102
1103 bool GenCollectedHeap::is_maximal_no_gc() const {
1104 return _young_gen->is_maximal_no_gc() && _old_gen->is_maximal_no_gc();
1105 }
1106
1107 void GenCollectedHeap::save_marks() {
1108 _young_gen->save_marks();
1109 _old_gen->save_marks();
1110 }
1111
1112 GenCollectedHeap* GenCollectedHeap::heap() {
1113 GenCollectedHeap* heap = (GenCollectedHeap*)Universe::heap();
1114 assert(heap != NULL, "Uninitialized access to GenCollectedHeap::heap()");
1115 assert(heap->kind() == CollectedHeap::GenCollectedHeap, "Not a GenCollectedHeap");
1116 return heap;
1117 }
1118
1119 void GenCollectedHeap::prepare_for_compaction() {
1120 // Start by compacting into same gen.
1121 CompactPoint cp(_old_gen);
1122 _old_gen->prepare_for_compaction(&cp);
1123 _young_gen->prepare_for_compaction(&cp);
1124 }
1125
1126 GCStats* GenCollectedHeap::gc_stats(int level) const {
1127 if (level == 0) {
1128 return _young_gen->gc_stats();
1129 } else {
1130 return _old_gen->gc_stats();
1131 }
1132 }
1133
1134 void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) {
1135 if (!silent) {
1136 gclog_or_tty->print("%s", _old_gen->name());
|