src/hotspot/share/memory/metaspace/smallBlocks.hpp
branchstuefe-new-metaspace-branch
changeset 58063 bdf136b8ae0e
parent 53244 9807daeb47c4
equal deleted inserted replaced
58062:65cad575ace3 58063:bdf136b8ae0e
    26 #define SHARE_MEMORY_METASPACE_SMALLBLOCKS_HPP
    26 #define SHARE_MEMORY_METASPACE_SMALLBLOCKS_HPP
    27 
    27 
    28 #include "memory/allocation.hpp"
    28 #include "memory/allocation.hpp"
    29 #include "memory/binaryTreeDictionary.hpp"
    29 #include "memory/binaryTreeDictionary.hpp"
    30 #include "memory/metaspace/metablock.hpp"
    30 #include "memory/metaspace/metablock.hpp"
       
    31 #include "utilities/debug.hpp"
    31 #include "utilities/globalDefinitions.hpp"
    32 #include "utilities/globalDefinitions.hpp"
    32 
    33 
    33 class outputStream;
    34 class outputStream;
    34 
    35 
    35 namespace metaspace {
    36 namespace metaspace {
    36 
    37 
    37 class SmallBlocks : public CHeapObj<mtClass> {
    38 class SmallBlocks : public CHeapObj<mtClass> {
    38 
    39 
    39   const static uint _small_block_max_size = sizeof(TreeChunk<Metablock,  FreeList<Metablock> >)/HeapWordSize;
    40   const static uint _small_block_max_byte_size = sizeof(TreeChunk<Metablock,  FreeList<Metablock> >);
       
    41   const static uint _small_block_max_word_size = _small_block_max_byte_size / BytesPerWord;
       
    42   STATIC_ASSERT(_small_block_max_word_size * BytesPerWord == _small_block_max_byte_size);
       
    43 
    40   // Note: this corresponds to the imposed miminum allocation size, see SpaceManager::get_allocation_word_size()
    44   // Note: this corresponds to the imposed miminum allocation size, see SpaceManager::get_allocation_word_size()
    41   const static uint _small_block_min_size = sizeof(Metablock)/HeapWordSize;
    45   const static uint _small_block_min_byte_size = sizeof(Metablock);
       
    46   const static uint _small_block_min_word_size = _small_block_min_byte_size / BytesPerWord;
       
    47   STATIC_ASSERT(_small_block_min_word_size * BytesPerWord == _small_block_min_byte_size);
    42 
    48 
    43 private:
    49 private:
    44   FreeList<Metablock> _small_lists[_small_block_max_size - _small_block_min_size];
    50   FreeList<Metablock> _small_lists[_small_block_max_word_size - _small_block_min_word_size];
    45 
    51 
    46   FreeList<Metablock>& list_at(size_t word_size) {
    52   FreeList<Metablock>& list_at(size_t word_size) {
    47     assert(word_size >= _small_block_min_size, "There are no metaspace objects less than %u words", _small_block_min_size);
    53     assert(word_size >= _small_block_min_word_size, "There are no metaspace objects less than %u words", _small_block_min_word_size);
    48     return _small_lists[word_size - _small_block_min_size];
    54     return _small_lists[word_size - _small_block_min_word_size];
    49   }
    55   }
    50 
    56 
    51 public:
    57 public:
    52   SmallBlocks() {
    58   SmallBlocks() {
    53     for (uint i = _small_block_min_size; i < _small_block_max_size; i++) {
    59     for (uint i = _small_block_min_word_size; i < _small_block_max_word_size; i++) {
    54       uint k = i - _small_block_min_size;
    60       uint k = i - _small_block_min_word_size;
    55       _small_lists[k].set_size(i);
    61       _small_lists[k].set_size(i);
    56     }
    62     }
    57   }
    63   }
    58 
    64 
    59   // Returns the total size, in words, of all blocks, across all block sizes.
    65   // Returns the total size, in words, of all blocks, across all block sizes.
    60   size_t total_size() const;
    66   size_t total_size() const;
    61 
    67 
    62   // Returns the total number of all blocks across all block sizes.
    68   // Returns the total number of all blocks across all block sizes.
    63   uintx total_num_blocks() const;
    69   uintx total_num_blocks() const;
    64 
    70 
    65   static uint small_block_max_size() { return _small_block_max_size; }
    71   static uint small_block_max_byte_size() { return _small_block_max_byte_size; }
    66   static uint small_block_min_size() { return _small_block_min_size; }
    72   static uint small_block_max_word_size() { return _small_block_max_word_size; }
       
    73   static uint small_block_min_byte_size() { return _small_block_min_byte_size; }
       
    74   static uint small_block_min_word_size() { return _small_block_min_word_size; }
    67 
    75 
    68   MetaWord* get_block(size_t word_size) {
    76   MetaWord* get_block(size_t word_size) {
    69     if (list_at(word_size).count() > 0) {
    77     if (list_at(word_size).count() > 0) {
    70       MetaWord* new_block = (MetaWord*) list_at(word_size).get_chunk_at_head();
    78       MetaWord* new_block = (MetaWord*) list_at(word_size).get_chunk_at_head();
    71       return new_block;
    79       return new_block;