duke@435: /*
mikael@6198:  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
duke@435:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435:  *
duke@435:  * This code is free software; you can redistribute it and/or modify it
duke@435:  * under the terms of the GNU General Public License version 2 only, as
duke@435:  * published by the Free Software Foundation.
duke@435:  *
duke@435:  * This code is distributed in the hope that it will be useful, but WITHOUT
duke@435:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
duke@435:  * version 2 for more details (a copy is included in the LICENSE file that
duke@435:  * accompanied this code).
duke@435:  *
duke@435:  * You should have received a copy of the GNU General Public License version
duke@435:  * 2 along with this work; if not, write to the Free Software Foundation,
duke@435:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435:  *
trims@1907:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907:  * or visit www.oracle.com if you need additional information or have any
trims@1907:  * questions.
duke@435:  *
duke@435:  */
duke@435: 
stefank@2314: #ifndef SHARE_VM_SERVICES_MEMORYPOOL_HPP
stefank@2314: #define SHARE_VM_SERVICES_MEMORYPOOL_HPP
stefank@2314: 
stefank@2314: #include "gc_implementation/shared/mutableSpace.hpp"
stefank@2314: #include "memory/defNewGeneration.hpp"
stefank@2314: #include "memory/heap.hpp"
stefank@2314: #include "memory/space.hpp"
stefank@2314: #include "services/memoryUsage.hpp"
jprovino@4542: #include "utilities/macros.hpp"
jprovino@4542: #if INCLUDE_ALL_GCS
stefank@2314: #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
jprovino@4542: #endif // INCLUDE_ALL_GCS
stefank@2314: 
duke@435: // A memory pool represents the memory area that the VM manages.
duke@435: // The Java virtual machine has at least one memory pool
duke@435: // and it may create or remove memory pools during execution.
duke@435: // A memory pool can belong to the heap or the non-heap memory.
duke@435: // A Java virtual machine may also have memory pools belonging to
duke@435: // both heap and non-heap memory.
duke@435: 
duke@435: // Forward declaration
duke@435: class MemoryManager;
duke@435: class SensorInfo;
duke@435: class Generation;
duke@435: class DefNewGeneration;
duke@435: class ThresholdSupport;
duke@435: 
zgu@3900: class MemoryPool : public CHeapObj<mtInternal> {
duke@435:   friend class MemoryManager;
duke@435:  public:
duke@435:   enum PoolType {
duke@435:     Heap    = 1,
duke@435:     NonHeap = 2
duke@435:   };
duke@435: 
duke@435:  private:
duke@435:   enum {
duke@435:     max_num_managers = 5
duke@435:   };
duke@435: 
duke@435:   // We could make some of the following as performance counters
duke@435:   // for external monitoring.
duke@435:   const char*      _name;
duke@435:   PoolType         _type;
duke@435:   size_t           _initial_size;
duke@435:   size_t           _max_size;
duke@435:   bool             _available_for_allocation; // Default is true
duke@435:   MemoryManager*   _managers[max_num_managers];
duke@435:   int              _num_managers;
duke@435:   MemoryUsage      _peak_usage;               // Peak memory usage
duke@435:   MemoryUsage      _after_gc_usage;           // After GC memory usage
duke@435: 
duke@435:   ThresholdSupport* _usage_threshold;
duke@435:   ThresholdSupport* _gc_usage_threshold;
duke@435: 
duke@435:   SensorInfo*      _usage_sensor;
duke@435:   SensorInfo*      _gc_usage_sensor;
duke@435: 
duke@435:   volatile instanceOop _memory_pool_obj;
duke@435: 
duke@435:   void add_manager(MemoryManager* mgr);
duke@435: 
duke@435:  public:
duke@435:   MemoryPool(const char* name,
duke@435:              PoolType type,
duke@435:              size_t init_size,
duke@435:              size_t max_size,
duke@435:              bool support_usage_threshold,
duke@435:              bool support_gc_threshold);
duke@435: 
duke@435:   const char* name()                       { return _name; }
duke@435:   bool        is_heap()                    { return _type == Heap; }
duke@435:   bool        is_non_heap()                { return _type == NonHeap; }
duke@435:   size_t      initial_size()   const       { return _initial_size; }
duke@435:   int         num_memory_managers() const  { return _num_managers; }
duke@435:   // max size could be changed
duke@435:   virtual size_t max_size()    const       { return _max_size; }
duke@435: 
duke@435:   bool is_pool(instanceHandle pool) { return (pool() == _memory_pool_obj); }
duke@435: 
duke@435:   bool available_for_allocation()   { return _available_for_allocation; }
duke@435:   bool set_available_for_allocation(bool value) {
duke@435:     bool prev = _available_for_allocation;
duke@435:     _available_for_allocation = value;
duke@435:     return prev;
duke@435:   }
duke@435: 
duke@435:   MemoryManager* get_memory_manager(int index) {
duke@435:     assert(index >= 0 && index < _num_managers, "Invalid index");
duke@435:     return _managers[index];
duke@435:   }
duke@435: 
duke@435:   // Records current memory usage if it's a peak usage
duke@435:   void record_peak_memory_usage();
duke@435: 
duke@435:   MemoryUsage get_peak_memory_usage() {
duke@435:     // check current memory usage first and then return peak usage
duke@435:     record_peak_memory_usage();
duke@435:     return _peak_usage;
duke@435:   }
duke@435:   void        reset_peak_memory_usage() {
duke@435:     _peak_usage = get_memory_usage();
duke@435:   }
duke@435: 
duke@435:   ThresholdSupport* usage_threshold()      { return _usage_threshold; }
duke@435:   ThresholdSupport* gc_usage_threshold()   { return _gc_usage_threshold; }
duke@435: 
duke@435:   SensorInfo*       usage_sensor()         {  return _usage_sensor; }
duke@435:   SensorInfo*       gc_usage_sensor()      { return _gc_usage_sensor; }
duke@435: 
duke@435:   void        set_usage_sensor_obj(instanceHandle s);
duke@435:   void        set_gc_usage_sensor_obj(instanceHandle s);
duke@435:   void        set_last_collection_usage(MemoryUsage u)  { _after_gc_usage = u; }
duke@435: 
duke@435:   virtual instanceOop get_memory_pool_instance(TRAPS);
duke@435:   virtual MemoryUsage get_memory_usage() = 0;
duke@435:   virtual size_t      used_in_bytes() = 0;
duke@435:   virtual bool        is_collected_pool()         { return false; }
duke@435:   virtual MemoryUsage get_last_collection_usage() { return _after_gc_usage; }
duke@435: 
duke@435:   // GC support
duke@435:   void oops_do(OopClosure* f);
duke@435: };
duke@435: 
duke@435: class CollectedMemoryPool : public MemoryPool {
duke@435: public:
duke@435:   CollectedMemoryPool(const char* name, PoolType type, size_t init_size, size_t max_size, bool support_usage_threshold) :
duke@435:     MemoryPool(name, type, init_size, max_size, support_usage_threshold, true) {};
duke@435:   bool is_collected_pool()            { return true; }
duke@435: };
duke@435: 
duke@435: class ContiguousSpacePool : public CollectedMemoryPool {
duke@435: private:
duke@435:   ContiguousSpace* _space;
duke@435: 
duke@435: public:
duke@435:   ContiguousSpacePool(ContiguousSpace* space, const char* name, PoolType type, size_t max_size, bool support_usage_threshold);
duke@435: 
duke@435:   ContiguousSpace* space()              { return _space; }
duke@435:   MemoryUsage get_memory_usage();
duke@435:   size_t used_in_bytes()                { return space()->used(); }
duke@435: };
duke@435: 
duke@435: class SurvivorContiguousSpacePool : public CollectedMemoryPool {
duke@435: private:
duke@435:   DefNewGeneration* _gen;
duke@435: 
duke@435: public:
duke@435:   SurvivorContiguousSpacePool(DefNewGeneration* gen,
duke@435:                               const char* name,
duke@435:                               PoolType type,
duke@435:                               size_t max_size,
duke@435:                               bool support_usage_threshold);
duke@435: 
duke@435:   MemoryUsage get_memory_usage();
duke@435: 
duke@435:   size_t used_in_bytes() {
duke@435:     return _gen->from()->used();
duke@435:   }
duke@435:   size_t committed_in_bytes() {
duke@435:     return _gen->from()->capacity();
duke@435:   }
duke@435: };
duke@435: 
jprovino@4542: #if INCLUDE_ALL_GCS
duke@435: class CompactibleFreeListSpacePool : public CollectedMemoryPool {
duke@435: private:
duke@435:   CompactibleFreeListSpace* _space;
duke@435: public:
duke@435:   CompactibleFreeListSpacePool(CompactibleFreeListSpace* space,
duke@435:                                const char* name,
duke@435:                                PoolType type,
duke@435:                                size_t max_size,
duke@435:                                bool support_usage_threshold);
duke@435: 
duke@435:   MemoryUsage get_memory_usage();
duke@435:   size_t used_in_bytes()            { return _space->used(); }
duke@435: };
jprovino@4542: #endif // INCLUDE_ALL_GCS
duke@435: 
duke@435: 
duke@435: class GenerationPool : public CollectedMemoryPool {
duke@435: private:
duke@435:   Generation* _gen;
duke@435: public:
duke@435:   GenerationPool(Generation* gen, const char* name, PoolType type, bool support_usage_threshold);
duke@435: 
duke@435:   MemoryUsage get_memory_usage();
duke@435:   size_t used_in_bytes()                { return _gen->used(); }
duke@435: };
duke@435: 
duke@435: class CodeHeapPool: public MemoryPool {
duke@435: private:
duke@435:   CodeHeap* _codeHeap;
duke@435: public:
duke@435:   CodeHeapPool(CodeHeap* codeHeap, const char* name, bool support_usage_threshold);
duke@435:   MemoryUsage get_memory_usage();
duke@435:   size_t used_in_bytes()            { return _codeHeap->allocated_capacity(); }
duke@435: };
stefank@2314: 
ehelin@5312: class MetaspacePool : public MemoryPool {
ehelin@5312:   size_t calculate_max_size() const;
ehelin@5312:  public:
ehelin@5312:   MetaspacePool();
ehelin@5312:   MemoryUsage get_memory_usage();
ehelin@5312:   size_t used_in_bytes();
ehelin@5312: };
ehelin@5312: 
ehelin@5312: class CompressedKlassSpacePool : public MemoryPool {
ehelin@5312:  public:
ehelin@5312:   CompressedKlassSpacePool();
ehelin@5312:   MemoryUsage get_memory_usage();
ehelin@5312:   size_t used_in_bytes();
ehelin@5312: };
ehelin@5312: 
stefank@2314: #endif // SHARE_VM_SERVICES_MEMORYPOOL_HPP