graal-compiler: src/share/vm/memory/allocation.cpp comparison

comparison src/share/vm/memory/allocation.cpp @ 6197:d2a62e0f25eb

6995781: Native Memory Tracking (Phase 1) 7151532: DCmd for hotspot native memory tracking Summary: Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd Reviewed-by: acorn, coleenp, fparain

author	zgu
date	Thu, 28 Jun 2012 17:03:16 -0400
parents	f08d439fab8c
children	da91efe96a93

comparison

equal deleted inserted replaced

-:74533f63b116
+:d2a62e0f25eb
 #include "precompiled.hpp"
 #include "memory/allocation.hpp"
 #include "memory/allocation.inline.hpp"
 #include "memory/resourceArea.hpp"
+#include "runtime/atomic.hpp"
 #include "runtime/os.hpp"
 #include "runtime/task.hpp"
 #include "runtime/threadCritical.hpp"
+#include "services/memTracker.hpp"
 #include "utilities/ostream.hpp"
 #ifdef TARGET_OS_FAMILY_linux
 # include "os_linux.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_solaris
 # include "os_solaris.inline.hpp"
 # include "os_windows.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_bsd
 # include "os_bsd.inline.hpp"
 #endif
-void* CHeapObj::operator new(size_t size){
-return (void *) AllocateHeap(size, "CHeapObj-new");
-}
-void* CHeapObj::operator new (size_t size, const std::nothrow_t&  nothrow_constant) {
-char* p = (char*) os::malloc(size);
-#ifdef ASSERT
-if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p);
-#endif
-return p;
-}
-void CHeapObj::operator delete(void* p){
-FreeHeap(p);
-}
 void* StackObj::operator new(size_t size)  { ShouldNotCallThis(); return 0; };
 void  StackObj::operator delete(void* p)   { ShouldNotCallThis(); };
 void* _ValueObj::operator new(size_t size)  { ShouldNotCallThis(); return 0; };
 void  _ValueObj::operator delete(void* p)   { ShouldNotCallThis(); };
-void* ResourceObj::operator new(size_t size, allocation_type type) {
+void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) {
 address res;
 switch (type) {
 case C_HEAP:
-res = (address)AllocateHeap(size, "C_Heap: ResourceOBJ");
+res = (address)AllocateHeap(size, flags, CALLER_PC);
 DEBUG_ONLY(set_allocation_type(res, C_HEAP);)
 break;
 case RESOURCE_AREA:
 // new(size) sets allocation type RESOURCE_AREA.
 res = (address)operator new(size);
 //--------------------------------------------------------------------------------------
 // ChunkPool implementation
 // MT-safe pool of chunks to reduce malloc/free thrashing
 // NB: not using Mutex because pools are used before Threads are initialized
-class ChunkPool {
+class ChunkPool: public CHeapObj<mtInternal> {
 Chunk*       _first;        // first cached Chunk; its first word points to next chunk
 size_t       _num_chunks;   // number of unused chunks in pool
 size_t       _num_used;     // number of chunks currently checked out
 const size_t _size;         // size of each chunk (must be uniform)
 public:
 // All chunks in a ChunkPool has the same size
 ChunkPool(size_t size) : _size(size) { _first = NULL; _num_chunks = _num_used = 0; }
 // Allocate a new chunk from the pool (might expand the pool)
-void* allocate(size_t bytes) {
+_NOINLINE_ void* allocate(size_t bytes) {
 assert(bytes == _size, "bad size");
 void* p = NULL;
+// No VM lock can be taken inside ThreadCritical lock, so os::malloc
+// should be done outside ThreadCritical lock due to NMT
 { ThreadCritical tc;
 _num_used++;
 p = get_first();
-if (p == NULL) p = os::malloc(bytes);
+}
-}
+if (p == NULL) p = os::malloc(bytes, mtChunk, CURRENT_PC);
 if (p == NULL)
 vm_exit_out_of_memory(bytes, "ChunkPool::allocate");
 return p;
 }
 _num_chunks++;
 }
 // Prune the pool
 void free_all_but(size_t n) {
+Chunk* cur = NULL;
+Chunk* next;
+{
 // if we have more than n chunks, free all of them
 ThreadCritical tc;
 if (_num_chunks > n) {
 // free chunks at end of queue, for better locality
-Chunk* cur = _first;
+cur = _first;
 for (size_t i = 0; i < (n - 1) && cur != NULL; i++) cur = cur->next();
 if (cur != NULL) {
-Chunk* next = cur->next();
+next = cur->next();
 cur->set_next(NULL);
 cur = next;
-// Free all remaining chunks
+_num_chunks = n;
+}
+}
+}
+// Free all remaining chunks, outside of ThreadCritical
+// to avoid deadlock with NMT
 while(cur != NULL) {
 next = cur->next();
-os::free(cur);
+os::free(cur, mtChunk);
-_num_chunks--;
 cur = next;
 }
 }
-}
-}
 // Accessors to preallocated pool's
 static ChunkPool* large_pool()  { assert(_large_pool  != NULL, "must be initialized"); return _large_pool;  }
 static ChunkPool* medium_pool() { assert(_medium_pool != NULL, "must be initialized"); return _medium_pool; }
 static ChunkPool* small_pool()  { assert(_small_pool  != NULL, "must be initialized"); return _small_pool;  }
 switch (length) {
 case Chunk::size:        return ChunkPool::large_pool()->allocate(bytes);
 case Chunk::medium_size: return ChunkPool::medium_pool()->allocate(bytes);
 case Chunk::init_size:   return ChunkPool::small_pool()->allocate(bytes);
 default: {
-void *p =  os::malloc(bytes);
+void *p =  os::malloc(bytes, mtChunk, CALLER_PC);
 if (p == NULL)
 vm_exit_out_of_memory(bytes, "Chunk::new");
 return p;
 }
 }
 Chunk* c = (Chunk*)p;
 switch (c->length()) {
 case Chunk::size:        ChunkPool::large_pool()->free(c); break;
 case Chunk::medium_size: ChunkPool::medium_pool()->free(c); break;
 case Chunk::init_size:   ChunkPool::small_pool()->free(c); break;
-default:                 os::free(c);
+default:                 os::free(c, mtChunk);
 }
 }
 Chunk::Chunk(size_t length) : _len(length) {
 _next = NULL;         // Chain on the linked list
 ChunkPoolCleaner* cleaner = new ChunkPoolCleaner();
 cleaner->enroll();
 }
 //------------------------------Arena------------------------------------------
