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