1 /* 2 * Copyright (c) 2020, 2021 Amazon.com, Inc. and/or its affiliates. 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 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 #ifndef SHARE_VM_GC_SHENANDOAH_SHENANDOAHGENERATION_HPP 26 #define SHARE_VM_GC_SHENANDOAH_SHENANDOAHGENERATION_HPP 27 28 #include "memory/allocation.hpp" 29 #include "gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp" 30 #include "gc/shenandoah/mode/shenandoahGenerationalMode.hpp" 31 #include "gc/shenandoah/shenandoahLock.hpp" 32 #include "gc/shenandoah/shenandoahMarkingContext.hpp" 33 34 class ShenandoahHeapRegion; 35 class ShenandoahHeapRegionClosure; 36 class ShenandoahReferenceProcessor; 37 class ShenandoahHeap; 38 39 class ShenandoahGeneration : public CHeapObj<mtGC> { 40 private: 41 GenerationMode const _generation_mode; 42 43 // Marking task queues and completeness 44 ShenandoahObjToScanQueueSet* _task_queues; 45 ShenandoahSharedFlag _is_marking_complete; 46 47 ShenandoahReferenceProcessor* const _ref_processor; 48 49 double _collection_thread_time_s; 50 51 protected: 52 // Usage 53 size_t _affiliated_region_count; 54 volatile size_t _used; 55 volatile size_t _bytes_allocated_since_gc_start; 56 size_t _max_capacity; 57 size_t _soft_max_capacity; 58 59 size_t _adjusted_capacity; 60 61 ShenandoahHeuristics* _heuristics; 62 63 private: 64 // Compute evacuation budgets prior to choosing collection set. 65 void compute_evacuation_budgets(ShenandoahHeap* heap, bool* preselected_regions, ShenandoahCollectionSet* collection_set, 66 size_t &consumed_by_advance_promotion); 67 68 // Adjust evacuation budgets after choosing collection set. 69 void adjust_evacuation_budgets(ShenandoahHeap* heap, ShenandoahCollectionSet* collection_set, 70 size_t consumed_by_advance_promotion); 71 72 public: 73 ShenandoahGeneration(GenerationMode generation_mode, uint max_workers, size_t max_capacity, size_t soft_max_capacity); 74 ~ShenandoahGeneration(); 75 76 bool is_young() const { return _generation_mode == YOUNG; } 77 bool is_old() const { return _generation_mode == OLD; } 78 bool is_global() const { return _generation_mode == GLOBAL; } 79 80 inline GenerationMode generation_mode() const { return _generation_mode; } 81 82 inline ShenandoahHeuristics* heuristics() const { return _heuristics; } 83 84 ShenandoahReferenceProcessor* ref_processor() { return _ref_processor; } 85 86 virtual const char* name() const = 0; 87 88 virtual ShenandoahHeuristics* initialize_heuristics(ShenandoahMode* gc_mode); 89 90 virtual size_t soft_max_capacity() const { return _soft_max_capacity; } 91 virtual size_t max_capacity() const { return _max_capacity; } 92 virtual size_t used_regions() const; 93 virtual size_t used_regions_size() const; 94 virtual size_t free_unaffiliated_regions() const; 95 virtual size_t used() const { return _used; } 96 virtual size_t available() const; 97 98 // During evacuation and update-refs, some memory may be shifted between generations. In particular, memory 99 // may be loaned by old-gen to young-gen based on the promise the loan will be promptly repaid from the memory reclaimed 100 // when the current collection set is recycled. The capacity adjustment also takes into consideration memory that is 101 // set aside within each generation to hold the results of evacuation, but not promotion, into that region. Promotions 102 // into old-gen are bounded by adjusted_available() whereas evacuations into old-gen are pre-committed. 103 virtual size_t adjusted_available() const; 104 virtual size_t adjusted_capacity() const; 105 106 // This is the number of FREE regions that are eligible to be affiliated with this generation according to the current 107 // adjusted capacity. 108 virtual size_t adjusted_unaffiliated_regions() const; 109 110 // Both of following return new value of available 111 virtual size_t adjust_available(intptr_t adjustment); 112 virtual size_t unadjust_available(); 113 114 size_t bytes_allocated_since_gc_start(); 115 void reset_bytes_allocated_since_gc_start(); 116 void increase_allocated(size_t bytes); 117 118 // These methods change the capacity of the region by adding or subtracting the given number of bytes from the current 119 // capacity. 120 void increase_capacity(size_t increment); 121 void decrease_capacity(size_t decrement); 122 123 void set_soft_max_capacity(size_t soft_max_capacity) { 124 _soft_max_capacity = soft_max_capacity; 125 } 126 127 void log_status(const char* msg) const; 128 129 // Used directly by FullGC 130 void reset_mark_bitmap(); 131 132 // Used by concurrent and degenerated GC to reset remembered set. 133 void swap_remembered_set(); 134 135 // Update the read cards with the state of the write table (write table is not cleared). 136 void merge_write_table(); 137 138 // Called before init mark, expected to prepare regions for marking. 139 virtual void prepare_gc(); 140 141 // Called during final mark, chooses collection set, rebuilds free set. 142 virtual void prepare_regions_and_collection_set(bool concurrent); 143 144 // Cancel marking (used by Full collect and when cancelling cycle). 145 virtual void cancel_marking(); 146 147 // Return true if this region is affiliated with this generation. 148 virtual bool contains(ShenandoahHeapRegion* region) const = 0; 149 150 // Return true if this object is affiliated with this generation. 151 virtual bool contains(oop obj) const = 0; 152 153 // Apply closure to all regions affiliated with this generation. 154 virtual void parallel_heap_region_iterate(ShenandoahHeapRegionClosure* cl) = 0; 155 156 // Apply closure to all regions affiliated with this generation (single threaded). 157 virtual void heap_region_iterate(ShenandoahHeapRegionClosure* cl) = 0; 158 159 // This is public to support cancellation of marking when a Full cycle is started. 160 virtual void set_concurrent_mark_in_progress(bool in_progress) = 0; 161 162 // Check the bitmap only for regions belong to this generation. 163 bool is_bitmap_clear(); 164 165 // We need to track the status of marking for different generations. 166 bool is_mark_complete(); 167 void set_mark_complete(); 168 void set_mark_incomplete(); 169 170 ShenandoahMarkingContext* complete_marking_context(); 171 172 // Task queues 173 ShenandoahObjToScanQueueSet* task_queues() const { return _task_queues; } 174 virtual void reserve_task_queues(uint workers); 175 virtual ShenandoahObjToScanQueueSet* old_gen_task_queues() const; 176 177 // Scan remembered set at start of concurrent young-gen marking. 178 void scan_remembered_set(bool is_concurrent); 179 180 // Return the updated value of affiliated_region_count 181 size_t increment_affiliated_region_count(); 182 183 // Return the updated value of affiliated_region_count 184 size_t decrement_affiliated_region_count(); 185 186 void clear_used(); 187 void increase_used(size_t bytes); 188 void decrease_used(size_t bytes); 189 190 virtual bool is_concurrent_mark_in_progress() = 0; 191 void confirm_heuristics_mode(); 192 193 virtual void record_success_concurrent(bool abbreviated); 194 virtual void record_success_degenerated(); 195 196 // Record the total on-cpu time a thread has spent collecting this 197 // generation. This is only called by the control thread (at the start 198 // of a collection) and by the VM thread at the end of the collection, 199 // so there are no locking concerns. 200 virtual void add_collection_time(double time_seconds); 201 202 // This returns the accumulated collection time and resets it to zero. 203 // This is used to decide which generation should be resized. 204 double reset_collection_time(); 205 }; 206 207 #endif // SHARE_VM_GC_SHENANDOAH_SHENANDOAHGENERATION_HPP