Thu, 22 Sep 2011 10:57:37 -0700
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
1 /*
2 * Copyright (c) 2005, 2010, 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 */
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP
28 #include "memory/allocation.hpp"
29 #include "utilities/stack.hpp"
30 #include "utilities/taskqueue.hpp"
32 // Move to some global location
33 #define HAS_BEEN_MOVED 0x1501d01d
34 // End move to some global location
37 class MutableSpace;
38 class PSOldGen;
39 class ParCompactionManager;
40 class ObjectStartArray;
41 class ParallelCompactData;
42 class ParMarkBitMap;
44 class ParCompactionManager : public CHeapObj {
45 friend class ParallelTaskTerminator;
46 friend class ParMarkBitMap;
47 friend class PSParallelCompact;
48 friend class StealRegionCompactionTask;
49 friend class UpdateAndFillClosure;
50 friend class RefProcTaskExecutor;
52 public:
54 // ------------------------ Don't putback if not needed
55 // Actions that the compaction manager should take.
56 enum Action {
57 Update,
58 Copy,
59 UpdateAndCopy,
60 CopyAndUpdate,
61 VerifyUpdate,
62 ResetObjects,
63 NotValid
64 };
65 // ------------------------ End don't putback if not needed
67 private:
68 // 32-bit: 4K * 8 = 32KiB; 64-bit: 8K * 16 = 128KiB
69 #define QUEUE_SIZE (1 << NOT_LP64(12) LP64_ONLY(13))
70 typedef OverflowTaskQueue<ObjArrayTask, QUEUE_SIZE> ObjArrayTaskQueue;
71 typedef GenericTaskQueueSet<ObjArrayTaskQueue> ObjArrayTaskQueueSet;
72 #undef QUEUE_SIZE
74 static ParCompactionManager** _manager_array;
75 static OopTaskQueueSet* _stack_array;
76 static ObjArrayTaskQueueSet* _objarray_queues;
77 static ObjectStartArray* _start_array;
78 static RegionTaskQueueSet* _region_array;
79 static PSOldGen* _old_gen;
81 private:
82 OverflowTaskQueue<oop> _marking_stack;
83 ObjArrayTaskQueue _objarray_stack;
85 // Is there a way to reuse the _marking_stack for the
86 // saving empty regions? For now just create a different
87 // type of TaskQueue.
88 RegionTaskQueue _region_stack;
90 Stack<Klass*> _revisit_klass_stack;
91 Stack<DataLayout*> _revisit_mdo_stack;
93 static ParMarkBitMap* _mark_bitmap;
95 Action _action;
97 static PSOldGen* old_gen() { return _old_gen; }
98 static ObjectStartArray* start_array() { return _start_array; }
99 static OopTaskQueueSet* stack_array() { return _stack_array; }
101 static void initialize(ParMarkBitMap* mbm);
103 protected:
104 // Array of tasks. Needed by the ParallelTaskTerminator.
105 static RegionTaskQueueSet* region_array() { return _region_array; }
106 OverflowTaskQueue<oop>* marking_stack() { return &_marking_stack; }
107 RegionTaskQueue* region_stack() { return &_region_stack; }
109 // Pushes onto the marking stack. If the marking stack is full,
110 // pushes onto the overflow stack.
111 void stack_push(oop obj);
112 // Do not implement an equivalent stack_pop. Deal with the
113 // marking stack and overflow stack directly.
115 public:
116 Action action() { return _action; }
117 void set_action(Action v) { _action = v; }
119 inline static ParCompactionManager* manager_array(int index);
121 ParCompactionManager();
123 ParMarkBitMap* mark_bitmap() { return _mark_bitmap; }
125 // Take actions in preparation for a compaction.
126 static void reset();
128 // void drain_stacks();
130 bool should_update();
131 bool should_copy();
132 bool should_verify_only();
133 bool should_reset_only();
135 Stack<Klass*>* revisit_klass_stack() { return &_revisit_klass_stack; }
136 Stack<DataLayout*>* revisit_mdo_stack() { return &_revisit_mdo_stack; }
138 // Save for later processing. Must not fail.
139 inline void push(oop obj) { _marking_stack.push(obj); }
140 inline void push_objarray(oop objarray, size_t index);
141 inline void push_region(size_t index);
143 // Access function for compaction managers
144 static ParCompactionManager* gc_thread_compaction_manager(int index);
146 static bool steal(int queue_num, int* seed, oop& t) {
147 return stack_array()->steal(queue_num, seed, t);
148 }
150 static bool steal_objarray(int queue_num, int* seed, ObjArrayTask& t) {
151 return _objarray_queues->steal(queue_num, seed, t);
152 }
154 static bool steal(int queue_num, int* seed, size_t& region) {
155 return region_array()->steal(queue_num, seed, region);
156 }
158 // Process tasks remaining on any marking stack
159 void follow_marking_stacks();
160 inline bool marking_stacks_empty() const;
162 // Process tasks remaining on any stack
163 void drain_region_stacks();
165 };
167 inline ParCompactionManager* ParCompactionManager::manager_array(int index) {
168 assert(_manager_array != NULL, "access of NULL manager_array");
169 assert(index >= 0 && index <= (int)ParallelGCThreads,
170 "out of range manager_array access");
171 return _manager_array[index];
172 }
174 bool ParCompactionManager::marking_stacks_empty() const {
175 return _marking_stack.is_empty() && _objarray_stack.is_empty();
176 }
178 #endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP