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

annotate src/share/vm/services/memBaseline.cpp @ 6882:716c64bda5ba

7199092: NMT: NMT needs to deal overlapped virtual memory ranges Summary: Enhanced virtual memory tracking to track committed regions as well as reserved regions, so NMT now can generate virtual memory map. Reviewed-by: acorn, coleenp

author	zgu
date	Fri, 19 Oct 2012 21:40:07 -0400
parents	d2a62e0f25eb
children	fb3190e77d3c

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 "classfile/systemDictionary.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	26 #include "memory/allocation.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	27 #include "services/memBaseline.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	28 #include "services/memTracker.hpp"
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	29
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	30 MemType2Name MemBaseline::MemType2NameMap[NUMBER_OF_MEMORY_TYPE] = {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	31 {mtJavaHeap, "Java Heap"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	32 {mtClass, "Class"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	33 {mtThreadStack,"Thread Stack"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	34 {mtThread, "Thread"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	35 {mtCode, "Code"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	36 {mtGC, "GC"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	37 {mtCompiler, "Compiler"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	38 {mtInternal, "Internal"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	39 {mtOther, "Other"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	40 {mtSymbol, "Symbol"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	41 {mtNMT, "Memory Tracking"},
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	42 {mtChunk, "Pooled Free Chunks"},
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	43 {mtClassShared,"Shared spaces for classes"},
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();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	118 _total_malloced += size;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	119 _malloc_data[index].inc(size);
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	120 if (MemPointerRecord::is_arena_record(malloc_ptr->flags())) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	121 // see if arena size record present
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	122 MemPointerRecord* next_malloc_ptr = (MemPointerRecordEx*)malloc_itr.peek_next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	123 if (MemPointerRecord::is_arena_size_record(next_malloc_ptr->flags())) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	124 assert(next_malloc_ptr->is_size_record_of_arena(malloc_ptr), "arena records do not match");
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	125 size = next_malloc_ptr->size();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	126 _arena_data[index].inc(size);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	127 used_arena_size += size;
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	128 malloc_itr.next();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	129 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	130 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	131 malloc_ptr = (MemPointerRecordEx*)malloc_itr.next();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	132 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	133
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	134 // substract used arena size to get size of arena chunk in free list
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	135 index = flag2index(mtChunk);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	136 _malloc_data[index].reduce(used_arena_size);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	137 // 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	138 // 0
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	139 _malloc_data[index].overwrite_counter(0);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	140
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	141 return true;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	142 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	143
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	144 // baseline mmap'd memory records, generate overall summary and summaries by
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	145 // memory types
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	146 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	147 MemPointerArrayIteratorImpl vm_itr((MemPointerArray*)vm_records);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	148 VMMemRegion* vm_ptr = (VMMemRegion*)vm_itr.current();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	149 int index;
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	150 while (vm_ptr != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	151 if (vm_ptr->is_reserved_region()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	152 index = flag2index(FLAGS_TO_MEMORY_TYPE(vm_ptr->flags()));
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	153 // 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	154 if (IS_MEMORY_TYPE(vm_ptr->flags(), mtThreadStack)) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	155 _number_of_threads ++;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	156 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	157 _total_vm_reserved += vm_ptr->size();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	158 _vm_data[index].inc(vm_ptr->size(), 0);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	159 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	160 _total_vm_committed += vm_ptr->size();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	161 _vm_data[index].inc(0, vm_ptr->size());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	162 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	163 vm_ptr = (VMMemRegion*)vm_itr.next();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	164 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	165 return true;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	166 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	167
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	168 // baseline malloc'd memory by callsites, but only the callsites with memory allocation
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	169 // over 1KB are stored.
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	170 bool MemBaseline::baseline_malloc_details(const MemPointerArray* malloc_records) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	171 assert(MemTracker::track_callsite(), "detail tracking is off");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	172
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	173 MemPointerArrayIteratorImpl malloc_itr(const_cast<MemPointerArray*>(malloc_records));
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	174 MemPointerRecordEx* malloc_ptr = (MemPointerRecordEx*)malloc_itr.current();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	175 MallocCallsitePointer malloc_callsite;
6197 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 // initailize malloc callsite array
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	178 if (_malloc_cs == NULL) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	179 _malloc_cs = new (std::nothrow) MemPointerArrayImpl<MallocCallsitePointer>(64);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	180 // out of native memory
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	181 if (_malloc_cs == NULL \|\| _malloc_cs->out_of_memory()) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	182 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	183 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	184 } else {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	185 _malloc_cs->clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	186 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	187
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	188 MemPointerArray* malloc_data = const_cast<MemPointerArray*>(malloc_records);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	189
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	190 // 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	191 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	192 bool ret = true;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	193
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	194 // 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	195 while (malloc_ptr != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	196 if (!MemPointerRecord::is_arena_size_record(malloc_ptr->flags())) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	197 // skip thread stacks
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	198 if (!IS_MEMORY_TYPE(malloc_ptr->flags(), mtThreadStack)) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	199 if (malloc_callsite.addr() != malloc_ptr->pc()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	200 if ((malloc_callsite.amount()/K) > 0) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	201 if (!_malloc_cs->append(&malloc_callsite)) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	202 ret = false;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	203 break;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	204 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	205 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	206 malloc_callsite = MallocCallsitePointer(malloc_ptr->pc());
6197 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 malloc_callsite.inc(malloc_ptr->size());
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	209 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	210 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	211 malloc_ptr = (MemPointerRecordEx*)malloc_itr.next();
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 // 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	215 // address order.
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	216 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	217
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	218 if (!ret) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	219 return false;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	220 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	221 // deal with last record
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	222 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	223 if (!_malloc_cs->append(&malloc_callsite)) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	224 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	225 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	226 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	227 return true;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	228 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	229
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	230 // baseline mmap'd memory by callsites
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	231 bool MemBaseline::baseline_vm_details(const MemPointerArray* vm_records) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	232 assert(MemTracker::track_callsite(), "detail tracking is off");
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 VMCallsitePointer vm_callsite;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	235 VMCallsitePointer* cur_callsite = NULL;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	236 MemPointerArrayIteratorImpl vm_itr((MemPointerArray*)vm_records);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	237 VMMemRegionEx* vm_ptr = (VMMemRegionEx*)vm_itr.current();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	238
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	239 // initialize virtual memory map array
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	240 if (_vm_map == NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	241 _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	242 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	243 return false;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	244 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	245 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	246 _vm_map->clear();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	247 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	248
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	249 // initialize virtual memory callsite array
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	250 if (_vm_cs == NULL) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	251 _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	252 if (_vm_cs == NULL \|\| _vm_cs->out_of_memory()) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	253 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	254 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	255 } else {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	256 _vm_cs->clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	257 }
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 // consolidate virtual memory data
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	260 VMMemRegionEx* reserved_rec = NULL;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	261 VMMemRegionEx* committed_rec = NULL;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	262
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	263 // 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	264 while (vm_ptr != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	265 if (vm_ptr->is_reserved_region()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	266 // consolidate reserved memory regions for virtual memory map.
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	267 // The criteria for consolidation is:
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	268 // 1. two adjacent reserved memory regions
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	269 // 2. belong to the same memory type
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	270 // 3. reserved from the same callsite
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	271 if (reserved_rec == NULL \|\|
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	272 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	273 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	274 reserved_rec->pc() != vm_ptr->pc()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	275 if (!_vm_map->append(vm_ptr)) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	276 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	277 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	278 // 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	279 // memory map array.
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	280 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	281 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	282 reserved_rec->expand_region(vm_ptr->addr(), vm_ptr->size());
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	283 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	284
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	285 if (cur_callsite != NULL && !_vm_cs->append(cur_callsite)) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	286 return false;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	287 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	288 vm_callsite = VMCallsitePointer(vm_ptr->pc());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	289 cur_callsite = &vm_callsite;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	290 vm_callsite.inc(vm_ptr->size(), 0);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	291 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	292 // consolidate committed memory regions for virtual memory map
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	293 // The criterial is:
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	294 // 1. two adjacent committed memory regions
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	295 // 2. committed from the same callsite
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	296 if (committed_rec == NULL \|\|
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	297 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	298 committed_rec->pc() != vm_ptr->pc()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	299 if (!_vm_map->append(vm_ptr)) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	300 return false;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	301 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	302 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	303 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	304 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	305 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	306 vm_callsite.inc(0, vm_ptr->size());
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	307 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	308 vm_ptr = (VMMemRegionEx*)vm_itr.next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	309 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	310 // deal with last record
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	311 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	312 return false;
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
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	315 // 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	316 _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	317
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	318 // walk the array to consolidate record by pc
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	319 MemPointerArrayIteratorImpl itr(_vm_cs);
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	320 VMCallsitePointer* callsite_rec = (VMCallsitePointer*)itr.current();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	321 VMCallsitePointer* next_rec = (VMCallsitePointer*)itr.next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	322 while (next_rec != NULL) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	323 assert(callsite_rec != NULL, "Sanity check");
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	324 if (next_rec->addr() == callsite_rec->addr()) {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	325 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	326 itr.remove();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	327 next_rec = (VMCallsitePointer*)itr.current();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	328 } else {
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	329 callsite_rec = next_rec;
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	330 next_rec = (VMCallsitePointer*)itr.next();
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	331 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	332 }
716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	333
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	334 return true;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	335 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	336
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	337 // baseline a snapshot. If summary_only = false, memory usages aggregated by
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	338 // callsites are also baselined.
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	339 bool MemBaseline::baseline(MemSnapshot& snapshot, bool summary_only) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	340 MutexLockerEx snapshot_locker(snapshot._lock, true);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	341 reset();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	342 _baselined = baseline_malloc_summary(snapshot._alloc_ptrs) &&
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	343 baseline_vm_summary(snapshot._vm_ptrs);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	344 _number_of_classes = SystemDictionary::number_of_classes();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	345
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	346 if (!summary_only && MemTracker::track_callsite() && _baselined) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	347 _baselined = baseline_malloc_details(snapshot._alloc_ptrs) &&
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	348 baseline_vm_details(snapshot._vm_ptrs);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	349 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	350 return _baselined;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	351 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	352
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	353
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	354 int MemBaseline::flag2index(MEMFLAGS flag) const {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	355 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	356 if (MemType2NameMap[index]._flag == flag) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	357 return index;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	358 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	359 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	360 assert(false, "no type");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	361 return -1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	362 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	363
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	364 const char* MemBaseline::type2name(MEMFLAGS type) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	365 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	366 if (MemType2NameMap[index]._flag == type) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	367 return MemType2NameMap[index]._name;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	368 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	369 }
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6197 diff changeset	370 assert(false, err_msg("bad type %x", type));
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	371 return NULL;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	372 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	373
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	374
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	375 MemBaseline& MemBaseline::operator=(const MemBaseline& other) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	376 _total_malloced = other._total_malloced;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	377 _total_vm_reserved = other._total_vm_reserved;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	378 _total_vm_committed = other._total_vm_committed;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	379
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	380 _baselined = other._baselined;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	381 _number_of_classes = other._number_of_classes;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	382
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	383 for (int index = 0; index < NUMBER_OF_MEMORY_TYPE; index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	384 _malloc_data[index] = other._malloc_data[index];
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	385 _vm_data[index] = other._vm_data[index];
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	386 _arena_data[index] = other._arena_data[index];
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	387 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	388
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	389 if (MemTracker::track_callsite()) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	390 assert(_malloc_cs != NULL && _vm_cs != NULL, "out of memory");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	391 assert(other._malloc_cs != NULL && other._vm_cs != NULL,
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	392 "not properly baselined");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	393 _malloc_cs->clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	394 _vm_cs->clear();
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	395 int index;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	396 for (index = 0; index < other._malloc_cs->length(); index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	397 _malloc_cs->append(other._malloc_cs->at(index));
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	398 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	399
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	400 for (index = 0; index < other._vm_cs->length(); index ++) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	401 _vm_cs->append(other._vm_cs->at(index));
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	402 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	403 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	404 return *this;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	405 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	406
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	407 /* compare functions for sorting */
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	408
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	409 // sort snapshot malloc'd records in callsite pc order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	410 int MemBaseline::malloc_sort_by_pc(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	411 assert(MemTracker::track_callsite(),"Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	412 const MemPointerRecordEx* mp1 = (const MemPointerRecordEx*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	413 const MemPointerRecordEx* mp2 = (const MemPointerRecordEx*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	414 return UNSIGNED_COMPARE(mp1->pc(), mp2->pc());
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	415 }
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 baselined malloc'd records in size order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	418 int MemBaseline::bl_malloc_sort_by_size(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	419 assert(MemTracker::is_on(), "Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	420 const MallocCallsitePointer* mp1 = (const MallocCallsitePointer*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	421 const MallocCallsitePointer* mp2 = (const MallocCallsitePointer*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	422 return UNSIGNED_COMPARE(mp2->amount(), mp1->amount());
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 callsite pc order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	426 int MemBaseline::bl_malloc_sort_by_pc(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(mp1->addr(), mp2->addr());
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
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	434 // sort baselined mmap'd records in size (reserved size) order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	435 int MemBaseline::bl_vm_sort_by_size(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	436 assert(MemTracker::is_on(), "Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	437 const VMCallsitePointer* mp1 = (const VMCallsitePointer*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	438 const VMCallsitePointer* mp2 = (const VMCallsitePointer*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	439 return UNSIGNED_COMPARE(mp2->reserved_amount(), mp1->reserved_amount());
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 callsite pc order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	443 int MemBaseline::bl_vm_sort_by_pc(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(mp1->addr(), mp2->addr());
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
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	451 // sort snapshot malloc'd records in memory block address order
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	452 int MemBaseline::malloc_sort_by_addr(const void* p1, const void* p2) {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	453 assert(MemTracker::is_on(), "Just check");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	454 const MemPointerRecord* mp1 = (const MemPointerRecord*)p1;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	455 const MemPointerRecord* mp2 = (const MemPointerRecord*)p2;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	456 int delta = UNSIGNED_COMPARE(mp1->addr(), mp2->addr());
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	457 assert(delta != 0, "dup pointer");
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	458 return delta;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	459 }
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: diff changeset	460

Mercurial > hg > truffle

annotate src/share/vm/services/memBaseline.cpp @ 6882:716c64bda5ba