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

comparison src/share/vm/memory/metaspace.cpp @ 6885:685df3c6f84b

7045397: NPG: Add freelists to class loader arenas. Reviewed-by: coleenp, stefank, jprovino, ohair

author	jmasa
date	Tue, 18 Sep 2012 23:35:42 -0700
parents	5baec2e69518
children	6bc207d87e5d

comparison

equal deleted inserted replaced

-:d0e7716b179e
+:685df3c6f84b
 *
 */
 #include "precompiled.hpp"
 #include "gc_interface/collectedHeap.hpp"
 #include "memory/binaryTreeDictionary.hpp"
+#include "memory/freeList.hpp"
 #include "memory/collectorPolicy.hpp"
 #include "memory/filemap.hpp"
 #include "memory/freeList.hpp"
+#include "memory/metablock.hpp"
+#include "memory/metachunk.hpp"
 #include "memory/metaspace.hpp"
 #include "memory/metaspaceShared.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/universe.hpp"
 #include "runtime/globals.hpp"
 #include "runtime/mutex.hpp"
 #include "services/memTracker.hpp"
 #include "utilities/copy.hpp"
 #include "utilities/debug.hpp"
-// Define this macro to deallocate Metablock.  If not defined,
+typedef BinaryTreeDictionary<Metablock, FreeList> BlockTreeDictionary;
-// blocks are not yet deallocated and are only mangled.
+typedef BinaryTreeDictionary<Metachunk, FreeList> ChunkTreeDictionary;
-#undef DEALLOCATE_BLOCKS
-// Easily recognizable patterns
-// These patterns can be the same in 32bit or 64bit since
-// they only have to be easily recognizable.
-const void* metaspace_allocation_leader = (void*) 0X11111111;
-const void* metaspace_allocation_trailer = (void*) 0X77777777;
 // Parameters for stress mode testing
 const uint metadata_deallocate_a_lot_block = 10;
 const uint metadata_deallocate_a_lock_chunk = 3;
 size_t const allocation_from_dictionary_limit = 64 * K;
 const size_t metadata_chunk_initialize = 0xf7f7f7f7;
 const size_t metadata_deallocate = 0xf5f5f5f5;
-const size_t metadata_space_manager_allocate = 0xf3f3f3f3;
 MetaWord* last_allocated = 0;
 // Used in declarations in SpaceManager and ChunkManager
 enum ChunkIndex {
 SmallIndex = 0,
 MediumIndex = 1,
 HumongousIndex = 2,
-NumberOfFreeLists = 3
+NumberOfFreeLists = 2,
+NumberOfInUseLists = 3
 };
 static ChunkIndex next_chunk_index(ChunkIndex i) {
-assert(i < NumberOfFreeLists, "Out of bound");
+assert(i < NumberOfInUseLists, "Out of bound");
 return (ChunkIndex) (i+1);
 }
 // Originally _capacity_until_GC was set to MetaspaceSize here but
 // the default MetaspaceSize before argument processing was being
 // allocation.hpp.  Note that the latter Chunk is the space for
 // allocation (allocations from the chunk are out of the space in
 // the Chunk after the header for the Chunk) where as Metachunks
 // point to space in a VirtualSpace.  To replace Metachunks with
 // Chunks, change Chunks so that they can be allocated out of a VirtualSpace.
