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

annotate src/share/vm/services/memSnapshot.hpp @ 8733:9def4075da6d

8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate(). Reviewed-by: johnc, ysr Contributed-by: tamao <tao.mao@oracle.com>

author	tamao
date	Tue, 05 Mar 2013 15:36:56 -0800
parents	ecd24264898b
children	b80cc96882f7

rev	line source
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	1 /*
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	2 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
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
6741 33143ee07800 7181995: NMT ON: NMT assertion failure assert(cur_vm->is_uncommit_record() \|\| cur_vm->is_deallocation_record zgu parents: 6599 diff changeset	311 class StagingArea : public _ValueObj {
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 @ 8733:9def4075da6d