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

comparison src/share/vm/memory/metaspace.cpp @ 12873:4e7f99b70d9d

Merge

author	adlertz
date	Wed, 09 Oct 2013 05:03:34 -0700
parents	bc918fd1e584
children	85c1ca43713f

comparison

equal deleted inserted replaced

-:98692a2d36d7
+:4e7f99b70d9d
 * questions.
 *
 */
 #include "precompiled.hpp"
 #include "gc_interface/collectedHeap.hpp"
+#include "memory/allocation.hpp"
 #include "memory/binaryTreeDictionary.hpp"
 #include "memory/freeList.hpp"
 #include "memory/collectorPolicy.hpp"
 #include "memory/filemap.hpp"
 #include "memory/freeList.hpp"
 // Manages the global free lists of chunks.
 // Has three lists of free chunks, and a total size and
 // count that includes all three
-class ChunkManager VALUE_OBJ_CLASS_SPEC {
+class ChunkManager : public CHeapObj<mtInternal> {
 // Free list of chunks of different sizes.
 //   SpecializedChunk
 //   SmallChunk
 //   MediumChunk
 }
 void verify_free_chunks_count();
 public:
-ChunkManager() : _free_chunks_total(0), _free_chunks_count(0) {}
+ChunkManager(size_t specialized_size, size_t small_size, size_t medium_size)
+: _free_chunks_total(0), _free_chunks_count(0) {
+_free_chunks[SpecializedIndex].set_size(specialized_size);
+_free_chunks[SmallIndex].set_size(small_size);
+_free_chunks[MediumIndex].set_size(medium_size);
+}
 // add or delete (return) a chunk to the global freelist.
 Metachunk* chunk_freelist_allocate(size_t word_size);
 void chunk_freelist_deallocate(Metachunk* chunk);
 void verify_free_chunks_total();
 void locked_print_free_chunks(outputStream* st);
 void locked_print_sum_free_chunks(outputStream* st);
-void print_on(outputStream* st);
+void print_on(outputStream* st) const;
 };
 // Used to manage the free list of Metablocks (a block corresponds
 // to the allocation of a quantum of metadata).
 class BlockFreelist VALUE_OBJ_CLASS_SPEC {
 // The first Metachunk will be allocated at the bottom of the
 // VirtualSpace
 Metachunk* first_chunk() { return (Metachunk*) bottom(); }
-void inc_container_count();
-#ifdef ASSERT
-uint container_count_slow();
-#endif
 public:
 VirtualSpaceNode(size_t byte_size);
 VirtualSpaceNode(ReservedSpace rs) : _top(NULL), _next(NULL), _rs(rs), _container_count(0) {}
 ~VirtualSpaceNode();
 MetaWord* top() const { return _top; }
 void inc_top(size_t word_size) { _top += word_size; }
 uintx container_count() { return _container_count; }
+void inc_container_count();
 void dec_container_count();
 #ifdef ASSERT
+uint container_count_slow();
 void verify_container_count();
 #endif
 // used and capacity in this single entry in the list
 size_t used_words_in_vs() const;
 // Global list of virtual spaces
 // Head of the list
 VirtualSpaceNode* _virtual_space_list;
 // virtual space currently being used for allocations
 VirtualSpaceNode* _current_virtual_space;
-// Free chunk list for all other metadata
-ChunkManager      _chunk_manager;
 // Can this virtual list allocate >1 spaces?  Also, used to determine
 // whether to allocate unlimited small chunks in this virtual space
 bool _is_class;
 bool can_grow() const { return !is_class() || !UseCompressedClassPointers; }
 VirtualSpaceNode* current_virtual_space() {
 return _current_virtual_space;
 }
-ChunkManager* chunk_manager() { return &_chunk_manager; }
 bool is_class() const { return _is_class; }
 // Allocate the first virtualspace.
 void initialize(size_t word_size);
 void dec_committed_words(size_t v);
 void inc_virtual_space_count();
 void dec_virtual_space_count();
 // Unlink empty VirtualSpaceNodes and free it.
-void purge();
+void purge(ChunkManager* chunk_manager);
-// Used and capacity in the entire list of virtual spaces.
-// These are global values shared by all Metaspaces
-size_t capacity_words_sum();
-size_t capacity_bytes_sum() { return capacity_words_sum() * BytesPerWord; }
-size_t used_words_sum();
-size_t used_bytes_sum() { return used_words_sum() * BytesPerWord; }
 bool contains(const void *ptr);
 void print_on(outputStream* st) const;
 Mutex* const _lock;
 // Type of metadata allocated.
 Metaspace::MetadataType _mdtype;
-// Chunk related size
-size_t _medium_chunk_bunch;
 // List of chunks in use by this SpaceManager.  Allocations
 // are done from the current chunk.  The list is used for deallocating
 // chunks when the SpaceManager is freed.
 Metachunk* _chunks_in_use[NumberOfInUseLists];
 Metachunk* _current_chunk;
-// Virtual space where allocation comes from.
-VirtualSpaceList* _vs_list;
 // Number of small chunks to allocate to a manager
 // If class space manager, small chunks are unlimited
 static uint const _small_chunk_limit;
 // Sum of all space in allocated chunks
 BlockFreelist* block_freelists() const {
 return (BlockFreelist*) &_block_freelists;
 }
 Metaspace::MetadataType mdtype() { return _mdtype; }
-VirtualSpaceList* vs_list() const    { return _vs_list; }
+VirtualSpaceList* vs_list()   const { return Metaspace::get_space_list(_mdtype); }
+ChunkManager* chunk_manager() const { return Metaspace::get_chunk_manager(_mdtype); }
 Metachunk* current_chunk() const { return _current_chunk; }
 void set_current_chunk(Metachunk* v) {
 _current_chunk = v;
 }
 protected:
 void initialize();
 public:
 SpaceManager(Metaspace::MetadataType mdtype,
-Mutex* lock,
+Mutex* lock);
-VirtualSpaceList* vs_list);
 ~SpaceManager();
 enum ChunkMultiples {
 MediumChunkMultiple = 4
 };
