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

src/share/vm/memory/resourceArea.hpp@167c2986d91b (annotated)

src/share/vm/memory/resourceArea.hpp

Wed, 16 Dec 2009 12:54:49 -0500

author

phh

date

Wed, 16 Dec 2009 12:54:49 -0500

changeset 1558

167c2986d91b

parent 435

a61af66fc99e

child 1907

c18cbe5936b8

permissions

-rw-r--r--

6843629: Make current hotspot build part of jdk5 control build
Summary: Source changes for older compilers plus makefile changes.
Reviewed-by: xlu

duke@435	1	/*
duke@435	2	* Copyright 1997-2003 Sun Microsystems, Inc. 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	*
duke@435	19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435	20	* CA 95054 USA or visit www.sun.com if you need additional information or
duke@435	21	* have any questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
duke@435	25	// The resource area holds temporary data structures in the VM.
duke@435	26	// The actual allocation areas are thread local. Typical usage:
duke@435	27	//
duke@435	28	// ...
duke@435	29	// {
duke@435	30	// ResourceMark rm;
duke@435	31	// int foo[] = NEW_RESOURCE_ARRAY(int, 64);
duke@435	32	// ...
duke@435	33	// }
duke@435	34	// ...
duke@435	35
duke@435	36	//------------------------------ResourceArea-----------------------------------
duke@435	37	// A ResourceArea is an Arena that supports safe usage of ResourceMark.
duke@435	38	class ResourceArea: public Arena {
duke@435	39	friend class ResourceMark;
duke@435	40	friend class DeoptResourceMark;
duke@435	41	debug_only(int _nesting;) // current # of nested ResourceMarks
duke@435	42	debug_only(static int _warned;) // to suppress multiple warnings
duke@435	43
duke@435	44	public:
duke@435	45	ResourceArea() {
duke@435	46	debug_only(_nesting = 0;)
duke@435	47	}
duke@435	48
duke@435	49	ResourceArea(size_t init_size) : Arena(init_size) {
duke@435	50	debug_only(_nesting = 0;);
duke@435	51	}
duke@435	52
duke@435	53	char* allocate_bytes(size_t size) {
duke@435	54	#ifdef ASSERT
duke@435	55	if (_nesting < 1 && !_warned++)
duke@435	56	fatal("memory leak: allocating without ResourceMark");
duke@435	57	if (UseMallocOnly) {
duke@435	58	// use malloc, but save pointer in res. area for later freeing
duke@435	59	char** save = (char**)internal_malloc_4(sizeof(char*));
duke@435	60	return (*save = (char*)os::malloc(size));
duke@435	61	}
duke@435	62	#endif
duke@435	63	return (char*)Amalloc(size);
duke@435	64	}
duke@435	65
duke@435	66	debug_only(int nesting() const { return _nesting; });
duke@435	67	};
duke@435	68
duke@435	69
duke@435	70	//------------------------------ResourceMark-----------------------------------
duke@435	71	// A resource mark releases all resources allocated after it was constructed
duke@435	72	// when the destructor is called. Typically used as a local variable.
duke@435	73	class ResourceMark: public StackObj {
duke@435	74	protected:
duke@435	75	ResourceArea *_area; // Resource area to stack allocate
duke@435	76	Chunk *_chunk; // saved arena chunk
duke@435	77	char *_hwm, *_max;
duke@435	78	NOT_PRODUCT(size_t _size_in_bytes;)
duke@435	79
duke@435	80	void initialize(Thread *thread) {
duke@435	81	_area = thread->resource_area();
duke@435	82	_chunk = _area->_chunk;
duke@435	83	_hwm = _area->_hwm;
duke@435	84	_max= _area->_max;
duke@435	85	NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
duke@435	86	debug_only(_area->_nesting++;)
duke@435	87	assert( _area->_nesting > 0, "must stack allocate RMs" );
duke@435	88	}
duke@435	89
duke@435	90	public:
duke@435	91
duke@435	92	#ifndef ASSERT
duke@435	93	ResourceMark(Thread *thread) {
duke@435	94	assert(thread == Thread::current(), "not the current thread");
duke@435	95	initialize(thread);
duke@435	96	}
duke@435	97	#else
duke@435	98	ResourceMark(Thread *thread);
duke@435	99	#endif // ASSERT
duke@435	100
duke@435	101	ResourceMark() { initialize(Thread::current()); }
duke@435	102
duke@435	103	ResourceMark( ResourceArea *r ) :
duke@435	104	_area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
duke@435	105	NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
duke@435	106	debug_only(_area->_nesting++;)
duke@435	107	assert( _area->_nesting > 0, "must stack allocate RMs" );
duke@435	108	}
duke@435	109
duke@435	110	void reset_to_mark() {
duke@435	111	if (UseMallocOnly) free_malloced_objects();
duke@435	112
duke@435	113	if( _chunk->next() ) // Delete later chunks
duke@435	114	_chunk->next_chop();
duke@435	115	_area->_chunk = _chunk; // Roll back arena to saved chunk
duke@435	116	_area->_hwm = _hwm;
duke@435	117	_area->_max = _max;
duke@435	118
duke@435	119	// clear out this chunk (to detect allocation bugs)
duke@435	120	if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
duke@435	121	_area->set_size_in_bytes(size_in_bytes());
duke@435	122	}
duke@435	123
duke@435	124	~ResourceMark() {
duke@435	125	assert( _area->_nesting > 0, "must stack allocate RMs" );
duke@435	126	debug_only(_area->_nesting--;)
duke@435	127	reset_to_mark();
duke@435	128	}
duke@435	129
duke@435	130
duke@435	131	private:
duke@435	132	void free_malloced_objects() PRODUCT_RETURN;
duke@435	133	size_t size_in_bytes() NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0;
duke@435	134	};
duke@435	135
duke@435	136	//------------------------------DeoptResourceMark-----------------------------------
duke@435	137	// A deopt resource mark releases all resources allocated after it was constructed
duke@435	138	// when the destructor is called. Typically used as a local variable. It differs
duke@435	139	// from a typical resource more in that it is C-Heap allocated so that deoptimization
duke@435	140	// can use data structures that are arena based but are not amenable to vanilla
duke@435	141	// ResourceMarks because deoptimization can not use a stack allocated mark. During
duke@435	142	// deoptimization we go thru the following steps:
duke@435	143	//
duke@435	144	// 0: start in assembly stub and call either uncommon_trap/fetch_unroll_info
duke@435	145	// 1: create the vframeArray (contains pointers to Resource allocated structures)
duke@435	146	// This allocates the DeoptResourceMark.
duke@435	147	// 2: return to assembly stub and remove stub frame and deoptee frame and create
duke@435	148	// the new skeletal frames.
duke@435	149	// 3: push new stub frame and call unpack_frames
duke@435	150	// 4: retrieve information from the vframeArray to populate the skeletal frames
duke@435	151	// 5: release the DeoptResourceMark
duke@435	152	// 6: return to stub and eventually to interpreter
duke@435	153	//
duke@435	154	// With old style eager deoptimization the vframeArray was created by the vmThread there
duke@435	155	// was no way for the vframeArray to contain resource allocated objects and so
duke@435	156	// a complex set of data structures to simulate an array of vframes in CHeap memory
duke@435	157	// was used. With new style lazy deoptimization the vframeArray is created in the
duke@435	158	// the thread that will use it and we can use a much simpler scheme for the vframeArray
duke@435	159	// leveraging existing data structures if we simply create a way to manage this one
duke@435	160	// special need for a ResourceMark. If ResourceMark simply inherited from CHeapObj
duke@435	161	// then existing ResourceMarks would work fine since no one use new to allocate them
duke@435	162	// and they would be stack allocated. This leaves open the possibilty of accidental
duke@435	163	// misuse so we simple duplicate the ResourceMark functionality here.
duke@435	164
duke@435	165	class DeoptResourceMark: public CHeapObj {
duke@435	166	protected:
duke@435	167	ResourceArea *_area; // Resource area to stack allocate
duke@435	168	Chunk *_chunk; // saved arena chunk
duke@435	169	char *_hwm, *_max;
duke@435	170	NOT_PRODUCT(size_t _size_in_bytes;)
duke@435	171
duke@435	172	void initialize(Thread *thread) {
duke@435	173	_area = thread->resource_area();
duke@435	174	_chunk = _area->_chunk;
duke@435	175	_hwm = _area->_hwm;
duke@435	176	_max= _area->_max;
duke@435	177	NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
duke@435	178	debug_only(_area->_nesting++;)
duke@435	179	assert( _area->_nesting > 0, "must stack allocate RMs" );
duke@435	180	}
duke@435	181
duke@435	182	public:
duke@435	183
duke@435	184	#ifndef ASSERT
duke@435	185	DeoptResourceMark(Thread *thread) {
duke@435	186	assert(thread == Thread::current(), "not the current thread");
duke@435	187	initialize(thread);
duke@435	188	}
duke@435	189	#else
duke@435	190	DeoptResourceMark(Thread *thread);
duke@435	191	#endif // ASSERT
duke@435	192
duke@435	193	DeoptResourceMark() { initialize(Thread::current()); }
duke@435	194
duke@435	195	DeoptResourceMark( ResourceArea *r ) :
duke@435	196	_area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
duke@435	197	NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
duke@435	198	debug_only(_area->_nesting++;)
duke@435	199	assert( _area->_nesting > 0, "must stack allocate RMs" );
duke@435	200	}
duke@435	201
duke@435	202	void reset_to_mark() {
duke@435	203	if (UseMallocOnly) free_malloced_objects();
duke@435	204
duke@435	205	if( _chunk->next() ) // Delete later chunks
duke@435	206	_chunk->next_chop();
duke@435	207	_area->_chunk = _chunk; // Roll back arena to saved chunk
duke@435	208	_area->_hwm = _hwm;
duke@435	209	_area->_max = _max;
duke@435	210
duke@435	211	// clear out this chunk (to detect allocation bugs)
duke@435	212	if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
duke@435	213	_area->set_size_in_bytes(size_in_bytes());
duke@435	214	}
duke@435	215
duke@435	216	~DeoptResourceMark() {
duke@435	217	assert( _area->_nesting > 0, "must stack allocate RMs" );
duke@435	218	debug_only(_area->_nesting--;)
duke@435	219	reset_to_mark();
duke@435	220	}
duke@435	221
duke@435	222
duke@435	223	private:
duke@435	224	void free_malloced_objects() PRODUCT_RETURN;
duke@435	225	size_t size_in_bytes() NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0;
duke@435	226	};