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

annotate src/share/vm/services/memBaseline.cpp @ 7971:4102b59539ce

8005012: Add WB APIs to better support NMT testing Summary: Add WB API functions to enable better NMT testing Reviewed-by: dholmes, zgu

author	ctornqvi
date	Fri, 01 Feb 2013 23:48:08 +0100
parents	ecd24264898b
children	fbca7eaeac2e

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

Mercurial > hg > truffle

annotate src/share/vm/services/memBaseline.cpp @ 7971:4102b59539ce