+bool is_class() { return _mdtype == Metaspace::ClassType; }
 // Accessors
 size_t specialized_chunk_size() { return SpecializedChunk; }
-size_t small_chunk_size() { return (size_t) vs_list()->is_class() ? ClassSmallChunk : SmallChunk; }
+size_t small_chunk_size() { return (size_t) is_class() ? ClassSmallChunk : SmallChunk; }
-size_t medium_chunk_size() { return (size_t) vs_list()->is_class() ? ClassMediumChunk : MediumChunk; }
+size_t medium_chunk_size() { return (size_t) is_class() ? ClassMediumChunk : MediumChunk; }
 size_t medium_chunk_bunch() { return medium_chunk_size() * MediumChunkMultiple; }
 size_t allocated_blocks_words() const { return _allocated_blocks_words; }
 size_t allocated_blocks_bytes() const { return _allocated_blocks_words * BytesPerWord; }
 size_t allocated_chunks_words() const { return _allocated_chunks_words; }
 void VirtualSpaceNode::inc_container_count() {
 assert_lock_strong(SpaceManager::expand_lock());
 _container_count++;
 assert(_container_count == container_count_slow(),
 err_msg("Inconsistency in countainer_count _container_count " SIZE_FORMAT
-"container_count_slow() " SIZE_FORMAT,
+" container_count_slow() " SIZE_FORMAT,
 _container_count, container_count_slow()));
 }
 void VirtualSpaceNode::dec_container_count() {
 assert_lock_strong(SpaceManager::expand_lock());
 #ifdef ASSERT
 void VirtualSpaceNode::verify_container_count() {
 assert(_container_count == container_count_slow(),
 err_msg("Inconsistency in countainer_count _container_count " SIZE_FORMAT
-"container_count_slow() " SIZE_FORMAT, _container_count, container_count_slow()));
+" container_count_slow() " SIZE_FORMAT, _container_count, container_count_slow()));
 }
 #endif
 // BlockFreelist methods
 }
 // Walk the list of VirtualSpaceNodes and delete
 // nodes with a 0 container_count.  Remove Metachunks in
 // the node from their respective freelists.
