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" 54 #include "runtime/handles.inline.hpp" 55 #include "runtime/java.hpp" 56 #include "runtime/vmThread.hpp" 57 #include "services/management.hpp" 58 #include "services/memoryService.hpp" 59 #include "utilities/debug.hpp" 60 #include "utilities/formatBuffer.hpp" 61 #include "utilities/macros.hpp" 62 #include "utilities/stack.inline.hpp" 63 #include "utilities/vmError.hpp" 64 65 GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) : 66 CollectedHeap(), 67 _rem_set(NULL), 68 _gen_policy(policy), 69 _soft_ref_gen_policy(), 70 _process_strong_tasks(new SubTasksDone(GCH_PS_NumElements)), 71 _full_collections_completed(0) 72 { 73 assert(policy != NULL, "Sanity check"); 74 } 75 76 jint GenCollectedHeap::initialize() { 77 // While there are no constraints in the GC code that HeapWordSize 78 // be any particular value, there are multiple other areas in the 79 // system which believe this to be true (e.g. oop->object_size in some 80 // cases incorrectly returns the size in wordSize units rather than 81 // HeapWordSize). 82 guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize"); 83 84 // Allocate space for the heap. 85 86 char* heap_address; 87 ReservedSpace heap_rs; 88 89 size_t heap_alignment = collector_policy()->heap_alignment(); 90 91 heap_address = allocate(heap_alignment, &heap_rs); 92 93 if (!heap_rs.is_reserved()) { 94 vm_shutdown_during_initialization( 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() { 184 _old_gen->save_used_region(); 185 _young_gen->save_used_region(); 186 } 187 188 size_t GenCollectedHeap::max_capacity() const { 189 return _young_gen->max_capacity() + _old_gen->max_capacity(); 190 } 191 192 // Update the _full_collections_completed counter | 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" 54 #include "runtime/handles.inline.hpp" 55 #include "runtime/java.hpp" 56 #include "runtime/vmThread.hpp" 57 #include "services/management.hpp" 58 #include "services/memoryService.hpp" 59 #include "utilities/debug.hpp" 60 #include "utilities/formatBuffer.hpp" 61 #include "utilities/macros.hpp" 62 #include "utilities/stack.inline.hpp" 63 #include "utilities/vmError.hpp" 64 65 GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy, 66 Generation::Name young, 67 Generation::Name old) : 68 CollectedHeap(), 69 _rem_set(NULL), 70 _young_gen_spec(new GenerationSpec(young, 71 policy->initial_young_size(), 72 policy->max_young_size(), 73 policy->gen_alignment())), 74 _old_gen_spec(new GenerationSpec(old, 75 policy->initial_old_size(), 76 policy->max_old_size(), 77 policy->gen_alignment())), 78 _gen_policy(policy), 79 _soft_ref_gen_policy(), 80 _process_strong_tasks(new SubTasksDone(GCH_PS_NumElements)), 81 _full_collections_completed(0) { 82 } 83 84 jint GenCollectedHeap::initialize() { 85 // While there are no constraints in the GC code that HeapWordSize 86 // be any particular value, there are multiple other areas in the 87 // system which believe this to be true (e.g. oop->object_size in some 88 // cases incorrectly returns the size in wordSize units rather than 89 // HeapWordSize). 90 guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize"); 91 92 // Allocate space for the heap. 93 94 char* heap_address; 95 ReservedSpace heap_rs; 96 97 size_t heap_alignment = collector_policy()->heap_alignment(); 98 99 heap_address = allocate(heap_alignment, &heap_rs); 100 101 if (!heap_rs.is_reserved()) { 102 vm_shutdown_during_initialization( 103 "Could not reserve enough space for object heap"); 104 return JNI_ENOMEM; 105 } 106 107 initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size())); 108 109 _rem_set = new CardTableRS(reserved_region()); 110 set_barrier_set(rem_set()->bs()); 111 112 ReservedSpace young_rs = heap_rs.first_part(_young_gen_spec->max_size(), false, false); 113 _young_gen = _young_gen_spec->init(young_rs, rem_set()); 114 heap_rs = heap_rs.last_part(_young_gen_spec->max_size()); 115 116 ReservedSpace old_rs = heap_rs.first_part(_old_gen_spec->max_size(), false, false); 117 _old_gen = _old_gen_spec->init(old_rs, rem_set()); 118 clear_incremental_collection_failed(); 119 120 return JNI_OK; 121 } 122 123 void GenCollectedHeap::initialize_size_policy(size_t init_eden_size, 124 size_t init_promo_size, 125 size_t init_survivor_size) { 126 const double max_gc_pause_sec = ((double) MaxGCPauseMillis) / 1000.0; 127 _size_policy = new AdaptiveSizePolicy(init_eden_size, 128 init_promo_size, 129 init_survivor_size, 130 max_gc_pause_sec, 131 GCTimeRatio); 132 } 133 134 char* GenCollectedHeap::allocate(size_t alignment, 135 ReservedSpace* heap_rs){ 136 // Now figure out the total size. 137 const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size(); 138 assert(alignment % pageSize == 0, "Must be"); 139 140 // Check for overflow. 141 size_t total_reserved = _young_gen_spec->max_size() + _old_gen_spec->max_size(); 142 if (total_reserved < _young_gen_spec->max_size()) { 143 vm_exit_during_initialization("The size of the object heap + VM data exceeds " 144 "the maximum representable size"); 145 } 146 assert(total_reserved % alignment == 0, 147 "Gen size; total_reserved=" SIZE_FORMAT ", alignment=" 148 SIZE_FORMAT, total_reserved, alignment); 149 150 *heap_rs = Universe::reserve_heap(total_reserved, alignment); 151 152 os::trace_page_sizes("Heap", 153 collector_policy()->min_heap_byte_size(), 154 total_reserved, 155 alignment, 156 heap_rs->base(), 157 heap_rs->size()); 158 159 return heap_rs->base(); 160 } 161 162 void GenCollectedHeap::post_initialize() { 163 CollectedHeap::post_initialize(); 164 ref_processing_init(); 165 check_gen_kinds(); 166 DefNewGeneration* def_new_gen = (DefNewGeneration*)_young_gen; 167 168 initialize_size_policy(def_new_gen->eden()->capacity(), 169 _old_gen->capacity(), 170 def_new_gen->from()->capacity()); 171 172 _gen_policy->initialize_gc_policy_counters(); 173 } 174 175 void GenCollectedHeap::ref_processing_init() { 176 _young_gen->ref_processor_init(); 177 _old_gen->ref_processor_init(); 178 } 179 180 GenerationSpec* GenCollectedHeap::young_gen_spec() const { 181 return _young_gen_spec; 182 } 183 184 GenerationSpec* GenCollectedHeap::old_gen_spec() const { 185 return _old_gen_spec; 186 } 187 188 size_t GenCollectedHeap::capacity() const { 189 return _young_gen->capacity() + _old_gen->capacity(); 190 } 191 192 size_t GenCollectedHeap::used() const { 193 return _young_gen->used() + _old_gen->used(); 194 } 195 196 void GenCollectedHeap::save_used_regions() { 197 _old_gen->save_used_region(); 198 _young_gen->save_used_region(); 199 } 200 201 size_t GenCollectedHeap::max_capacity() const { 202 return _young_gen->max_capacity() + _old_gen->max_capacity(); 203 } 204 205 // Update the _full_collections_completed counter |