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/parallelScavengeHeap.hpp"
27 #include "gc/parallel/parMarkBitMap.inline.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,
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 }
|
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/parallelScavengeHeap.hpp"
27 #include "gc/parallel/parMarkBitMap.inline.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/flatArrayKlass.inline.hpp"
40 #include "oops/instanceKlass.inline.hpp"
41 #include "oops/instanceMirrorKlass.inline.hpp"
42 #include "oops/objArrayKlass.inline.hpp"
43 #include "oops/oop.inline.hpp"
44
45 PSOldGen* ParCompactionManager::_old_gen = nullptr;
46 ParCompactionManager** ParCompactionManager::_manager_array = nullptr;
47
48 ParCompactionManager::PSMarkTasksQueueSet* ParCompactionManager::_marking_stacks = nullptr;
49 ParCompactionManager::RegionTaskQueueSet* ParCompactionManager::_region_task_queues = nullptr;
50 PartialArrayStateManager* ParCompactionManager::_partial_array_state_manager = nullptr;
51
52 ObjectStartArray* ParCompactionManager::_start_array = nullptr;
53 ParMarkBitMap* ParCompactionManager::_mark_bitmap = nullptr;
54 GrowableArray<size_t >* ParCompactionManager::_shadow_region_array = nullptr;
55 Monitor* ParCompactionManager::_shadow_region_monitor = nullptr;
56
57 PreservedMarksSet* ParCompactionManager::_preserved_marks_set = nullptr;
58
59 ParCompactionManager::ParCompactionManager(PreservedMarks* preserved_marks,
103
104 _shadow_region_array = new (mtGC) GrowableArray<size_t >(10, mtGC);
105
106 _shadow_region_monitor = new Monitor(Mutex::nosafepoint, "CompactionManager_lock");
107 }
108
109 void ParCompactionManager::flush_all_string_dedup_requests() {
110 uint parallel_gc_threads = ParallelScavengeHeap::heap()->workers().max_workers();
111 for (uint i=0; i<parallel_gc_threads; i++) {
112 _manager_array[i]->flush_string_dedup_requests();
113 }
114 }
115
116 ParCompactionManager*
117 ParCompactionManager::gc_thread_compaction_manager(uint index) {
118 assert(index < ParallelGCThreads, "index out of range");
119 assert(_manager_array != nullptr, "Sanity");
120 return _manager_array[index];
121 }
122
123 void ParCompactionManager::push_objArray(objArrayOop obj) {
124 assert(obj->is_array_with_oops(), "precondition");
125 _mark_and_push_closure.do_klass(obj->klass());
126
127 if (obj->is_flatArray()) {
128 FlatArrayKlass* faklass = FlatArrayKlass::cast(obj->klass());
129 _mark_and_push_closure.do_klass(faklass->element_klass());
130 }
131
132 size_t array_length = obj->length();
133 size_t initial_chunk_size =
134 _partial_array_splitter.start(&_marking_stack, obj, nullptr, array_length);
135 follow_array(obj, 0, initial_chunk_size);
136 }
137
138 void ParCompactionManager::process_array_chunk(PartialArrayState* state, bool stolen) {
139 // Access before release by claim().
140 oop obj = state->source();
141 PartialArraySplitter::Claim claim =
142 _partial_array_splitter.claim(state, &_marking_stack, stolen);
143 follow_array(objArrayOop(obj), claim._start, claim._end);
144 }
145
146 void ParCompactionManager::follow_marking_stacks() {
147 ScannerTask task;
148 do {
149 // First, try to move tasks from the overflow stack into the shared buffer, so
150 // that other threads can steal. Otherwise process the overflow stack first.
151 while (marking_stack()->pop_overflow(task)) {
152 if (!marking_stack()->try_push_to_taskqueue(task)) {
153 follow_contents(task, false);
154 }
155 }
|