1 /*
2 * Copyright (c) 2003, 2013, 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 *
58 int num_memory_pools() const { return _num_pools; }
59 MemoryPool* get_memory_pool(int index) {
60 assert(index >= 0 && index < _num_pools, "Invalid index");
61 return _pools[index];
62 }
63
64 void add_pool(MemoryPool* pool);
65
66 bool is_manager(instanceHandle mh) { return mh() == _memory_mgr_obj; }
67
68 virtual instanceOop get_memory_manager_instance(TRAPS);
69 virtual bool is_gc_memory_manager() { return false; }
70 virtual const char* name() = 0;
71
72 // GC support
73 void oops_do(OopClosure* f);
74
75 // Static factory methods to get a memory manager of a specific type
76 static MemoryManager* get_code_cache_memory_manager();
77 static MemoryManager* get_metaspace_memory_manager();
78 static GCMemoryManager* get_copy_memory_manager();
79 static GCMemoryManager* get_msc_memory_manager();
80 static GCMemoryManager* get_parnew_memory_manager();
81 static GCMemoryManager* get_cms_memory_manager();
82 static GCMemoryManager* get_psScavenge_memory_manager();
83 static GCMemoryManager* get_psMarkSweep_memory_manager();
84 static GCMemoryManager* get_g1YoungGen_memory_manager();
85 static GCMemoryManager* get_g1OldGen_memory_manager();
86 };
87
88 class CodeCacheMemoryManager : public MemoryManager {
89 private:
90 public:
91 CodeCacheMemoryManager() : MemoryManager() {}
92
93 const char* name() { return "CodeCacheManager"; }
94 };
95
96 class MetaspaceMemoryManager : public MemoryManager {
97 public:
98 MetaspaceMemoryManager() : MemoryManager() {}
99
100 const char* name() { return "Metaspace Manager"; }
101 };
102
103 class GCStatInfo : public ResourceObj {
104 private:
105 size_t _index;
148 void clear();
149 };
150
151 class GCMemoryManager : public MemoryManager {
152 private:
153 // TODO: We should unify the GCCounter and GCMemoryManager statistic
154 size_t _num_collections;
155 elapsedTimer _accumulated_timer;
156 elapsedTimer _gc_timer; // for measuring every GC duration
157 GCStatInfo* _last_gc_stat;
158 Mutex* _last_gc_lock;
159 GCStatInfo* _current_gc_stat;
160 int _num_gc_threads;
161 volatile bool _notification_enabled;
162 public:
163 GCMemoryManager();
164 ~GCMemoryManager();
165
166 void initialize_gc_stat_info();
167
168 bool is_gc_memory_manager() { return true; }
169 jlong gc_time_ms() { return _accumulated_timer.milliseconds(); }
170 size_t gc_count() { return _num_collections; }
171 int num_gc_threads() { return _num_gc_threads; }
172 void set_num_gc_threads(int count) { _num_gc_threads = count; }
173
174 void gc_begin(bool recordGCBeginTime, bool recordPreGCUsage,
175 bool recordAccumulatedGCTime);
176 void gc_end(bool recordPostGCUsage, bool recordAccumulatedGCTime,
177 bool recordGCEndTime, bool countCollection, GCCause::Cause cause);
178
179 void reset_gc_stat() { _num_collections = 0; _accumulated_timer.reset(); }
180
181 // Copy out _last_gc_stat to the given destination, returning
182 // the collection count. Zero signifies no gc has taken place.
183 size_t get_last_gc_stat(GCStatInfo* dest);
184
185 void set_notification_enabled(bool enabled) { _notification_enabled = enabled; }
186 bool is_notification_enabled() { return _notification_enabled; }
187 };
188
189 // These subclasses of GCMemoryManager are defined to include
190 // GC-specific information.
191 // TODO: Add GC-specific information
192 class CopyMemoryManager : public GCMemoryManager {
193 private:
194 public:
195 CopyMemoryManager() : GCMemoryManager() {}
196
197 const char* name() { return "Copy"; }
198 };
199
200 class MSCMemoryManager : public GCMemoryManager {
201 private:
202 public:
203 MSCMemoryManager() : GCMemoryManager() {}
204
205 const char* name() { return "MarkSweepCompact"; }
206 };
207
208 class ParNewMemoryManager : public GCMemoryManager {
209 private:
210 public:
211 ParNewMemoryManager() : GCMemoryManager() {}
212
213 const char* name() { return "ParNew"; }
214 };
215
216 class CMSMemoryManager : public GCMemoryManager {
217 private:
218 public:
219 CMSMemoryManager() : GCMemoryManager() {}
220
221 const char* name() { return "ConcurrentMarkSweep";}
222 };
223
224 class PSScavengeMemoryManager : public GCMemoryManager {
225 private:
226 public:
227 PSScavengeMemoryManager() : GCMemoryManager() {}
228
229 const char* name() { return "PS Scavenge"; }
230 };
231
232 class PSMarkSweepMemoryManager : public GCMemoryManager {
233 private:
234 public:
235 PSMarkSweepMemoryManager() : GCMemoryManager() {}
236
237 const char* name() { return "PS MarkSweep"; }
238 };
239
240 class G1YoungGenMemoryManager : public GCMemoryManager {
241 private:
242 public:
243 G1YoungGenMemoryManager() : GCMemoryManager() {}
244
245 const char* name() { return "G1 Young Generation"; }
246 };
247
248 class G1OldGenMemoryManager : public GCMemoryManager {
249 private:
250 public:
251 G1OldGenMemoryManager() : GCMemoryManager() {}
252
253 const char* name() { return "G1 Old Generation"; }
254 };
255
256 #endif // SHARE_VM_SERVICES_MEMORYMANAGER_HPP
|
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 *
58 int num_memory_pools() const { return _num_pools; }
59 MemoryPool* get_memory_pool(int index) {
60 assert(index >= 0 && index < _num_pools, "Invalid index");
61 return _pools[index];
62 }
63
64 void add_pool(MemoryPool* pool);
65
66 bool is_manager(instanceHandle mh) { return mh() == _memory_mgr_obj; }
67
68 virtual instanceOop get_memory_manager_instance(TRAPS);
69 virtual bool is_gc_memory_manager() { return false; }
70 virtual const char* name() = 0;
71
72 // GC support
73 void oops_do(OopClosure* f);
74
75 // Static factory methods to get a memory manager of a specific type
76 static MemoryManager* get_code_cache_memory_manager();
77 static MemoryManager* get_metaspace_memory_manager();
78 };
79
80 class CodeCacheMemoryManager : public MemoryManager {
81 private:
82 public:
83 CodeCacheMemoryManager() : MemoryManager() {}
84
85 const char* name() { return "CodeCacheManager"; }
86 };
87
88 class MetaspaceMemoryManager : public MemoryManager {
89 public:
90 MetaspaceMemoryManager() : MemoryManager() {}
91
92 const char* name() { return "Metaspace Manager"; }
93 };
94
95 class GCStatInfo : public ResourceObj {
96 private:
97 size_t _index;
140 void clear();
141 };
142
143 class GCMemoryManager : public MemoryManager {
144 private:
145 // TODO: We should unify the GCCounter and GCMemoryManager statistic
146 size_t _num_collections;
147 elapsedTimer _accumulated_timer;
148 elapsedTimer _gc_timer; // for measuring every GC duration
149 GCStatInfo* _last_gc_stat;
150 Mutex* _last_gc_lock;
151 GCStatInfo* _current_gc_stat;
152 int _num_gc_threads;
153 volatile bool _notification_enabled;
154 public:
155 GCMemoryManager();
156 ~GCMemoryManager();
157
158 void initialize_gc_stat_info();
159
160 virtual const char* gc_end_message() = 0;
161
162 bool is_gc_memory_manager() { return true; }
163 jlong gc_time_ms() { return _accumulated_timer.milliseconds(); }
164 size_t gc_count() { return _num_collections; }
165 int num_gc_threads() { return _num_gc_threads; }
166 void set_num_gc_threads(int count) { _num_gc_threads = count; }
167
168 void gc_begin(bool recordGCBeginTime, bool recordPreGCUsage,
169 bool recordAccumulatedGCTime);
170 void gc_end(bool recordPostGCUsage, bool recordAccumulatedGCTime,
171 bool recordGCEndTime, bool countCollection, GCCause::Cause cause);
172
173 void reset_gc_stat() { _num_collections = 0; _accumulated_timer.reset(); }
174
175 // Copy out _last_gc_stat to the given destination, returning
176 // the collection count. Zero signifies no gc has taken place.
177 size_t get_last_gc_stat(GCStatInfo* dest);
178
179 void set_notification_enabled(bool enabled) { _notification_enabled = enabled; }
180 bool is_notification_enabled() { return _notification_enabled; }
181 };
182
183 #endif // SHARE_VM_SERVICES_MEMORYMANAGER_HPP
|