src/share/vm/services/memoryService.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File 8015774 Sdiff src/share/vm/services

src/share/vm/services/memoryService.hpp

Print this page




  36 class MemoryManager;
  37 class GCMemoryManager;
  38 class CollectedHeap;
  39 class Generation;
  40 class DefNewGeneration;
  41 class PSYoungGen;
  42 class PSOldGen;
  43 class CodeHeap;
  44 class ContiguousSpace;
  45 class CompactibleFreeListSpace;
  46 class GenCollectedHeap;
  47 class ParallelScavengeHeap;
  48 class G1CollectedHeap;
  49 
  50 // VM Monitoring and Management Support
  51 
  52 class MemoryService : public AllStatic {
  53 private:
  54   enum {
  55     init_pools_list_size = 10,
  56     init_managers_list_size = 5

  57   };
  58 
  59   // index for minor and major generations
  60   enum {
  61     minor = 0,
  62     major = 1,
  63     n_gens = 2
  64   };
  65 
  66   static GrowableArray<MemoryPool*>*    _pools_list;
  67   static GrowableArray<MemoryManager*>* _managers_list;
  68 
  69   // memory managers for minor and major GC statistics
  70   static GCMemoryManager*               _major_gc_manager;
  71   static GCMemoryManager*               _minor_gc_manager;
  72 
  73   // Code heap memory pool
  74   static MemoryPool*                    _code_heap_pool;

  75 
  76   static MemoryPool*                    _metaspace_pool;
  77   static MemoryPool*                    _compressed_class_pool;
  78 
  79   static void add_generation_memory_pool(Generation* gen,
  80                                          MemoryManager* major_mgr,
  81                                          MemoryManager* minor_mgr);
  82   static void add_generation_memory_pool(Generation* gen,
  83                                          MemoryManager* major_mgr) {
  84     add_generation_memory_pool(gen, major_mgr, NULL);
  85   }
  86 
  87 
  88   static void add_psYoung_memory_pool(PSYoungGen* gen,
  89                                       MemoryManager* major_mgr,
  90                                       MemoryManager* minor_mgr);
  91   static void add_psOld_memory_pool(PSOldGen* gen,
  92                                     MemoryManager* mgr);
  93 
  94   static void add_g1YoungGen_memory_pool(G1CollectedHeap* g1h,


 106                                          const char* name,
 107                                          bool is_heap,
 108                                          size_t max_size,
 109                                          bool support_usage_threshold);
 110   static MemoryPool* add_gen(Generation* gen,
 111                              const char* name,
 112                              bool is_heap,
 113                              bool support_usage_threshold);
 114   static MemoryPool* add_cms_space(CompactibleFreeListSpace* space,
 115                                    const char* name,
 116                                    bool is_heap,
 117                                    size_t max_size,
 118                                    bool support_usage_threshold);
 119 
 120   static void add_gen_collected_heap_info(GenCollectedHeap* heap);
 121   static void add_parallel_scavenge_heap_info(ParallelScavengeHeap* heap);
 122   static void add_g1_heap_info(G1CollectedHeap* g1h);
 123 
 124 public:
 125   static void set_universe_heap(CollectedHeap* heap);
 126   static void add_code_heap_memory_pool(CodeHeap* heap);
 127   static void add_metaspace_memory_pools();
 128 
 129   static MemoryPool*    get_memory_pool(instanceHandle pool);
 130   static MemoryManager* get_memory_manager(instanceHandle mgr);
 131 
 132   static const int num_memory_pools() {
 133     return _pools_list->length();
 134   }
 135   static const int num_memory_managers() {
 136     return _managers_list->length();
 137   }
 138 
 139   static MemoryPool* get_memory_pool(int index) {
 140     return _pools_list->at(index);
 141   }
 142 
 143   static MemoryManager* get_memory_manager(int index) {
 144     return _managers_list->at(index);
 145   }
 146 
 147   static void track_memory_usage();
 148   static void track_code_cache_memory_usage() {
 149     track_memory_pool_usage(_code_heap_pool);



 150   }
 151   static void track_metaspace_memory_usage() {
 152     track_memory_pool_usage(_metaspace_pool);
 153   }
 154   static void track_compressed_class_memory_usage() {
 155     track_memory_pool_usage(_compressed_class_pool);
 156   }
 157   static void track_memory_pool_usage(MemoryPool* pool);
 158 
 159   static void gc_begin(bool fullGC, bool recordGCBeginTime,
 160                        bool recordAccumulatedGCTime,
 161                        bool recordPreGCUsage, bool recordPeakUsage);
 162   static void gc_end(bool fullGC, bool recordPostGCUsage,
 163                      bool recordAccumulatedGCTime,
 164                      bool recordGCEndTime, bool countCollection,
 165                      GCCause::Cause cause);
 166 
 167 
 168   static void oops_do(OopClosure* f);
 169 




  36 class MemoryManager;
  37 class GCMemoryManager;
  38 class CollectedHeap;
  39 class Generation;
  40 class DefNewGeneration;
  41 class PSYoungGen;
  42 class PSOldGen;
  43 class CodeHeap;
  44 class ContiguousSpace;
  45 class CompactibleFreeListSpace;
  46 class GenCollectedHeap;
  47 class ParallelScavengeHeap;
  48 class G1CollectedHeap;
  49 
  50 // VM Monitoring and Management Support
  51 
  52 class MemoryService : public AllStatic {
  53 private:
  54   enum {
  55     init_pools_list_size = 10,
  56     init_managers_list_size = 5,
  57     init_code_heap_pools_size = 9
  58   };
  59 
  60   // index for minor and major generations
  61   enum {
  62     minor = 0,
  63     major = 1,
  64     n_gens = 2
  65   };
  66 
  67   static GrowableArray<MemoryPool*>*    _pools_list;
  68   static GrowableArray<MemoryManager*>* _managers_list;
  69 
  70   // memory managers for minor and major GC statistics
  71   static GCMemoryManager*               _major_gc_manager;
  72   static GCMemoryManager*               _minor_gc_manager;
  73 
  74   // memory manager and code heap pools for the CodeCache
  75   static MemoryManager*                 _code_cache_manager;
  76   static GrowableArray<MemoryPool*>*    _code_heap_pools;
  77 
  78   static MemoryPool*                    _metaspace_pool;
  79   static MemoryPool*                    _compressed_class_pool;
  80 
  81   static void add_generation_memory_pool(Generation* gen,
  82                                          MemoryManager* major_mgr,
  83                                          MemoryManager* minor_mgr);
  84   static void add_generation_memory_pool(Generation* gen,
  85                                          MemoryManager* major_mgr) {
  86     add_generation_memory_pool(gen, major_mgr, NULL);
  87   }
  88 
  89 
  90   static void add_psYoung_memory_pool(PSYoungGen* gen,
  91                                       MemoryManager* major_mgr,
  92                                       MemoryManager* minor_mgr);
  93   static void add_psOld_memory_pool(PSOldGen* gen,
  94                                     MemoryManager* mgr);
  95 
  96   static void add_g1YoungGen_memory_pool(G1CollectedHeap* g1h,


 108                                          const char* name,
 109                                          bool is_heap,
 110                                          size_t max_size,
 111                                          bool support_usage_threshold);
 112   static MemoryPool* add_gen(Generation* gen,
 113                              const char* name,
 114                              bool is_heap,
 115                              bool support_usage_threshold);
 116   static MemoryPool* add_cms_space(CompactibleFreeListSpace* space,
 117                                    const char* name,
 118                                    bool is_heap,
 119                                    size_t max_size,
 120                                    bool support_usage_threshold);
 121 
 122   static void add_gen_collected_heap_info(GenCollectedHeap* heap);
 123   static void add_parallel_scavenge_heap_info(ParallelScavengeHeap* heap);
 124   static void add_g1_heap_info(G1CollectedHeap* g1h);
 125 
 126 public:
 127   static void set_universe_heap(CollectedHeap* heap);
 128   static void add_code_heap_memory_pool(CodeHeap* heap, const char* name);
 129   static void add_metaspace_memory_pools();
 130 
 131   static MemoryPool*    get_memory_pool(instanceHandle pool);
 132   static MemoryManager* get_memory_manager(instanceHandle mgr);
 133 
 134   static const int num_memory_pools() {
 135     return _pools_list->length();
 136   }
 137   static const int num_memory_managers() {
 138     return _managers_list->length();
 139   }
 140 
 141   static MemoryPool* get_memory_pool(int index) {
 142     return _pools_list->at(index);
 143   }
 144 
 145   static MemoryManager* get_memory_manager(int index) {
 146     return _managers_list->at(index);
 147   }
 148 
 149   static void track_memory_usage();
 150   static void track_code_cache_memory_usage() {
 151     // Track memory pool usage of all CodeCache memory pools
 152     for (int i = 0; i < _code_heap_pools->length(); ++i) {
 153       track_memory_pool_usage(_code_heap_pools->at(i));
 154     }
 155   }
 156   static void track_metaspace_memory_usage() {
 157     track_memory_pool_usage(_metaspace_pool);
 158   }
 159   static void track_compressed_class_memory_usage() {
 160     track_memory_pool_usage(_compressed_class_pool);
 161   }
 162   static void track_memory_pool_usage(MemoryPool* pool);
 163 
 164   static void gc_begin(bool fullGC, bool recordGCBeginTime,
 165                        bool recordAccumulatedGCTime,
 166                        bool recordPreGCUsage, bool recordPeakUsage);
 167   static void gc_end(bool fullGC, bool recordPostGCUsage,
 168                      bool recordAccumulatedGCTime,
 169                      bool recordGCEndTime, bool countCollection,
 170                      GCCause::Cause cause);
 171 
 172 
 173   static void oops_do(OopClosure* f);
 174 


src/share/vm/services/memoryService.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File