1 /*
2 * Copyright (c) 2017, 2018, 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 "precompiled.hpp"
26 #include "gc/g1/g1CollectedHeap.hpp"
27 #include "gc/g1/g1ConcurrentMarkBitMap.inline.hpp"
28 #include "gc/g1/g1FullCollector.hpp"
29 #include "gc/g1/g1FullGCAdjustTask.hpp"
30 #include "gc/g1/g1FullGCCompactionPoint.hpp"
31 #include "gc/g1/g1FullGCMarker.hpp"
32 #include "gc/g1/g1FullGCOopClosures.inline.hpp"
33 #include "gc/g1/heapRegion.inline.hpp"
34 #include "gc/shared/gcTraceTime.inline.hpp"
35 #include "gc/shared/referenceProcessor.hpp"
36 #include "gc/shared/weakProcessor.inline.hpp"
37 #include "logging/log.hpp"
38 #include "memory/iterator.inline.hpp"
39 #include "runtime/atomic.hpp"
40
41 class G1AdjustLiveClosure : public StackObj {
42 G1AdjustClosure* _adjust_closure;
43 public:
44 G1AdjustLiveClosure(G1AdjustClosure* cl) :
45 _adjust_closure(cl) { }
46
47 size_t apply(oop object) {
48 return object->oop_iterate_size(_adjust_closure);
49 }
50 };
51
52 class G1AdjustRegionClosure : public HeapRegionClosure {
53 G1CMBitMap* _bitmap;
54 uint _worker_id;
55 public:
56 G1AdjustRegionClosure(G1CMBitMap* bitmap, uint worker_id) :
57 _bitmap(bitmap),
58 _worker_id(worker_id) { }
59
60 bool do_heap_region(HeapRegion* r) {
61 G1AdjustClosure cl;
62 if (r->is_humongous()) {
63 oop obj = oop(r->humongous_start_region()->bottom());
64 obj->oop_iterate(&cl, MemRegion(r->bottom(), r->top()));
65 } else if (r->is_open_archive()) {
66 // Only adjust the open archive regions, the closed ones
67 // never change.
68 G1AdjustLiveClosure adjust(&cl);
69 r->apply_to_marked_objects(_bitmap, &adjust);
70 // Open archive regions will not be compacted and the marking information is
71 // no longer needed. Clear it here to avoid having to do it later.
72 _bitmap->clear_region(r);
73 } else {
74 G1AdjustLiveClosure adjust(&cl);
75 r->apply_to_marked_objects(_bitmap, &adjust);
76 }
77 return false;
78 }
79 };
80
81 G1FullGCAdjustTask::G1FullGCAdjustTask(G1FullCollector* collector) :
82 G1FullGCTask("G1 Adjust", collector),
83 _root_processor(G1CollectedHeap::heap(), collector->workers()),
84 _references_done(0),
85 _weak_proc_task(collector->workers()),
86 _hrclaimer(collector->workers()),
87 _adjust(),
88 _adjust_string_dedup(NULL, &_adjust, G1StringDedup::is_enabled()) {
89 // Need cleared claim bits for the roots processing
90 ClassLoaderDataGraph::clear_claimed_marks();
91 }
92
93 void G1FullGCAdjustTask::work(uint worker_id) {
94 Ticks start = Ticks::now();
95 ResourceMark rm;
96
97 // Adjust preserved marks first since they are not balanced.
98 G1FullGCMarker* marker = collector()->marker(worker_id);
99 marker->preserved_stack()->adjust_during_full_gc();
100
101 // Adjust the weak roots.
102
103 if (Atomic::add(1u, &_references_done) == 1u) { // First incr claims task.
104 G1CollectedHeap::heap()->ref_processor_stw()->weak_oops_do(&_adjust);
105 }
106
107 AlwaysTrueClosure always_alive;
108 _weak_proc_task.work(worker_id, &always_alive, &_adjust);
109
110 CLDToOopClosure adjust_cld(&_adjust, ClassLoaderData::_claim_value_strong);
111 CodeBlobToOopClosure adjust_code(&_adjust, CodeBlobToOopClosure::FixRelocations);
112 _root_processor.process_all_roots(
113 &_adjust,
114 &adjust_cld,
115 &adjust_code);
116
117 // Adjust string dedup if enabled.
118 if (G1StringDedup::is_enabled()) {
119 G1StringDedup::parallel_unlink(&_adjust_string_dedup, worker_id);
120 }
121
122 // Now adjust pointers region by region
123 G1AdjustRegionClosure blk(collector()->mark_bitmap(), worker_id);
124 G1CollectedHeap::heap()->heap_region_par_iterate_from_worker_offset(&blk, &_hrclaimer, worker_id);
125 log_task("Adjust task", worker_id, start);
126 }