-//
+size_t Metablock::_min_block_byte_size = sizeof(Metablock);
-// Metablock are the unit of allocation from a Chunk.  It contains
-// the size of the requested allocation in a debug build.
-// Also in a debug build it has a marker before and after the
-// body of the block. The address of the body is the address returned
-// by the allocation.
-//
-// Layout in a debug build.  In a product build only the body is present.
-//
-//     +-----------+-----------+------------+     +-----------+
-//     | word size | leader    | body       | ... | trailer   |
-//     +-----------+-----------+------------+     +-----------+
-//
-// A Metablock may be reused by its SpaceManager but are never moved between
-// SpaceManagers.  There is no explicit link to the Metachunk
-// from which it was allocated.  Metablock are not deallocated, rather
-// the Metachunk it is a part of will be deallocated when it's
-// associated class loader is collected.
-//
-// When the word size of a block is passed in to the deallocation
-// call the word size no longer needs to be part of a Metablock.
-class Metablock {
-friend class VMStructs;
-private:
-// Used to align the allocation (see below) and for debugging.
 #ifdef ASSERT
-struct {
+size_t Metablock::_overhead =
-size_t _word_size;
+Chunk::aligned_overhead_size(sizeof(Metablock)) / BytesPerWord;
-void*  _leader;
+#else
-} _header;
+size_t Metablock::_overhead = 0;
-void* _data[1];
 #endif
-static size_t _overhead;
-#ifdef ASSERT
-void set_word_size(size_t v) { _header._word_size = v; }
-void* leader() { return _header._leader; }
-void* trailer() {
-jlong index = (jlong) _header._word_size - sizeof(_header)/BytesPerWord - 1;
-assert(index > 0, err_msg("Bad indexling of trailer %d", index));
-void** ptr = &_data[index];
-return *ptr;
-}
-void set_leader(void* v) { _header._leader = v; }
-void set_trailer(void* v) {
-void** ptr = &_data[_header._word_size - sizeof(_header)/BytesPerWord - 1];
-*ptr = v;
-}
-public:
-size_t word_size() { return _header._word_size; }
-#endif
-public:
-static Metablock* initialize(MetaWord* p, size_t word_size);
-// This places the body of the block at a 2 word boundary
-// because every block starts on a 2 word boundary.  Work out
-// how to make the body on a 2 word boundary if the block
-// starts on a arbitrary boundary.  JJJ
-#ifdef ASSERT
-MetaWord* data() { return (MetaWord*) &_data[0]; }
-#else
-MetaWord* data() { return (MetaWord*) this; }
-#endif
-static Metablock* metablock_from_data(MetaWord* p) {
-#ifdef ASSERT
-size_t word_offset = offset_of(Metablock, _data)/BytesPerWord;
-Metablock* result = (Metablock*) (p - word_offset);
-return result;
-#else
-return (Metablock*) p;
-#endif
-}
-static size_t overhead() { return _overhead; }
-void verify();
-};
-//  Metachunk - Quantum of allocation from a Virtualspace
-//    Metachunks are reused (when freed are put on a global freelist) and
-//    have no permanent association to a SpaceManager.
-//            +--------------+ <- end
-//            |              |          --+       ---+
-//            |              |            | free     |
-//            |              |            |          |
-//            |              |            |          | capacity
-//            |              |            |          |
-//            |              | <- top   --+          |
-//            |              |           ---+        |
-//            |              |              | used   |
-//            |              |              |        |
-//            |              |              |        |
-//            +--------------+ <- bottom ---+     ---+
-class Metachunk VALUE_OBJ_CLASS_SPEC {
-// link to support lists of chunks
-Metachunk* _next;
-MetaWord* _bottom;
-MetaWord* _end;
-MetaWord* _top;
-size_t _word_size;
-// Metachunks are allocated out of a MetadataVirtualSpace and
-// and use some of its space to describe itself (plus alignment
-// considerations).  Metadata is allocated in the rest of the chunk.
-// This size is the overhead of maintaining the Metachunk within
-// the space.
-static size_t _overhead;
-void set_bottom(MetaWord* v) { _bottom = v; }
-void set_end(MetaWord* v) { _end = v; }
-void set_top(MetaWord* v) { _top = v; }
-void set_word_size(size_t v) { _word_size = v; }
-public:
-// Used to add a Metachunk to a list of Metachunks
-void set_next(Metachunk* v) { _next = v; assert(v != this, "Boom");}
-Metablock* allocate(size_t word_size);
-static Metachunk* initialize(MetaWord* ptr, size_t word_size);
-// Accessors
-Metachunk* next() const { return _next; }
-MetaWord* bottom() const { return _bottom; }
-MetaWord* end() const { return _end; }
-MetaWord* top() const { return _top; }
-size_t word_size() const { return _word_size; }
-static size_t overhead() { return _overhead; }
-// Reset top to bottom so chunk can be reused.
-void reset_empty() { _top = (_bottom + _overhead); }
-bool is_empty() { return _top == (_bottom + _overhead); }
-// used (has been allocated)
-// free (available for future allocations)
-// capacity (total size of chunk)
-size_t used_word_size();
-size_t free_word_size();
-size_t capacity_word_size();
-#ifdef ASSERT
-void mangle() {
-// Mangle the payload of the chunk and not the links that
-// maintain list of chunks.
-HeapWord* start = (HeapWord*)(bottom() + overhead());
-size_t word_size = capacity_word_size() - overhead();
-Copy::fill_to_words(start, word_size, metadata_chunk_initialize);
-}
-#endif // ASSERT
-void print_on(outputStream* st) const;
-void verify();
-};
 // Pointer to list of Metachunks.
 class ChunkList VALUE_OBJ_CLASS_SPEC {
 // List of free chunks
 // Free list of chunks of different sizes.
 //   SmallChunk
 //   MediumChunk
 //   HumongousChunk
-ChunkList _free_chunks[3];
+ChunkList _free_chunks[NumberOfFreeLists];
+//   HumongousChunk
+ChunkTreeDictionary _humongous_dictionary;
 // ChunkManager in all lists of this type
 size_t _free_chunks_total;
 size_t _free_chunks_count;
 Atomic::add_ptr(count, &_free_chunks_count);
 Atomic::add_ptr(v, &_free_chunks_total);
 }
 ChunkList* free_medium_chunks() { return &_free_chunks[1]; }
 ChunkList* free_small_chunks() { return &_free_chunks[0]; }
-ChunkList* free_humongous_chunks() { return &_free_chunks[2]; }
+ChunkTreeDictionary* humongous_dictionary() {
+return &_humongous_dictionary;
+}
 ChunkList* free_chunks(ChunkIndex index);
 // Returns the list for the given chunk word size.
 ChunkList* find_free_chunks_list(size_t word_size);
 void locked_verify();
 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);
 };
 // 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 {
-#ifdef DEALLOCATE_BLOCKS
+BlockTreeDictionary* _dictionary;
-BinaryTreeDictionary<Metablock>* _dictionary;
+static Metablock* initialize_free_chunk(MetaWord* p, size_t word_size);
-#endif
-static Metablock* initialize_free_chunk(Metablock* block, size_t word_size);
-#ifdef DEALLOCATE_BLOCKS
 // Accessors
-BinaryTreeDictionary<Metablock>* dictionary() const { return _dictionary; }
+BlockTreeDictionary* dictionary() const { return _dictionary; }
-#endif
 public:
 BlockFreelist();
 ~BlockFreelist();
 // Get and return a block to the free list
