truffle: src/share/vm/memory/metaspace.cpp comparison

comparison src/share/vm/memory/metaspace.cpp @ 10376:a1ebd310d5c1

8014912: Restore PrintSharedSpaces functionality after NPG Summary: Added dumping of object sizes in CDS archive, sorted by MetaspaceObj::Type Reviewed-by: coleenp, acorn

author	iklam
date	Tue, 28 May 2013 16:36:19 -0700
parents	2b1a9d972fc2
children	df7e1c0e3dc1 de2d15ce3d4a

comparison

equal deleted inserted replaced

-:9ea643afcaaf
+:a1ebd310d5c1
 void verify_chunk_size(Metachunk* chunk);
 NOT_PRODUCT(void mangle_freed_chunks();)
 #ifdef ASSERT
 void verify_allocated_blocks_words();
 #endif
+size_t get_raw_word_size(size_t word_size) {
+// If only the dictionary is going to be used (i.e., no
+// indexed free list), then there is a minimum size requirement.
+// MinChunkSize is a placeholder for the real minimum size JJJ
+size_t byte_size = word_size * BytesPerWord;
+size_t byte_size_with_overhead = byte_size + Metablock::overhead();
+size_t raw_bytes_size = MAX2(byte_size_with_overhead,
+Metablock::min_block_byte_size());
+raw_bytes_size = ARENA_ALIGN(raw_bytes_size);
+size_t raw_word_size = raw_bytes_size / BytesPerWord;
+assert(raw_word_size * BytesPerWord == raw_bytes_size, "Size problem");
+return raw_word_size;
+}
 };
 uint const SpaceManager::_small_chunk_limit = 4;
 const char* SpaceManager::_expand_lock_name =
 }
 MetaWord* SpaceManager::allocate(size_t word_size) {
 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
-// If only the dictionary is going to be used (i.e., no
+size_t raw_word_size = get_raw_word_size(word_size);
-// indexed free list), then there is a minimum size requirement.
-// MinChunkSize is a placeholder for the real minimum size JJJ
-size_t byte_size = word_size * BytesPerWord;
-size_t byte_size_with_overhead = byte_size + Metablock::overhead();
-size_t raw_bytes_size = MAX2(byte_size_with_overhead,
-Metablock::min_block_byte_size());
-raw_bytes_size = ARENA_ALIGN(raw_bytes_size);
-size_t raw_word_size = raw_bytes_size / BytesPerWord;
-assert(raw_word_size * BytesPerWord == raw_bytes_size, "Size problem");
 BlockFreelist* fl =  block_freelists();
 MetaWord* p = NULL;
 // Allocation from the dictionary is expensive in the sense that
 // the dictionary has to be searched for a size.  Don't allocate
 // from the dictionary until it starts to get fat.  Is this
 class_space_list()->get_initialization_chunk(class_word_size,
 class_vsm()->medium_chunk_bunch());
 if (class_chunk != NULL) {
 class_vsm()->add_chunk(class_chunk, true);
 }
+_alloc_record_head = NULL;
+_alloc_record_tail = NULL;
 }
 size_t Metaspace::align_word_size_up(size_t word_size) {
 size_t byte_size = word_size * wordSize;
 return ReservedSpace::allocation_align_size_up(byte_size) / wordSize;
 }
 }
 }
 Metablock* Metaspace::allocate(ClassLoaderData* loader_data, size_t word_size,
-bool read_only, MetadataType mdtype, TRAPS) {
+bool read_only, MetaspaceObj::Type type, TRAPS) {
 if (HAS_PENDING_EXCEPTION) {
 assert(false, "Should not allocate with exception pending");
 return NULL;  // caller does a CHECK_NULL too
 }
+MetadataType mdtype = (type == MetaspaceObj::ClassType) ? ClassType : NonClassType;
 // SSS: Should we align the allocations and make sure the sizes are aligned.
 MetaWord* result = NULL;
 assert(loader_data != NULL, "Should never pass around a NULL loader_data. "
 "ClassLoaderData::the_null_class_loader_data() should have been used.");
 // Allocate in metaspaces without taking out a lock, because it deadlocks
 // with the SymbolTable_lock.  Dumping is single threaded for now.  We'll have
 // to revisit this for application class data sharing.
 if (DumpSharedSpaces) {
-if (read_only) {
+assert(type > MetaspaceObj::UnknownType && type < MetaspaceObj::_number_of_types, "sanity");
-result = loader_data->ro_metaspace()->allocate(word_size, NonClassType);
+Metaspace* space = read_only ? loader_data->ro_metaspace() : loader_data->rw_metaspace();
-} else {
+result = space->allocate(word_size, NonClassType);
-result = loader_data->rw_metaspace()->allocate(word_size, NonClassType);
-}
 if (result == NULL) {
 report_out_of_shared_space(read_only ? SharedReadOnly : SharedReadWrite);
+} else {
+space->record_allocation(result, type, space->vsm()->get_raw_word_size(word_size));
 }
 return Metablock::initialize(result, word_size);
 }
 result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
 }
 }
 return Metablock::initialize(result, word_size);
 }
+void Metaspace::record_allocation(void* ptr, MetaspaceObj::Type type, size_t word_size) {
+assert(DumpSharedSpaces, "sanity");
+AllocRecord *rec = new AllocRecord((address)ptr, type, (int)word_size * HeapWordSize);
+if (_alloc_record_head == NULL) {
+_alloc_record_head = _alloc_record_tail = rec;
+} else {
+_alloc_record_tail->_next = rec;
+_alloc_record_tail = rec;
+}
+}
+void Metaspace::iterate(Metaspace::AllocRecordClosure *closure) {
+assert(DumpSharedSpaces, "unimplemented for !DumpSharedSpaces");
+address last_addr = (address)bottom();
+for (AllocRecord *rec = _alloc_record_head; rec; rec = rec->_next) {
+address ptr = rec->_ptr;
+if (last_addr < ptr) {
+closure->doit(last_addr, MetaspaceObj::UnknownType, ptr - last_addr);
+}
+closure->doit(ptr, rec->_type, rec->_byte_size);
+last_addr = ptr + rec->_byte_size;
+}
+address top = ((address)bottom()) + used_bytes_slow(Metaspace::NonClassType);
+if (last_addr < top) {
+closure->doit(last_addr, MetaspaceObj::UnknownType, top - last_addr);
+}
+}
 void Metaspace::purge() {
 MutexLockerEx cl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
 space_list()->purge();
 class_space_list()->purge();

Mercurial > hg > truffle

comparison src/share/vm/memory/metaspace.cpp @ 10376:a1ebd310d5c1