truffle: src/share/vm/services/memSnapshot.hpp annotate

annotate src/share/vm/services/memSnapshot.hpp @ 17524:89152779163c

Merge with jdk8-b132

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 11:59:32 +0200
parents	4ca6dc0799b6
children

rev	line source
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	1 /*
17524 89152779163c Merge with jdk8-b132 Gilles Duboscq <duboscq@ssw.jku.at> parents: 14909 diff changeset	2 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	4 *
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	7 * published by the Free Software Foundation.
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	8 *
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	13 * accompanied this code).
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	14 *
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	18 *
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	20 * or visit www.oracle.com if you need additional information or have any
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	21 * questions.
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	22 *
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	23 */
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	24
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	25 #ifndef SHARE_VM_SERVICES_MEM_SNAPSHOT_HPP
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	26 #define SHARE_VM_SERVICES_MEM_SNAPSHOT_HPP
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	27
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	28 #include "memory/allocation.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	29 #include "runtime/mutex.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	30 #include "runtime/mutexLocker.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	31 #include "services/memBaseline.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	32 #include "services/memPtrArray.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	33
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	34 // Snapshot pointer array iterator
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	35
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	36 // The pointer array contains malloc-ed pointers
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	37 class MemPointerIterator : public MemPointerArrayIteratorImpl {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	38 public:
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	39 MemPointerIterator(MemPointerArray* arr):
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	40 MemPointerArrayIteratorImpl(arr) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	41 assert(arr != NULL, "null array");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	42 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	43
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	44 #ifdef ASSERT
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	45 virtual bool is_dup_pointer(const MemPointer* ptr1,
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	46 const MemPointer* ptr2) const {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	47 MemPointerRecord* p1 = (MemPointerRecord*)ptr1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	48 MemPointerRecord* p2 = (MemPointerRecord*)ptr2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	49
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	50 if (p1->addr() != p2->addr()) return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	51 if ((p1->flags() & MemPointerRecord::tag_masks) !=
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	52 (p2->flags() & MemPointerRecord::tag_masks)) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	53 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	54 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	55 // we do see multiple commit/uncommit on the same memory, it is ok
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	56 return (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_alloc \|\|
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	57 (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_release;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	58 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	59
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	60 virtual bool insert(MemPointer* ptr) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	61 if (_pos > 0) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	62 MemPointer* p1 = (MemPointer*)ptr;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	63 MemPointer* p2 = (MemPointer*)_array->at(_pos - 1);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	64 assert(!is_dup_pointer(p1, p2),
6599 4acebbe310e1 7185614: NMT ON: "check by caller" assertion failed on nsk ThreadMXBean test zgu parents: 6197 diff changeset	65 err_msg("duplicated pointer, flag = [%x]", (unsigned int)((MemPointerRecord*)p1)->flags()));
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	66 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	67 if (_pos < _array->length() -1) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	68 MemPointer* p1 = (MemPointer*)ptr;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	69 MemPointer* p2 = (MemPointer*)_array->at(_pos + 1);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	70 assert(!is_dup_pointer(p1, p2),
6599 4acebbe310e1 7185614: NMT ON: "check by caller" assertion failed on nsk ThreadMXBean test zgu parents: 6197 diff changeset	71 err_msg("duplicated pointer, flag = [%x]", (unsigned int)((MemPointerRecord*)p1)->flags()));
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	72 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	73 return _array->insert_at(ptr, _pos);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	74 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	75
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	76 virtual bool insert_after(MemPointer* ptr) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	77 if (_pos > 0) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	78 MemPointer* p1 = (MemPointer*)ptr;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	79 MemPointer* p2 = (MemPointer*)_array->at(_pos - 1);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	80 assert(!is_dup_pointer(p1, p2),
6599 4acebbe310e1 7185614: NMT ON: "check by caller" assertion failed on nsk ThreadMXBean test zgu parents: 6197 diff changeset	81 err_msg("duplicated pointer, flag = [%x]", (unsigned int)((MemPointerRecord*)p1)->flags()));
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	82 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	83 if (_pos < _array->length() - 1) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	84 MemPointer* p1 = (MemPointer*)ptr;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	85 MemPointer* p2 = (MemPointer*)_array->at(_pos + 1);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	86
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	87 assert(!is_dup_pointer(p1, p2),
6599 4acebbe310e1 7185614: NMT ON: "check by caller" assertion failed on nsk ThreadMXBean test zgu parents: 6197 diff changeset	88 err_msg("duplicated pointer, flag = [%x]", (unsigned int)((MemPointerRecord*)p1)->flags()));
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	89 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	90 if (_array->insert_at(ptr, _pos + 1)) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	91 _pos ++;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	92 return true;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	93 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	94 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	95 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	96 #endif
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	97
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	98 virtual MemPointer* locate(address addr) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	99 MemPointer* cur = current();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	100 while (cur != NULL && cur->addr() < addr) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	101 cur = next();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	102 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	103 return cur;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	104 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	105 };
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	106
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	107 class VMMemPointerIterator : public MemPointerIterator {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	108 public:
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	109 VMMemPointerIterator(MemPointerArray* arr):
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	110 MemPointerIterator(arr) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	111 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	112
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	113 // locate an existing reserved memory region that contains specified address,
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	114 // or the reserved region just above this address, where the incoming
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	115 // reserved region should be inserted.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	116 virtual MemPointer* locate(address addr) {
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	117 reset();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	118 VMMemRegion* reg = (VMMemRegion*)current();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	119 while (reg != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	120 if (reg->is_reserved_region()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	121 if (reg->contains_address(addr) \|\| addr < reg->base()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	122 return reg;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	123 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	124 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	125 reg = (VMMemRegion*)next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	126 }
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	127 return NULL;
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	128 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	129
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	130 // following methods update virtual memory in the context
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	131 // of 'current' position, which is properly positioned by
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	132 // callers via locate method.
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	133 bool add_reserved_region(MemPointerRecord* rec);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	134 bool add_committed_region(MemPointerRecord* rec);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	135 bool remove_uncommitted_region(MemPointerRecord* rec);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	136 bool remove_released_region(MemPointerRecord* rec);
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	137
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	138 // split a reserved region to create a new memory region with specified base and size
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	139 bool split_reserved_region(VMMemRegion* rgn, address new_rgn_addr, size_t new_rgn_size);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	140 private:
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	141 bool insert_record(MemPointerRecord* rec);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	142 bool insert_record_after(MemPointerRecord* rec);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	143
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	144 bool insert_reserved_region(MemPointerRecord* rec);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	145
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	146 // reset current position
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	147 inline void reset() { _pos = 0; }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	148 #ifdef ASSERT
7166 49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	149 // check integrity of records on current reserved memory region.
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	150 bool check_reserved_region() {
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	151 VMMemRegion* reserved_region = (VMMemRegion*)current();
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	152 assert(reserved_region != NULL && reserved_region->is_reserved_region(),
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	153 "Sanity check");
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	154 // all committed regions that follow current reserved region, should all
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	155 // belong to the reserved region.
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	156 VMMemRegion* next_region = (VMMemRegion*)next();
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	157 for (; next_region != NULL && next_region->is_committed_region();
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	158 next_region = (VMMemRegion*)next() ) {
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	159 if(!reserved_region->contains_region(next_region)) {
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	160 return false;
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	161 }
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	162 }
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	163 return true;
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	164 }
49cbd3e25ba9 8003487: NMT: incorrect assertion in VMMemPointerIterator::remove_released_region method (memSnapshot.cpp) zgu parents: 6979 diff changeset	165
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	166 virtual bool is_dup_pointer(const MemPointer* ptr1,
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	167 const MemPointer* ptr2) const {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	168 VMMemRegion* p1 = (VMMemRegion*)ptr1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	169 VMMemRegion* p2 = (VMMemRegion*)ptr2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	170
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	171 if (p1->addr() != p2->addr()) return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	172 if ((p1->flags() & MemPointerRecord::tag_masks) !=
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	173 (p2->flags() & MemPointerRecord::tag_masks)) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	174 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	175 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	176 // we do see multiple commit/uncommit on the same memory, it is ok
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	177 return (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_alloc \|\|
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	178 (p1->flags() & MemPointerRecord::tag_masks) == MemPointerRecord::tag_release;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	179 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	180 #endif
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	181 };
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	182
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	183 class MallocRecordIterator : public MemPointerArrayIterator {
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	184 private:
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	185 MemPointerArrayIteratorImpl _itr;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	186
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	187
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	188
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	189 public:
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	190 MallocRecordIterator(MemPointerArray* arr) : _itr(arr) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	191 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	192
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	193 virtual MemPointer* current() const {
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	194 #ifdef ASSERT
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	195 MemPointer* cur_rec = _itr.current();
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	196 if (cur_rec != NULL) {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	197 MemPointer* prev_rec = _itr.peek_prev();
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	198 MemPointer* next_rec = _itr.peek_next();
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	199 assert(prev_rec == NULL \|\| prev_rec->addr() < cur_rec->addr(), "Sorting order");
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	200 assert(next_rec == NULL \|\| next_rec->addr() > cur_rec->addr(), "Sorting order");
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	201 }
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	202 #endif
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	203 return _itr.current();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	204 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	205 virtual MemPointer* next() {
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	206 MemPointerRecord* next_rec = (MemPointerRecord*)_itr.next();
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	207 // arena memory record is a special case, which we have to compare
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	208 // sequence number against its associated arena record.
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	209 if (next_rec != NULL && next_rec->is_arena_memory_record()) {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	210 MemPointerRecord* prev_rec = (MemPointerRecord*)_itr.peek_prev();
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	211 // if there is an associated arena record, it has to be previous
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	212 // record because of sorting order (by address) - NMT generates a pseudo address
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	213 // for arena's size record by offsetting arena's address, that guarantees
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	214 // the order of arena record and it's size record.
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	215 if (prev_rec != NULL && prev_rec->is_arena_record() &&
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	216 next_rec->is_memory_record_of_arena(prev_rec)) {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	217 if (prev_rec->seq() > next_rec->seq()) {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	218 // Skip this arena memory record
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	219 // Two scenarios:
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	220 // - if the arena record is an allocation record, this early
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	221 // size record must be leftover by previous arena,
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	222 // and the last size record should have size = 0.
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	223 // - if the arena record is a deallocation record, this
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	224 // size record should be its cleanup record, which should
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	225 // also have size = 0. In other world, arena alway reset
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	226 // its size before gone (see Arena's destructor)
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	227 assert(next_rec->size() == 0, "size not reset");
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	228 return _itr.next();
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	229 } else {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	230 assert(prev_rec->is_allocation_record(),
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	231 "Arena size record ahead of allocation record");
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	232 }
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	233 }
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	234 }
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	235 return next_rec;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	236 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	237
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	238 MemPointer* peek_next() const { ShouldNotReachHere(); return NULL; }
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	239 MemPointer* peek_prev() const { ShouldNotReachHere(); return NULL; }
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	240 void remove() { ShouldNotReachHere(); }
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	241 bool insert(MemPointer* ptr) { ShouldNotReachHere(); return false; }
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	242 bool insert_after(MemPointer* ptr) { ShouldNotReachHere(); return false; }
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	243 };
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	244
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	245 // collapse duplicated records. Eliminating duplicated records here, is much
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	246 // cheaper than during promotion phase. However, it does have limitation - it
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	247 // can only eliminate duplicated records within the generation, there are
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	248 // still chances seeing duplicated records during promotion.
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	249 // We want to use the record with higher sequence number, because it has
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	250 // more accurate callsite pc.
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	251 class VMRecordIterator : public MemPointerArrayIterator {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	252 private:
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	253 MemPointerArrayIteratorImpl _itr;
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	254
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	255 public:
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	256 VMRecordIterator(MemPointerArray* arr) : _itr(arr) {
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	257 MemPointerRecord* cur = (MemPointerRecord*)_itr.current();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	258 MemPointerRecord* next = (MemPointerRecord*)_itr.peek_next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	259 while (next != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	260 assert(cur != NULL, "Sanity check");
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	261 assert(((SeqMemPointerRecord)next)->seq() > ((SeqMemPointerRecord)cur)->seq(),
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	262 "pre-sort order");
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	263
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	264 if (is_duplicated_record(cur, next)) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	265 _itr.next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	266 next = (MemPointerRecord*)_itr.peek_next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	267 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	268 break;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	269 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	270 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	271 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	272
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	273 virtual MemPointer* current() const {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	274 return _itr.current();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	275 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	276
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	277 // get next record, but skip the duplicated records
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	278 virtual MemPointer* next() {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	279 MemPointerRecord* cur = (MemPointerRecord*)_itr.next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	280 MemPointerRecord* next = (MemPointerRecord*)_itr.peek_next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	281 while (next != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	282 assert(cur != NULL, "Sanity check");
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	283 assert(((SeqMemPointerRecord)next)->seq() > ((SeqMemPointerRecord)cur)->seq(),
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	284 "pre-sort order");
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	285
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	286 if (is_duplicated_record(cur, next)) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	287 _itr.next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	288 cur = next;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	289 next = (MemPointerRecord*)_itr.peek_next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	290 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	291 break;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	292 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	293 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	294 return cur;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	295 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	296
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	297 MemPointer* peek_next() const { ShouldNotReachHere(); return NULL; }
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	298 MemPointer* peek_prev() const { ShouldNotReachHere(); return NULL; }
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	299 void remove() { ShouldNotReachHere(); }
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	300 bool insert(MemPointer* ptr) { ShouldNotReachHere(); return false; }
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	301 bool insert_after(MemPointer* ptr) { ShouldNotReachHere(); return false; }
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	302
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	303 private:
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	304 bool is_duplicated_record(MemPointerRecord* p1, MemPointerRecord* p2) const {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	305 bool ret = (p1->addr() == p2->addr() && p1->size() == p2->size() && p1->flags() == p2->flags());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	306 assert(!(ret && FLAGS_TO_MEMORY_TYPE(p1->flags()) == mtThreadStack), "dup on stack record");
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	307 return ret;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	308 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	309 };
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	310
10127 b80cc96882f7 8012464: NMT: classes should not derive from _ValueObj, use VALUE_OBJ_CLASS_SPEC instead zgu parents: 7464 diff changeset	311 class StagingArea VALUE_OBJ_CLASS_SPEC {
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	312 private:
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	313 MemPointerArray* _malloc_data;
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	314 MemPointerArray* _vm_data;
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	315
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	316 public:
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	317 StagingArea() : _malloc_data(NULL), _vm_data(NULL) {
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	318 init();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	319 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	320
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	321 ~StagingArea() {
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	322 if (_malloc_data != NULL) delete _malloc_data;
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	323 if (_vm_data != NULL) delete _vm_data;
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	324 }
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	325
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	326 MallocRecordIterator malloc_record_walker() {
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	327 return MallocRecordIterator(malloc_data());
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	328 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	329
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	330 VMRecordIterator virtual_memory_record_walker();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	331
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	332 bool init();
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	333 void clear() {
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	334 assert(_malloc_data != NULL && _vm_data != NULL, "Just check");
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	335 _malloc_data->shrink();
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	336 _malloc_data->clear();
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	337 _vm_data->clear();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	338 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	339
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	340 inline MemPointerArray* malloc_data() { return _malloc_data; }
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	341 inline MemPointerArray* vm_data() { return _vm_data; }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	342 };
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	343
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	344 class MemBaseline;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	345 class MemSnapshot : public CHeapObj<mtNMT> {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	346 private:
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	347 // the following two arrays contain records of all known lived memory blocks
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	348 // live malloc-ed memory pointers
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	349 MemPointerArray* _alloc_ptrs;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	350 // live virtual memory pointers
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	351 MemPointerArray* _vm_ptrs;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	352
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	353 StagingArea _staging_area;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	354
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	355 // the lock to protect this snapshot
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	356 Monitor* _lock;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	357
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7166 diff changeset	358 // the number of instance classes
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7166 diff changeset	359 int _number_of_classes;
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7166 diff changeset	360
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	361 NOT_PRODUCT(size_t _untracked_count;)
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	362 friend class MemBaseline;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	363
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	364 public:
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	365 MemSnapshot();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	366 virtual ~MemSnapshot();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	367
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	368 // if we are running out of native memory
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	369 bool out_of_memory() {
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	370 return (_alloc_ptrs == NULL \|\|
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	371 _staging_area.malloc_data() == NULL \|\|
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	372 _staging_area.vm_data() == NULL \|\|
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	373 _vm_ptrs == NULL \|\| _lock == NULL \|\|
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	374 _alloc_ptrs->out_of_memory() \|\|
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	375 _vm_ptrs->out_of_memory());
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	376 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	377
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	378 // merge a per-thread memory recorder into staging area
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	379 bool merge(MemRecorder* rec);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	380 // promote staged data to snapshot
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7166 diff changeset	381 bool promote(int number_of_classes);
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	382
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 7166 diff changeset	383 int number_of_classes() const { return _number_of_classes; }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	384
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	385 void wait(long timeout) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	386 assert(_lock != NULL, "Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	387 MonitorLockerEx locker(_lock);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	388 locker.wait(true, timeout);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	389 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	390
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	391 NOT_PRODUCT(void print_snapshot_stats(outputStream* st);)
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	392 NOT_PRODUCT(void check_staging_data();)
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	393 NOT_PRODUCT(void check_malloc_pointers();)
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	394 NOT_PRODUCT(bool has_allocation_record(address addr);)
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	395 // dump all virtual memory pointers in snapshot
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6741 diff changeset	396 DEBUG_ONLY( void dump_all_vm_pointers();)
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	397
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	398 private:
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	399 // copy sequenced pointer from src to dest
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	400 void copy_seq_pointer(MemPointerRecord* dest, const MemPointerRecord* src);
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	401 // assign a sequenced pointer to non-sequenced pointer
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	402 void assign_pointer(MemPointerRecorddest, const MemPointerRecord src);
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	403
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	404 bool promote_malloc_records(MemPointerArrayIterator* itr);
33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	405 bool promote_virtual_memory_records(MemPointerArrayIterator* itr);
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	406 };
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	407
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	408 #endif // SHARE_VM_SERVICES_MEM_SNAPSHOT_HPP

Mercurial > hg > truffle

annotate src/share/vm/services/memSnapshot.hpp @ 17524:89152779163c