-void VirtualSpaceList::purge() {
+void VirtualSpaceList::purge(ChunkManager* chunk_manager) {
 assert_lock_strong(SpaceManager::expand_lock());
 // Don't use a VirtualSpaceListIterator because this
 // list is being changed and a straightforward use of an iterator is not safe.
 VirtualSpaceNode* purged_vsl = NULL;
 VirtualSpaceNode* prev_vsl = virtual_space_list();
 set_virtual_space_list(vsl->next());
 } else {
 prev_vsl->set_next(vsl->next());
 }
-vsl->purge(chunk_manager());
+vsl->purge(chunk_manager);
 dec_reserved_words(vsl->reserved_words());
 dec_committed_words(vsl->committed_words());
 dec_virtual_space_count();
 purged_vsl = vsl;
 delete vsl;
 VirtualSpaceNode* vsl = iter.get_next();
 assert(vsl != purged_vsl, "Purge of vsl failed");
 }
 }
 #endif
-}
-size_t VirtualSpaceList::used_words_sum() {
-size_t allocated_by_vs = 0;
-VirtualSpaceListIterator iter(virtual_space_list());
-while (iter.repeat()) {
-VirtualSpaceNode* vsl = iter.get_next();
-// Sum used region [bottom, top) in each virtualspace
-allocated_by_vs += vsl->used_words_in_vs();
-}
-assert(allocated_by_vs >= chunk_manager()->free_chunks_total_words(),
-err_msg("Total in free chunks " SIZE_FORMAT
-" greater than total from virtual_spaces " SIZE_FORMAT,
-allocated_by_vs, chunk_manager()->free_chunks_total_words()));
-size_t used =
-allocated_by_vs - chunk_manager()->free_chunks_total_words();
-return used;
-}
-// Space available in all MetadataVirtualspaces allocated
-// for metadata.  This is the upper limit on the capacity
-// of chunks allocated out of all the MetadataVirtualspaces.
-size_t VirtualSpaceList::capacity_words_sum() {
-size_t capacity = 0;
-VirtualSpaceListIterator iter(virtual_space_list());
-while (iter.repeat()) {
-VirtualSpaceNode* vsl = iter.get_next();
-capacity += vsl->capacity_words_in_vs();
-}
-return capacity;
 }
 VirtualSpaceList::VirtualSpaceList(size_t word_size ) :
 _is_class(false),
 _virtual_space_list(NULL),
 _committed_words(0),
 _virtual_space_count(0) {
 MutexLockerEx cl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
 bool initialization_succeeded = grow_vs(word_size);
-_chunk_manager.free_chunks(SpecializedIndex)->set_size(SpecializedChunk);
-_chunk_manager.free_chunks(SmallIndex)->set_size(SmallChunk);
-_chunk_manager.free_chunks(MediumIndex)->set_size(MediumChunk);
 assert(initialization_succeeded,
 " VirtualSpaceList initialization should not fail");
 }
 VirtualSpaceList::VirtualSpaceList(ReservedSpace rs) :
 _virtual_space_count(0) {
 MutexLockerEx cl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
 VirtualSpaceNode* class_entry = new VirtualSpaceNode(rs);
 bool succeeded = class_entry->initialize();
-_chunk_manager.free_chunks(SpecializedIndex)->set_size(SpecializedChunk);
-_chunk_manager.free_chunks(SmallIndex)->set_size(ClassSmallChunk);
-_chunk_manager.free_chunks(MediumIndex)->set_size(ClassMediumChunk);
 assert(succeeded, " VirtualSpaceList initialization should not fail");
 link_vs(class_entry);
 }
 size_t VirtualSpaceList::free_bytes() {
 if (vs_word_size == 0) {
 return false;
 }
 // Reserve the space
 size_t vs_byte_size = vs_word_size * BytesPerWord;
-assert(vs_byte_size % os::vm_page_size() == 0, "Not aligned");
+assert(vs_byte_size % os::vm_allocation_granularity() == 0, "Not aligned");
 // Allocate the meta virtual space and initialize it.
 VirtualSpaceNode* new_entry = new VirtualSpaceNode(vs_byte_size);
 if (!new_entry->initialize()) {
 delete new_entry;
 Metachunk* VirtualSpaceList::get_new_chunk(size_t word_size,
 size_t grow_chunks_by_words,
 size_t medium_chunk_bunch) {
-// Get a chunk from the chunk freelist
+// Allocate a chunk out of the current virtual space.
-Metachunk* next = chunk_manager()->chunk_freelist_allocate(grow_chunks_by_words);
+Metachunk* next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
-if (next != NULL) {
-next->container()->inc_container_count();
-} else {
-// Allocate a chunk out of the current virtual space.
-next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
-}
 if (next == NULL) {
 // Not enough room in current virtual space.  Try to commit
 // more space.
 size_t expand_vs_by_words = MAX2(medium_chunk_bunch,
 // Should the capacity of the metaspaces be expanded for
 // this allocation?  If it's the virtual space for classes and is
 // being used for CompressedHeaders, don't allocate a new virtualspace.
 if (can_grow() && MetaspaceGC::should_expand(this, word_size)) {
 // Get another virtual space.
-size_t grow_vs_words =
+size_t allocation_aligned_expand_words =
-MAX2((size_t)VirtualSpaceSize, aligned_expand_vs_by_words);
+align_size_up(aligned_expand_vs_by_words, os::vm_allocation_granularity() / BytesPerWord);
+size_t grow_vs_words =
+MAX2((size_t)VirtualSpaceSize, allocation_aligned_expand_words);
 if (grow_vs(grow_vs_words)) {
 // Got it.  It's on the list now.  Get a chunk from it.
 assert(current_virtual_space()->expanded_words() == 0,
-"New virtuals space nodes should not have expanded");
+"New virtual space nodes should not have expanded");
 size_t grow_chunks_by_words_aligned = align_size_up(grow_chunks_by_words,
 page_size_words);
 // We probably want to expand by aligned_expand_vs_by_words here.
 expand_by(current_virtual_space(), grow_chunks_by_words_aligned);
 // for non-class virtual space, compare against virtual spaces that are reserved.
 // For class virtual space, we only compare against the committed space, not
 // reserved space, because this is a larger space prereserved for compressed
 // class pointers.
 if (!FLAG_IS_DEFAULT(MaxMetaspaceSize)) {
-size_t real_allocated = Metaspace::space_list()->reserved_words() +
+size_t nonclass_allocated = MetaspaceAux::reserved_bytes(Metaspace::NonClassType);
-MetaspaceAux::allocated_capacity_bytes(Metaspace::ClassType);
+size_t class_allocated    = MetaspaceAux::allocated_capacity_bytes(Metaspace::ClassType);
+size_t real_allocated     = nonclass_allocated + class_allocated;
 if (real_allocated >= MaxMetaspaceSize) {
 return false;
 }
 }
 for (uint i = 0; i < metadata_deallocate_a_lock_chunk; i++) {
 Metachunk* dummy_chunk = vsl->current_virtual_space()->take_from_committed(chunk_word_size);
 if (dummy_chunk == NULL) {
 break;
 }
-vsl->chunk_manager()->chunk_freelist_deallocate(dummy_chunk);
+sm->chunk_manager()->chunk_freelist_deallocate(dummy_chunk);
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print("Metadebug::deallocate_chunk_a_lot: %d) ",
 sm->sum_count_in_chunks_in_use());
 dummy_chunk->print_on(gclog_or_tty);
 gclog_or_tty->print_cr("  Free chunks total %d  count %d",
-vsl->chunk_manager()->free_chunks_total_words(),
+sm->chunk_manager()->free_chunks_total_words(),
-vsl->chunk_manager()->free_chunks_count());
+sm->chunk_manager()->free_chunks_count());
 }
 }
 } else {
 Metadebug::inc_deallocate_chunk_a_lot_count();
 }
 #ifdef ASSERT
 // Chunk is no longer on any freelist. Setting to false make container_count_slow()
 // work.
 chunk->set_is_free(false);
 #endif
+chunk->container()->inc_container_count();
 slow_locked_verify();
 return chunk;
 }
 Metachunk* ChunkManager::chunk_freelist_allocate(size_t word_size) {
 }
 return chunk;
 }
-void ChunkManager::print_on(outputStream* out) {
+void ChunkManager::print_on(outputStream* out) const {
 if (PrintFLSStatistics != 0) {
-humongous_dictionary()->report_statistics();
+const_cast<ChunkManager *>(this)->humongous_dictionary()->report_statistics();
 }
 }
 // SpaceManager methods
 } else {
 st->print_cr("");
 }
 }
