1 /*
2 * Copyright (c) 2005, 2025, Oracle and/or its affiliates. All rights reserved.
3 * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "gc/parallel/objectStartArray.hpp"
27 #include "gc/parallel/parMarkBitMap.inline.hpp"
28 #include "gc/parallel/parallelScavengeHeap.hpp"
29 #include "gc/parallel/psCompactionManagerNew.inline.hpp"
30 #include "gc/parallel/psOldGen.hpp"
31 #include "gc/parallel/psParallelCompactNew.inline.hpp"
32 #include "gc/shared/partialArraySplitter.inline.hpp"
33 #include "gc/shared/partialArrayState.hpp"
34 #include "gc/shared/preservedMarks.inline.hpp"
35 #include "memory/iterator.inline.hpp"
36
37 PSOldGen* ParCompactionManagerNew::_old_gen = nullptr;
38 ParCompactionManagerNew** ParCompactionManagerNew::_manager_array = nullptr;
39
40 ParCompactionManagerNew::PSMarkTasksQueueSet* ParCompactionManagerNew::_marking_stacks = nullptr;
41 PartialArrayStateManager* ParCompactionManagerNew::_partial_array_state_manager = nullptr;
42
43 ObjectStartArray* ParCompactionManagerNew::_start_array = nullptr;
44 ParMarkBitMap* ParCompactionManagerNew::_mark_bitmap = nullptr;
45
46 PreservedMarksSet* ParCompactionManagerNew::_preserved_marks_set = nullptr;
47
48 ParCompactionManagerNew::ParCompactionManagerNew(PreservedMarks* preserved_marks,
49 ReferenceProcessor* ref_processor,
50 uint parallel_gc_threads)
51 :_partial_array_splitter(_partial_array_state_manager, parallel_gc_threads),
52 _mark_and_push_closure(this, ref_processor) {
53
54 _old_gen = ParallelScavengeHeap::old_gen();
55 _start_array = old_gen()->start_array();
56
57 _preserved_marks = preserved_marks;
58 }
59
60 void ParCompactionManagerNew::initialize(ParMarkBitMap* mbm) {
61 assert(ParallelScavengeHeap::heap() != nullptr, "Needed for initialization");
62 assert(PSParallelCompactNew::ref_processor() != nullptr, "precondition");
63 assert(ParallelScavengeHeap::heap()->workers().max_workers() != 0, "Not initialized?");
64
65 _mark_bitmap = mbm;
66
67 uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
68
69 assert(_manager_array == nullptr, "Attempt to initialize twice");
70 _manager_array = NEW_C_HEAP_ARRAY(ParCompactionManagerNew*, parallel_gc_threads, mtGC);
71
72 assert(_partial_array_state_manager == nullptr, "Attempt to initialize twice");
73 _partial_array_state_manager
74 = new PartialArrayStateManager(parallel_gc_threads);
75 _marking_stacks = new PSMarkTasksQueueSet(parallel_gc_threads);
76
77 _preserved_marks_set = new PreservedMarksSet(true);
78 _preserved_marks_set->init(parallel_gc_threads);
79
80 // Create and register the ParCompactionManagerNew(s) for the worker threads.
81 for(uint i=0; i<parallel_gc_threads; i++) {
82 _manager_array[i] = new ParCompactionManagerNew(_preserved_marks_set->get(i),
83 PSParallelCompactNew::ref_processor(),
84 parallel_gc_threads);
85 marking_stacks()->register_queue(i, _manager_array[i]->marking_stack());
86 }
87 }
88
89 void ParCompactionManagerNew::flush_all_string_dedup_requests() {
90 uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
91 for (uint i=0; i<parallel_gc_threads; i++) {
92 _manager_array[i]->flush_string_dedup_requests();
93 }
94 }
95
96 ParCompactionManagerNew*
97 ParCompactionManagerNew::gc_thread_compaction_manager(uint index) {
98 assert(index < ParallelGCThreads, "index out of range");
99 assert(_manager_array != nullptr, "Sanity");
100 return _manager_array[index];
101 }
102
103 void ParCompactionManagerNew::push_objArray(oop obj) {
104 assert(obj->is_objArray(), "precondition");
105 _mark_and_push_closure.do_klass(obj->klass());
106
107 objArrayOop obj_array = objArrayOop(obj);
108 size_t array_length = obj_array->length();
109 size_t initial_chunk_size =
110 _partial_array_splitter.start(&_marking_stack, obj_array, nullptr, array_length);
111 follow_array(obj_array, 0, initial_chunk_size);
112 }
113
114 void ParCompactionManagerNew::process_array_chunk(PartialArrayState* state, bool stolen) {
115 // Access before release by claim().
116 oop obj = state->source();
117 PartialArraySplitter::Claim claim =
118 _partial_array_splitter.claim(state, &_marking_stack, stolen);
119 follow_array(objArrayOop(obj), claim._start, claim._end);
120 }
121
122 void ParCompactionManagerNew::follow_marking_stacks() {
123 ScannerTask task;
124 do {
125 // First, try to move tasks from the overflow stack into the shared buffer, so
126 // that other threads can steal. Otherwise process the overflow stack first.
127 while (marking_stack()->pop_overflow(task)) {
128 if (!marking_stack()->try_push_to_taskqueue(task)) {
129 follow_contents(task, false);
130 }
131 }
132 while (marking_stack()->pop_local(task)) {
133 follow_contents(task, false);
134 }
135 } while (!marking_stack_empty());
136
137 assert(marking_stack_empty(), "Sanity");
138 }
139
140 #if TASKQUEUE_STATS
141 void ParCompactionManagerNew::print_and_reset_taskqueue_stats() {
142 marking_stacks()->print_and_reset_taskqueue_stats("Marking Stacks");
143
144 auto get_pa_stats = [&](uint i) {
145 return _manager_array[i]->partial_array_task_stats();
146 };
147 PartialArrayTaskStats::log_set(ParallelGCThreads, get_pa_stats,
148 "Partial Array Task Stats");
149 uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
150 for (uint i = 0; i < parallel_gc_threads; ++i) {
151 get_pa_stats(i)->reset();
152 }
153 }
154
155 PartialArrayTaskStats* ParCompactionManagerNew::partial_array_task_stats() {
156 return _partial_array_splitter.stats();
157 }
158 #endif // TASKQUEUE_STATS
159
160 #ifdef ASSERT
161 void ParCompactionManagerNew::verify_all_marking_stack_empty() {
162 uint parallel_gc_threads = ParallelGCThreads;
163 for (uint i = 0; i < parallel_gc_threads; i++) {
164 assert(_manager_array[i]->marking_stack_empty(), "Marking stack should be empty");
165 }
166 }
167 #endif