1 /*
2 * Copyright Amazon.com Inc. 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_GC_SHENANDOAH_SHENANDOAHGENERATIONALHEAP
26 #define SHARE_GC_SHENANDOAH_SHENANDOAHGENERATIONALHEAP
27
28 #include "gc/shenandoah/shenandoahHeap.hpp"
29
30 class PLAB;
31 class ShenandoahRegulatorThread;
32 class ShenandoahGenerationalControlThread;
33 class ShenandoahAgeCensus;
34
35 class ShenandoahGenerationalHeap : public ShenandoahHeap {
36 public:
37 explicit ShenandoahGenerationalHeap(ShenandoahCollectorPolicy* policy);
38 void post_initialize() override;
39 void initialize_heuristics() override;
40
41 static ShenandoahGenerationalHeap* heap();
42 static ShenandoahGenerationalHeap* cast(CollectedHeap* heap);
43
44 void print_init_logger() const override;
45 size_t unsafe_max_tlab_alloc(Thread *thread) const override;
46
47 private:
48 // ---------- Evacuations and Promotions
49 //
50 // True when regions and objects should be aged during the current cycle
51 ShenandoahSharedFlag _is_aging_cycle;
52 // Age census used for adapting tenuring threshold
53 ShenandoahAgeCensus* _age_census;
54
55 public:
56 void set_aging_cycle(bool cond) {
57 _is_aging_cycle.set_cond(cond);
58 }
59
60 inline bool is_aging_cycle() const {
61 return _is_aging_cycle.is_set();
62 }
63
64 // Return the age census object for young gen
65 ShenandoahAgeCensus* age_census() const {
66 return _age_census;
67 }
68
69 // Ages regions that haven't been used for allocations in the current cycle.
70 // Resets ages for regions that have been used for allocations.
71 void update_region_ages(ShenandoahMarkingContext* ctx);
72
73 oop evacuate_object(oop p, Thread* thread) override;
74 oop try_evacuate_object(oop p, Thread* thread, ShenandoahHeapRegion* from_region, ShenandoahAffiliation target_gen);
75
76 size_t plab_min_size() const { return _min_plab_size; }
77 size_t plab_max_size() const { return _max_plab_size; }
78
79 void retire_plab(PLAB* plab);
80 void retire_plab(PLAB* plab, Thread* thread);
81
82 // ---------- Update References
83 //
84 void update_heap_references(bool concurrent) override;
85 void final_update_refs_update_region_states() override;
86
87 private:
88 HeapWord* allocate_from_plab(Thread* thread, size_t size, bool is_promotion);
89 HeapWord* allocate_from_plab_slow(Thread* thread, size_t size, bool is_promotion);
90 HeapWord* allocate_new_plab(size_t min_size, size_t word_size, size_t* actual_size);
91
92 const size_t _min_plab_size;
93 const size_t _max_plab_size;
94
95 static size_t calculate_min_plab();
96 static size_t calculate_max_plab();
97
98 public:
99 // ---------- Serviceability
100 //
101 void initialize_serviceability() override;
102 GrowableArray<MemoryPool*> memory_pools() override;
103
104 ShenandoahRegulatorThread* regulator_thread() const { return _regulator_thread; }
105
106 void gc_threads_do(ThreadClosure* tcl) const override;
107
108 void stop() override;
109
110 // Used for logging the result of a region transfer outside the heap lock
111 struct TransferResult {
112 bool success;
113 size_t region_count;
114 const char* region_destination;
115
116 void print_on(const char* when, outputStream* ss) const;
117 };
118
119 const ShenandoahGenerationSizer* generation_sizer() const { return &_generation_sizer; }
120
121 // Zeros out the evacuation and promotion reserves
122 void reset_generation_reserves();
123
124 // Computes the optimal size for the old generation, represented as a surplus or deficit of old regions
125 void compute_old_generation_balance(size_t old_xfer_limit, size_t old_cset_regions);
126
127 // Transfers surplus old regions to young, or takes regions from young to satisfy old region deficit
128 TransferResult balance_generations();
129
130 // Balances generations, coalesces and fills old regions if necessary
131 void complete_degenerated_cycle();
132 void complete_concurrent_cycle();
133 private:
134 void initialize_controller() override;
135 void entry_global_coalesce_and_fill();
136
137 // Makes old regions parsable. This will also rebuild card offsets, which is necessary if classes were unloaded
138 void coalesce_and_fill_old_regions(bool concurrent);
139
140 ShenandoahRegulatorThread* _regulator_thread;
141
142 MemoryPool* _young_gen_memory_pool;
143 MemoryPool* _old_gen_memory_pool;
144
145 ShenandoahGenerationSizer _generation_sizer;
146 };
147
148 #endif //SHARE_GC_SHENANDOAH_SHENANDOAHGENERATIONALHEAP