-vs_list()->chunk_manager()->locked_print_free_chunks(st);
+chunk_manager()->locked_print_free_chunks(st);
-vs_list()->chunk_manager()->locked_print_sum_free_chunks(st);
+chunk_manager()->locked_print_sum_free_chunks(st);
 }
 size_t SpaceManager::calc_chunk_size(size_t word_size) {
 // Decide between a small chunk and a medium chunk.  Up to
 block_freelists()->total_size());
 }
 }
 SpaceManager::SpaceManager(Metaspace::MetadataType mdtype,
-Mutex* lock,
+Mutex* lock) :
-VirtualSpaceList* vs_list) :
-_vs_list(vs_list),
 _mdtype(mdtype),
 _allocated_blocks_words(0),
 _allocated_chunks_words(0),
 _allocated_chunks_count(0),
 _lock(lock)
 sum_capacity_in_chunks_in_use(), allocated_chunks_words()));
 MutexLockerEx fcl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
-ChunkManager* chunk_manager = vs_list()->chunk_manager();
+chunk_manager()->slow_locked_verify();
-chunk_manager->slow_locked_verify();
 dec_total_from_size_metrics();
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, this);
 // Do not mangle freed Metachunks.  The chunk size inside Metachunks
 // is during the freeing of a VirtualSpaceNodes.
 // Have to update before the chunks_in_use lists are emptied
 // below.