+NOT_PRODUCT(volatile jint Arena::_instance_count = 0;)
 Arena::Arena(size_t init_size) {
 size_t round_size = (sizeof (char *)) - 1;
 init_size = (init_size+round_size) & ~round_size;
 _first = _chunk = new (init_size) Chunk(init_size);
 _hwm = _chunk->bottom();      // Save the cached hwm, max
 _max = _chunk->top();
 set_size_in_bytes(init_size);
+NOT_PRODUCT(Atomic::inc(&_instance_count);)
 }
 Arena::Arena() {
 _first = _chunk = new (Chunk::init_size) Chunk(Chunk::init_size);
 _hwm = _chunk->bottom();      // Save the cached hwm, max
 _max = _chunk->top();
 set_size_in_bytes(Chunk::init_size);
+NOT_PRODUCT(Atomic::inc(&_instance_count);)
 }
 Arena::Arena(Arena *a) : _chunk(a->_chunk), _hwm(a->_hwm), _max(a->_max), _first(a->_first) {
 set_size_in_bytes(a->size_in_bytes());
-}
+NOT_PRODUCT(Atomic::inc(&_instance_count);)
+}
 Arena *Arena::move_contents(Arena *copy) {
 copy->destruct_contents();
 copy->_chunk = _chunk;
 copy->_hwm   = _hwm;
 return copy;            // Return Arena with contents
 }
 Arena::~Arena() {
 destruct_contents();
+NOT_PRODUCT(Atomic::dec(&_instance_count);)
+}
+void* Arena::operator new(size_t size) {
+assert(false, "Use dynamic memory type binding");
+return NULL;
+}
+void* Arena::operator new (size_t size, const std::nothrow_t&  nothrow_constant) {
+assert(false, "Use dynamic memory type binding");
+return NULL;
+}
+// dynamic memory type binding
+void* Arena::operator new(size_t size, MEMFLAGS flags) {
+#ifdef ASSERT
+void* p = (void*)AllocateHeap(size, flags|otArena, CALLER_PC);
+if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p);
+return p;
+#else
+return (void *) AllocateHeap(size, flags|otArena, CALLER_PC);
+#endif
+}
+void* Arena::operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags) {
+#ifdef ASSERT
+void* p = os::malloc(size, flags|otArena, CALLER_PC);
+if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p);
+return p;
+#else
+return os::malloc(size, flags|otArena, CALLER_PC);
+#endif
+}
+void Arena::operator delete(void* p) {
+FreeHeap(p);
 }
 // Destroy this arenas contents and reset to empty
 void Arena::destruct_contents() {
 if (UseMallocOnly && _first != NULL) {
 }
 _first->chop();
 reset();
 }
+// This is high traffic method, but many calls actually don't
+// change the size
+void Arena::set_size_in_bytes(size_t size) {
+if (_size_in_bytes != size) {
+_size_in_bytes = size;
+MemTracker::record_arena_size((address)this, size);
+}
+}
 // Total of all Chunks in arena
 size_t Arena::used() const {
 size_t sum = _chunk->length() - (_max-_hwm); // Size leftover in this Chunk
 register Chunk *k = _first;
 _chunk = new (len) Chunk(len);
 if (_chunk == NULL) {
 signal_out_of_memory(len * Chunk::aligned_overhead_size(), "Arena::grow");
 }
 if (k) k->set_next(_chunk);   // Append new chunk to end of linked list
 else _first = _chunk;
 _hwm  = _chunk->bottom();     // Save the cached hwm, max
 _max =  _chunk->top();
 set_size_in_bytes(size_in_bytes() + len);
 #ifdef ASSERT
 void* Arena::malloc(size_t size) {
 assert(UseMallocOnly, "shouldn't call");
 // 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));
+return (*save = (char*)os::malloc(size, mtChunk));
 }
 // for debugging with UseMallocOnly
 void* Arena::internal_malloc_4(size_t x) {
 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" );

Mercurial > hg > graal-compiler

comparison src/share/vm/memory/allocation.cpp @ 6197:d2a62e0f25eb