1 /*
  2  * Copyright (c) 2005, 2025, Oracle 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 #include "gc/parallel/objectStartArray.hpp"
 26 #include "gc/parallel/parMarkBitMap.inline.hpp"
 27 #include "gc/parallel/parallelScavengeHeap.hpp"
 28 #include "gc/parallel/psCompactionManager.inline.hpp"
 29 #include "gc/parallel/psOldGen.hpp"
 30 #include "gc/parallel/psParallelCompact.inline.hpp"
 31 #include "gc/shared/partialArraySplitter.inline.hpp"
 32 #include "gc/shared/partialArrayState.hpp"
 33 #include "gc/shared/preservedMarks.inline.hpp"
 34 #include "gc/shared/taskqueue.inline.hpp"
 35 #include "logging/log.hpp"
 36 #include "memory/iterator.inline.hpp"
 37 #include "oops/access.inline.hpp"
 38 #include "oops/compressedOops.inline.hpp"

 39 #include "oops/instanceKlass.inline.hpp"
 40 #include "oops/instanceMirrorKlass.inline.hpp"
 41 #include "oops/objArrayKlass.inline.hpp"
 42 #include "oops/oop.inline.hpp"
 43 
 44 PSOldGen*               ParCompactionManager::_old_gen = nullptr;
 45 ParCompactionManager**  ParCompactionManager::_manager_array = nullptr;
 46 
 47 ParCompactionManager::PSMarkTasksQueueSet*  ParCompactionManager::_marking_stacks = nullptr;
 48 ParCompactionManager::RegionTaskQueueSet*   ParCompactionManager::_region_task_queues = nullptr;
 49 PartialArrayStateManager* ParCompactionManager::_partial_array_state_manager = nullptr;
 50 
 51 ObjectStartArray*    ParCompactionManager::_start_array = nullptr;
 52 ParMarkBitMap*       ParCompactionManager::_mark_bitmap = nullptr;
 53 GrowableArray<size_t >* ParCompactionManager::_shadow_region_array = nullptr;
 54 Monitor*                ParCompactionManager::_shadow_region_monitor = nullptr;
 55 
 56 PreservedMarksSet* ParCompactionManager::_preserved_marks_set = nullptr;
 57 
 58 ParCompactionManager::ParCompactionManager(PreservedMarks* preserved_marks,
 59                                            ReferenceProcessor* ref_processor,
 60                                            uint parallel_gc_threads)
 61   :_partial_array_splitter(_partial_array_state_manager, parallel_gc_threads),
 62    _mark_and_push_closure(this, ref_processor) {
 63 
 64   ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
 65 
 66   _old_gen = heap->old_gen();
 67   _start_array = old_gen()->start_array();
 68 
 69   _preserved_marks = preserved_marks;
 70   _marking_stats_cache = nullptr;
 71 }
 72 
 73 void ParCompactionManager::initialize(ParMarkBitMap* mbm) {
 74   assert(ParallelScavengeHeap::heap() != nullptr, "Needed for initialization");
 75   assert(PSParallelCompact::ref_processor() != nullptr, "precondition");
 76   assert(ParallelScavengeHeap::heap()->workers().max_workers() != 0, "Not initialized?");
 77 
 78   _mark_bitmap = mbm;
 79 
 80   uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
 81 
 82   assert(_manager_array == nullptr, "Attempt to initialize twice");
 83   _manager_array = NEW_C_HEAP_ARRAY(ParCompactionManager*, parallel_gc_threads, mtGC);
 84 
 85   assert(_partial_array_state_manager == nullptr, "Attempt to initialize twice");
 86   _partial_array_state_manager
 87     = new PartialArrayStateManager(parallel_gc_threads);
 88   _marking_stacks = new PSMarkTasksQueueSet(parallel_gc_threads);
 89   _region_task_queues = new RegionTaskQueueSet(parallel_gc_threads);
 90 
 91   _preserved_marks_set = new PreservedMarksSet(true);
 92   _preserved_marks_set->init(parallel_gc_threads);
 93 
 94   // Create and register the ParCompactionManager(s) for the worker threads.
 95   for(uint i=0; i<parallel_gc_threads; i++) {
 96     _manager_array[i] = new ParCompactionManager(_preserved_marks_set->get(i),
 97                                                  PSParallelCompact::ref_processor(),
 98                                                  parallel_gc_threads);
 99     marking_stacks()->register_queue(i, _manager_array[i]->marking_stack());
100     region_task_queues()->register_queue(i, _manager_array[i]->region_stack());
101   }
102 
103   _shadow_region_array = new (mtGC) GrowableArray<size_t >(10, mtGC);
104 
105   _shadow_region_monitor = new Monitor(Mutex::nosafepoint, "CompactionManager_lock");
106 }
107 
108 void ParCompactionManager::flush_all_string_dedup_requests() {
109   uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
110   for (uint i=0; i<parallel_gc_threads; i++) {
111     _manager_array[i]->flush_string_dedup_requests();
112   }
113 }
114 
115 ParCompactionManager*
116 ParCompactionManager::gc_thread_compaction_manager(uint index) {
117   assert(index < ParallelGCThreads, "index out of range");
118   assert(_manager_array != nullptr, "Sanity");
119   return _manager_array[index];
120 }
121 
122 void ParCompactionManager::push_objArray(oop obj) {
123   assert(obj->is_objArray(), "precondition");
124   _mark_and_push_closure.do_klass(obj->klass());
125 
126   objArrayOop obj_array = objArrayOop(obj);
127   size_t array_length = obj_array->length();
128   size_t initial_chunk_size =
129     _partial_array_splitter.start(&_marking_stack, obj_array, nullptr, array_length);
130   follow_array(obj_array, 0, initial_chunk_size);
131 }
132 
133 void ParCompactionManager::process_array_chunk(PartialArrayState* state, bool stolen) {
134   // Access before release by claim().
135   oop obj = state->source();
136   PartialArraySplitter::Claim claim =
137     _partial_array_splitter.claim(state, &_marking_stack, stolen);
138   follow_array(objArrayOop(obj), claim._start, claim._end);
139 }
140 
141 void ParCompactionManager::follow_marking_stacks() {
142   ScannerTask task;
143   do {
144     // First, try to move tasks from the overflow stack into the shared buffer, so
145     // that other threads can steal. Otherwise process the overflow stack first.
146     while (marking_stack()->pop_overflow(task)) {
147       if (!marking_stack()->try_push_to_taskqueue(task)) {
148         follow_contents(task, false);
149       }
150     }
151     while (marking_stack()->pop_local(task)) {
152       follow_contents(task, false);
153     }
154   } while (!marking_stack_empty());
155 
156   assert(marking_stack_empty(), "Sanity");
157 }
158 
159 void ParCompactionManager::drain_region_stacks() {
160   do {
161     // Drain overflow stack first so other threads can steal.
162     size_t region_index;
163     while (region_stack()->pop_overflow(region_index)) {
164       PSParallelCompact::fill_and_update_region(this, region_index);
165     }
166 
167     while (region_stack()->pop_local(region_index)) {
168       PSParallelCompact::fill_and_update_region(this, region_index);
169     }
170   } while (!region_stack()->is_empty());
171 }
172 
173 size_t ParCompactionManager::pop_shadow_region_mt_safe(PSParallelCompact::RegionData* region_ptr) {
174   MonitorLocker ml(_shadow_region_monitor, Mutex::_no_safepoint_check_flag);
175   while (true) {
176     if (!_shadow_region_array->is_empty()) {
177       return _shadow_region_array->pop();
178     }
179     // Check if the corresponding heap region is available now.
180     // If so, we don't need to get a shadow region anymore, and
181     // we return InvalidShadow to indicate such a case.
182     if (region_ptr->claimed()) {
183       return InvalidShadow;
184     }
185     ml.wait(1);
186   }
187 }
188 
189 void ParCompactionManager::push_shadow_region_mt_safe(size_t shadow_region) {
190   MonitorLocker ml(_shadow_region_monitor, Mutex::_no_safepoint_check_flag);
191   _shadow_region_array->push(shadow_region);
192   ml.notify();
193 }
194 
195 void ParCompactionManager::push_shadow_region(size_t shadow_region) {
196   _shadow_region_array->push(shadow_region);
197 }
198 
199 void ParCompactionManager::remove_all_shadow_regions() {
200   _shadow_region_array->clear();
201 }
202 
203 
204 #if TASKQUEUE_STATS
205 void ParCompactionManager::print_and_reset_taskqueue_stats() {
206   marking_stacks()->print_and_reset_taskqueue_stats("Marking Stacks");
207 
208   auto get_pa_stats = [&](uint i) {
209     return _manager_array[i]->partial_array_task_stats();
210   };
211   PartialArrayTaskStats::log_set(ParallelGCThreads, get_pa_stats,
212                                  "Partial Array Task Stats");
213   uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
214   for (uint i = 0; i < parallel_gc_threads; ++i) {
215     get_pa_stats(i)->reset();
216   }
217 }
218 
219 PartialArrayTaskStats* ParCompactionManager::partial_array_task_stats() {
220   return _partial_array_splitter.stats();
221 }
222 #endif // TASKQUEUE_STATS
223 
224 #ifdef ASSERT
225 void ParCompactionManager::verify_all_marking_stack_empty() {
226   uint parallel_gc_threads = ParallelGCThreads;
227   for (uint i = 0; i < parallel_gc_threads; i++) {
228     assert(_manager_array[i]->marking_stack_empty(), "Marking stack should be empty");
229   }
230 }
231 
232 void ParCompactionManager::verify_all_region_stack_empty() {
233   uint parallel_gc_threads = ParallelGCThreads;
234   for (uint i = 0; i < parallel_gc_threads; i++) {
235     assert(_manager_array[i]->region_stack()->is_empty(), "Region stack should be empty");
236   }
237 }
238 #endif
--- EOF ---