-chunk_manager->inc_free_chunks_total(allocated_chunks_words(),
+chunk_manager()->inc_free_chunks_total(allocated_chunks_words(),
 sum_count_in_chunks_in_use());
 // Add all the chunks in use by this space manager
 // to the global list of free chunks.
 // Follow each list of chunks-in-use and add them to the
 gclog_or_tty->print_cr("returned %d %s chunks to freelist",
 sum_count_in_chunks_in_use(i),
 chunk_size_name(i));
 }
 Metachunk* chunks = chunks_in_use(i);
-chunk_manager->return_chunks(i, chunks);
+chunk_manager()->return_chunks(i, chunks);
 set_chunks_in_use(i, NULL);
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print_cr("updated freelist count %d %s",
-chunk_manager->free_chunks(i)->count(),
+chunk_manager()->free_chunks(i)->count(),
 chunk_size_name(i));
 }
 assert(i != HumongousIndex, "Humongous chunks are handled explicitly later");
 }
 err_msg("Humongous chunk size is wrong: word size " SIZE_FORMAT
 " granularity %d",
 humongous_chunks->word_size(), HumongousChunkGranularity));
 Metachunk* next_humongous_chunks = humongous_chunks->next();
 humongous_chunks->container()->dec_container_count();
-chunk_manager->humongous_dictionary()->return_chunk(humongous_chunks);
+chunk_manager()->humongous_dictionary()->return_chunk(humongous_chunks);
 humongous_chunks = next_humongous_chunks;
 }
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print_cr("");
 gclog_or_tty->print_cr("updated dictionary count %d %s",
-chunk_manager->humongous_dictionary()->total_count(),
+chunk_manager()->humongous_dictionary()->total_count(),
 chunk_size_name(HumongousIndex));
 }
