jdk8-mips64-public/hotspot: src/share/vm/services/memoryPool.hpp@2494ab195856 (annotated)

src/share/vm/services/memoryPool.hpp@2494ab195856 (annotated)

src/share/vm/services/memoryPool.hpp

Mon, 15 Dec 2008 13:58:57 -0800

author: swamyv
date: Mon, 15 Dec 2008 13:58:57 -0800
changeset 924: 2494ab195856
parent 435: a61af66fc99e
child 1907: c18cbe5936b8
permissions: -rw-r--r--

6653214: MemoryPoolMXBean.setUsageThreshold() does not support large heap sizes.
Reviewed-by: ysr, mchung

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

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/services/memoryPool.hpp@2494ab195856 (annotated)

src/share/vm/services/memoryPool.hpp