graal-jvmci-8: src/share/vm/memory/allocation.hpp comparison

comparison src/share/vm/memory/allocation.hpp @ 11173:6b0fd0964b87

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 31 Jul 2013 11:00:54 +0200
parents	836a62f43af9 cf9d71d3e474
children	cefad50507d8

comparison

equal deleted inserted replaced

-:4ea54634f03e
+:6b0fd0964b87
 class ClassLoaderData;
 class MetaspaceObj {
 public:
-bool is_metadata() const;
 bool is_metaspace_object() const;  // more specific test but slower
 bool is_shared() const;
 void print_address_on(outputStream* st) const;  // nonvirtual address printing
 #define METASPACE_OBJ_TYPES_DO(f) \
 protected:
 Chunk*       _next;     // Next Chunk in list
 const size_t _len;      // Size of this Chunk
 public:
-void* operator new(size_t size, size_t length);
+void* operator new(size_t size, AllocFailType alloc_failmode, size_t length);
 void  operator delete(void* p);
 Chunk(size_t length);
 enum {
 // default sizes; make them slightly smaller than 2**k to guard against
 //       a multiple of 8.
 #else
 slack      = 20,            // suspected sizeof(Chunk) + internal malloc headers
 #endif
-init_size  =  1*K  - slack, // Size of first chunk
+tiny_size  =  256  - slack, // Size of first chunk (tiny)
+init_size  =  1*K  - slack, // Size of first chunk (normal aka small)
 medium_size= 10*K  - slack, // Size of medium-sized chunk
 size       = 32*K  - slack, // Default size of an Arena chunk (following the first)
 non_pool_size = init_size + 32 // An initial size which is not one of above
 };
 debug_only(void* internal_malloc_4(size_t x);)
 NOT_PRODUCT(void inc_bytes_allocated(size_t x);)
 void signal_out_of_memory(size_t request, const char* whence) const;
-void check_for_overflow(size_t request, const char* whence) const {
+bool check_for_overflow(size_t request, const char* whence,
+AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) const {
 if (UINTPTR_MAX - request < (uintptr_t)_hwm) {
+if (alloc_failmode == AllocFailStrategy::RETURN_NULL) {
+return false;
+}
 signal_out_of_memory(request, whence);
 }
+return true;
 }
 public:
 Arena();
 Arena(size_t init_size);
 // Fast allocate in the arena.  Common case is: pointer test + increment.
 void* Amalloc(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
 assert(is_power_of_2(ARENA_AMALLOC_ALIGNMENT) , "should be a power of 2");
 x = ARENA_ALIGN(x);
 debug_only(if (UseMallocOnly) return malloc(x);)
-check_for_overflow(x, "Arena::Amalloc");
+if (!check_for_overflow(x, "Arena::Amalloc", alloc_failmode))
+return NULL;
 NOT_PRODUCT(inc_bytes_allocated(x);)
 if (_hwm + x > _max) {
 return grow(x, alloc_failmode);
 } else {
 char *old = _hwm;
 }
 // Further assume size is padded out to words
 void *Amalloc_4(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" );
 debug_only(if (UseMallocOnly) return malloc(x);)
-check_for_overflow(x, "Arena::Amalloc_4");
+if (!check_for_overflow(x, "Arena::Amalloc_4", alloc_failmode))
+return NULL;
 NOT_PRODUCT(inc_bytes_allocated(x);)
 if (_hwm + x > _max) {
 return grow(x, alloc_failmode);
 } else {
 char *old = _hwm;
 #if defined(SPARC) && !defined(_LP64)
 #define DALIGN_M1 7
 size_t delta = (((size_t)_hwm + DALIGN_M1) & ~DALIGN_M1) - (size_t)_hwm;
 x += delta;
 #endif
-check_for_overflow(x, "Arena::Amalloc_D");
+if (!check_for_overflow(x, "Arena::Amalloc_D", alloc_failmode))
+return NULL;
 NOT_PRODUCT(inc_bytes_allocated(x);)
 if (_hwm + x > _max) {
 return grow(x, alloc_failmode); // grow() returns a result aligned >= 8 bytes.
 } else {
 char *old = _hwm;
 (type*) resource_allocate_bytes((size) * sizeof(type), AllocFailStrategy::RETURN_NULL)
 #define NEW_RESOURCE_ARRAY_IN_THREAD(thread, type, size)\
 (type*) resource_allocate_bytes(thread, (size) * sizeof(type))
+#define NEW_RESOURCE_ARRAY_IN_THREAD_RETURN_NULL(thread, type, size)\
+(type*) resource_allocate_bytes(thread, (size) * sizeof(type), AllocFailStrategy::RETURN_NULL)
 #define REALLOC_RESOURCE_ARRAY(type, old, old_size, new_size)\
-(type*) resource_reallocate_bytes((char*)(old), (old_size) * sizeof(type), (new_size) * sizeof(type) )
+(type*) resource_reallocate_bytes((char*)(old), (old_size) * sizeof(type), (new_size) * sizeof(type))
+#define REALLOC_RESOURCE_ARRAY_RETURN_NULL(type, old, old_size, new_size)\
+(type*) resource_reallocate_bytes((char*)(old), (old_size) * sizeof(type),\
+(new_size) * sizeof(type), AllocFailStrategy::RETURN_NULL)
 #define FREE_RESOURCE_ARRAY(type, old, size)\
 resource_free_bytes((char*)(old), (size) * sizeof(type))
 #define FREE_FAST(old)\
 /* nop */
 #define NEW_RESOURCE_OBJ(type)\
 NEW_RESOURCE_ARRAY(type, 1)
+#define NEW_RESOURCE_OBJ_RETURN_NULL(type)\
+NEW_RESOURCE_ARRAY_RETURN_NULL(type, 1)
+#define NEW_C_HEAP_ARRAY3(type, size, memflags, pc, allocfail)\
+(type*) AllocateHeap(size * sizeof(type), memflags, pc, allocfail)
+#define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\
+(type*) (AllocateHeap((size) * sizeof(type), memflags, pc))
 #define NEW_C_HEAP_ARRAY(type, size, memflags)\
 (type*) (AllocateHeap((size) * sizeof(type), memflags))
+#define NEW_C_HEAP_ARRAY2_RETURN_NULL(type, size, memflags, pc)\
+NEW_C_HEAP_ARRAY3(type, size, memflags, pc, AllocFailStrategy::RETURN_NULL)
+#define NEW_C_HEAP_ARRAY_RETURN_NULL(type, size, memflags)\
+NEW_C_HEAP_ARRAY3(type, size, memflags, (address)0, AllocFailStrategy::RETURN_NULL)
 #define REALLOC_C_HEAP_ARRAY(type, old, size, memflags)\
 (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags))
+#define REALLOC_C_HEAP_ARRAY_RETURN_NULL(type, old, size, memflags)\
+(type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags, AllocFailStrategy::RETURN_NULL))
 #define FREE_C_HEAP_ARRAY(type, old, memflags) \
 FreeHeap((char*)(old), memflags)
-#define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\
-(type*) (AllocateHeap((size) * sizeof(type), memflags, pc))
-#define REALLOC_C_HEAP_ARRAY2(type, old, size, memflags, pc)\
-(type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags, pc))
-#define NEW_C_HEAP_ARRAY3(type, size, memflags, pc, allocfail)         \
-(type*) AllocateHeap(size * sizeof(type), memflags, pc, allocfail)
 // allocate type in heap without calling ctor
 #define NEW_C_HEAP_OBJ(type, memflags)\
 NEW_C_HEAP_ARRAY(type, 1, memflags)
+#define NEW_C_HEAP_OBJ_RETURN_NULL(type, memflags)\
+NEW_C_HEAP_ARRAY_RETURN_NULL(type, 1, memflags)
 // deallocate obj of type in heap without calling dtor
 #define FREE_C_HEAP_OBJ(objname, memflags)\
 FreeHeap((char*)objname, memflags);
 // Most OS mallocs do something similar but Solaris malloc does not revert
 // to mapped memory for large allocations. By default ArrayAllocatorMallocLimit
 // is set so that we always use malloc except for Solaris where we set the
 // limit to get mapped memory.
 template <class E, MEMFLAGS F>
-class ArrayAllocator : StackObj {
+class ArrayAllocator VALUE_OBJ_CLASS_SPEC {
 char* _addr;
 bool _use_malloc;
 size_t _size;
-public:
+bool _free_in_destructor;
-ArrayAllocator() : _addr(NULL), _use_malloc(false), _size(0) { }
+public:
-~ArrayAllocator() { free(); }
+ArrayAllocator(bool free_in_destructor = true) :
+_addr(NULL), _use_malloc(false), _size(0), _free_in_destructor(free_in_destructor) { }
+~ArrayAllocator() {
+if (_free_in_destructor) {
+free();
+}
+}
 E* allocate(size_t length);
 void free();
 };
 #endif // SHARE_VM_MEMORY_ALLOCATION_HPP

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/memory/allocation.hpp @ 11173:6b0fd0964b87