hotspot/src/share/vm/memory/resourceArea.hpp - platform/libcore - Git at Google

 /*
  * Copyright 1997-2003 Sun Microsystems, Inc.  All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  * CA 95054 USA or visit www.sun.com if you need additional information or
  * have any questions.
  *
  */

 // The resource area holds temporary data structures in the VM.
 // The actual allocation areas are thread local. Typical usage:
 //
 //   ...
 //   {
 //     ResourceMark rm;
 //     int foo[] = NEW_RESOURCE_ARRAY(int, 64);
 //     ...
 //   }
 //   ...

 //------------------------------ResourceArea-----------------------------------
 // A ResourceArea is an Arena that supports safe usage of ResourceMark.
 class ResourceArea: public Arena {
   friend class ResourceMark;
   friend class DeoptResourceMark;
   debug_only(int _nesting;)             // current # of nested ResourceMarks
   debug_only(static int _warned;)       // to suppress multiple warnings

 public:
   ResourceArea() {
     debug_only(_nesting = 0;)
   }

   ResourceArea(size_t init_size) : Arena(init_size) {
     debug_only(_nesting = 0;);
   }

   char* allocate_bytes(size_t size) {
 #ifdef ASSERT
     if (_nesting < 1 && !_warned++)
       fatal("memory leak: allocating without ResourceMark");
     if (UseMallocOnly) {
       // use malloc, but save pointer in res. area for later freeing
       char** save = (char**)internal_malloc_4(sizeof(char*));
       return (*save = (char*)os::malloc(size));
     }
 #endif
     return (char*)Amalloc(size);
   }

   debug_only(int nesting() const { return _nesting; });
 };


 //------------------------------ResourceMark-----------------------------------
 // A resource mark releases all resources allocated after it was constructed
 // when the destructor is called.  Typically used as a local variable.
 class ResourceMark: public StackObj {
 protected:
   ResourceArea *_area;          // Resource area to stack allocate
   Chunk *_chunk;                // saved arena chunk
   char *_hwm, *_max;
   NOT_PRODUCT(size_t _size_in_bytes;)

   void initialize(Thread *thread) {
     _area = thread->resource_area();
     _chunk = _area->_chunk;
     _hwm = _area->_hwm;
     _max= _area->_max;
     NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
     debug_only(_area->_nesting++;)
     assert( _area->_nesting > 0, "must stack allocate RMs" );
   }

  public:

 #ifndef ASSERT
   ResourceMark(Thread *thread) {
     assert(thread == Thread::current(), "not the current thread");
     initialize(thread);
   }
 #else
   ResourceMark(Thread *thread);
 #endif // ASSERT

   ResourceMark()               { initialize(Thread::current()); }

   ResourceMark( ResourceArea *r ) :
     _area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
     NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
     debug_only(_area->_nesting++;)
     assert( _area->_nesting > 0, "must stack allocate RMs" );
   }

   void reset_to_mark() {
     if (UseMallocOnly) free_malloced_objects();

     if( _chunk->next() )        // Delete later chunks
       _chunk->next_chop();
     _area->_chunk = _chunk;     // Roll back arena to saved chunk
     _area->_hwm = _hwm;
     _area->_max = _max;

     // clear out this chunk (to detect allocation bugs)
     if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
     _area->set_size_in_bytes(size_in_bytes());
   }

   ~ResourceMark() {
     assert( _area->_nesting > 0, "must stack allocate RMs" );
     debug_only(_area->_nesting--;)
     reset_to_mark();
   }


  private:
   void free_malloced_objects()                                         PRODUCT_RETURN;
   size_t size_in_bytes()       NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0;
 };

 //------------------------------DeoptResourceMark-----------------------------------
 // A deopt resource mark releases all resources allocated after it was constructed
 // when the destructor is called.  Typically used as a local variable. It differs
 // from a typical resource more in that it is C-Heap allocated so that deoptimization
 // can use data structures that are arena based but are not amenable to vanilla
 // ResourceMarks because deoptimization can not use a stack allocated mark. During
 // deoptimization we go thru the following steps:
 //
 // 0: start in assembly stub and call either uncommon_trap/fetch_unroll_info
 // 1: create the vframeArray (contains pointers to Resource allocated structures)
 //   This allocates the DeoptResourceMark.
 // 2: return to assembly stub and remove stub frame and deoptee frame and create
 //    the new skeletal frames.
 // 3: push new stub frame and call unpack_frames
 // 4: retrieve information from the vframeArray to populate the skeletal frames
 // 5: release the DeoptResourceMark
 // 6: return to stub and eventually to interpreter
 //
 // With old style eager deoptimization the vframeArray was created by the vmThread there
 // was no way for the vframeArray to contain resource allocated objects and so
 // a complex set of data structures to simulate an array of vframes in CHeap memory
 // was used. With new style lazy deoptimization the vframeArray is created in the
 // the thread that will use it and we can use a much simpler scheme for the vframeArray
 // leveraging existing data structures if we simply create a way to manage this one
 // special need for a ResourceMark. If ResourceMark simply inherited from CHeapObj
 // then existing ResourceMarks would work fine since no one use new to allocate them
 // and they would be stack allocated. This leaves open the possibilty of accidental
 // misuse so we simple duplicate the ResourceMark functionality here.

 class DeoptResourceMark: public CHeapObj {
 protected:
   ResourceArea *_area;          // Resource area to stack allocate
   Chunk *_chunk;                // saved arena chunk
   char *_hwm, *_max;
   NOT_PRODUCT(size_t _size_in_bytes;)

   void initialize(Thread *thread) {
     _area = thread->resource_area();
     _chunk = _area->_chunk;
     _hwm = _area->_hwm;
     _max= _area->_max;
     NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
     debug_only(_area->_nesting++;)
     assert( _area->_nesting > 0, "must stack allocate RMs" );
   }

  public:

 #ifndef ASSERT
   DeoptResourceMark(Thread *thread) {
     assert(thread == Thread::current(), "not the current thread");
     initialize(thread);
   }
 #else
   DeoptResourceMark(Thread *thread);
 #endif // ASSERT

   DeoptResourceMark()               { initialize(Thread::current()); }

   DeoptResourceMark( ResourceArea *r ) :
     _area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
     NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
     debug_only(_area->_nesting++;)
     assert( _area->_nesting > 0, "must stack allocate RMs" );
   }

   void reset_to_mark() {
     if (UseMallocOnly) free_malloced_objects();

     if( _chunk->next() )        // Delete later chunks
       _chunk->next_chop();
     _area->_chunk = _chunk;     // Roll back arena to saved chunk
     _area->_hwm = _hwm;
     _area->_max = _max;

     // clear out this chunk (to detect allocation bugs)
     if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
     _area->set_size_in_bytes(size_in_bytes());
   }

   ~DeoptResourceMark() {
     assert( _area->_nesting > 0, "must stack allocate RMs" );
     debug_only(_area->_nesting--;)
     reset_to_mark();
   }


  private:
   void free_malloced_objects()                                         PRODUCT_RETURN;
   size_t size_in_bytes()       NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0;
 };
	/*
	* Copyright 1997-2003 Sun Microsystems, Inc. All Rights Reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
	* CA 95054 USA or visit www.sun.com if you need additional information or
	* have any questions.
	*
	*/

	// The resource area holds temporary data structures in the VM.
	// The actual allocation areas are thread local. Typical usage:
	//
	// ...
	// {
	// ResourceMark rm;
	// int foo[] = NEW_RESOURCE_ARRAY(int, 64);
	// ...
	// }
	// ...

	//------------------------------ResourceArea-----------------------------------
	// A ResourceArea is an Arena that supports safe usage of ResourceMark.
	class ResourceArea: public Arena {
	friend class ResourceMark;
	friend class DeoptResourceMark;
	debug_only(int _nesting;) // current # of nested ResourceMarks
	debug_only(static int _warned;) // to suppress multiple warnings

	public:
	ResourceArea() {
	debug_only(_nesting = 0;)
	}

	ResourceArea(size_t init_size) : Arena(init_size) {
	debug_only(_nesting = 0;);
	}

	char* allocate_bytes(size_t size) {
	#ifdef ASSERT
	if (_nesting < 1 && !_warned++)
	fatal("memory leak: allocating without ResourceMark");
	if (UseMallocOnly) {
	// use malloc, but save pointer in res. area for later freeing
	char save = (char)internal_malloc_4(sizeof(char*));
	return (save = (char)os::malloc(size));
	}
	#endif
	return (char*)Amalloc(size);
	}

	debug_only(int nesting() const { return _nesting; });
	};


	//------------------------------ResourceMark-----------------------------------
	// A resource mark releases all resources allocated after it was constructed
	// when the destructor is called. Typically used as a local variable.
	class ResourceMark: public StackObj {
	protected:
	ResourceArea *_area; // Resource area to stack allocate
	Chunk *_chunk; // saved arena chunk
	char _hwm, _max;
	NOT_PRODUCT(size_t _size_in_bytes;)

	void initialize(Thread *thread) {
	_area = thread->resource_area();
	_chunk = _area->_chunk;
	_hwm = _area->_hwm;
	_max= _area->_max;
	NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
	debug_only(_area->_nesting++;)
	assert( _area->_nesting > 0, "must stack allocate RMs" );
	}

	public:

	#ifndef ASSERT
	ResourceMark(Thread *thread) {
	assert(thread == Thread::current(), "not the current thread");
	initialize(thread);
	}
	#else
	ResourceMark(Thread *thread);
	#endif // ASSERT

	ResourceMark() { initialize(Thread::current()); }

	ResourceMark( ResourceArea *r ) :
	_area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
	NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
	debug_only(_area->_nesting++;)
	assert( _area->_nesting > 0, "must stack allocate RMs" );
	}

	void reset_to_mark() {
	if (UseMallocOnly) free_malloced_objects();

	if( _chunk->next() ) // Delete later chunks
	_chunk->next_chop();
	_area->_chunk = _chunk; // Roll back arena to saved chunk
	_area->_hwm = _hwm;
	_area->_max = _max;

	// clear out this chunk (to detect allocation bugs)
	if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
	_area->set_size_in_bytes(size_in_bytes());
	}

	~ResourceMark() {
	assert( _area->_nesting > 0, "must stack allocate RMs" );
	debug_only(_area->_nesting--;)
	reset_to_mark();
	}


	private:
	void free_malloced_objects() PRODUCT_RETURN;
	size_t size_in_bytes() NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0;
	};

	//------------------------------DeoptResourceMark-----------------------------------
	// A deopt resource mark releases all resources allocated after it was constructed
	// when the destructor is called. Typically used as a local variable. It differs
	// from a typical resource more in that it is C-Heap allocated so that deoptimization
	// can use data structures that are arena based but are not amenable to vanilla
	// ResourceMarks because deoptimization can not use a stack allocated mark. During
	// deoptimization we go thru the following steps:
	//
	// 0: start in assembly stub and call either uncommon_trap/fetch_unroll_info
	// 1: create the vframeArray (contains pointers to Resource allocated structures)
	// This allocates the DeoptResourceMark.
	// 2: return to assembly stub and remove stub frame and deoptee frame and create
	// the new skeletal frames.
	// 3: push new stub frame and call unpack_frames
	// 4: retrieve information from the vframeArray to populate the skeletal frames
	// 5: release the DeoptResourceMark
	// 6: return to stub and eventually to interpreter
	//
	// With old style eager deoptimization the vframeArray was created by the vmThread there
	// was no way for the vframeArray to contain resource allocated objects and so
	// a complex set of data structures to simulate an array of vframes in CHeap memory
	// was used. With new style lazy deoptimization the vframeArray is created in the
	// the thread that will use it and we can use a much simpler scheme for the vframeArray
	// leveraging existing data structures if we simply create a way to manage this one
	// special need for a ResourceMark. If ResourceMark simply inherited from CHeapObj
	// then existing ResourceMarks would work fine since no one use new to allocate them
	// and they would be stack allocated. This leaves open the possibilty of accidental
	// misuse so we simple duplicate the ResourceMark functionality here.

	class DeoptResourceMark: public CHeapObj {
	protected:
	ResourceArea *_area; // Resource area to stack allocate
	Chunk *_chunk; // saved arena chunk
	char _hwm, _max;
	NOT_PRODUCT(size_t _size_in_bytes;)

	void initialize(Thread *thread) {
	_area = thread->resource_area();
	_chunk = _area->_chunk;
	_hwm = _area->_hwm;
	_max= _area->_max;
	NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
	debug_only(_area->_nesting++;)
	assert( _area->_nesting > 0, "must stack allocate RMs" );
	}

	public:

	#ifndef ASSERT
	DeoptResourceMark(Thread *thread) {
	assert(thread == Thread::current(), "not the current thread");
	initialize(thread);
	}
	#else
	DeoptResourceMark(Thread *thread);
	#endif // ASSERT

	DeoptResourceMark() { initialize(Thread::current()); }

	DeoptResourceMark( ResourceArea *r ) :
	_area(r), _chunk(r->_chunk), _hwm(r->_hwm), _max(r->_max) {
	NOT_PRODUCT(_size_in_bytes = _area->size_in_bytes();)
	debug_only(_area->_nesting++;)
	assert( _area->_nesting > 0, "must stack allocate RMs" );
	}

	void reset_to_mark() {
	if (UseMallocOnly) free_malloced_objects();

	if( _chunk->next() ) // Delete later chunks
	_chunk->next_chop();
	_area->_chunk = _chunk; // Roll back arena to saved chunk
	_area->_hwm = _hwm;
	_area->_max = _max;

	// clear out this chunk (to detect allocation bugs)
	if (ZapResourceArea) memset(_hwm, badResourceValue, _max - _hwm);
	_area->set_size_in_bytes(size_in_bytes());
	}

	~DeoptResourceMark() {
	assert( _area->_nesting > 0, "must stack allocate RMs" );
	debug_only(_area->_nesting--;)
	reset_to_mark();
	}


	private:
	void free_malloced_objects() PRODUCT_RETURN;
	size_t size_in_bytes() NOT_PRODUCT({ return _size_in_bytes; }) PRODUCT_RETURN0;
	};