30 #include "runtime/javaCalls.hpp"

    30 #include "runtime/javaCalls.hpp"

    31 #include "services/lowMemoryDetector.hpp"

    31 #include "services/lowMemoryDetector.hpp"

    32 #include "services/management.hpp"

    32 #include "services/management.hpp"

    33 #include "services/memoryManager.hpp"

    33 #include "services/memoryManager.hpp"

    34 #include "services/memoryPool.hpp"

    34 #include "services/memoryPool.hpp"

    35 

    36 

    36 MemoryPool::MemoryPool(const char* name,

    37 MemoryPool::MemoryPool(const char* name,

    37                        PoolType type,

    38                        PoolType type,

    38                        size_t init_size,

    39                        size_t init_size,

    39                        size_t max_size,

    40                        size_t max_size,

   206   size_t committed = committed_in_bytes();

   207   size_t committed = committed_in_bytes();

   207 

   208 

   208   return MemoryUsage(initial_size(), used, committed, maxSize);

   209   return MemoryUsage(initial_size(), used, committed, maxSize);

   209 }

   210 }

   210 

   211 

   212 CompactibleFreeListSpacePool::CompactibleFreeListSpacePool(CompactibleFreeListSpace* space,

   213 CompactibleFreeListSpacePool::CompactibleFreeListSpacePool(CompactibleFreeListSpace* space,

   213                                                            const char* name,

   214                                                            const char* name,

   214                                                            PoolType type,

   215                                                            PoolType type,

   215                                                            size_t max_size,

   216                                                            size_t max_size,

   216                                                            bool support_usage_threshold) :

   217                                                            bool support_usage_threshold) :

   223   size_t used      = used_in_bytes();

   224   size_t used      = used_in_bytes();

   224   size_t committed = _space->capacity();

   225   size_t committed = _space->capacity();

   225 

   226 

   226   return MemoryUsage(initial_size(), used, committed, maxSize);

   227   return MemoryUsage(initial_size(), used, committed, maxSize);

   227 }

   228 }

   229 

   230 

   230 GenerationPool::GenerationPool(Generation* gen,

   231 GenerationPool::GenerationPool(Generation* gen,

   231                                const char* name,

   232                                const char* name,

   232                                PoolType type,

   233                                PoolType type,

   233                                bool support_usage_threshold) :

   234                                bool support_usage_threshold) :