-Metablock* get_block(size_t word_size);
+MetaWord* get_block(size_t word_size);
-void return_block(Metablock* block, size_t word_size);
+void return_block(MetaWord* p, size_t word_size);
-size_t totalSize() {
+size_t total_size() {
-#ifdef DEALLOCATE_BLOCKS
+if (dictionary() == NULL) {
-if (dictionary() == NULL) {
-return 0;
-} else {
-return dictionary()->totalSize();
-}
-#else
 return 0;
-#endif
+} else {
-}
+return dictionary()->total_size();
+}
+}
 void print_on(outputStream* st) const;
 };
 class VirtualSpaceNode : public CHeapObj<mtClass> {
 return result;
 }
 };
 };
 class Metadebug : AllStatic {
 // Debugging support for Metaspaces
 static int _deallocate_block_a_lot_count;
 static int _deallocate_chunk_a_lot_count;
 static int _allocation_fail_alot_count;
 Mutex* const _lock;
 // 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[NumberOfFreeLists];
+Metachunk* _chunks_in_use[NumberOfInUseLists];
 Metachunk* _current_chunk;
 // Virtual space where allocation comes from.
 VirtualSpaceList* _vs_list;
 Metachunk* find_current_chunk(size_t word_size);
 // Add chunk to the list of chunks in use
 void add_chunk(Metachunk* v, bool make_current);
-// Debugging support
-void verify_chunks_in_use_index(ChunkIndex index, Metachunk* v) {
-switch (index) {
-case 0:
-assert(v->word_size() == SmallChunk, "Not a SmallChunk");
-break;
-case 1:
-assert(v->word_size() == MediumChunk, "Not a MediumChunk");
-break;
-case 2:
-assert(v->word_size() > MediumChunk, "Not a HumongousChunk");
-break;
-default:
-assert(false, "Wrong list.");
-}
-}
-protected:
 Mutex* lock() const { return _lock; }
 public:
 SpaceManager(Mutex* lock, VirtualSpaceList* vs_list);
 ~SpaceManager();
 // Block allocation and deallocation.
 // Allocates a block from the current chunk
 MetaWord* allocate(size_t word_size);
 // Helper for allocations
-Metablock* allocate_work(size_t word_size);
+MetaWord* allocate_work(size_t word_size);
 // Returns a block to the per manager freelist
-void deallocate(MetaWord* p);
+void deallocate(MetaWord* p, size_t word_size);
 // Based on the allocation size and a minimum chunk size,
 // returned chunk size (for expanding space for chunk allocation).
 size_t calc_chunk_size(size_t allocation_word_size);
 // Called when an allocation from the current chunk fails.
 // Gets a new chunk (may require getting a new virtual space),
 // and allocates from that chunk.
-Metablock* grow_and_allocate(size_t word_size);
+MetaWord* grow_and_allocate(size_t word_size);
 // debugging support.
 void dump(outputStream* const out) const;
 void print_on(outputStream* st) const;
 void verify_allocation_total();
 #endif
 };
 uint const SpaceManager::_small_chunk_limit = 4;
 const char* SpaceManager::_expand_lock_name =
 "SpaceManager chunk allocation lock";
 const int SpaceManager::_expand_lock_rank = Monitor::leaf - 1;
 Mutex* const SpaceManager::_expand_lock =
 new Mutex(SpaceManager::_expand_lock_rank,
 SpaceManager::_expand_lock_name,
 Mutex::_allow_vm_block_flag);
-#ifdef ASSERT
-size_t Metablock::_overhead =
-Chunk::aligned_overhead_size(sizeof(Metablock)) / BytesPerWord;
-#else
-size_t Metablock::_overhead = 0;
-#endif
 size_t Metachunk::_overhead =
 Chunk::aligned_overhead_size(sizeof(Metachunk)) / BytesPerWord;
 // New blocks returned by the Metaspace are zero initialized.
 // We should fix the constructors to not assume this instead.
 Metablock* Metablock::initialize(MetaWord* p, size_t word_size) {
+if (p == NULL) {
+return NULL;
+}
 Metablock* result = (Metablock*) p;
 // Clear the memory
 Copy::fill_to_aligned_words((HeapWord*)result, word_size);
 #ifdef ASSERT
 result->set_word_size(word_size);
-// Check after work size is set.
-result->set_leader((void*) metaspace_allocation_leader);
-result->set_trailer((void*) metaspace_allocation_trailer);
 #endif
 return result;
-}
-void Metablock::verify() {
-#ifdef ASSERT
-assert(leader() == metaspace_allocation_leader &&
-trailer() == metaspace_allocation_trailer,
-"block has been corrupted");
-#endif
 }
 // Metachunk methods
 Metachunk* Metachunk::initialize(MetaWord* ptr, size_t word_size) {
 #endif
 return chunk;
 }
-Metablock* Metachunk::allocate(size_t word_size) {
+MetaWord* Metachunk::allocate(size_t word_size) {
-Metablock* result = NULL;
+MetaWord* result = NULL;
 // If available, bump the pointer to allocate.
 if (free_word_size() >= word_size) {
-result = Metablock::initialize(_top, word_size);
+result = _top;
 _top = _top + word_size;
 }
-#ifdef ASSERT
-assert(result == NULL ||
-result->word_size() == word_size,
-"Block size is not set correctly");
-#endif
 return result;
 }
 // _bottom points to the start of the chunk including the overhead.
 size_t Metachunk::used_word_size() {
 " bottom " PTR_FORMAT " top " PTR_FORMAT
 " end " PTR_FORMAT " size " SIZE_FORMAT,
 bottom(), top(), end(), word_size());
 }
