stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8218558: NMT stack traces in output should show mt component for virtual memory allocations

Browse Source 
Reviewed-by: shade, stuefe, coleenp
This commit is contained in:
Zhengyu Gu 2019-02-07 14:29:17 -05:00
parent 63663b64d1
commit d5e0b71435
7 changed files with 34 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/hotspot/share/services/allocationSite.hpp
View File

@ -25,6 +25,7 @@
#ifndef SHARE_SERVICES_ALLOCATIONSITE_HPP
#define SHARE_SERVICES_ALLOCATIONSITE_HPP
#include "memory/allocation.hpp"
#include "utilities/nativeCallStack.hpp"
// Allocation site represents a code path that makes a memory
@ -33,8 +34,9 @@ template <class E> class AllocationSite {
private:
NativeCallStack _call_stack;
E e;
MEMFLAGS _flag;
public:
AllocationSite(const NativeCallStack& stack) : _call_stack(stack) { }
AllocationSite(const NativeCallStack& stack, MEMFLAGS flag) : _call_stack(stack), _flag(flag) { }
int hash() const { return _call_stack.hash(); }
bool equals(const NativeCallStack& stack) const {
return _call_stack.equals(stack);
@ -51,6 +53,8 @@ template <class E> class AllocationSite {
// Information regarding this allocation
E* data() { return &e; }
const E* peek() const { return &e; }
MEMFLAGS flag() const { return _flag; }
};
#endif // SHARE_SERVICES_ALLOCATIONSITE_HPP

4
src/hotspot/share/services/mallocSiteTable.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -138,7 +138,7 @@ MallocSite* MallocSiteTable::lookup_or_add(const NativeCallStack& key, size_t* b
MallocSiteHashtableEntry* head = _table[index];
while (head != NULL && (*pos_idx) <= MAX_BUCKET_LENGTH) {
MallocSite* site = head->data();
if (site->flags() == flags && site->equals(key)) {
if (site->flag() == flags && site->equals(key)) {
return head->data();
}

8
src/hotspot/share/services/mallocSiteTable.hpp
View File

@ -37,15 +37,12 @@
// MallocSite represents a code path that eventually calls
// os::malloc() to allocate memory
class MallocSite : public AllocationSite<MemoryCounter> {
private:
MEMFLAGS _flags;
public:
MallocSite() :
AllocationSite<MemoryCounter>(NativeCallStack::empty_stack()), _flags(mtNone) {}
AllocationSite<MemoryCounter>(NativeCallStack::empty_stack(), mtNone) {}
MallocSite(const NativeCallStack& stack, MEMFLAGS flags) :
AllocationSite<MemoryCounter>(stack), _flags(flags) {}
AllocationSite<MemoryCounter>(stack, flags) {}
void allocate(size_t size) { data()->allocate(size); }
@ -55,7 +52,6 @@ class MallocSite : public AllocationSite<MemoryCounter> {
size_t size() const { return peek()->size(); }
// The number of calls were made
size_t count() const { return peek()->count(); }
MEMFLAGS flags() const { return (MEMFLAGS)_flags; }
};
// Malloc site hashtable entry

6
src/hotspot/share/services/memBaseline.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -64,7 +64,7 @@ int compare_malloc_site(const MallocSite& s1, const MallocSite& s2) {
int compare_malloc_site_and_type(const MallocSite& s1, const MallocSite& s2) {
int res = compare_malloc_site(s1, s2);
if (res == 0) {
res = (int)(s1.flags() - s2.flags());
res = (int)(s1.flag() - s2.flag());
}
return res;
@ -212,7 +212,7 @@ bool MemBaseline::aggregate_virtual_memory_allocation_sites() {
const ReservedMemoryRegion* rgn;
VirtualMemoryAllocationSite* site;
while ((rgn = itr.next()) != NULL) {
VirtualMemoryAllocationSite tmp(*rgn->call_stack());
VirtualMemoryAllocationSite tmp(*rgn->call_stack(), rgn->flag());
site = allocation_sites.find(tmp);
if (site == NULL) {
LinkedListNode<VirtualMemoryAllocationSite>* node =

29
src/hotspot/share/services/memReporter.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -240,7 +240,7 @@ void MemDetailReporter::report_malloc_sites() {
const NativeCallStack* stack = malloc_site->call_stack();
stack->print_on(out);
out->print("%29s", " ");
MEMFLAGS flag = malloc_site->flags();
MEMFLAGS flag = malloc_site->flag();
assert((flag >= 0 && flag < (int)mt_number_of_types) && flag != mtNone,
"Must have a valid memory type");
print_malloc(malloc_site->size(), malloc_site->count(),flag);
@ -266,6 +266,10 @@ void MemDetailReporter::report_virtual_memory_allocation_sites() {
stack->print_on(out);
out->print("%28s (", " ");
print_total(virtual_memory_site->reserved(), virtual_memory_site->committed());
MEMFLAGS flag = virtual_memory_site->flag();
if (flag != mtNone) {
out->print(" Type=%s", NMTUtil::flag_to_name(flag));
}
out->print_cr(")\n");
}
}
@ -690,19 +694,19 @@ void MemDetailDiffReporter::diff_virtual_memory_sites() const {
void MemDetailDiffReporter::new_malloc_site(const MallocSite* malloc_site) const {
diff_malloc_site(malloc_site->call_stack(), malloc_site->size(), malloc_site->count(),
0, 0, malloc_site->flags());
0, 0, malloc_site->flag());
}
void MemDetailDiffReporter::old_malloc_site(const MallocSite* malloc_site) const {
diff_malloc_site(malloc_site->call_stack(), 0, 0, malloc_site->size(),
malloc_site->count(), malloc_site->flags());
malloc_site->count(), malloc_site->flag());
}
void MemDetailDiffReporter::diff_malloc_site(const MallocSite* early,
const MallocSite* current) const {
assert(early->flags() == current->flags(), "Must be the same memory type");
assert(early->flag() == current->flag(), "Must be the same memory type");
diff_malloc_site(current->call_stack(), current->size(), current->count(),
early->size(), early->count(), early->flags());
early->size(), early->count(), early->flag());
}
void MemDetailDiffReporter::diff_malloc_site(const NativeCallStack* stack, size_t current_size,
@ -725,21 +729,22 @@ void MemDetailDiffReporter::diff_malloc_site(const NativeCallStack* stack, size_
void MemDetailDiffReporter::new_virtual_memory_site(const VirtualMemoryAllocationSite* site) const {
diff_virtual_memory_site(site->call_stack(), site->reserved(), site->committed(), 0, 0);
diff_virtual_memory_site(site->call_stack(), site->reserved(), site->committed(), 0, 0, site->flag());
}
void MemDetailDiffReporter::old_virtual_memory_site(const VirtualMemoryAllocationSite* site) const {
diff_virtual_memory_site(site->call_stack(), 0, 0, site->reserved(), site->committed());
diff_virtual_memory_site(site->call_stack(), 0, 0, site->reserved(), site->committed(), site->flag());
}
void MemDetailDiffReporter::diff_virtual_memory_site(const VirtualMemoryAllocationSite* early,
const VirtualMemoryAllocationSite* current) const {
assert(early->flag() == current->flag(), "Should be the same");
diff_virtual_memory_site(current->call_stack(), current->reserved(), current->committed(),
early->reserved(), early->committed());
early->reserved(), early->committed(), current->flag());
}
void MemDetailDiffReporter::diff_virtual_memory_site(const NativeCallStack* stack, size_t current_reserved,
size_t current_committed, size_t early_reserved, size_t early_committed) const {
size_t current_committed, size_t early_reserved, size_t early_committed, MEMFLAGS flag) const {
outputStream* out = output();
// no change
@ -753,5 +758,9 @@ void MemDetailDiffReporter::diff_virtual_memory_site(const NativeCallStack* stac
print_virtual_memory_diff(current_reserved, current_committed,
early_reserved, early_committed);
if (flag != mtNone) {
out->print(" Type=%s", NMTUtil::flag_to_name(flag));
}
out->print_cr(")\n");
}

2
src/hotspot/share/services/memReporter.hpp
View File

@ -230,7 +230,7 @@ class MemDetailDiffReporter : public MemSummaryDiffReporter {
void diff_malloc_site(const NativeCallStack* stack, size_t current_size,
size_t currrent_count, size_t early_size, size_t early_count, MEMFLAGS flags) const;
void diff_virtual_memory_site(const NativeCallStack* stack, size_t current_reserved,
size_t current_committed, size_t early_reserved, size_t early_committed) const;
size_t current_committed, size_t early_reserved, size_t early_committed, MEMFLAGS flag) const;
};
#endif // INCLUDE_NMT

4
src/hotspot/share/services/virtualMemoryTracker.hpp
View File

@ -70,8 +70,8 @@ class VirtualMemory {
// Virtual memory allocation site, keeps track where the virtual memory is reserved.
class VirtualMemoryAllocationSite : public AllocationSite<VirtualMemory> {
public:
VirtualMemoryAllocationSite(const NativeCallStack& stack) :
AllocationSite<VirtualMemory>(stack) { }
VirtualMemoryAllocationSite(const NativeCallStack& stack, MEMFLAGS flag) :
AllocationSite<VirtualMemory>(stack, flag) { }
inline void reserve_memory(size_t sz) { data()->reserve_memory(sz); }
inline void commit_memory (size_t sz) { data()->commit_memory(sz); }