• file
• revisions
• annotate
• diff
• comparison
• raw

src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp@4dfb2df418f2 (annotated)

src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp

Thu, 22 Sep 2011 10:57:37 -0700

author

johnc

date

Thu, 22 Sep 2011 10:57:37 -0700

changeset 3175

4dfb2df418f2

parent 2314

f95d63e2154a

child 3294

bca17e38de00

permissions

-rw-r--r--

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

duke@435	1	/*
jcoomes@1993	2	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
stefank@2314	25	#ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP
stefank@2314	26	#define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP
stefank@2314	27
stefank@2314	28	#include "memory/allocation.hpp"
stefank@2314	29	#include "utilities/stack.hpp"
stefank@2314	30	#include "utilities/taskqueue.hpp"
stefank@2314	31
duke@435	32	// Move to some global location
duke@435	33	#define HAS_BEEN_MOVED 0x1501d01d
duke@435	34	// End move to some global location
duke@435	35
duke@435	36
duke@435	37	class MutableSpace;
duke@435	38	class PSOldGen;
duke@435	39	class ParCompactionManager;
duke@435	40	class ObjectStartArray;
duke@435	41	class ParallelCompactData;
duke@435	42	class ParMarkBitMap;
duke@435	43
duke@435	44	class ParCompactionManager : public CHeapObj {
duke@435	45	friend class ParallelTaskTerminator;
duke@435	46	friend class ParMarkBitMap;
duke@435	47	friend class PSParallelCompact;
jcoomes@810	48	friend class StealRegionCompactionTask;
duke@435	49	friend class UpdateAndFillClosure;
duke@435	50	friend class RefProcTaskExecutor;
duke@435	51
duke@435	52	public:
duke@435	53
duke@435	54	// ------------------------ Don't putback if not needed
duke@435	55	// Actions that the compaction manager should take.
duke@435	56	enum Action {
duke@435	57	Update,
duke@435	58	Copy,
duke@435	59	UpdateAndCopy,
duke@435	60	CopyAndUpdate,
duke@435	61	VerifyUpdate,
duke@435	62	ResetObjects,
duke@435	63	NotValid
duke@435	64	};
duke@435	65	// ------------------------ End don't putback if not needed
duke@435	66
duke@435	67	private:
jcoomes@1746	68	// 32-bit: 4K * 8 = 32KiB; 64-bit: 8K * 16 = 128KiB
jcoomes@1993	69	#define QUEUE_SIZE (1 << NOT_LP64(12) LP64_ONLY(13))
jcoomes@1993	70	typedef OverflowTaskQueue<ObjArrayTask, QUEUE_SIZE> ObjArrayTaskQueue;
jcoomes@1993	71	typedef GenericTaskQueueSet<ObjArrayTaskQueue> ObjArrayTaskQueueSet;
jcoomes@1993	72	#undef QUEUE_SIZE
jcoomes@1746	73
jcoomes@810	74	static ParCompactionManager** _manager_array;
jcoomes@810	75	static OopTaskQueueSet* _stack_array;
jcoomes@1746	76	static ObjArrayTaskQueueSet* _objarray_queues;
jcoomes@810	77	static ObjectStartArray* _start_array;
jcoomes@810	78	static RegionTaskQueueSet* _region_array;
jcoomes@810	79	static PSOldGen* _old_gen;
duke@435	80
jcoomes@1746	81	private:
jcoomes@1993	82	OverflowTaskQueue<oop> _marking_stack;
jcoomes@1993	83	ObjArrayTaskQueue _objarray_stack;
jcoomes@1746	84
duke@435	85	// Is there a way to reuse the _marking_stack for the
jcoomes@810	86	// saving empty regions? For now just create a different
duke@435	87	// type of TaskQueue.
jcoomes@810	88	RegionTaskQueue _region_stack;
duke@435	89
jcoomes@2191	90	Stack<Klass*> _revisit_klass_stack;
jcoomes@2191	91	Stack<DataLayout*> _revisit_mdo_stack;
jcoomes@2191	92
duke@435	93	static ParMarkBitMap* _mark_bitmap;
duke@435	94
duke@435	95	Action _action;
duke@435	96
duke@435	97	static PSOldGen* old_gen() { return _old_gen; }
duke@435	98	static ObjectStartArray* start_array() { return _start_array; }
jcoomes@810	99	static OopTaskQueueSet* stack_array() { return _stack_array; }
duke@435	100
duke@435	101	static void initialize(ParMarkBitMap* mbm);
duke@435	102
duke@435	103	protected:
duke@435	104	// Array of tasks. Needed by the ParallelTaskTerminator.
jcoomes@810	105	static RegionTaskQueueSet* region_array() { return _region_array; }
jcoomes@1993	106	OverflowTaskQueue<oop>* marking_stack() { return &_marking_stack; }
jcoomes@1993	107	RegionTaskQueue* region_stack() { return &_region_stack; }
duke@435	108
duke@435	109	// Pushes onto the marking stack. If the marking stack is full,
duke@435	110	// pushes onto the overflow stack.
duke@435	111	void stack_push(oop obj);
duke@435	112	// Do not implement an equivalent stack_pop. Deal with the
duke@435	113	// marking stack and overflow stack directly.
duke@435	114
jcoomes@1993	115	public:
duke@435	116	Action action() { return _action; }
duke@435	117	void set_action(Action v) { _action = v; }
duke@435	118
duke@435	119	inline static ParCompactionManager* manager_array(int index);
duke@435	120
duke@435	121	ParCompactionManager();
duke@435	122
duke@435	123	ParMarkBitMap* mark_bitmap() { return _mark_bitmap; }
duke@435	124
duke@435	125	// Take actions in preparation for a compaction.
duke@435	126	static void reset();
duke@435	127
duke@435	128	// void drain_stacks();
duke@435	129
duke@435	130	bool should_update();
duke@435	131	bool should_copy();
duke@435	132	bool should_verify_only();
duke@435	133	bool should_reset_only();
duke@435	134
jcoomes@2191	135	Stack<Klass*>* revisit_klass_stack() { return &_revisit_klass_stack; }
jcoomes@2191	136	Stack<DataLayout*>* revisit_mdo_stack() { return &_revisit_mdo_stack; }
duke@435	137
jcoomes@1993	138	// Save for later processing. Must not fail.
jcoomes@1993	139	inline void push(oop obj) { _marking_stack.push(obj); }
jcoomes@1993	140	inline void push_objarray(oop objarray, size_t index);
jcoomes@1993	141	inline void push_region(size_t index);
duke@435	142
duke@435	143	// Access function for compaction managers
duke@435	144	static ParCompactionManager* gc_thread_compaction_manager(int index);
duke@435	145
jcoomes@1993	146	static bool steal(int queue_num, int* seed, oop& t) {
duke@435	147	return stack_array()->steal(queue_num, seed, t);
duke@435	148	}
duke@435	149
jcoomes@1746	150	static bool steal_objarray(int queue_num, int* seed, ObjArrayTask& t) {
jcoomes@1746	151	return _objarray_queues->steal(queue_num, seed, t);
jcoomes@1746	152	}
jcoomes@1746	153
jcoomes@1993	154	static bool steal(int queue_num, int* seed, size_t& region) {
jcoomes@1993	155	return region_array()->steal(queue_num, seed, region);
duke@435	156	}
duke@435	157
jcoomes@1746	158	// Process tasks remaining on any marking stack
jcoomes@1746	159	void follow_marking_stacks();
jcoomes@1746	160	inline bool marking_stacks_empty() const;
duke@435	161
duke@435	162	// Process tasks remaining on any stack
jcoomes@810	163	void drain_region_stacks();
duke@435	164
duke@435	165	};
duke@435	166
duke@435	167	inline ParCompactionManager* ParCompactionManager::manager_array(int index) {
duke@435	168	assert(_manager_array != NULL, "access of NULL manager_array");
duke@435	169	assert(index >= 0 && index <= (int)ParallelGCThreads,
duke@435	170	"out of range manager_array access");
duke@435	171	return _manager_array[index];
duke@435	172	}
jcoomes@1746	173
jcoomes@1746	174	bool ParCompactionManager::marking_stacks_empty() const {
jcoomes@1993	175	return _marking_stack.is_empty() && _objarray_stack.is_empty();
jcoomes@1746	176	}
stefank@2314	177
stefank@2314	178	#endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_HPP