+#ifdef ASSERT
+void Metachunk::mangle() {
+// Mangle the payload of the chunk and not the links that
+// maintain list of chunks.
+HeapWord* start = (HeapWord*)(bottom() + overhead());
+size_t word_size = capacity_word_size() - overhead();
+Copy::fill_to_words(start, word_size, metadata_chunk_initialize);
+}
+#endif // ASSERT
 void Metachunk::verify() {
 #ifdef ASSERT
 // Cannot walk through the blocks unless the blocks have
 // headers with sizes.
-MetaWord* curr = bottom() + overhead();
+assert(_bottom <= _top &&
-while (curr < top()) {
+_top <= _end,
-Metablock* block = (Metablock*) curr;
+"Chunk has been smashed");
-size_t word_size = block->word_size();
+assert(SpaceManager::is_humongous(_word_size) ||
-block->verify();
+_word_size == SpaceManager::MediumChunk ||
-curr = curr + word_size;
+_word_size == SpaceManager::SmallChunk,
-}
+"Chunk size is wrong");
 #endif
 return;
 }
 // BlockFreelist methods
-#ifdef DEALLOCATE_BLOCKS
 BlockFreelist::BlockFreelist() : _dictionary(NULL) {}
-#else
-BlockFreelist::BlockFreelist() {}
-#endif
 BlockFreelist::~BlockFreelist() {
-#ifdef DEALLOCATE_BLOCKS
 if (_dictionary != NULL) {
 if (Verbose && TraceMetadataChunkAllocation) {
 _dictionary->print_free_lists(gclog_or_tty);
 }
 delete _dictionary;
 }
-#endif
+}
-}
+Metablock* BlockFreelist::initialize_free_chunk(MetaWord* p, size_t word_size) {
-Metablock* BlockFreelist::initialize_free_chunk(Metablock* block, size_t word_size) {
+Metablock* block = (Metablock*) p;
-#ifdef DEALLOCATE_BLOCKS
+block->set_word_size(word_size);
-#ifdef ASSERT
+block->set_prev(NULL);
-assert(word_size = block->word_size(), "Wrong chunk size");
+block->set_next(NULL);
-#endif
-Metablock* result = block;
-result->setSize(word_size);
-result->linkPrev(NULL);
-result->linkNext(NULL);
-return result;
-#else
-ShouldNotReachHere();
 return block;
-#endif
+}
-}
+void BlockFreelist::return_block(MetaWord* p, size_t word_size) {
-void BlockFreelist::return_block(Metablock* block, size_t word_size) {
+Metablock* free_chunk = initialize_free_chunk(p, word_size);
-#ifdef ASSERT
-assert(word_size = block->word_size(), "Block size is wrong");;
-#endif
-Metablock* free_chunk = initialize_free_chunk(block, word_size);
-#ifdef DEALLOCATE_BLOCKS
 if (dictionary() == NULL) {
-_dictionary = new BinaryTreeDictionary<Metablock>(false /* adaptive_freelists */);
+_dictionary = new BlockTreeDictionary();
 }
-dictionary()->returnChunk(free_chunk);
+dictionary()->return_chunk(free_chunk);
-#endif
+}
-}
+MetaWord* BlockFreelist::get_block(size_t word_size) {
-Metablock* BlockFreelist::get_block(size_t word_size) {
-#ifdef DEALLOCATE_BLOCKS
 if (dictionary() == NULL) {
 return NULL;
 }
-Metablock* free_chunk =
+if (word_size < TreeChunk<Metablock, FreeList>::min_size()) {
-dictionary()->getChunk(word_size, FreeBlockDictionary<Metablock>::exactly);
+// Dark matter.  Too small for dictionary.
-#else
-Metablock* free_chunk = NULL;
-#endif
-if (free_chunk == NULL) {
 return NULL;
 }
-assert(free_chunk->word_size() == word_size, "Size of chunk is incorrect");
-Metablock* block = Metablock::initialize((MetaWord*) free_chunk, word_size);
+Metablock* free_block =
-#ifdef ASSERT
+dictionary()->get_chunk(word_size, FreeBlockDictionary<Metablock>::exactly);
-assert(block->word_size() == word_size, "Block size is not set correctly");
+if (free_block == NULL) {
-#endif
+return NULL;
+}
-return block;
+return (MetaWord*) free_block;
 }
 void BlockFreelist::print_on(outputStream* st) const {
-#ifdef DEALLOCATE_BLOCKS
 if (dictionary() == NULL) {
 return;
 }
 dictionary()->print_free_lists(st);
-#else
-return;
-#endif
 }
 // VirtualSpaceNode methods
 VirtualSpaceNode::~VirtualSpaceNode() {
 #ifdef ASSERT
 if (MetaDataDeallocateALot &&
 Metadebug::deallocate_block_a_lot_count() % MetaDataDeallocateALotInterval == 0 ) {
 Metadebug::set_deallocate_block_a_lot_count(0);
 for (uint i = 0; i < metadata_deallocate_a_lot_block; i++) {
-Metablock* dummy_block = sm->allocate_work(raw_word_size);
+MetaWord* dummy_block = sm->allocate_work(raw_word_size);
 if (dummy_block == 0) {
 break;
 }
-#ifdef ASSERT
+sm->deallocate(dummy_block, raw_word_size);
-assert(dummy_block->word_size() == raw_word_size, "Block size is not set correctly");
-#endif
-sm->deallocate(dummy_block->data());
 }
 } else {
 Metadebug::inc_deallocate_block_a_lot_count();
 }
 #endif
 }
 #endif
 }
 void ChunkManager::locked_verify() {
+locked_verify_free_chunks_count();
 locked_verify_free_chunks_total();
-locked_verify_free_chunks_count();
 }
 void ChunkManager::locked_print_free_chunks(outputStream* st) {
 assert_lock_strong(SpaceManager::expand_lock());
 st->print_cr("Free chunk total 0x%x  count 0x%x",
 sum_free_chunks(), sum_free_chunks_count());
 }
 ChunkList* ChunkManager::free_chunks(ChunkIndex index) {
 return &_free_chunks[index];
 }
 // These methods that sum the free chunk lists are used in printing
 // methods that are used in product builds.
 size_t ChunkManager::sum_free_chunks() {
 assert_lock_strong(SpaceManager::expand_lock());
 continue;
 }
 result = result + list->sum_list_capacity();
 }
