1 /* 2 * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_VM_SERVICES_MEMORYPOOL_HPP 26 #define SHARE_VM_SERVICES_MEMORYPOOL_HPP 27 28 #include "memory/heap.hpp" 29 #include "services/memoryUsage.hpp" 30 #include "utilities/macros.hpp" 31 32 // A memory pool represents the memory area that the VM manages. 33 // The Java virtual machine has at least one memory pool 34 // and it may create or remove memory pools during execution. 35 // A memory pool can belong to the heap or the non-heap memory. 36 // A Java virtual machine may also have memory pools belonging to 37 // both heap and non-heap memory. 38 39 // Forward declaration 40 class CompactibleFreeListSpace; 41 class ContiguousSpace; 42 class MemoryManager; 43 class SensorInfo; 44 class Generation; 45 class DefNewGeneration; 46 class ThresholdSupport; 47 48 class MemoryPool : public CHeapObj<mtInternal> { 49 friend class MemoryManager; 50 public: 51 enum PoolType { 52 Heap = 1, 53 NonHeap = 2 54 }; 55 56 private: 57 enum { 58 max_num_managers = 5 59 }; 60 61 // We could make some of the following as performance counters 62 // for external monitoring. 63 const char* _name; 64 PoolType _type; 65 size_t _initial_size; 66 size_t _max_size; 67 bool _available_for_allocation; // Default is true 68 MemoryManager* _managers[max_num_managers]; 69 int _num_managers; 70 MemoryUsage _peak_usage; // Peak memory usage 71 MemoryUsage _after_gc_usage; // After GC memory usage 72 73 ThresholdSupport* _usage_threshold; 74 ThresholdSupport* _gc_usage_threshold; 75 76 SensorInfo* _usage_sensor; 77 SensorInfo* _gc_usage_sensor; 78 79 volatile instanceOop _memory_pool_obj; 80 81 void add_manager(MemoryManager* mgr); 82 83 public: 84 MemoryPool(const char* name, 85 PoolType type, 86 size_t init_size, 87 size_t max_size, 88 bool support_usage_threshold, 89 bool support_gc_threshold); 90 91 const char* name() { return _name; } 92 bool is_heap() { return _type == Heap; } 93 bool is_non_heap() { return _type == NonHeap; } 94 size_t initial_size() const { return _initial_size; } 95 int num_memory_managers() const { return _num_managers; } 96 // max size could be changed 97 virtual size_t max_size() const { return _max_size; } 98 99 bool is_pool(instanceHandle pool) { return (pool() == _memory_pool_obj); } 100 101 bool available_for_allocation() { return _available_for_allocation; } 102 bool set_available_for_allocation(bool value) { 103 bool prev = _available_for_allocation; 104 _available_for_allocation = value; 105 return prev; 106 } 107 108 MemoryManager* get_memory_manager(int index) { 109 assert(index >= 0 && index < _num_managers, "Invalid index"); 110 return _managers[index]; 111 } 112 113 // Records current memory usage if it's a peak usage 114 void record_peak_memory_usage(); 115 116 MemoryUsage get_peak_memory_usage() { 117 // check current memory usage first and then return peak usage 118 record_peak_memory_usage(); 119 return _peak_usage; 120 } 121 void reset_peak_memory_usage() { 122 _peak_usage = get_memory_usage(); 123 } 124 125 ThresholdSupport* usage_threshold() { return _usage_threshold; } 126 ThresholdSupport* gc_usage_threshold() { return _gc_usage_threshold; } 127 128 SensorInfo* usage_sensor() { return _usage_sensor; } 129 SensorInfo* gc_usage_sensor() { return _gc_usage_sensor; } 130 131 void set_usage_sensor_obj(instanceHandle s); 132 void set_gc_usage_sensor_obj(instanceHandle s); 133 void set_last_collection_usage(MemoryUsage u) { _after_gc_usage = u; } 134 135 virtual instanceOop get_memory_pool_instance(TRAPS); 136 virtual MemoryUsage get_memory_usage() = 0; 137 virtual size_t used_in_bytes() = 0; 138 virtual bool is_collected_pool() { return false; } 139 virtual MemoryUsage get_last_collection_usage() { return _after_gc_usage; } 140 141 // GC support 142 void oops_do(OopClosure* f); 143 }; 144 145 class CollectedMemoryPool : public MemoryPool { 146 public: 147 CollectedMemoryPool(const char* name, PoolType type, size_t init_size, size_t max_size, bool support_usage_threshold) : 148 MemoryPool(name, type, init_size, max_size, support_usage_threshold, true) {}; 149 bool is_collected_pool() { return true; } 150 }; 151 152 class ContiguousSpacePool : public CollectedMemoryPool { 153 private: 154 ContiguousSpace* _space; 155 156 public: 157 ContiguousSpacePool(ContiguousSpace* space, const char* name, PoolType type, size_t max_size, bool support_usage_threshold); 158 159 ContiguousSpace* space() { return _space; } 160 MemoryUsage get_memory_usage(); 161 size_t used_in_bytes(); 162 }; 163 164 class SurvivorContiguousSpacePool : public CollectedMemoryPool { 165 private: 166 DefNewGeneration* _young_gen; 167 168 public: 169 SurvivorContiguousSpacePool(DefNewGeneration* young_gen, 170 const char* name, 171 PoolType type, 172 size_t max_size, 173 bool support_usage_threshold); 174 175 MemoryUsage get_memory_usage(); 176 177 size_t used_in_bytes(); 178 size_t committed_in_bytes(); 179 }; 180 181 182 class GenerationPool : public CollectedMemoryPool { 183 private: 184 Generation* _gen; 185 public: 186 GenerationPool(Generation* gen, const char* name, PoolType type, bool support_usage_threshold); 187 188 MemoryUsage get_memory_usage(); 189 size_t used_in_bytes(); 190 }; 191 192 class CodeHeapPool: public MemoryPool { 193 private: 194 CodeHeap* _codeHeap; 195 public: 196 CodeHeapPool(CodeHeap* codeHeap, const char* name, bool support_usage_threshold); 197 MemoryUsage get_memory_usage(); 198 size_t used_in_bytes() { return _codeHeap->allocated_capacity(); } 199 }; 200 201 class MetaspacePool : public MemoryPool { 202 size_t calculate_max_size() const; 203 public: 204 MetaspacePool(); 205 MemoryUsage get_memory_usage(); 206 size_t used_in_bytes(); 207 }; 208 209 class CompressedKlassSpacePool : public MemoryPool { 210 public: 211 CompressedKlassSpacePool(); 212 MemoryUsage get_memory_usage(); 213 size_t used_in_bytes(); 214 }; 215 216 #endif // SHARE_VM_SERVICES_MEMORYPOOL_HPP