-chunk_manager->slow_locked_verify();
+chunk_manager()->slow_locked_verify();
 }
 const char* SpaceManager::chunk_size_name(ChunkIndex index) const {
 switch (index) {
 case SpecializedIndex:
 assert(new_chunk->is_empty(), "Not ready for reuse");
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print("SpaceManager::add_chunk: %d) ",
 sum_count_in_chunks_in_use());
 new_chunk->print_on(gclog_or_tty);
-if (vs_list() != NULL) {
+chunk_manager()->locked_print_free_chunks(gclog_or_tty);
-vs_list()->chunk_manager()->locked_print_free_chunks(gclog_or_tty);
-}
 }
 }
 void SpaceManager::retire_current_chunk() {
 if (current_chunk() != NULL) {
 }
 }
 Metachunk* SpaceManager::get_new_chunk(size_t word_size,
 size_t grow_chunks_by_words) {
+// Get a chunk from the chunk freelist
-Metachunk* next = vs_list()->get_new_chunk(word_size,
+Metachunk* next = chunk_manager()->chunk_freelist_allocate(grow_chunks_by_words);
-grow_chunks_by_words,
-medium_chunk_bunch());
+if (next == NULL) {
+next = vs_list()->get_new_chunk(word_size,
+grow_chunks_by_words,
+medium_chunk_bunch());
+}
 if (TraceMetadataHumongousAllocation && next != NULL &&
 SpaceManager::is_humongous(next->word_size())) {
 gclog_or_tty->print_cr("  new humongous chunk word size "
 PTR_FORMAT, next->word_size());
 }
 size_t MetaspaceAux::min_chunk_size_words() { return Metaspace::first_chunk_word_size(); }
 size_t MetaspaceAux::free_chunks_total_words(Metaspace::MetadataType mdtype) {
-VirtualSpaceList* list = Metaspace::get_space_list(mdtype);
+ChunkManager* chunk_manager = Metaspace::get_chunk_manager(mdtype);
-if (list == NULL) {
+if (chunk_manager == NULL) {
 return 0;
 }
-ChunkManager* chunk = list->chunk_manager();
+chunk_manager->slow_verify();
-chunk->slow_verify();
+return chunk_manager->free_chunks_total_words();
-return chunk->free_chunks_total_words();
 }
 size_t MetaspaceAux::free_chunks_total_bytes(Metaspace::MetadataType mdtype) {
 return free_chunks_total_words(mdtype) * BytesPerWord;
 }
 out->print("class space: "); print_on(out, Metaspace::ClassType);
 print_waste(out);
 }
 void MetaspaceAux::verify_free_chunks() {
-Metaspace::space_list()->chunk_manager()->verify();
+Metaspace::chunk_manager_metadata()->verify();
 if (Metaspace::using_class_space()) {
-Metaspace::class_space_list()->chunk_manager()->verify();
+Metaspace::chunk_manager_class()->verify();
 }
 }
 void MetaspaceAux::verify_capacity() {
 #ifdef ASSERT
 }
 VirtualSpaceList* Metaspace::_space_list = NULL;
 VirtualSpaceList* Metaspace::_class_space_list = NULL;
+ChunkManager* Metaspace::_chunk_manager_metadata = NULL;
+ChunkManager* Metaspace::_chunk_manager_class = NULL;
 #define VIRTUALSPACEMULTIPLIER 2
 #ifdef _LP64
 void Metaspace::set_narrow_klass_base_and_shift(address metaspace_base, address cds_base) {
 // Figure out the narrow_klass_base and the narrow_klass_shift.  The
 // The reserved space size may be bigger because of alignment, esp with UseLargePages
 assert(rs.size() >= CompressedClassSpaceSize,
 err_msg(SIZE_FORMAT " != " UINTX_FORMAT, rs.size(), CompressedClassSpaceSize));
 assert(using_class_space(), "Must be using class space");
 _class_space_list = new VirtualSpaceList(rs);
+_chunk_manager_class = new ChunkManager(SpecializedChunk, ClassSmallChunk, ClassMediumChunk);
 }
 #endif
 void Metaspace::global_initialize() {
 // Initialize with the sum of the shared space sizes.  The read-only
 // and read write metaspace chunks will be allocated out of this and the
 // remainder is the misc code and data chunks.
 cds_total = FileMapInfo::shared_spaces_size();
 _space_list = new VirtualSpaceList(cds_total/wordSize);
+_chunk_manager_metadata = new ChunkManager(SpecializedChunk, SmallChunk, MediumChunk);
 #ifdef _LP64
 // Set the compressed klass pointer base so that decoding of these pointers works
 // properly when creating the shared archive.
 assert(UseCompressedOops && UseCompressedClassPointers,
 // Arbitrarily set the initial virtual space to a multiple
 // of the boot class loader size.
 size_t word_size = VIRTUALSPACEMULTIPLIER * first_chunk_word_size();
 // Initialize the list of virtual spaces.
 _space_list = new VirtualSpaceList(word_size);
-}
+_chunk_manager_metadata = new ChunkManager(SpecializedChunk, SmallChunk, MediumChunk);
+}
+}
+Metachunk* Metaspace::get_initialization_chunk(MetadataType mdtype,
+size_t chunk_word_size,
+size_t chunk_bunch) {
+// Get a chunk from the chunk freelist
+Metachunk* chunk = get_chunk_manager(mdtype)->chunk_freelist_allocate(chunk_word_size);
+if (chunk != NULL) {
+return chunk;
+}
+return get_space_list(mdtype)->get_initialization_chunk(chunk_word_size, chunk_bunch);
 }
 void Metaspace::initialize(Mutex* lock, MetaspaceType type) {
 assert(space_list() != NULL,
 "Metadata VirtualSpaceList has not been initialized");
+assert(chunk_manager_metadata() != NULL,
-_vsm = new SpaceManager(NonClassType, lock, space_list());
+"Metadata ChunkManager has not been initialized");
+_vsm = new SpaceManager(NonClassType, lock);
 if (_vsm == NULL) {
 return;
 }
 size_t word_size;
 size_t class_word_size;
 vsm()->get_initial_chunk_sizes(type, &word_size, &class_word_size);
 if (using_class_space()) {
 assert(class_space_list() != NULL,
 "Class VirtualSpaceList has not been initialized");
+assert(chunk_manager_class() != NULL,
+"Class ChunkManager has not been initialized");
 // Allocate SpaceManager for classes.
-_class_vsm = new SpaceManager(ClassType, lock, class_space_list());
+_class_vsm = new SpaceManager(ClassType, lock);
 if (_class_vsm == NULL) {
 return;
 }
 }
 MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag);
 // Allocate chunk for metadata objects