+result = result + humongous_dictionary()->total_size();
 return result;
 }
 size_t ChunkManager::sum_free_chunks_count() {
 assert_lock_strong(SpaceManager::expand_lock());
 if (list == NULL) {
 continue;
 }
 count = count + list->sum_list_count();
 }
+count = count + humongous_dictionary()->total_free_blocks();
 return count;
 }
 ChunkList* ChunkManager::find_free_chunks_list(size_t word_size) {
 switch (word_size) {
 Metachunk* ChunkManager::free_chunks_get(size_t word_size) {
 assert_lock_strong(SpaceManager::expand_lock());
 locked_verify();
-ChunkList* free_list = find_free_chunks_list(word_size);
-assert(free_list != NULL, "Sanity check");
+Metachunk* chunk = NULL;
+if (!SpaceManager::is_humongous(word_size)) {
-Metachunk* chunk = free_list->head();
+ChunkList* free_list = find_free_chunks_list(word_size);
-debug_only(Metachunk* debug_head = chunk;)
+assert(free_list != NULL, "Sanity check");
-if (chunk == NULL) {
+chunk = free_list->head();
-return NULL;
+debug_only(Metachunk* debug_head = chunk;)
-}
+if (chunk == NULL) {
-Metachunk* prev_chunk = chunk;
+return NULL;
-if (chunk->word_size() == word_size) {
+}
-// Chunk is being removed from the chunks free list.
-dec_free_chunks_total(chunk->capacity_word_size());
 // Remove the chunk as the head of the list.
 free_list->set_head(chunk->next());
 chunk->set_next(NULL);
+// Chunk has been removed from the chunks free list.
+dec_free_chunks_total(chunk->capacity_word_size());
 if (TraceMetadataChunkAllocation && Verbose) {
 tty->print_cr("ChunkManager::free_chunks_get: free_list "
 PTR_FORMAT " head " PTR_FORMAT " size " SIZE_FORMAT,
 free_list, chunk, chunk->word_size());
 }
 } else {
-assert(SpaceManager::is_humongous(word_size),
+chunk = humongous_dictionary()->get_chunk(
-"Should only need to check humongous");
+word_size,
-// This code to find the best fit is just for purposes of
+FreeBlockDictionary<Metachunk>::atLeast);
-// investigating the loss due to fragmentation on a humongous
-// chunk.  It will be replace by a binaryTreeDictionary for
+if (chunk != NULL) {
-// the humongous chunks.
+if (TraceMetadataHumongousAllocation) {
-uint count = 0;
+size_t waste = chunk->word_size() - word_size;
-Metachunk* best_fit = NULL;
+tty->print_cr("Free list allocate humongous chunk size " SIZE_FORMAT
-Metachunk* best_fit_prev = NULL;
+" for requested size " SIZE_FORMAT
-while (chunk != NULL) {
+" waste " SIZE_FORMAT,
-count++;
+chunk->word_size(), word_size, waste);
-if (chunk->word_size() < word_size) {
-prev_chunk = chunk;
-chunk = chunk->next();
-} else if (chunk->word_size() == word_size) {
-break;
-} else {
-if (best_fit == NULL ||
-best_fit->word_size() > chunk->word_size()) {
-best_fit_prev = prev_chunk;
-best_fit = chunk;
-}
-prev_chunk = chunk;
-chunk = chunk->next();
 }
-}
+// Chunk is being removed from the chunks free list.
-if (chunk == NULL) {
+dec_free_chunks_total(chunk->capacity_word_size());
-prev_chunk = best_fit_prev;
+#ifdef ASSERT
-chunk = best_fit;
+chunk->set_is_free(false);
-}
+#endif
-if (chunk != NULL) {
+}
-if (TraceMetadataHumongousAllocation) {
-size_t waste = chunk->word_size() - word_size;
-tty->print_cr("Free list allocate humongous chunk size " SIZE_FORMAT
-" for requested size " SIZE_FORMAT
-" waste " SIZE_FORMAT
-" found at " SIZE_FORMAT " of " SIZE_FORMAT,
-chunk->word_size(), word_size, waste,
-count, free_list->sum_list_count());
-}
-// Chunk is being removed from the chunks free list.
-dec_free_chunks_total(chunk->capacity_word_size());
-// Remove the chunk if it is at the head of the list.
-if (chunk == free_list->head()) {
-free_list->set_head(chunk->next());
-if (TraceMetadataHumongousAllocation) {
-tty->print_cr("ChunkManager::free_chunks_get: humongous free_list "
-PTR_FORMAT " chunk " PTR_FORMAT " size " SIZE_FORMAT
-" new head " PTR_FORMAT,
-free_list, chunk, chunk->word_size(),
-free_list->head());
-}
-} else {
-// Remove a chunk in the interior of the list
-prev_chunk->set_next(chunk->next());
-if (TraceMetadataHumongousAllocation) {
-tty->print_cr("ChunkManager::free_chunks_get: humongous free_list "
-PTR_FORMAT " chunk " PTR_FORMAT " size " SIZE_FORMAT
-PTR_FORMAT "  prev " PTR_FORMAT " next " PTR_FORMAT,
-free_list, chunk, chunk->word_size(),
-prev_chunk, chunk->next());
-}
-}
-chunk->set_next(NULL);
-} else {
-if (TraceMetadataHumongousAllocation) {
-tty->print_cr("ChunkManager::free_chunks_get: New humongous chunk of size "
-SIZE_FORMAT,
-word_size);
-}
-}
 }
 locked_verify();
 return chunk;
 }
 }
 return chunk;
 }
+void ChunkManager::print_on(outputStream* out) {
+if (PrintFLSStatistics != 0) {
+humongous_dictionary()->report_statistics();
+}
+}
 // SpaceManager methods
 size_t SpaceManager::sum_free_in_chunks_in_use() const {
 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
 size_t free = 0;
-for (ChunkIndex i = SmallIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
+for (ChunkIndex i = SmallIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
 Metachunk* chunk = chunks_in_use(i);
 while (chunk != NULL) {
 free += chunk->free_word_size();
 chunk = chunk->next();
 }
 }
 size_t SpaceManager::sum_waste_in_chunks_in_use() const {
 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
 size_t result = 0;
-for (ChunkIndex i = SmallIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
+for (ChunkIndex i = SmallIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
-// Count the free space in all the chunk but not the
-// current chunk from which allocations are still being done.
 result += sum_waste_in_chunks_in_use(i);
 }
 return result;
 }
 size_t SpaceManager::sum_waste_in_chunks_in_use(ChunkIndex index) const {
 size_t result = 0;
 size_t count = 0;
 Metachunk* chunk = chunks_in_use(index);
 // Count the free space in all the chunk but not the
 // current chunk from which allocations are still being done.
 if (chunk != NULL) {
-while (chunk != NULL) {
+Metachunk* prev = chunk;
-if (chunk != current_chunk()) {
+while (chunk != NULL && chunk != current_chunk()) {
 result += chunk->free_word_size();
-}
+prev = chunk;
 chunk = chunk->next();
 count++;
 }
 }
 return result;
 }
 size_t SpaceManager::sum_capacity_in_chunks_in_use() const {
 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
 size_t sum = 0;
-for (ChunkIndex i = SmallIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
+for (ChunkIndex i = SmallIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
 Metachunk* chunk = chunks_in_use(i);
 while (chunk != NULL) {
 // Just changed this sum += chunk->capacity_word_size();
 // sum += chunk->word_size() - Metachunk::overhead();
 sum += chunk->capacity_word_size();
 return sum;
 }
 size_t SpaceManager::sum_count_in_chunks_in_use() {
 size_t count = 0;
-for (ChunkIndex i = SmallIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
+for (ChunkIndex i = SmallIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
 count = count + sum_count_in_chunks_in_use(i);
 }
 return count;
 }
 size_t SpaceManager::sum_count_in_chunks_in_use(ChunkIndex i) {
 size_t count = 0;
 size_t SpaceManager::sum_used_in_chunks_in_use() const {
 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
 size_t used = 0;
-for (ChunkIndex i = SmallIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
+for (ChunkIndex i = SmallIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
 Metachunk* chunk = chunks_in_use(i);
 while (chunk != NULL) {
 used += chunk->used_word_size();
 chunk = chunk->next();
 }
 SpaceManager::is_humongous(word_size)) {
 gclog_or_tty->print_cr("Metadata humongous allocation:");
 gclog_or_tty->print_cr("  word_size " PTR_FORMAT, word_size);
 gclog_or_tty->print_cr("  chunk_word_size " PTR_FORMAT,
 chunk_word_size);
-gclog_or_tty->print_cr("    block overhead " PTR_FORMAT
+gclog_or_tty->print_cr("    chunk overhead " PTR_FORMAT,
-" chunk overhead " PTR_FORMAT,
-Metablock::overhead(),
 Metachunk::overhead());
 }
 return chunk_word_size;
 }
-Metablock* SpaceManager::grow_and_allocate(size_t word_size) {
+MetaWord* SpaceManager::grow_and_allocate(size_t word_size) {
 assert(vs_list()->current_virtual_space() != NULL,
 "Should have been set");
 assert(current_chunk() == NULL ||
 current_chunk()->allocate(word_size) == NULL,
 "Don't need to expand");
 }
 void SpaceManager::print_on(outputStream* st) const {
 for (ChunkIndex i = SmallIndex;
-i < NumberOfFreeLists ;
+i < NumberOfInUseLists ;
 i = next_chunk_index(i) ) {
 st->print_cr("  chunks_in_use " PTR_FORMAT " chunk size " PTR_FORMAT,
 chunks_in_use(i),
 chunks_in_use(i) == NULL ? 0 : chunks_in_use(i)->word_size());
 }
 st->print_cr("    waste:  Small " SIZE_FORMAT " Medium " SIZE_FORMAT
 " Humongous " SIZE_FORMAT,
 sum_waste_in_chunks_in_use(SmallIndex),
 sum_waste_in_chunks_in_use(MediumIndex),
 sum_waste_in_chunks_in_use(HumongousIndex));
-// Nothing in them yet
+// block free lists
-// block_freelists()->print_on(st);
+if (block_freelists() != NULL) {
+st->print_cr("total in block free lists " SIZE_FORMAT,
+block_freelists()->total_size());
+}
 }
 SpaceManager::SpaceManager(Mutex* lock, VirtualSpaceList* vs_list) :
 _vs_list(vs_list),
 _allocation_total(0),
 _lock(lock) {
 Metadebug::init_allocation_fail_alot_count();
-for (ChunkIndex i = SmallIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
+for (ChunkIndex i = SmallIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
 _chunks_in_use[i] = NULL;
 }
 _current_chunk = NULL;
 if (TraceMetadataChunkAllocation && Verbose) {
 gclog_or_tty->print_cr("SpaceManager(): " PTR_FORMAT, this);
 // Humongous chunks
 // Humongous chunks are never the current chunk.
 Metachunk* humongous_chunks = chunks_in_use(HumongousIndex);
-if (humongous_chunks != NULL) {
+while (humongous_chunks != NULL) {
-chunk_manager->free_humongous_chunks()->add_at_head(humongous_chunks);
+#ifdef ASSERT
-set_chunks_in_use(HumongousIndex, NULL);
+humongous_chunks->set_is_free(true);
-}
+#endif
+Metachunk* next_humongous_chunks = humongous_chunks->next();
+chunk_manager->humongous_dictionary()->return_chunk(humongous_chunks);
+humongous_chunks = next_humongous_chunks;
+}
+set_chunks_in_use(HumongousIndex, NULL);
 chunk_manager->locked_verify();
 }
-void SpaceManager::deallocate(MetaWord* p) {
+void SpaceManager::deallocate(MetaWord* p, size_t word_size) {
 assert_lock_strong(_lock);
-ShouldNotReachHere();  // Where is this needed.
+size_t min_size = TreeChunk<Metablock, FreeList>::min_size();
-#ifdef DEALLOCATE_BLOCKS
+assert(word_size >= min_size,
-Metablock* block = Metablock::metablock_from_data(p);
+err_msg("Should not deallocate dark matter " SIZE_FORMAT, word_size));
-// This is expense but kept it until integration JJJ
+block_freelists()->return_block(p, word_size);
-assert(contains((address)block), "Block does not belong to this metaspace");
-block_freelists()->return_block(block, word_size);
-#endif
 }
 // Adds a chunk to the list of chunks in use.
 void SpaceManager::add_chunk(Metachunk* new_chunk, bool make_current) {
 }
 MetaWord* SpaceManager::allocate(size_t word_size) {
 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
-size_t block_overhead = Metablock::overhead();
 // 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_with_overhead = (word_size + block_overhead) * BytesPerWord;
+size_t byte_size = word_size * BytesPerWord;
-#ifdef DEALLOCATE_BLOCKS
-size_t raw_bytes_size = MAX2(ARENA_ALIGN(byte_size_with_overhead),
+size_t byte_size_with_overhead = byte_size + Metablock::overhead();
-MinChunkSize * BytesPerWord);
-#else
+size_t raw_bytes_size = MAX2(byte_size_with_overhead,
-size_t raw_bytes_size = ARENA_ALIGN(byte_size_with_overhead);
+Metablock::min_block_byte_size());
-#endif
+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();
-Metablock* block = NULL;
+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
 // a reasonable policy?  Maybe an skinny dictionary is fast enough
 // for allocations.  Do some profiling.  JJJ
-if (fl->totalSize() > allocation_from_dictionary_limit) {
+if (fl->total_size() > allocation_from_dictionary_limit) {
-block = fl->get_block(raw_word_size);
+p = fl->get_block(raw_word_size);
 }
-if (block == NULL) {
+if (p == NULL) {
-block = allocate_work(raw_word_size);
+p = allocate_work(raw_word_size);
-if (block == NULL) {
-return NULL;
-}
 }
 Metadebug::deallocate_block_a_lot(this, raw_word_size);
-// Push the allocation past the word containing the size and leader.
+return p;
-#ifdef ASSERT
-MetaWord* result =  block->data();
-return result;
-#else
-return (MetaWord*) block;
-#endif
 }
 // Returns the address of spaced allocated for "word_size".
 // This methods does not know about blocks (Metablocks)
-Metablock* SpaceManager::allocate_work(size_t word_size) {
+MetaWord* SpaceManager::allocate_work(size_t word_size) {
 assert_lock_strong(_lock);
 #ifdef ASSERT
 if (Metadebug::test_metadata_failure()) {
 return NULL;
 }
 #endif
 // Is there space in the current chunk?
-Metablock* result = NULL;
+MetaWord* result = NULL;
 // For DumpSharedSpaces, only allocate out of the current chunk which is
 // never null because we gave it the size we wanted.   Caller reports out
 // of memory if this returns null.
 if (DumpSharedSpaces) {
 if (result == NULL) {
 result = grow_and_allocate(word_size);
 }
 if (result > 0) {
 inc_allocation_total(word_size);
-assert(result != (Metablock*) chunks_in_use(MediumIndex), "Head of the list is being allocated");
+assert(result != (MetaWord*) chunks_in_use(MediumIndex),
-assert(result->word_size() == word_size, "Size not set correctly");
+"Head of the list is being allocated");
 }
 return result;
 }
 void SpaceManager::verify() {
 // If there are blocks in the dictionary, then
 // verfication of chunks does not work since
 // being in the dictionary alters a chunk.
-if (block_freelists()->totalSize() == 0) {
+if (block_freelists()->total_size() == 0) {
 // Skip the small chunks because their next link points to
 // medium chunks.  This is because the small chunk is the
 // current chunk (for allocations) until it is full and the
 // the addition of the next chunk does not NULL the next
 // like of the small chunk.
-for (ChunkIndex i = MediumIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
+for (ChunkIndex i = MediumIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
 Metachunk* curr = chunks_in_use(i);
 while (curr != NULL) {
 curr->verify();
 curr = curr->next();
 }
 size_t used = 0;
 size_t capacity = 0;
 // Add up statistics for all chunks in this SpaceManager.
 for (ChunkIndex index = SmallIndex;
-index < NumberOfFreeLists;
+index < NumberOfInUseLists;
 index = next_chunk_index(index)) {
 for (Metachunk* curr = chunks_in_use(index);
 curr != NULL;
 curr = curr->next()) {
 out->print("%d) ", i++);
 }
 #ifdef ASSERT
 void SpaceManager::mangle_freed_chunks() {
 for (ChunkIndex index = SmallIndex;
-index < NumberOfFreeLists;
+index < NumberOfInUseLists;
 index = next_chunk_index(index)) {
 for (Metachunk* curr = chunks_in_use(index);
 curr != NULL;
 curr = curr->next()) {
 // Try to detect incorrectly terminated small chunk
 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)
 if (mdtype == ClassType && !DumpSharedSpaces) {
-return class_vsm()->allocate(word_size);
+return  class_vsm()->allocate(word_size);
 } else {
-return vsm()->allocate(word_size);
+return  vsm()->allocate(word_size);
 }
 }
 MetaWord* Metaspace::expand_and_allocate(size_t word_size, MetadataType mdtype) {
 MetaWord* result;
 MetaspaceGC::inc_capacity_until_GC(delta_words);
 if (PrintGCDetails && Verbose) {
 gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT
 " to " SIZE_FORMAT, before_inc, MetaspaceGC::capacity_until_GC());
 }
 result = allocate(word_size, mdtype);
 return result;
 }
 }
 void Metaspace::deallocate(MetaWord* ptr, size_t word_size, bool is_class) {
 if (SafepointSynchronize::is_at_safepoint()) {
 assert(Thread::current()->is_VM_thread(), "should be the VM thread");
-// Don't take lock
+// Don't take Heap_lock
-#ifdef DEALLOCATE_BLOCKS
+MutexLocker ml(vsm()->lock());
+if (word_size < TreeChunk<Metablock, FreeList>::min_size()) {
+// Dark matter.  Too small for dictionary.
+#ifdef ASSERT
+Copy::fill_to_words((HeapWord*)ptr, word_size, 0xf5f5f5f5);
+#endif
+return;
+}
 if (is_class) {
-class_vsm()->deallocate(ptr);
+class_vsm()->deallocate(ptr, word_size);
 } else {
-vsm()->deallocate(ptr);
+vsm()->deallocate(ptr, word_size);
 }
-#else
-#ifdef ASSERT
-Copy::fill_to_words((HeapWord*)ptr, word_size, metadata_deallocate);
-#endif
-#endif
 } else {
 MutexLocker ml(vsm()->lock());
-#ifdef DEALLOCATE_BLOCKS
+if (word_size < TreeChunk<Metablock, FreeList>::min_size()) {
+// Dark matter.  Too small for dictionary.
+#ifdef ASSERT
+Copy::fill_to_words((HeapWord*)ptr, word_size, 0xf5f5f5f5);
+#endif
+return;
+}
 if (is_class) {
-class_vsm()->deallocate(ptr);
+class_vsm()->deallocate(ptr, word_size);
 } else {
-vsm()->deallocate(ptr);
+vsm()->deallocate(ptr, word_size);
 }
-#else
+}
-#ifdef ASSERT
+}
-Copy::fill_to_words((HeapWord*)ptr, word_size, metadata_deallocate);
-#endif
+Metablock* Metaspace::allocate(ClassLoaderData* loader_data, size_t word_size,
-#endif
-}
-}
-MetaWord* Metaspace::allocate(ClassLoaderData* loader_data, size_t word_size,
 bool read_only, MetadataType mdtype, TRAPS) {
 if (HAS_PENDING_EXCEPTION) {
 assert(false, "Should not allocate with exception pending");
 return NULL;  // caller does a CHECK_NULL too
 }
 result = loader_data->rw_metaspace()->allocate(word_size, NonClassType);
 }
 if (result == NULL) {
 report_out_of_shared_space(read_only ? SharedReadOnly : SharedReadWrite);
 }
-return result;
+return Metablock::initialize(result, word_size);
 }
 result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
 if (result == NULL) {
 // Try to clean out some memory and retry.
 result =
 Universe::heap()->collector_policy()->satisfy_failed_metadata_allocation(
 loader_data, word_size, mdtype);
 // If result is still null, we are out of memory.
 if (result == NULL) {
 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
 "Metadata space");
 }
 THROW_OOP_0(Universe::out_of_memory_error_perm_gen());
 }
 }
-return result;
+return Metablock::initialize(result, word_size);
 }
 void Metaspace::print_on(outputStream* out) const {
 // Print both class virtual space counts and metaspace.
 if (Verbose) {

Mercurial > hg > truffle

comparison src/share/vm/memory/metaspace.cpp @ 6885:685df3c6f84b