truffle: src/share/vm/services/memBaseline.cpp annotate

annotate src/share/vm/services/memBaseline.cpp @ 10221:c18152e0554e

8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check Summary: Fixed NMT to deal with releasing virtual memory region when there are still committed regions within it Reviewed-by: acorn, coleenp

author	zgu
date	Mon, 06 May 2013 11:15:13 -0400
parents	ed5a590835a4
children	f2110083203d

rev	line source
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	1 /*
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 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 #include "precompiled.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	25 #include "memory/allocation.hpp"
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	26 #include "runtime/safepoint.hpp"
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	27 #include "runtime/thread.inline.hpp"
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	28 #include "services/memBaseline.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	29 #include "services/memTracker.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	30
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	31
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	32 MemType2Name MemBaseline::MemType2NameMap[NUMBER_OF_MEMORY_TYPE] = {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	33 {mtJavaHeap, "Java Heap"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	34 {mtClass, "Class"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	35 {mtThreadStack,"Thread Stack"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	36 {mtThread, "Thread"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	37 {mtCode, "Code"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	38 {mtGC, "GC"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	39 {mtCompiler, "Compiler"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	40 {mtInternal, "Internal"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	41 {mtOther, "Other"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	42 {mtSymbol, "Symbol"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	43 {mtNMT, "Memory Tracking"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	44 {mtChunk, "Pooled Free Chunks"},
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	45 {mtClassShared,"Shared spaces for classes"},
7971 4102b59539ce 8005012: Add WB APIs to better support NMT testing ctornqvi parents: 7464 diff changeset	46 {mtTest, "Test"},
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	47 {mtNone, "Unknown"} // It can happen when type tagging records are lagging
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	48 // behind
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	49 };
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	50
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	51 MemBaseline::MemBaseline() {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	52 _baselined = false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	53
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	54 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	55 _malloc_data[index].set_type(MemType2NameMap[index]._flag);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	56 _vm_data[index].set_type(MemType2NameMap[index]._flag);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	57 _arena_data[index].set_type(MemType2NameMap[index]._flag);
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 _malloc_cs = NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	61 _vm_cs = NULL;
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	62 _vm_map = NULL;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	63
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	64 _number_of_classes = 0;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	65 _number_of_threads = 0;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	66 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	67
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	68
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	69 void MemBaseline::clear() {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	70 if (_malloc_cs != NULL) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	71 delete _malloc_cs;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	72 _malloc_cs = NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	73 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	74
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	75 if (_vm_cs != NULL) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	76 delete _vm_cs;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	77 _vm_cs = NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	78 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	79
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	80 if (_vm_map != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	81 delete _vm_map;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	82 _vm_map = NULL;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	83 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	84
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	85 reset();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	86 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	87
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	88
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	89 void MemBaseline::reset() {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	90 _baselined = false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	91 _total_vm_reserved = 0;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	92 _total_vm_committed = 0;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	93 _total_malloced = 0;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	94 _number_of_classes = 0;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	95
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	96 if (_malloc_cs != NULL) _malloc_cs->clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	97 if (_vm_cs != NULL) _vm_cs->clear();
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	98 if (_vm_map != NULL) _vm_map->clear();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	99
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	100 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	101 _malloc_data[index].clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	102 _vm_data[index].clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	103 _arena_data[index].clear();
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 MemBaseline::~MemBaseline() {
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	108 clear();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	109 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	110
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	111 // baseline malloc'd memory records, generate overall summary and summaries by
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	112 // memory types
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	113 bool MemBaseline::baseline_malloc_summary(const MemPointerArray* malloc_records) {
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	114 MemPointerArrayIteratorImpl malloc_itr((MemPointerArray*)malloc_records);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	115 MemPointerRecord* malloc_ptr = (MemPointerRecord*)malloc_itr.current();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	116 size_t used_arena_size = 0;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	117 int index;
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	118 while (malloc_ptr != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	119 index = flag2index(FLAGS_TO_MEMORY_TYPE(malloc_ptr->flags()));
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	120 size_t size = malloc_ptr->size();
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	121 if (malloc_ptr->is_arena_memory_record()) {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	122 // We do have anonymous arenas, they are either used as value objects,
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	123 // which are embedded inside other objects, or used as stack objects.
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	124 _arena_data[index].inc(size);
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	125 used_arena_size += size;
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	126 } else {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	127 _total_malloced += size;
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	128 _malloc_data[index].inc(size);
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	129 if (malloc_ptr->is_arena_record()) {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	130 // see if arena memory record present
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	131 MemPointerRecord* next_malloc_ptr = (MemPointerRecordEx*)malloc_itr.peek_next();
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	132 if (next_malloc_ptr->is_arena_memory_record()) {
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	133 assert(next_malloc_ptr->is_memory_record_of_arena(malloc_ptr),
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	134 "Arena records do not match");
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	135 size = next_malloc_ptr->size();
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	136 _arena_data[index].inc(size);
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	137 used_arena_size += size;
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	138 malloc_itr.next();
fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	139 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	140 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	141 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	142 malloc_ptr = (MemPointerRecordEx*)malloc_itr.next();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	143 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	144
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	145 // substract used arena size to get size of arena chunk in free list
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	146 index = flag2index(mtChunk);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	147 _malloc_data[index].reduce(used_arena_size);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	148 // we really don't know how many chunks in free list, so just set to
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	149 // 0
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	150 _malloc_data[index].overwrite_counter(0);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	151
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	152 return true;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	153 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	154
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	155 // check if there is a safepoint in progress, if so, block the thread
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	156 // for the safepoint
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	157 void MemBaseline::check_safepoint(JavaThread* thr) {
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	158 if (SafepointSynchronize::is_synchronizing()) {
10160 ed5a590835a4 8013214: BigApps fails due to 'fatal error: Illegal threadstate encountered: 6' zgu parents: 10148 diff changeset	159 // grab and drop the SR_lock to honor the safepoint protocol
ed5a590835a4 8013214: BigApps fails due to 'fatal error: Illegal threadstate encountered: 6' zgu parents: 10148 diff changeset	160 MutexLocker ml(thr->SR_lock());
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	161 }
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	162 }
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	163
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	164 // baseline mmap'd memory records, generate overall summary and summaries by
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	165 // memory types
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	166 bool MemBaseline::baseline_vm_summary(const MemPointerArray* vm_records) {
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	167 MemPointerArrayIteratorImpl vm_itr((MemPointerArray*)vm_records);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	168 VMMemRegion* vm_ptr = (VMMemRegion*)vm_itr.current();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	169 int index;
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	170 while (vm_ptr != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	171 if (vm_ptr->is_reserved_region()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	172 index = flag2index(FLAGS_TO_MEMORY_TYPE(vm_ptr->flags()));
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	173 // we use the number of thread stack to count threads
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	174 if (IS_MEMORY_TYPE(vm_ptr->flags(), mtThreadStack)) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	175 _number_of_threads ++;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	176 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	177 _total_vm_reserved += vm_ptr->size();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	178 _vm_data[index].inc(vm_ptr->size(), 0);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	179 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	180 _total_vm_committed += vm_ptr->size();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	181 _vm_data[index].inc(0, vm_ptr->size());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	182 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	183 vm_ptr = (VMMemRegion*)vm_itr.next();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	184 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	185 return true;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	186 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	187
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	188 // baseline malloc'd memory by callsites, but only the callsites with memory allocation
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	189 // over 1KB are stored.
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	190 bool MemBaseline::baseline_malloc_details(const MemPointerArray* malloc_records) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	191 assert(MemTracker::track_callsite(), "detail tracking is off");
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: 6197 diff changeset	193 MemPointerArrayIteratorImpl malloc_itr(const_cast<MemPointerArray*>(malloc_records));
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	194 MemPointerRecordEx* malloc_ptr = (MemPointerRecordEx*)malloc_itr.current();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	195 MallocCallsitePointer malloc_callsite;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	196
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	197 // initailize malloc callsite array
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	198 if (_malloc_cs == NULL) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	199 _malloc_cs = new (std::nothrow) MemPointerArrayImpl<MallocCallsitePointer>(64);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	200 // out of native memory
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	201 if (_malloc_cs == NULL \|\| _malloc_cs->out_of_memory()) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	202 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	203 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	204 } else {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	205 _malloc_cs->clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	206 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	207
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	208 MemPointerArray* malloc_data = const_cast<MemPointerArray*>(malloc_records);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	209
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	210 // sort into callsite pc order. Details are aggregated by callsites
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	211 malloc_data->sort((FN_SORT)malloc_sort_by_pc);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	212 bool ret = true;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	213
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	214 // baseline memory that is totaled over 1 KB
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	215 while (malloc_ptr != NULL) {
6979 fb3190e77d3c 8001592: NMT: assertion failed: assert(_amount >= amt) failed: Just check: memBaseline.hpp:180 zgu parents: 6882 diff changeset	216 if (!MemPointerRecord::is_arena_memory_record(malloc_ptr->flags())) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	217 // skip thread stacks
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	218 if (!IS_MEMORY_TYPE(malloc_ptr->flags(), mtThreadStack)) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	219 if (malloc_callsite.addr() != malloc_ptr->pc()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	220 if ((malloc_callsite.amount()/K) > 0) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	221 if (!_malloc_cs->append(&malloc_callsite)) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	222 ret = false;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	223 break;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	224 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	225 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	226 malloc_callsite = MallocCallsitePointer(malloc_ptr->pc());
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	227 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	228 malloc_callsite.inc(malloc_ptr->size());
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	229 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	230 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	231 malloc_ptr = (MemPointerRecordEx*)malloc_itr.next();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	232 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	233
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	234 // restore to address order. Snapshot malloc data is maintained in memory
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	235 // address order.
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	236 malloc_data->sort((FN_SORT)malloc_sort_by_addr);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	237
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	238 if (!ret) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	239 return false;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	240 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	241 // deal with last record
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	242 if (malloc_callsite.addr() != 0 && (malloc_callsite.amount()/K) > 0) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	243 if (!_malloc_cs->append(&malloc_callsite)) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	244 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	245 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	246 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	247 return true;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	248 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	249
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	250 // baseline mmap'd memory by callsites
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	251 bool MemBaseline::baseline_vm_details(const MemPointerArray* vm_records) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	252 assert(MemTracker::track_callsite(), "detail tracking is off");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	253
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	254 VMCallsitePointer vm_callsite;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	255 VMCallsitePointer* cur_callsite = NULL;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	256 MemPointerArrayIteratorImpl vm_itr((MemPointerArray*)vm_records);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	257 VMMemRegionEx* vm_ptr = (VMMemRegionEx*)vm_itr.current();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	258
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	259 // initialize virtual memory map array
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	260 if (_vm_map == NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	261 _vm_map = new (std::nothrow) MemPointerArrayImpl<VMMemRegionEx>(vm_records->length());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	262 if (_vm_map == NULL \|\| _vm_map->out_of_memory()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	263 return false;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	264 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	265 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	266 _vm_map->clear();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	267 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	268
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	269 // initialize virtual memory callsite array
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	270 if (_vm_cs == NULL) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	271 _vm_cs = new (std::nothrow) MemPointerArrayImpl<VMCallsitePointer>(64);
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	272 if (_vm_cs == NULL \|\| _vm_cs->out_of_memory()) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	273 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	274 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	275 } else {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	276 _vm_cs->clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	277 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	278
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	279 // consolidate virtual memory data
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	280 VMMemRegionEx* reserved_rec = NULL;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	281 VMMemRegionEx* committed_rec = NULL;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	282
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	283 // vm_ptr is coming in increasing base address order
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	284 while (vm_ptr != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	285 if (vm_ptr->is_reserved_region()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	286 // consolidate reserved memory regions for virtual memory map.
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	287 // The criteria for consolidation is:
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	288 // 1. two adjacent reserved memory regions
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	289 // 2. belong to the same memory type
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	290 // 3. reserved from the same callsite
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	291 if (reserved_rec == NULL \|\|
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	292 reserved_rec->base() + reserved_rec->size() != vm_ptr->addr() \|\|
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	293 FLAGS_TO_MEMORY_TYPE(reserved_rec->flags()) != FLAGS_TO_MEMORY_TYPE(vm_ptr->flags()) \|\|
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	294 reserved_rec->pc() != vm_ptr->pc()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	295 if (!_vm_map->append(vm_ptr)) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	296 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	297 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	298 // inserted reserved region, we need the pointer to the element in virtual
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	299 // memory map array.
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	300 reserved_rec = (VMMemRegionEx*)_vm_map->at(_vm_map->length() - 1);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	301 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	302 reserved_rec->expand_region(vm_ptr->addr(), vm_ptr->size());
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	303 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	304
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	305 if (cur_callsite != NULL && !_vm_cs->append(cur_callsite)) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	306 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	307 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	308 vm_callsite = VMCallsitePointer(vm_ptr->pc());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	309 cur_callsite = &vm_callsite;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	310 vm_callsite.inc(vm_ptr->size(), 0);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	311 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	312 // consolidate committed memory regions for virtual memory map
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	313 // The criterial is:
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	314 // 1. two adjacent committed memory regions
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	315 // 2. committed from the same callsite
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	316 if (committed_rec == NULL \|\|
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	317 committed_rec->base() + committed_rec->size() != vm_ptr->addr() \|\|
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	318 committed_rec->pc() != vm_ptr->pc()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	319 if (!_vm_map->append(vm_ptr)) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	320 return false;
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	321 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	322 committed_rec = (VMMemRegionEx*)_vm_map->at(_vm_map->length() - 1);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	323 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	324 committed_rec->expand_region(vm_ptr->addr(), vm_ptr->size());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	325 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	326 vm_callsite.inc(0, vm_ptr->size());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	327 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	328 vm_ptr = (VMMemRegionEx*)vm_itr.next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	329 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	330 // deal with last record
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	331 if (cur_callsite != NULL && !_vm_cs->append(cur_callsite)) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	332 return false;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	333 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	334
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	335 // sort it into callsite pc order. Details are aggregated by callsites
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	336 _vm_cs->sort((FN_SORT)bl_vm_sort_by_pc);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	337
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	338 // walk the array to consolidate record by pc
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	339 MemPointerArrayIteratorImpl itr(_vm_cs);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	340 VMCallsitePointer* callsite_rec = (VMCallsitePointer*)itr.current();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	341 VMCallsitePointer* next_rec = (VMCallsitePointer*)itr.next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	342 while (next_rec != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	343 assert(callsite_rec != NULL, "Sanity check");
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	344 if (next_rec->addr() == callsite_rec->addr()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	345 callsite_rec->inc(next_rec->reserved_amount(), next_rec->committed_amount());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	346 itr.remove();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	347 next_rec = (VMCallsitePointer*)itr.current();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	348 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	349 callsite_rec = next_rec;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	350 next_rec = (VMCallsitePointer*)itr.next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	351 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	352 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	353
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	354 return true;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	355 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	356
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	357 // baseline a snapshot. If summary_only = false, memory usages aggregated by
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	358 // callsites are also baselined.
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	359 // The method call can be lengthy, especially when detail tracking info is
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	360 // requested. So the method checks for safepoint explicitly.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	361 bool MemBaseline::baseline(MemSnapshot& snapshot, bool summary_only) {
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	362 Thread* THREAD = Thread::current();
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	363 assert(THREAD->is_Java_thread(), "must be a JavaThread");
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	364 MutexLocker snapshot_locker(snapshot._lock);
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	365 reset();
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	366 _baselined = baseline_malloc_summary(snapshot._alloc_ptrs);
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	367 if (_baselined) {
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	368 check_safepoint((JavaThread*)THREAD);
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	369 _baselined = baseline_vm_summary(snapshot._vm_ptrs);
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	370 }
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6979 diff changeset	371 _number_of_classes = snapshot.number_of_classes();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	372
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	373 if (!summary_only && MemTracker::track_callsite() && _baselined) {
10148 fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	374 check_safepoint((JavaThread*)THREAD);
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	375 _baselined = baseline_malloc_details(snapshot._alloc_ptrs);
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	376 if (_baselined) {
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	377 check_safepoint((JavaThread*)THREAD);
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	378 _baselined = baseline_vm_details(snapshot._vm_ptrs);
fbca7eaeac2e 8011218: Kitchensink hanged, likely NMT is to blame zgu parents: 7971 diff changeset	379 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	380 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	381 return _baselined;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	382 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	383
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	384
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	385 int MemBaseline::flag2index(MEMFLAGS flag) const {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	386 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	387 if (MemType2NameMap[index]._flag == flag) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	388 return index;
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 assert(false, "no type");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	392 return -1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	393 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	394
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	395 const char* MemBaseline::type2name(MEMFLAGS type) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	396 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	397 if (MemType2NameMap[index]._flag == type) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	398 return MemType2NameMap[index]._name;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	399 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	400 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	401 assert(false, err_msg("bad type %x", type));
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	402 return NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	403 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	404
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	405
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	406 MemBaseline& MemBaseline::operator=(const MemBaseline& other) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	407 _total_malloced = other._total_malloced;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	408 _total_vm_reserved = other._total_vm_reserved;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	409 _total_vm_committed = other._total_vm_committed;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	410
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	411 _baselined = other._baselined;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	412 _number_of_classes = other._number_of_classes;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	413
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	414 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	415 _malloc_data[index] = other._malloc_data[index];
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	416 _vm_data[index] = other._vm_data[index];
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	417 _arena_data[index] = other._arena_data[index];
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	418 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	419
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	420 if (MemTracker::track_callsite()) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	421 assert(_malloc_cs != NULL && _vm_cs != NULL, "out of memory");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	422 assert(other._malloc_cs != NULL && other._vm_cs != NULL,
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	423 "not properly baselined");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	424 _malloc_cs->clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	425 _vm_cs->clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	426 int index;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	427 for (index = 0; index < other._malloc_cs->length(); index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	428 _malloc_cs->append(other._malloc_cs->at(index));
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	429 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	430
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	431 for (index = 0; index < other._vm_cs->length(); index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	432 _vm_cs->append(other._vm_cs->at(index));
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	433 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	434 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	435 return *this;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	436 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	437
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	438 /* compare functions for sorting */
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	439
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	440 // sort snapshot malloc'd records in callsite pc order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	441 int MemBaseline::malloc_sort_by_pc(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	442 assert(MemTracker::track_callsite(),"Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	443 const MemPointerRecordEx* mp1 = (const MemPointerRecordEx*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	444 const MemPointerRecordEx* mp2 = (const MemPointerRecordEx*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	445 return UNSIGNED_COMPARE(mp1->pc(), mp2->pc());
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	446 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	447
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	448 // sort baselined malloc'd records in size order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	449 int MemBaseline::bl_malloc_sort_by_size(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	450 assert(MemTracker::is_on(), "Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	451 const MallocCallsitePointer* mp1 = (const MallocCallsitePointer*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	452 const MallocCallsitePointer* mp2 = (const MallocCallsitePointer*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	453 return UNSIGNED_COMPARE(mp2->amount(), mp1->amount());
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	454 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	455
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	456 // sort baselined malloc'd records in callsite pc order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	457 int MemBaseline::bl_malloc_sort_by_pc(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	458 assert(MemTracker::is_on(), "Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	459 const MallocCallsitePointer* mp1 = (const MallocCallsitePointer*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	460 const MallocCallsitePointer* mp2 = (const MallocCallsitePointer*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	461 return UNSIGNED_COMPARE(mp1->addr(), mp2->addr());
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	462 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	463
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	464
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	465 // sort baselined mmap'd records in size (reserved size) order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	466 int MemBaseline::bl_vm_sort_by_size(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	467 assert(MemTracker::is_on(), "Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	468 const VMCallsitePointer* mp1 = (const VMCallsitePointer*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	469 const VMCallsitePointer* mp2 = (const VMCallsitePointer*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	470 return UNSIGNED_COMPARE(mp2->reserved_amount(), mp1->reserved_amount());
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	471 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	472
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	473 // sort baselined mmap'd records in callsite pc order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	474 int MemBaseline::bl_vm_sort_by_pc(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	475 assert(MemTracker::is_on(), "Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	476 const VMCallsitePointer* mp1 = (const VMCallsitePointer*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	477 const VMCallsitePointer* mp2 = (const VMCallsitePointer*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	478 return UNSIGNED_COMPARE(mp1->addr(), mp2->addr());
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	479 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	480
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	481
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	482 // sort snapshot malloc'd records in memory block address order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	483 int MemBaseline::malloc_sort_by_addr(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	484 assert(MemTracker::is_on(), "Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	485 const MemPointerRecord* mp1 = (const MemPointerRecord*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	486 const MemPointerRecord* mp2 = (const MemPointerRecord*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	487 int delta = UNSIGNED_COMPARE(mp1->addr(), mp2->addr());
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	488 assert(delta != 0, "dup pointer");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	489 return delta;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	490 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	491

Mercurial > hg > truffle

annotate src/share/vm/services/memBaseline.cpp @ 10221:c18152e0554e