-Metachunk* new_chunk =
+Metachunk* new_chunk = get_initialization_chunk(NonClassType,
-space_list()->get_initialization_chunk(word_size,
+word_size,
 vsm()->medium_chunk_bunch());
 assert(!DumpSharedSpaces || new_chunk != NULL, "should have enough space for both chunks");
 if (new_chunk != NULL) {
 // Add to this manager's list of chunks in use and current_chunk().
 vsm()->add_chunk(new_chunk, true);
 }
 // Allocate chunk for class metadata objects
 if (using_class_space()) {
-Metachunk* class_chunk =
+Metachunk* class_chunk = get_initialization_chunk(ClassType,
-class_space_list()->get_initialization_chunk(class_word_size,
+class_word_size,
 class_vsm()->medium_chunk_bunch());
 if (class_chunk != NULL) {
 class_vsm()->add_chunk(class_chunk, true);
 }
 }
 }
 MetaWord* Metaspace::allocate(size_t word_size, MetadataType mdtype) {
 // DumpSharedSpaces doesn't use class metadata area (yet)
 // Also, don't use class_vsm() unless UseCompressedClassPointers is true.
-if (mdtype == ClassType && using_class_space()) {
+if (is_class_space_allocation(mdtype)) {
 return  class_vsm()->allocate(word_size);
 } else {
 return  vsm()->allocate(word_size);
 }
 }
 SIZE_FORMAT, word_size);
 if (loader_data->metaspace_or_null() != NULL) loader_data->dump(gclog_or_tty);
 MetaspaceAux::dump(gclog_or_tty);
 }
 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
