1 /*
2 * Copyright (c) 2012, 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 *
23 */
24
25 #ifndef SHARE_VM_SERVICES_MEM_PTR_HPP
26 #define SHARE_VM_SERVICES_MEM_PTR_HPP
27
28 #include "memory/allocation.hpp"
29 #include "runtime/os.hpp"
30 #include "runtime/safepoint.hpp"
31
32 /*
33 * global sequence generator that generates sequence numbers to serialize
34 * memory records.
35 */
36 class SequenceGenerator : AllStatic {
37 public:
38 static jint next();
39
40 // peek last sequence number
41 static jint peek() {
42 return _seq_number;
43 }
44
45 // reset sequence number
46 static void reset() {
47 assert(SafepointSynchronize::is_at_safepoint(), "Safepoint required");
48 _seq_number = 1;
49 _generation ++;
50 };
51
52 static unsigned long current_generation() { return _generation; }
53 NOT_PRODUCT(static jint max_seq_num() { return _max_seq_number; })
54
55 private:
56 static volatile jint _seq_number;
57 static volatile unsigned long _generation;
58 NOT_PRODUCT(static jint _max_seq_number; )
59 };
60
61 /*
62 * followings are the classes that are used to hold memory activity records in different stages.
63 * MemPointer
64 * |--------MemPointerRecord
65 * |
66 * |----MemPointerRecordEx
67 * | |
68 * | |-------SeqMemPointerRecordEx
69 * |
70 * |----SeqMemPointerRecord
71 * |
72 * |----VMMemRegion
73 * |
74 * |-----VMMemRegionEx
75 *
76 *
77 * prefix 'Seq' - sequenced, the record contains a sequence number
78 * surfix 'Ex' - extension, the record contains a caller's pc
79 *
80 * per-thread recorder : SeqMemPointerRecord(Ex)
81 * snapshot staging : SeqMemPointerRecord(Ex)
82 * snapshot : MemPointerRecord(Ex) and VMMemRegion(Ex)
83 *
84 */
85
86 /*
87 * class that wraps an address to a memory block,
88 * the memory pointer either points to a malloc'd
89 * memory block, or a mmap'd memory block
90 */
91 class MemPointer VALUE_OBJ_CLASS_SPEC {
92 public:
93 MemPointer(): _addr(0) { }
94 MemPointer(address addr): _addr(addr) { }
95
96 MemPointer(const MemPointer& copy_from) {
97 _addr = copy_from.addr();
98 }
99
100 inline address addr() const {
101 return _addr;
102 }
103
104 inline operator address() const {
105 return addr();
106 }
107
108 inline bool operator == (const MemPointer& other) const {
109 return addr() == other.addr();
110 }
111
112 inline MemPointer& operator = (const MemPointer& other) {
113 _addr = other.addr();
114 return *this;
115 }
116
117 protected:
118 inline void set_addr(address addr) { _addr = addr; }
119
120 protected:
121 // memory address
122 address _addr;
123 };
124
125 /* MemPointerRecord records an activityand associated
126 * attributes on a memory block.
127 */
128 class MemPointerRecord : public MemPointer {
129 private:
130 MEMFLAGS _flags;
131 size_t _size;
132
133 public:
134 /* extension of MemoryType enum
135 * see share/vm/memory/allocation.hpp for details.
136 *
137 * The tag values are associated to sorting orders, so be
138 * careful if changes are needed.
139 * The allocation records should be sorted ahead of tagging
140 * records, which in turn ahead of deallocation records
141 */
142 enum MemPointerTags {
143 tag_alloc = 0x0001, // malloc or reserve record
144 tag_commit = 0x0002, // commit record
145 tag_type = 0x0003, // tag virtual memory to a memory type
146 tag_uncommit = 0x0004, // uncommit record
147 tag_release = 0x0005, // free or release record
148 tag_size = 0x0006, // arena size
149 tag_masks = 0x0007, // all tag bits
150 vmBit = 0x0008
151 };
152
153 /* helper functions to interpret the tagging flags */
154
155 inline static bool is_allocation_record(MEMFLAGS flags) {
156 return (flags & tag_masks) == tag_alloc;
157 }
158
159 inline static bool is_deallocation_record(MEMFLAGS flags) {
160 return (flags & tag_masks) == tag_release;
161 }
162
163 inline static bool is_arena_record(MEMFLAGS flags) {
164 return (flags & (otArena | tag_size)) == otArena;
165 }
166
167 inline static bool is_arena_memory_record(MEMFLAGS flags) {
168 return (flags & (otArena | tag_size)) == (otArena | tag_size);
169 }
170
171 inline static bool is_virtual_memory_record(MEMFLAGS flags) {
172 return (flags & vmBit) != 0;
173 }
174
175 inline static bool is_virtual_memory_reserve_record(MEMFLAGS flags) {
176 return (flags & 0x0F) == (tag_alloc | vmBit);
177 }
178
179 inline static bool is_virtual_memory_commit_record(MEMFLAGS flags) {
180 return (flags & 0x0F) == (tag_commit | vmBit);
181 }
182
183 inline static bool is_virtual_memory_uncommit_record(MEMFLAGS flags) {
184 return (flags & 0x0F) == (tag_uncommit | vmBit);
185 }
186
187 inline static bool is_virtual_memory_release_record(MEMFLAGS flags) {
188 return (flags & 0x0F) == (tag_release | vmBit);
189 }
190
191 inline static bool is_virtual_memory_type_record(MEMFLAGS flags) {
192 return (flags & 0x0F) == (tag_type | vmBit);
193 }
194
195 /* tagging flags */
196 inline static MEMFLAGS malloc_tag() { return tag_alloc; }
197 inline static MEMFLAGS free_tag() { return tag_release; }
198 inline static MEMFLAGS arena_size_tag() { return tag_size | otArena; }
199 inline static MEMFLAGS virtual_memory_tag() { return vmBit; }
200 inline static MEMFLAGS virtual_memory_reserve_tag() { return (tag_alloc | vmBit); }
201 inline static MEMFLAGS virtual_memory_commit_tag() { return (tag_commit | vmBit); }
202 inline static MEMFLAGS virtual_memory_uncommit_tag(){ return (tag_uncommit | vmBit); }
203 inline static MEMFLAGS virtual_memory_release_tag() { return (tag_release | vmBit); }
204 inline static MEMFLAGS virtual_memory_type_tag() { return (tag_type | vmBit); }
205
206 public:
207 MemPointerRecord(): _size(0), _flags(mtNone) { }
208
209 MemPointerRecord(address addr, MEMFLAGS memflags, size_t size = 0):
210 MemPointer(addr), _flags(memflags), _size(size) { }
211
212 MemPointerRecord(const MemPointerRecord& copy_from):
213 MemPointer(copy_from), _flags(copy_from.flags()),
214 _size(copy_from.size()) {
215 }
216
217 /* MemPointerRecord is not sequenced, it always return
218 * 0 to indicate non-sequenced
219 */
220 virtual jint seq() const { return 0; }
221
222 inline size_t size() const { return _size; }
223 inline void set_size(size_t size) { _size = size; }
224
225 inline MEMFLAGS flags() const { return _flags; }
226 inline void set_flags(MEMFLAGS flags) { _flags = flags; }
227
228 MemPointerRecord& operator= (const MemPointerRecord& ptr) {
229 MemPointer::operator=(ptr);
230 _flags = ptr.flags();
231 #ifdef ASSERT
232 if (IS_ARENA_OBJ(_flags)) {
233 assert(!is_vm_pointer(), "wrong flags");
234 assert((_flags & ot_masks) == otArena, "wrong flags");
235 }
236 #endif
237 _size = ptr.size();
238 return *this;
239 }
240
241 // if the pointer represents a malloc-ed memory address
242 inline bool is_malloced_pointer() const {
243 return !is_vm_pointer();
244 }
245
246 // if the pointer represents a virtual memory address
247 inline bool is_vm_pointer() const {
248 return is_virtual_memory_record(_flags);
249 }
250
251 // if this record records a 'malloc' or virtual memory
252 // 'reserve' call
253 inline bool is_allocation_record() const {
254 return is_allocation_record(_flags);
255 }
256
257 // if this record records a size information of an arena
258 inline bool is_arena_memory_record() const {
259 return is_arena_memory_record(_flags);
260 }
261
262 // if this pointer represents an address to an arena object
263 inline bool is_arena_record() const {
264 return is_arena_record(_flags);
265 }
266
267 // if this record represents a size information of specific arena
268 inline bool is_memory_record_of_arena(const MemPointerRecord* arena_rc) {
269 assert(is_arena_memory_record(), "not size record");
270 assert(arena_rc->is_arena_record(), "not arena record");
271 return (arena_rc->addr() + sizeof(void*)) == addr();
272 }
273
274 // if this record records a 'free' or virtual memory 'free' call
275 inline bool is_deallocation_record() const {
276 return is_deallocation_record(_flags);
277 }
278
279 // if this record records a virtual memory 'commit' call
280 inline bool is_commit_record() const {
281 return is_virtual_memory_commit_record(_flags);
282 }
283
284 // if this record records a virtual memory 'uncommit' call
285 inline bool is_uncommit_record() const {
286 return is_virtual_memory_uncommit_record(_flags);
287 }
288
289 // if this record is a tagging record of a virtual memory block
290 inline bool is_type_tagging_record() const {
291 return is_virtual_memory_type_record(_flags);
292 }
293
294 // if the two memory pointer records actually represent the same
295 // memory block
296 inline bool is_same_region(const MemPointerRecord* other) const {
297 return (addr() == other->addr() && size() == other->size());
298 }
299
300 // if this memory region fully contains another one
301 inline bool contains_region(const MemPointerRecord* other) const {
302 return contains_region(other->addr(), other->size());
303 }
304
305 // if this memory region fully contains specified memory range
306 inline bool contains_region(address add, size_t sz) const {
307 return (addr() <= add && addr() + size() >= add + sz);
308 }
309
310 inline bool contains_address(address add) const {
311 return (addr() <= add && addr() + size() > add);
312 }
313
314 // if this memory region overlaps another region
315 inline bool overlaps_region(const MemPointerRecord* other) const {
316 assert(other != NULL, "Just check");
317 assert(size() > 0 && other->size() > 0, "empty range");
318 return contains_address(other->addr()) ||
319 contains_address(other->addr() + other->size() - 1) || // exclude end address
320 other->contains_address(addr()) ||
321 other->contains_address(addr() + size() - 1); // exclude end address
322 }
323
324 };
325
326 // MemPointerRecordEx also records callsite pc, from where
327 // the memory block is allocated
328 class MemPointerRecordEx : public MemPointerRecord {
329 private:
330 address _pc; // callsite pc
331
332 public:
333 MemPointerRecordEx(): _pc(0) { }
334
335 MemPointerRecordEx(address addr, MEMFLAGS memflags, size_t size = 0, address pc = 0):
336 MemPointerRecord(addr, memflags, size), _pc(pc) {}
337
338 MemPointerRecordEx(const MemPointerRecordEx& copy_from):
339 MemPointerRecord(copy_from), _pc(copy_from.pc()) {}
340
341 inline address pc() const { return _pc; }
342
343 void init(const MemPointerRecordEx* mpe) {
344 MemPointerRecord::operator=(*mpe);
345 _pc = mpe->pc();
346 }
347
348 void init(const MemPointerRecord* mp) {
349 MemPointerRecord::operator=(*mp);
350 _pc = 0;
351 }
352 };
353
354 // a virtual memory region. The region can represent a reserved
355 // virtual memory region or a committed memory region
356 class VMMemRegion : public MemPointerRecord {
357 public:
358 VMMemRegion() { }
359
360 void init(const MemPointerRecord* mp) {
361 assert(mp->is_vm_pointer(), "Sanity check");
362 _addr = mp->addr();
363 set_size(mp->size());
364 set_flags(mp->flags());
365 }
366
367 VMMemRegion& operator=(const VMMemRegion& other) {
368 MemPointerRecord::operator=(other);
369 return *this;
370 }
371
372 inline bool is_reserved_region() const {
373 return is_allocation_record();
374 }
375
376 inline bool is_committed_region() const {
377 return is_commit_record();
378 }
379
380 /* base address of this virtual memory range */
381 inline address base() const {
382 return addr();
383 }
384
385 /* tag this virtual memory range to the specified memory type */
386 inline void tag(MEMFLAGS f) {
387 set_flags(flags() | (f & mt_masks));
388 }
389
390 // expand this region to also cover specified range.
391 // The range has to be on either end of the memory region.
392 void expand_region(address addr, size_t sz) {
393 if (addr < base()) {
394 assert(addr + sz == base(), "Sanity check");
395 _addr = addr;
396 set_size(size() + sz);
397 } else {
398 assert(base() + size() == addr, "Sanity check");
399 set_size(size() + sz);
400 }
401 }
402
403 // exclude the specified address range from this region.
404 // The excluded memory range has to be on either end of this memory
405 // region.
406 inline void exclude_region(address add, size_t sz) {
407 assert(is_reserved_region() || is_committed_region(), "Sanity check");
408 assert(addr() != NULL && size() != 0, "Sanity check");
409 assert(add >= addr() && add < addr() + size(), "Sanity check");
410 assert(add == addr() || (add + sz) == (addr() + size()),
411 "exclude in the middle");
412 if (add == addr()) {
413 set_addr(add + sz);
414 set_size(size() - sz);
415 } else {
416 set_size(size() - sz);
417 }
418 }
419 };
420
421 class VMMemRegionEx : public VMMemRegion {
422 private:
423 jint _seq; // sequence number
424
425 public:
426 VMMemRegionEx(): _pc(0) { }
427
428 void init(const MemPointerRecordEx* mpe) {
429 VMMemRegion::init(mpe);
430 _pc = mpe->pc();
431 }
432
433 void init(const MemPointerRecord* mpe) {
434 VMMemRegion::init(mpe);
435 _pc = 0;
436 }
437
438 VMMemRegionEx& operator=(const VMMemRegionEx& other) {
439 VMMemRegion::operator=(other);
440 _pc = other.pc();
441 return *this;
442 }
443
444 inline address pc() const { return _pc; }
445 private:
446 address _pc;
447 };
448
449 /*
450 * Sequenced memory record
451 */
452 class SeqMemPointerRecord : public MemPointerRecord {
453 private:
454 jint _seq; // sequence number
455
456 public:
457 SeqMemPointerRecord(): _seq(0){ }
458
459 SeqMemPointerRecord(address addr, MEMFLAGS flags, size_t size, jint seq)
460 : MemPointerRecord(addr, flags, size), _seq(seq) {
461 }
462
463 SeqMemPointerRecord(const SeqMemPointerRecord& copy_from)
464 : MemPointerRecord(copy_from) {
465 _seq = copy_from.seq();
466 }
467
468 SeqMemPointerRecord& operator= (const SeqMemPointerRecord& ptr) {
469 MemPointerRecord::operator=(ptr);
470 _seq = ptr.seq();
471 return *this;
472 }
473
474 inline jint seq() const {
475 return _seq;
476 }
477 };
478
479
480
481 class SeqMemPointerRecordEx : public MemPointerRecordEx {
482 private:
483 jint _seq; // sequence number
484
485 public:
486 SeqMemPointerRecordEx(): _seq(0) { }
487
488 SeqMemPointerRecordEx(address addr, MEMFLAGS flags, size_t size,
489 jint seq, address pc):
490 MemPointerRecordEx(addr, flags, size, pc), _seq(seq) {
491 }
492
493 SeqMemPointerRecordEx(const SeqMemPointerRecordEx& copy_from)
494 : MemPointerRecordEx(copy_from) {
495 _seq = copy_from.seq();
496 }
497
498 SeqMemPointerRecordEx& operator= (const SeqMemPointerRecordEx& ptr) {
499 MemPointerRecordEx::operator=(ptr);
500 _seq = ptr.seq();
501 return *this;
502 }
503
504 inline jint seq() const {
505 return _seq;
506 }
507 };
508
509 #endif // SHARE_VM_SERVICES_MEM_PTR_HPP