-const char* space_string = (mdtype == ClassType) ? "Compressed class space" :
+const char* space_string = is_class_space_allocation(mdtype) ? "Compressed class space" :
 "Metadata space";
 report_java_out_of_memory(space_string);
 if (JvmtiExport::should_post_resource_exhausted()) {
 JvmtiExport::post_resource_exhausted(
 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
 space_string);
 }
-if (mdtype == ClassType) {
+if (is_class_space_allocation(mdtype)) {
 THROW_OOP_0(Universe::out_of_memory_error_class_metaspace());
 } else {
 THROW_OOP_0(Universe::out_of_memory_error_metaspace());
 }
 }
 if (last_addr < top) {
 closure->doit(last_addr, MetaspaceObj::UnknownType, top - last_addr);
 }
 }
+void Metaspace::purge(MetadataType mdtype) {
+get_space_list(mdtype)->purge(get_chunk_manager(mdtype));
+}
 void Metaspace::purge() {
 MutexLockerEx cl(SpaceManager::expand_lock(),
 Mutex::_no_safepoint_check_flag);
-space_list()->purge();
+purge(NonClassType);
 if (using_class_space()) {
-class_space_list()->purge();
+purge(ClassType);
 }
 }
 void Metaspace::print_on(outputStream* out) const {
 // Print both class virtual space counts and metaspace.
 /////////////// Unit tests ///////////////
 #ifndef PRODUCT
-class MetaspaceAuxTest : AllStatic {
+class TestMetaspaceAuxTest : AllStatic {
 public:
 static void test_reserved() {
 size_t reserved = MetaspaceAux::reserved_bytes();
 assert(reserved > 0, "assert");
 assert(committed_class > 0, "assert");
 assert(committed_class < committed, "assert");
 }
 }
+static void test_virtual_space_list_large_chunk() {
+VirtualSpaceList* vs_list = new VirtualSpaceList(os::vm_allocation_granularity());
+MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag);
+// A size larger than VirtualSpaceSize (256k) and add one page to make it _not_ be
+// vm_allocation_granularity aligned on Windows.
+size_t large_size = (size_t)(2*256*K + (os::vm_page_size()/BytesPerWord));
+large_size += (os::vm_page_size()/BytesPerWord);
+vs_list->get_new_chunk(large_size, large_size, 0);
+}
 static void test() {
 test_reserved();
 test_committed();
+test_virtual_space_list_large_chunk();
 }
 };
-void MetaspaceAux_test() {
+void TestMetaspaceAux_test() {
-MetaspaceAuxTest::test();
+TestMetaspaceAuxTest::test();
 }
 #endif

Mercurial > hg > truffle

comparison src/share/vm/memory/metaspace.cpp @ 12873:4e7f99b70d9d