author | tonyp |
Wed, 03 Jul 2019 15:46:48 -0400 | |
changeset 55576 | 4d193e40e7af |
parent 55545 | 8a153a932d0f |
child 55586 | 014c8cd323af |
permissions | -rw-r--r-- |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1 |
/* |
53547 | 2 |
* Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved. |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
4 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
5 |
* This code is free software; you can redistribute it and/or modify it |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
7 |
* published by the Free Software Foundation. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
8 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
13 |
* accompanied this code). |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
14 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
15 |
* You should have received a copy of the GNU General Public License version |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
18 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
21 |
* questions. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
22 |
* |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
23 |
*/ |
50193 | 24 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
25 |
#include "precompiled.hpp" |
42650 | 26 |
#include "aot/aotLoader.hpp" |
51959
db0c3952de52
8209645: Split ClassLoaderData and ClassLoaderDataGraph into separate files
coleenp
parents:
51444
diff
changeset
|
27 |
#include "classfile/classLoaderDataGraph.hpp" |
50380
bec342339138
8204195: Clean up macroAssembler.inline.hpp and other inline.hpp files included in .hpp files
coleenp
parents:
50372
diff
changeset
|
28 |
#include "gc/shared/collectedHeap.hpp" |
35061 | 29 |
#include "logging/log.hpp" |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46674
diff
changeset
|
30 |
#include "logging/logStream.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
31 |
#include "memory/filemap.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
32 |
#include "memory/metaspace.hpp" |
50193 | 33 |
#include "memory/metaspace/chunkManager.hpp" |
34 |
#include "memory/metaspace/metachunk.hpp" |
|
49980 | 35 |
#include "memory/metaspace/metaspaceCommon.hpp" |
50193 | 36 |
#include "memory/metaspace/printCLDMetaspaceInfoClosure.hpp" |
37 |
#include "memory/metaspace/spaceManager.hpp" |
|
38 |
#include "memory/metaspace/virtualSpaceList.hpp" |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
39 |
#include "memory/metaspaceShared.hpp" |
23465
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
40 |
#include "memory/metaspaceTracer.hpp" |
50380
bec342339138
8204195: Clean up macroAssembler.inline.hpp and other inline.hpp files included in .hpp files
coleenp
parents:
50372
diff
changeset
|
41 |
#include "memory/universe.hpp" |
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
54623
diff
changeset
|
42 |
#include "oops/compressedOops.hpp" |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
43 |
#include "runtime/init.hpp" |
50429
83aec1d357d4
8204301: Make OrderAccess functions available to hpp rather than inline.hpp files
coleenp
parents:
50380
diff
changeset
|
44 |
#include "runtime/orderAccess.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
45 |
#include "services/memTracker.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
46 |
#include "utilities/copy.hpp" |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
47 |
#include "utilities/debug.hpp" |
50380
bec342339138
8204195: Clean up macroAssembler.inline.hpp and other inline.hpp files included in .hpp files
coleenp
parents:
50372
diff
changeset
|
48 |
#include "utilities/formatBuffer.hpp" |
49980 | 49 |
#include "utilities/globalDefinitions.hpp" |
54842 | 50 |
#include "utilities/vmError.hpp" |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
51 |
|
20729 | 52 |
|
50193 | 53 |
using namespace metaspace; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
54 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
55 |
MetaWord* last_allocated = 0; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
56 |
|
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
57 |
size_t Metaspace::_compressed_class_space_size; |
23465
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
58 |
const MetaspaceTracer* Metaspace::_tracer = NULL; |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
59 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
60 |
DEBUG_ONLY(bool Metaspace::_frozen = false;) |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
61 |
|
49980 | 62 |
static const char* space_type_name(Metaspace::MetaspaceType t) { |
63 |
const char* s = NULL; |
|
64 |
switch (t) { |
|
65 |
case Metaspace::StandardMetaspaceType: s = "Standard"; break; |
|
66 |
case Metaspace::BootMetaspaceType: s = "Boot"; break; |
|
51444
3e5d28e6de32
8209301: JVM rename is_anonymous, host_klass to unsafe specific terminology ahead of Unsafe.defineAnonymousClass deprecation
lfoltan
parents:
51334
diff
changeset
|
67 |
case Metaspace::UnsafeAnonymousMetaspaceType: s = "UnsafeAnonymous"; break; |
49980 | 68 |
case Metaspace::ReflectionMetaspaceType: s = "Reflection"; break; |
69 |
default: ShouldNotReachHere(); |
|
70 |
} |
|
71 |
return s; |
|
47802
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
72 |
} |
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
73 |
|
50119
bf9177eac58d
8189271: Metaspace::_capacity_until_GC should be size_t
aharlap
parents:
50066
diff
changeset
|
74 |
volatile size_t MetaspaceGC::_capacity_until_GC = 0; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
75 |
uint MetaspaceGC::_shrink_factor = 0; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
76 |
bool MetaspaceGC::_should_concurrent_collect = false; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
77 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
78 |
// BlockFreelist methods |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
79 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
80 |
// VirtualSpaceNode methods |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
81 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
82 |
// MetaspaceGC methods |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
83 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
84 |
// VM_CollectForMetadataAllocation is the vm operation used to GC. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
85 |
// Within the VM operation after the GC the attempt to allocate the metadata |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
86 |
// should succeed. If the GC did not free enough space for the metaspace |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
87 |
// allocation, the HWM is increased so that another virtualspace will be |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
88 |
// allocated for the metadata. With perm gen the increase in the perm |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
89 |
// gen had bounds, MinMetaspaceExpansion and MaxMetaspaceExpansion. The |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
90 |
// metaspace policy uses those as the small and large steps for the HWM. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
91 |
// |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
92 |
// After the GC the compute_new_size() for MetaspaceGC is called to |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
93 |
// resize the capacity of the metaspaces. The current implementation |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
94 |
// is based on the flags MinMetaspaceFreeRatio and MaxMetaspaceFreeRatio used |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
95 |
// to resize the Java heap by some GC's. New flags can be implemented |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
96 |
// if really needed. MinMetaspaceFreeRatio is used to calculate how much |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
97 |
// free space is desirable in the metaspace capacity to decide how much |
15610
528d799702c7
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
15488
diff
changeset
|
98 |
// to increase the HWM. MaxMetaspaceFreeRatio is used to decide how much |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
99 |
// free space is desirable in the metaspace capacity before decreasing |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
100 |
// the HWM. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
101 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
102 |
// Calculate the amount to increase the high water mark (HWM). |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
103 |
// Increase by a minimum amount (MinMetaspaceExpansion) so that |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
104 |
// another expansion is not requested too soon. If that is not |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
105 |
// enough to satisfy the allocation, increase by MaxMetaspaceExpansion. |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
106 |
// If that is still not enough, expand by the size of the allocation |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
107 |
// plus some. |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
108 |
size_t MetaspaceGC::delta_capacity_until_GC(size_t bytes) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
109 |
size_t min_delta = MinMetaspaceExpansion; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
110 |
size_t max_delta = MaxMetaspaceExpansion; |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
111 |
size_t delta = align_up(bytes, Metaspace::commit_alignment()); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
112 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
113 |
if (delta <= min_delta) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
114 |
delta = min_delta; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
115 |
} else if (delta <= max_delta) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
116 |
// Don't want to hit the high water mark on the next |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
117 |
// allocation so make the delta greater than just enough |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
118 |
// for this allocation. |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
119 |
delta = max_delta; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
120 |
} else { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
121 |
// This allocation is large but the next ones are probably not |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
122 |
// so increase by the minimum. |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
123 |
delta = delta + min_delta; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
124 |
} |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
125 |
|
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
126 |
assert_is_aligned(delta, Metaspace::commit_alignment()); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
127 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
128 |
return delta; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
129 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
130 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
131 |
size_t MetaspaceGC::capacity_until_GC() { |
47634
6a0c42c40cd1
8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents:
47599
diff
changeset
|
132 |
size_t value = OrderAccess::load_acquire(&_capacity_until_GC); |
27693
3eee985a97e7
8059492: Wrong spelling in assert: "Not initialied properly?"
aharlap
parents:
27683
diff
changeset
|
133 |
assert(value >= MetaspaceSize, "Not initialized properly?"); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
134 |
return value; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
135 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
136 |
|
53602
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
137 |
// Try to increase the _capacity_until_GC limit counter by v bytes. |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
138 |
// Returns true if it succeeded. It may fail if either another thread |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
139 |
// concurrently increased the limit or the new limit would be larger |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
140 |
// than MaxMetaspaceSize. |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
141 |
// On success, optionally returns new and old metaspace capacity in |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
142 |
// new_cap_until_GC and old_cap_until_GC respectively. |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
143 |
// On error, optionally sets can_retry to indicate whether if there is |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
144 |
// actually enough space remaining to satisfy the request. |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
145 |
bool MetaspaceGC::inc_capacity_until_GC(size_t v, size_t* new_cap_until_GC, size_t* old_cap_until_GC, bool* can_retry) { |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
146 |
assert_is_aligned(v, Metaspace::commit_alignment()); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
147 |
|
50283
2f9811d99ba8
8203262: Incorrect cmpxchg usage in MetaspaceGC::inc_capacity_until_GC
tschatzl
parents:
50193
diff
changeset
|
148 |
size_t old_capacity_until_GC = _capacity_until_GC; |
2f9811d99ba8
8203262: Incorrect cmpxchg usage in MetaspaceGC::inc_capacity_until_GC
tschatzl
parents:
50193
diff
changeset
|
149 |
size_t new_value = old_capacity_until_GC + v; |
26938
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
150 |
|
50283
2f9811d99ba8
8203262: Incorrect cmpxchg usage in MetaspaceGC::inc_capacity_until_GC
tschatzl
parents:
50193
diff
changeset
|
151 |
if (new_value < old_capacity_until_GC) { |
26938
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
152 |
// The addition wrapped around, set new_value to aligned max value. |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
153 |
new_value = align_down(max_uintx, Metaspace::commit_alignment()); |
26938
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
154 |
} |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
155 |
|
53602
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
156 |
if (new_value > MaxMetaspaceSize) { |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
157 |
if (can_retry != NULL) { |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
158 |
*can_retry = false; |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
159 |
} |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
160 |
return false; |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
161 |
} |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
162 |
|
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
163 |
if (can_retry != NULL) { |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
164 |
*can_retry = true; |
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
165 |
} |
50283
2f9811d99ba8
8203262: Incorrect cmpxchg usage in MetaspaceGC::inc_capacity_until_GC
tschatzl
parents:
50193
diff
changeset
|
166 |
size_t prev_value = Atomic::cmpxchg(new_value, &_capacity_until_GC, old_capacity_until_GC); |
26938
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
167 |
|
50283
2f9811d99ba8
8203262: Incorrect cmpxchg usage in MetaspaceGC::inc_capacity_until_GC
tschatzl
parents:
50193
diff
changeset
|
168 |
if (old_capacity_until_GC != prev_value) { |
26938
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
169 |
return false; |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
170 |
} |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
171 |
|
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
172 |
if (new_cap_until_GC != NULL) { |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
173 |
*new_cap_until_GC = new_value; |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
174 |
} |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
175 |
if (old_cap_until_GC != NULL) { |
50283
2f9811d99ba8
8203262: Incorrect cmpxchg usage in MetaspaceGC::inc_capacity_until_GC
tschatzl
parents:
50193
diff
changeset
|
176 |
*old_cap_until_GC = old_capacity_until_GC; |
26938
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
177 |
} |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
178 |
return true; |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
179 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
180 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
181 |
size_t MetaspaceGC::dec_capacity_until_GC(size_t v) { |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
182 |
assert_is_aligned(v, Metaspace::commit_alignment()); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
183 |
|
50119
bf9177eac58d
8189271: Metaspace::_capacity_until_GC should be size_t
aharlap
parents:
50066
diff
changeset
|
184 |
return Atomic::sub(v, &_capacity_until_GC); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
185 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
186 |
|
24847
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
187 |
void MetaspaceGC::initialize() { |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
188 |
// Set the high-water mark to MaxMetapaceSize during VM initializaton since |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
189 |
// we can't do a GC during initialization. |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
190 |
_capacity_until_GC = MaxMetaspaceSize; |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
191 |
} |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
192 |
|
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
193 |
void MetaspaceGC::post_initialize() { |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
194 |
// Reset the high-water mark once the VM initialization is done. |
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
195 |
_capacity_until_GC = MAX2(MetaspaceUtils::committed_bytes(), MetaspaceSize); |
24847
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
196 |
} |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
197 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
198 |
bool MetaspaceGC::can_expand(size_t word_size, bool is_class) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
199 |
// Check if the compressed class space is full. |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
200 |
if (is_class && Metaspace::using_class_space()) { |
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
201 |
size_t class_committed = MetaspaceUtils::committed_bytes(Metaspace::ClassType); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
202 |
if (class_committed + word_size * BytesPerWord > CompressedClassSpaceSize) { |
49365 | 203 |
log_trace(gc, metaspace, freelist)("Cannot expand %s metaspace by " SIZE_FORMAT " words (CompressedClassSpaceSize = " SIZE_FORMAT " words)", |
204 |
(is_class ? "class" : "non-class"), word_size, CompressedClassSpaceSize / sizeof(MetaWord)); |
|
18491
dd63ba6b0ee4
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
17858
diff
changeset
|
205 |
return false; |
dd63ba6b0ee4
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
17858
diff
changeset
|
206 |
} |
16391
7bf8a7699f5f
8004241: NPG: Metaspace occupies more memory than specified by -XX:MaxMetaspaceSize option
mgerdin
parents:
16387
diff
changeset
|
207 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
208 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
209 |
// Check if the user has imposed a limit on the metaspace memory. |
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
210 |
size_t committed_bytes = MetaspaceUtils::committed_bytes(); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
211 |
if (committed_bytes + word_size * BytesPerWord > MaxMetaspaceSize) { |
49365 | 212 |
log_trace(gc, metaspace, freelist)("Cannot expand %s metaspace by " SIZE_FORMAT " words (MaxMetaspaceSize = " SIZE_FORMAT " words)", |
213 |
(is_class ? "class" : "non-class"), word_size, MaxMetaspaceSize / sizeof(MetaWord)); |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
214 |
return false; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
215 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
216 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
217 |
return true; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
218 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
219 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
220 |
size_t MetaspaceGC::allowed_expansion() { |
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
221 |
size_t committed_bytes = MetaspaceUtils::committed_bytes(); |
24847
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
222 |
size_t capacity_until_gc = capacity_until_GC(); |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
223 |
|
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
224 |
assert(capacity_until_gc >= committed_bytes, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31374
diff
changeset
|
225 |
"capacity_until_gc: " SIZE_FORMAT " < committed_bytes: " SIZE_FORMAT, |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31374
diff
changeset
|
226 |
capacity_until_gc, committed_bytes); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
227 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
228 |
size_t left_until_max = MaxMetaspaceSize - committed_bytes; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
229 |
size_t left_until_GC = capacity_until_gc - committed_bytes; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
230 |
size_t left_to_commit = MIN2(left_until_GC, left_until_max); |
49365 | 231 |
log_trace(gc, metaspace, freelist)("allowed expansion words: " SIZE_FORMAT |
232 |
" (left_until_max: " SIZE_FORMAT ", left_until_GC: " SIZE_FORMAT ".", |
|
233 |
left_to_commit / BytesPerWord, left_until_max / BytesPerWord, left_until_GC / BytesPerWord); |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
234 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
235 |
return left_to_commit / BytesPerWord; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
236 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
237 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
238 |
void MetaspaceGC::compute_new_size() { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
239 |
assert(_shrink_factor <= 100, "invalid shrink factor"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
240 |
uint current_shrink_factor = _shrink_factor; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
241 |
_shrink_factor = 0; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
242 |
|
24847
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
243 |
// Using committed_bytes() for used_after_gc is an overestimation, since the |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
244 |
// chunk free lists are included in committed_bytes() and the memory in an |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
245 |
// un-fragmented chunk free list is available for future allocations. |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
246 |
// However, if the chunk free lists becomes fragmented, then the memory may |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
247 |
// not be available for future allocations and the memory is therefore "in use". |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
248 |
// Including the chunk free lists in the definition of "in use" is therefore |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
249 |
// necessary. Not including the chunk free lists can cause capacity_until_GC to |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
250 |
// shrink below committed_bytes() and this has caused serious bugs in the past. |
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
251 |
const size_t used_after_gc = MetaspaceUtils::committed_bytes(); |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
252 |
const size_t capacity_until_GC = MetaspaceGC::capacity_until_GC(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
253 |
|
15610
528d799702c7
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
15488
diff
changeset
|
254 |
const double minimum_free_percentage = MinMetaspaceFreeRatio / 100.0; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
255 |
const double maximum_used_percentage = 1.0 - minimum_free_percentage; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
256 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
257 |
const double min_tmp = used_after_gc / maximum_used_percentage; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
258 |
size_t minimum_desired_capacity = |
53602
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
259 |
(size_t)MIN2(min_tmp, double(MaxMetaspaceSize)); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
260 |
// Don't shrink less than the initial generation size |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
261 |
minimum_desired_capacity = MAX2(minimum_desired_capacity, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
262 |
MetaspaceSize); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
263 |
|
35061 | 264 |
log_trace(gc, metaspace)("MetaspaceGC::compute_new_size: "); |
265 |
log_trace(gc, metaspace)(" minimum_free_percentage: %6.2f maximum_used_percentage: %6.2f", |
|
266 |
minimum_free_percentage, maximum_used_percentage); |
|
267 |
log_trace(gc, metaspace)(" used_after_gc : %6.1fKB", used_after_gc / (double) K); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
268 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
269 |
|
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
270 |
size_t shrink_bytes = 0; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
271 |
if (capacity_until_GC < minimum_desired_capacity) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
272 |
// If we have less capacity below the metaspace HWM, then |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
273 |
// increment the HWM. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
274 |
size_t expand_bytes = minimum_desired_capacity - capacity_until_GC; |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
275 |
expand_bytes = align_up(expand_bytes, Metaspace::commit_alignment()); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
276 |
// Don't expand unless it's significant |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
277 |
if (expand_bytes >= MinMetaspaceExpansion) { |
26938
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
278 |
size_t new_capacity_until_GC = 0; |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
279 |
bool succeeded = MetaspaceGC::inc_capacity_until_GC(expand_bytes, &new_capacity_until_GC); |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
280 |
assert(succeeded, "Should always succesfully increment HWM when at safepoint"); |
e0b35f8104a7
8049599: MetaspaceGC::_capacity_until_GC can overflow
ehelin
parents:
26304
diff
changeset
|
281 |
|
23465
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
282 |
Metaspace::tracer()->report_gc_threshold(capacity_until_GC, |
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
283 |
new_capacity_until_GC, |
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
284 |
MetaspaceGCThresholdUpdater::ComputeNewSize); |
35061 | 285 |
log_trace(gc, metaspace)(" expanding: minimum_desired_capacity: %6.1fKB expand_bytes: %6.1fKB MinMetaspaceExpansion: %6.1fKB new metaspace HWM: %6.1fKB", |
286 |
minimum_desired_capacity / (double) K, |
|
287 |
expand_bytes / (double) K, |
|
288 |
MinMetaspaceExpansion / (double) K, |
|
289 |
new_capacity_until_GC / (double) K); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
290 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
291 |
return; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
292 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
293 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
294 |
// No expansion, now see if we want to shrink |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
295 |
// We would never want to shrink more than this |
22499 | 296 |
assert(capacity_until_GC >= minimum_desired_capacity, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31374
diff
changeset
|
297 |
SIZE_FORMAT " >= " SIZE_FORMAT, |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31374
diff
changeset
|
298 |
capacity_until_GC, minimum_desired_capacity); |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
299 |
size_t max_shrink_bytes = capacity_until_GC - minimum_desired_capacity; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
300 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
301 |
// Should shrinking be considered? |
15610
528d799702c7
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
15488
diff
changeset
|
302 |
if (MaxMetaspaceFreeRatio < 100) { |
528d799702c7
8005452: NPG: Create new flags for Metaspace resizing policy
jmasa
parents:
15488
diff
changeset
|
303 |
const double maximum_free_percentage = MaxMetaspaceFreeRatio / 100.0; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
304 |
const double minimum_used_percentage = 1.0 - maximum_free_percentage; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
305 |
const double max_tmp = used_after_gc / minimum_used_percentage; |
53602
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
306 |
size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, double(MaxMetaspaceSize)); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
307 |
maximum_desired_capacity = MAX2(maximum_desired_capacity, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
308 |
MetaspaceSize); |
35061 | 309 |
log_trace(gc, metaspace)(" maximum_free_percentage: %6.2f minimum_used_percentage: %6.2f", |
310 |
maximum_free_percentage, minimum_used_percentage); |
|
311 |
log_trace(gc, metaspace)(" minimum_desired_capacity: %6.1fKB maximum_desired_capacity: %6.1fKB", |
|
312 |
minimum_desired_capacity / (double) K, maximum_desired_capacity / (double) K); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
313 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
314 |
assert(minimum_desired_capacity <= maximum_desired_capacity, |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
315 |
"sanity check"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
316 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
317 |
if (capacity_until_GC > maximum_desired_capacity) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
318 |
// Capacity too large, compute shrinking size |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
319 |
shrink_bytes = capacity_until_GC - maximum_desired_capacity; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
320 |
// We don't want shrink all the way back to initSize if people call |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
321 |
// System.gc(), because some programs do that between "phases" and then |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
322 |
// we'd just have to grow the heap up again for the next phase. So we |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
323 |
// damp the shrinking: 0% on the first call, 10% on the second call, 40% |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
324 |
// on the third call, and 100% by the fourth call. But if we recompute |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
325 |
// size without shrinking, it goes back to 0%. |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
326 |
shrink_bytes = shrink_bytes / 100 * current_shrink_factor; |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
327 |
|
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
328 |
shrink_bytes = align_down(shrink_bytes, Metaspace::commit_alignment()); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
329 |
|
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
330 |
assert(shrink_bytes <= max_shrink_bytes, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31374
diff
changeset
|
331 |
"invalid shrink size " SIZE_FORMAT " not <= " SIZE_FORMAT, |
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31374
diff
changeset
|
332 |
shrink_bytes, max_shrink_bytes); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
333 |
if (current_shrink_factor == 0) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
334 |
_shrink_factor = 10; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
335 |
} else { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
336 |
_shrink_factor = MIN2(current_shrink_factor * 4, (uint) 100); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
337 |
} |
37151
bcda1fb89431
8151845: Comment in globals.hpp for MetaspaceSize is incorrect.
jmasa
parents:
37139
diff
changeset
|
338 |
log_trace(gc, metaspace)(" shrinking: initThreshold: %.1fK maximum_desired_capacity: %.1fK", |
35061 | 339 |
MetaspaceSize / (double) K, maximum_desired_capacity / (double) K); |
340 |
log_trace(gc, metaspace)(" shrink_bytes: %.1fK current_shrink_factor: %d new shrink factor: %d MinMetaspaceExpansion: %.1fK", |
|
341 |
shrink_bytes / (double) K, current_shrink_factor, _shrink_factor, MinMetaspaceExpansion / (double) K); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
342 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
343 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
344 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
345 |
// Don't shrink unless it's significant |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
346 |
if (shrink_bytes >= MinMetaspaceExpansion && |
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
347 |
((capacity_until_GC - shrink_bytes) >= MetaspaceSize)) { |
23465
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
348 |
size_t new_capacity_until_GC = MetaspaceGC::dec_capacity_until_GC(shrink_bytes); |
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
349 |
Metaspace::tracer()->report_gc_threshold(capacity_until_GC, |
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
350 |
new_capacity_until_GC, |
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
351 |
MetaspaceGCThresholdUpdater::ComputeNewSize); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
352 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
353 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
354 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
355 |
// MetaspaceUtils |
49980 | 356 |
size_t MetaspaceUtils::_capacity_words [Metaspace:: MetadataTypeCount] = {0, 0}; |
357 |
size_t MetaspaceUtils::_overhead_words [Metaspace:: MetadataTypeCount] = {0, 0}; |
|
358 |
volatile size_t MetaspaceUtils::_used_words [Metaspace:: MetadataTypeCount] = {0, 0}; |
|
359 |
||
360 |
// Collect used metaspace statistics. This involves walking the CLDG. The resulting |
|
361 |
// output will be the accumulated values for all live metaspaces. |
|
362 |
// Note: method does not do any locking. |
|
363 |
void MetaspaceUtils::collect_statistics(ClassLoaderMetaspaceStatistics* out) { |
|
364 |
out->reset(); |
|
365 |
ClassLoaderDataGraphMetaspaceIterator iter; |
|
366 |
while (iter.repeat()) { |
|
367 |
ClassLoaderMetaspace* msp = iter.get_next(); |
|
368 |
if (msp != NULL) { |
|
369 |
msp->add_to_statistics(out); |
|
370 |
} |
|
371 |
} |
|
372 |
} |
|
373 |
||
374 |
size_t MetaspaceUtils::free_in_vs_bytes(Metaspace::MetadataType mdtype) { |
|
19322
e35f9ed4f081
8014659: NPG: performance counters for compressed klass space
ehelin
parents:
19319
diff
changeset
|
375 |
VirtualSpaceList* list = Metaspace::get_space_list(mdtype); |
e35f9ed4f081
8014659: NPG: performance counters for compressed klass space
ehelin
parents:
19319
diff
changeset
|
376 |
return list == NULL ? 0 : list->free_bytes(); |
e35f9ed4f081
8014659: NPG: performance counters for compressed klass space
ehelin
parents:
19319
diff
changeset
|
377 |
} |
e35f9ed4f081
8014659: NPG: performance counters for compressed klass space
ehelin
parents:
19319
diff
changeset
|
378 |
|
49980 | 379 |
size_t MetaspaceUtils::free_in_vs_bytes() { |
380 |
return free_in_vs_bytes(Metaspace::ClassType) + free_in_vs_bytes(Metaspace::NonClassType); |
|
381 |
} |
|
382 |
||
383 |
static void inc_stat_nonatomically(size_t* pstat, size_t words) { |
|
384 |
assert_lock_strong(MetaspaceExpand_lock); |
|
385 |
(*pstat) += words; |
|
386 |
} |
|
387 |
||
388 |
static void dec_stat_nonatomically(size_t* pstat, size_t words) { |
|
389 |
assert_lock_strong(MetaspaceExpand_lock); |
|
390 |
const size_t size_now = *pstat; |
|
391 |
assert(size_now >= words, "About to decrement counter below zero " |
|
392 |
"(current value: " SIZE_FORMAT ", decrement value: " SIZE_FORMAT ".", |
|
393 |
size_now, words); |
|
394 |
*pstat = size_now - words; |
|
395 |
} |
|
396 |
||
397 |
static void inc_stat_atomically(volatile size_t* pstat, size_t words) { |
|
398 |
Atomic::add(words, pstat); |
|
399 |
} |
|
400 |
||
401 |
static void dec_stat_atomically(volatile size_t* pstat, size_t words) { |
|
402 |
const size_t size_now = *pstat; |
|
403 |
assert(size_now >= words, "About to decrement counter below zero " |
|
404 |
"(current value: " SIZE_FORMAT ", decrement value: " SIZE_FORMAT ".", |
|
405 |
size_now, words); |
|
406 |
Atomic::sub(words, pstat); |
|
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
407 |
} |
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
408 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
409 |
void MetaspaceUtils::dec_capacity(Metaspace::MetadataType mdtype, size_t words) { |
49980 | 410 |
dec_stat_nonatomically(&_capacity_words[mdtype], words); |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
411 |
} |
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
412 |
void MetaspaceUtils::inc_capacity(Metaspace::MetadataType mdtype, size_t words) { |
49980 | 413 |
inc_stat_nonatomically(&_capacity_words[mdtype], words); |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
414 |
} |
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
415 |
void MetaspaceUtils::dec_used(Metaspace::MetadataType mdtype, size_t words) { |
49980 | 416 |
dec_stat_atomically(&_used_words[mdtype], words); |
13733
e41e23ae6758
7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong
jmasa
parents:
13729
diff
changeset
|
417 |
} |
49980 | 418 |
void MetaspaceUtils::inc_used(Metaspace::MetadataType mdtype, size_t words) { |
419 |
inc_stat_atomically(&_used_words[mdtype], words); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
420 |
} |
49980 | 421 |
void MetaspaceUtils::dec_overhead(Metaspace::MetadataType mdtype, size_t words) { |
422 |
dec_stat_nonatomically(&_overhead_words[mdtype], words); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
423 |
} |
49980 | 424 |
void MetaspaceUtils::inc_overhead(Metaspace::MetadataType mdtype, size_t words) { |
425 |
inc_stat_nonatomically(&_overhead_words[mdtype], words); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
426 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
427 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
428 |
size_t MetaspaceUtils::reserved_bytes(Metaspace::MetadataType mdtype) { |
19988 | 429 |
VirtualSpaceList* list = Metaspace::get_space_list(mdtype); |
19989
0fc247fb59bc
8024638: Count and expose the amount of committed memory in the metaspaces
stefank
parents:
19988
diff
changeset
|
430 |
return list == NULL ? 0 : list->reserved_bytes(); |
0fc247fb59bc
8024638: Count and expose the amount of committed memory in the metaspaces
stefank
parents:
19988
diff
changeset
|
431 |
} |
0fc247fb59bc
8024638: Count and expose the amount of committed memory in the metaspaces
stefank
parents:
19988
diff
changeset
|
432 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
433 |
size_t MetaspaceUtils::committed_bytes(Metaspace::MetadataType mdtype) { |
19989
0fc247fb59bc
8024638: Count and expose the amount of committed memory in the metaspaces
stefank
parents:
19988
diff
changeset
|
434 |
VirtualSpaceList* list = Metaspace::get_space_list(mdtype); |
0fc247fb59bc
8024638: Count and expose the amount of committed memory in the metaspaces
stefank
parents:
19988
diff
changeset
|
435 |
return list == NULL ? 0 : list->committed_bytes(); |
19988 | 436 |
} |
437 |
||
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
438 |
size_t MetaspaceUtils::min_chunk_size_words() { return Metaspace::first_chunk_word_size(); } |
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
439 |
|
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
440 |
size_t MetaspaceUtils::free_chunks_total_words(Metaspace::MetadataType mdtype) { |
20081
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
441 |
ChunkManager* chunk_manager = Metaspace::get_chunk_manager(mdtype); |
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
442 |
if (chunk_manager == NULL) { |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
443 |
return 0; |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
444 |
} |
20081
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
445 |
return chunk_manager->free_chunks_total_words(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
446 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
447 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
448 |
size_t MetaspaceUtils::free_chunks_total_bytes(Metaspace::MetadataType mdtype) { |
19988 | 449 |
return free_chunks_total_words(mdtype) * BytesPerWord; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
450 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
451 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
452 |
size_t MetaspaceUtils::free_chunks_total_words() { |
19988 | 453 |
return free_chunks_total_words(Metaspace::ClassType) + |
454 |
free_chunks_total_words(Metaspace::NonClassType); |
|
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
455 |
} |
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
456 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
457 |
size_t MetaspaceUtils::free_chunks_total_bytes() { |
19988 | 458 |
return free_chunks_total_words() * BytesPerWord; |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
459 |
} |
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
460 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
461 |
bool MetaspaceUtils::has_chunk_free_list(Metaspace::MetadataType mdtype) { |
23470
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
462 |
return Metaspace::get_chunk_manager(mdtype) != NULL; |
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
463 |
} |
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
464 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
465 |
MetaspaceChunkFreeListSummary MetaspaceUtils::chunk_free_list_summary(Metaspace::MetadataType mdtype) { |
23470
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
466 |
if (!has_chunk_free_list(mdtype)) { |
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
467 |
return MetaspaceChunkFreeListSummary(); |
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
468 |
} |
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
469 |
|
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
470 |
const ChunkManager* cm = Metaspace::get_chunk_manager(mdtype); |
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
471 |
return cm->chunk_free_list_summary(); |
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
472 |
} |
ff2a7ea4225d
8036703: Add trace event with statistics for the metaspace chunk free lists
ehelin
parents:
23469
diff
changeset
|
473 |
|
55576
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
474 |
void MetaspaceUtils::print_metaspace_change(const metaspace::MetaspaceSizesSnapshot& pre_meta_values) { |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
475 |
const metaspace::MetaspaceSizesSnapshot meta_values; |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
476 |
|
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
477 |
if (Metaspace::using_class_space()) { |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
478 |
log_info(gc, metaspace)(HEAP_CHANGE_FORMAT" " |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
479 |
HEAP_CHANGE_FORMAT" " |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
480 |
HEAP_CHANGE_FORMAT, |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
481 |
HEAP_CHANGE_FORMAT_ARGS("Metaspace", |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
482 |
pre_meta_values.used(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
483 |
pre_meta_values.committed(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
484 |
meta_values.used(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
485 |
meta_values.committed()), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
486 |
HEAP_CHANGE_FORMAT_ARGS("NonClass", |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
487 |
pre_meta_values.non_class_used(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
488 |
pre_meta_values.non_class_committed(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
489 |
meta_values.non_class_used(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
490 |
meta_values.non_class_committed()), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
491 |
HEAP_CHANGE_FORMAT_ARGS("Class", |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
492 |
pre_meta_values.class_used(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
493 |
pre_meta_values.class_committed(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
494 |
meta_values.class_used(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
495 |
meta_values.class_committed())); |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
496 |
} else { |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
497 |
log_info(gc, metaspace)(HEAP_CHANGE_FORMAT, |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
498 |
HEAP_CHANGE_FORMAT_ARGS("Metaspace", |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
499 |
pre_meta_values.used(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
500 |
pre_meta_values.committed(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
501 |
meta_values.used(), |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
502 |
meta_values.committed())); |
4d193e40e7af
8223575: add subspace transitions to gc+metaspace=info log lines
tonyp
parents:
55545
diff
changeset
|
503 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
504 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
505 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
506 |
void MetaspaceUtils::print_on(outputStream* out) { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
507 |
Metaspace::MetadataType nct = Metaspace::NonClassType; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
508 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
509 |
out->print_cr(" Metaspace " |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
510 |
"used " SIZE_FORMAT "K, " |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
511 |
"capacity " SIZE_FORMAT "K, " |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
512 |
"committed " SIZE_FORMAT "K, " |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
513 |
"reserved " SIZE_FORMAT "K", |
23854
50f7f89b34e0
8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents:
23503
diff
changeset
|
514 |
used_bytes()/K, |
50f7f89b34e0
8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents:
23503
diff
changeset
|
515 |
capacity_bytes()/K, |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
516 |
committed_bytes()/K, |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
517 |
reserved_bytes()/K); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
518 |
|
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
519 |
if (Metaspace::using_class_space()) { |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
520 |
Metaspace::MetadataType ct = Metaspace::ClassType; |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
521 |
out->print_cr(" class space " |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
522 |
"used " SIZE_FORMAT "K, " |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
523 |
"capacity " SIZE_FORMAT "K, " |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
524 |
"committed " SIZE_FORMAT "K, " |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
525 |
"reserved " SIZE_FORMAT "K", |
23854
50f7f89b34e0
8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents:
23503
diff
changeset
|
526 |
used_bytes(ct)/K, |
50f7f89b34e0
8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents:
23503
diff
changeset
|
527 |
capacity_bytes(ct)/K, |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
528 |
committed_bytes(ct)/K, |
19988 | 529 |
reserved_bytes(ct)/K); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
530 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
531 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
532 |
|
47802
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
533 |
|
49980 | 534 |
void MetaspaceUtils::print_vs(outputStream* out, size_t scale) { |
535 |
const size_t reserved_nonclass_words = reserved_bytes(Metaspace::NonClassType) / sizeof(MetaWord); |
|
536 |
const size_t committed_nonclass_words = committed_bytes(Metaspace::NonClassType) / sizeof(MetaWord); |
|
537 |
{ |
|
538 |
if (Metaspace::using_class_space()) { |
|
539 |
out->print(" Non-class space: "); |
|
540 |
} |
|
541 |
print_scaled_words(out, reserved_nonclass_words, scale, 7); |
|
542 |
out->print(" reserved, "); |
|
543 |
print_scaled_words_and_percentage(out, committed_nonclass_words, reserved_nonclass_words, scale, 7); |
|
544 |
out->print_cr(" committed "); |
|
545 |
||
546 |
if (Metaspace::using_class_space()) { |
|
547 |
const size_t reserved_class_words = reserved_bytes(Metaspace::ClassType) / sizeof(MetaWord); |
|
548 |
const size_t committed_class_words = committed_bytes(Metaspace::ClassType) / sizeof(MetaWord); |
|
549 |
out->print(" Class space: "); |
|
550 |
print_scaled_words(out, reserved_class_words, scale, 7); |
|
551 |
out->print(" reserved, "); |
|
552 |
print_scaled_words_and_percentage(out, committed_class_words, reserved_class_words, scale, 7); |
|
553 |
out->print_cr(" committed "); |
|
554 |
||
555 |
const size_t reserved_words = reserved_nonclass_words + reserved_class_words; |
|
556 |
const size_t committed_words = committed_nonclass_words + committed_class_words; |
|
557 |
out->print(" Both: "); |
|
558 |
print_scaled_words(out, reserved_words, scale, 7); |
|
559 |
out->print(" reserved, "); |
|
560 |
print_scaled_words_and_percentage(out, committed_words, reserved_words, scale, 7); |
|
561 |
out->print_cr(" committed "); |
|
562 |
} |
|
563 |
} |
|
564 |
} |
|
565 |
||
54341
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
566 |
static void print_basic_switches(outputStream* out, size_t scale) { |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
567 |
out->print("MaxMetaspaceSize: "); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
568 |
if (MaxMetaspaceSize >= (max_uintx) - (2 * os::vm_page_size())) { |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
569 |
// aka "very big". Default is max_uintx, but due to rounding in arg parsing the real |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
570 |
// value is smaller. |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
571 |
out->print("unlimited"); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
572 |
} else { |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
573 |
print_human_readable_size(out, MaxMetaspaceSize, scale); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
574 |
} |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
575 |
out->cr(); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
576 |
if (Metaspace::using_class_space()) { |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
577 |
out->print("CompressedClassSpaceSize: "); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
578 |
print_human_readable_size(out, CompressedClassSpaceSize, scale); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
579 |
} |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
580 |
out->cr(); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
581 |
} |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
582 |
|
49980 | 583 |
// This will print out a basic metaspace usage report but |
584 |
// unlike print_report() is guaranteed not to lock or to walk the CLDG. |
|
585 |
void MetaspaceUtils::print_basic_report(outputStream* out, size_t scale) { |
|
586 |
||
587 |
out->cr(); |
|
588 |
out->print_cr("Usage:"); |
|
47802
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
589 |
|
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
590 |
if (Metaspace::using_class_space()) { |
49980 | 591 |
out->print(" Non-class: "); |
592 |
} |
|
593 |
||
594 |
// In its most basic form, we do not require walking the CLDG. Instead, just print the running totals from |
|
595 |
// MetaspaceUtils. |
|
596 |
const size_t cap_nc = MetaspaceUtils::capacity_words(Metaspace::NonClassType); |
|
597 |
const size_t overhead_nc = MetaspaceUtils::overhead_words(Metaspace::NonClassType); |
|
598 |
const size_t used_nc = MetaspaceUtils::used_words(Metaspace::NonClassType); |
|
599 |
const size_t free_and_waste_nc = cap_nc - overhead_nc - used_nc; |
|
600 |
||
601 |
print_scaled_words(out, cap_nc, scale, 5); |
|
602 |
out->print(" capacity, "); |
|
603 |
print_scaled_words_and_percentage(out, used_nc, cap_nc, scale, 5); |
|
604 |
out->print(" used, "); |
|
605 |
print_scaled_words_and_percentage(out, free_and_waste_nc, cap_nc, scale, 5); |
|
606 |
out->print(" free+waste, "); |
|
607 |
print_scaled_words_and_percentage(out, overhead_nc, cap_nc, scale, 5); |
|
608 |
out->print(" overhead. "); |
|
609 |
out->cr(); |
|
47802
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
610 |
|
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
611 |
if (Metaspace::using_class_space()) { |
49980 | 612 |
const size_t cap_c = MetaspaceUtils::capacity_words(Metaspace::ClassType); |
613 |
const size_t overhead_c = MetaspaceUtils::overhead_words(Metaspace::ClassType); |
|
614 |
const size_t used_c = MetaspaceUtils::used_words(Metaspace::ClassType); |
|
615 |
const size_t free_and_waste_c = cap_c - overhead_c - used_c; |
|
616 |
out->print(" Class: "); |
|
617 |
print_scaled_words(out, cap_c, scale, 5); |
|
618 |
out->print(" capacity, "); |
|
619 |
print_scaled_words_and_percentage(out, used_c, cap_c, scale, 5); |
|
620 |
out->print(" used, "); |
|
621 |
print_scaled_words_and_percentage(out, free_and_waste_c, cap_c, scale, 5); |
|
622 |
out->print(" free+waste, "); |
|
623 |
print_scaled_words_and_percentage(out, overhead_c, cap_c, scale, 5); |
|
624 |
out->print(" overhead. "); |
|
625 |
out->cr(); |
|
626 |
||
627 |
out->print(" Both: "); |
|
628 |
const size_t cap = cap_nc + cap_c; |
|
629 |
||
630 |
print_scaled_words(out, cap, scale, 5); |
|
631 |
out->print(" capacity, "); |
|
632 |
print_scaled_words_and_percentage(out, used_nc + used_c, cap, scale, 5); |
|
633 |
out->print(" used, "); |
|
634 |
print_scaled_words_and_percentage(out, free_and_waste_nc + free_and_waste_c, cap, scale, 5); |
|
635 |
out->print(" free+waste, "); |
|
636 |
print_scaled_words_and_percentage(out, overhead_nc + overhead_c, cap, scale, 5); |
|
637 |
out->print(" overhead. "); |
|
638 |
out->cr(); |
|
47802
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
639 |
} |
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
640 |
|
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
641 |
out->cr(); |
49980 | 642 |
out->print_cr("Virtual space:"); |
643 |
||
644 |
print_vs(out, scale); |
|
47802
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
645 |
|
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
646 |
out->cr(); |
49980 | 647 |
out->print_cr("Chunk freelists:"); |
648 |
||
649 |
if (Metaspace::using_class_space()) { |
|
650 |
out->print(" Non-Class: "); |
|
651 |
} |
|
53598
69ccc5584e12
8218156: "jcmd VM.metaspace basic" misreports free chunk space
stuefe
parents:
53547
diff
changeset
|
652 |
print_human_readable_size(out, Metaspace::chunk_manager_metadata()->free_chunks_total_bytes(), scale); |
47802
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
653 |
out->cr(); |
49980 | 654 |
if (Metaspace::using_class_space()) { |
655 |
out->print(" Class: "); |
|
53598
69ccc5584e12
8218156: "jcmd VM.metaspace basic" misreports free chunk space
stuefe
parents:
53547
diff
changeset
|
656 |
print_human_readable_size(out, Metaspace::chunk_manager_class()->free_chunks_total_bytes(), scale); |
49980 | 657 |
out->cr(); |
658 |
out->print(" Both: "); |
|
53598
69ccc5584e12
8218156: "jcmd VM.metaspace basic" misreports free chunk space
stuefe
parents:
53547
diff
changeset
|
659 |
print_human_readable_size(out, Metaspace::chunk_manager_class()->free_chunks_total_bytes() + |
69ccc5584e12
8218156: "jcmd VM.metaspace basic" misreports free chunk space
stuefe
parents:
53547
diff
changeset
|
660 |
Metaspace::chunk_manager_metadata()->free_chunks_total_bytes(), scale); |
49980 | 661 |
out->cr(); |
662 |
} |
|
54341
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
663 |
|
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
664 |
out->cr(); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
665 |
|
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
666 |
// Print basic settings |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
667 |
print_basic_switches(out, scale); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
668 |
|
49980 | 669 |
out->cr(); |
670 |
||
47802
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
671 |
} |
18dccdc438d7
8189688: NMT: Report per-class load metadata information
zgu
parents:
47654
diff
changeset
|
672 |
|
49980 | 673 |
void MetaspaceUtils::print_report(outputStream* out, size_t scale, int flags) { |
674 |
||
675 |
const bool print_loaders = (flags & rf_show_loaders) > 0; |
|
50309
37ebfe8bac7f
8203219: VM.metaspace jcmd should optionally show loaded classes for loaders
stuefe
parents:
50283
diff
changeset
|
676 |
const bool print_classes = (flags & rf_show_classes) > 0; |
49980 | 677 |
const bool print_by_chunktype = (flags & rf_break_down_by_chunktype) > 0; |
678 |
const bool print_by_spacetype = (flags & rf_break_down_by_spacetype) > 0; |
|
679 |
||
680 |
// Some report options require walking the class loader data graph. |
|
50309
37ebfe8bac7f
8203219: VM.metaspace jcmd should optionally show loaded classes for loaders
stuefe
parents:
50283
diff
changeset
|
681 |
PrintCLDMetaspaceInfoClosure cl(out, scale, print_loaders, print_classes, print_by_chunktype); |
49980 | 682 |
if (print_loaders) { |
683 |
out->cr(); |
|
684 |
out->print_cr("Usage per loader:"); |
|
685 |
out->cr(); |
|
686 |
} |
|
687 |
||
52586
74109912c738
8213751: ClassLoaderDataGraph::cld_do() should sometimes require CLDG_lock
coleenp
parents:
52468
diff
changeset
|
688 |
ClassLoaderDataGraph::loaded_cld_do(&cl); // collect data and optionally print |
49980 | 689 |
|
690 |
// Print totals, broken up by space type. |
|
691 |
if (print_by_spacetype) { |
|
692 |
out->cr(); |
|
693 |
out->print_cr("Usage per space type:"); |
|
694 |
out->cr(); |
|
695 |
for (int space_type = (int)Metaspace::ZeroMetaspaceType; |
|
696 |
space_type < (int)Metaspace::MetaspaceTypeCount; space_type ++) |
|
697 |
{ |
|
54820 | 698 |
uintx num_loaders = cl._num_loaders_by_spacetype[space_type]; |
699 |
uintx num_classes = cl._num_classes_by_spacetype[space_type]; |
|
700 |
out->print("%s - " UINTX_FORMAT " %s", |
|
49980 | 701 |
space_type_name((Metaspace::MetaspaceType)space_type), |
54820 | 702 |
num_loaders, loaders_plural(num_loaders)); |
703 |
if (num_classes > 0) { |
|
704 |
out->print(", "); |
|
705 |
print_number_of_classes(out, num_classes, cl._num_classes_shared_by_spacetype[space_type]); |
|
706 |
out->print(":"); |
|
49980 | 707 |
cl._stats_by_spacetype[space_type].print_on(out, scale, print_by_chunktype); |
54820 | 708 |
} else { |
709 |
out->print("."); |
|
710 |
out->cr(); |
|
49980 | 711 |
} |
712 |
out->cr(); |
|
713 |
} |
|
714 |
} |
|
715 |
||
716 |
// Print totals for in-use data: |
|
717 |
out->cr(); |
|
54820 | 718 |
{ |
719 |
uintx num_loaders = cl._num_loaders; |
|
720 |
out->print("Total Usage - " UINTX_FORMAT " %s, ", |
|
721 |
num_loaders, loaders_plural(num_loaders)); |
|
722 |
print_number_of_classes(out, cl._num_classes, cl._num_classes_shared); |
|
723 |
out->print(":"); |
|
724 |
cl._stats_total.print_on(out, scale, print_by_chunktype); |
|
725 |
out->cr(); |
|
726 |
} |
|
49980 | 727 |
|
728 |
// -- Print Virtual space. |
|
729 |
out->cr(); |
|
730 |
out->print_cr("Virtual space:"); |
|
731 |
||
732 |
print_vs(out, scale); |
|
733 |
||
734 |
// -- Print VirtualSpaceList details. |
|
735 |
if ((flags & rf_show_vslist) > 0) { |
|
736 |
out->cr(); |
|
737 |
out->print_cr("Virtual space list%s:", Metaspace::using_class_space() ? "s" : ""); |
|
738 |
||
739 |
if (Metaspace::using_class_space()) { |
|
740 |
out->print_cr(" Non-Class:"); |
|
741 |
} |
|
742 |
Metaspace::space_list()->print_on(out, scale); |
|
743 |
if (Metaspace::using_class_space()) { |
|
744 |
out->print_cr(" Class:"); |
|
745 |
Metaspace::class_space_list()->print_on(out, scale); |
|
746 |
} |
|
747 |
} |
|
748 |
out->cr(); |
|
749 |
||
750 |
// -- Print VirtualSpaceList map. |
|
751 |
if ((flags & rf_show_vsmap) > 0) { |
|
752 |
out->cr(); |
|
753 |
out->print_cr("Virtual space map:"); |
|
754 |
||
755 |
if (Metaspace::using_class_space()) { |
|
756 |
out->print_cr(" Non-Class:"); |
|
757 |
} |
|
758 |
Metaspace::space_list()->print_map(out); |
|
759 |
if (Metaspace::using_class_space()) { |
|
760 |
out->print_cr(" Class:"); |
|
761 |
Metaspace::class_space_list()->print_map(out); |
|
762 |
} |
|
763 |
} |
|
764 |
out->cr(); |
|
765 |
||
766 |
// -- Print Freelists (ChunkManager) details |
|
767 |
out->cr(); |
|
768 |
out->print_cr("Chunk freelist%s:", Metaspace::using_class_space() ? "s" : ""); |
|
769 |
||
770 |
ChunkManagerStatistics non_class_cm_stat; |
|
771 |
Metaspace::chunk_manager_metadata()->collect_statistics(&non_class_cm_stat); |
|
772 |
||
773 |
if (Metaspace::using_class_space()) { |
|
774 |
out->print_cr(" Non-Class:"); |
|
775 |
} |
|
776 |
non_class_cm_stat.print_on(out, scale); |
|
777 |
||
778 |
if (Metaspace::using_class_space()) { |
|
779 |
ChunkManagerStatistics class_cm_stat; |
|
780 |
Metaspace::chunk_manager_class()->collect_statistics(&class_cm_stat); |
|
781 |
out->print_cr(" Class:"); |
|
782 |
class_cm_stat.print_on(out, scale); |
|
783 |
} |
|
784 |
||
785 |
// As a convenience, print a summary of common waste. |
|
786 |
out->cr(); |
|
787 |
out->print("Waste "); |
|
788 |
// For all wastages, print percentages from total. As total use the total size of memory committed for metaspace. |
|
789 |
const size_t committed_words = committed_bytes() / BytesPerWord; |
|
790 |
||
791 |
out->print("(percentages refer to total committed size "); |
|
792 |
print_scaled_words(out, committed_words, scale); |
|
793 |
out->print_cr("):"); |
|
794 |
||
795 |
// Print space committed but not yet used by any class loader |
|
796 |
const size_t unused_words_in_vs = MetaspaceUtils::free_in_vs_bytes() / BytesPerWord; |
|
797 |
out->print(" Committed unused: "); |
|
798 |
print_scaled_words_and_percentage(out, unused_words_in_vs, committed_words, scale, 6); |
|
799 |
out->cr(); |
|
800 |
||
801 |
// Print waste for in-use chunks. |
|
802 |
UsedChunksStatistics ucs_nonclass = cl._stats_total.nonclass_sm_stats().totals(); |
|
803 |
UsedChunksStatistics ucs_class = cl._stats_total.class_sm_stats().totals(); |
|
804 |
UsedChunksStatistics ucs_all; |
|
805 |
ucs_all.add(ucs_nonclass); |
|
806 |
ucs_all.add(ucs_class); |
|
807 |
||
808 |
out->print(" Waste in chunks in use: "); |
|
809 |
print_scaled_words_and_percentage(out, ucs_all.waste(), committed_words, scale, 6); |
|
810 |
out->cr(); |
|
811 |
out->print(" Free in chunks in use: "); |
|
812 |
print_scaled_words_and_percentage(out, ucs_all.free(), committed_words, scale, 6); |
|
813 |
out->cr(); |
|
814 |
out->print(" Overhead in chunks in use: "); |
|
815 |
print_scaled_words_and_percentage(out, ucs_all.overhead(), committed_words, scale, 6); |
|
816 |
out->cr(); |
|
817 |
||
818 |
// Print waste in free chunks. |
|
819 |
const size_t total_capacity_in_free_chunks = |
|
820 |
Metaspace::chunk_manager_metadata()->free_chunks_total_words() + |
|
821 |
(Metaspace::using_class_space() ? Metaspace::chunk_manager_class()->free_chunks_total_words() : 0); |
|
822 |
out->print(" In free chunks: "); |
|
823 |
print_scaled_words_and_percentage(out, total_capacity_in_free_chunks, committed_words, scale, 6); |
|
824 |
out->cr(); |
|
825 |
||
826 |
// Print waste in deallocated blocks. |
|
827 |
const uintx free_blocks_num = |
|
828 |
cl._stats_total.nonclass_sm_stats().free_blocks_num() + |
|
829 |
cl._stats_total.class_sm_stats().free_blocks_num(); |
|
830 |
const size_t free_blocks_cap_words = |
|
831 |
cl._stats_total.nonclass_sm_stats().free_blocks_cap_words() + |
|
832 |
cl._stats_total.class_sm_stats().free_blocks_cap_words(); |
|
833 |
out->print("Deallocated from chunks in use: "); |
|
834 |
print_scaled_words_and_percentage(out, free_blocks_cap_words, committed_words, scale, 6); |
|
50020
9e82ca74f086
8202672: Build failed in metaspace.cpp with VS2017
kbarrett
parents:
49980
diff
changeset
|
835 |
out->print(" (" UINTX_FORMAT " blocks)", free_blocks_num); |
49980 | 836 |
out->cr(); |
837 |
||
838 |
// Print total waste. |
|
839 |
const size_t total_waste = ucs_all.waste() + ucs_all.free() + ucs_all.overhead() + total_capacity_in_free_chunks |
|
840 |
+ free_blocks_cap_words + unused_words_in_vs; |
|
841 |
out->print(" -total-: "); |
|
842 |
print_scaled_words_and_percentage(out, total_waste, committed_words, scale, 6); |
|
843 |
out->cr(); |
|
844 |
||
845 |
// Print internal statistics |
|
846 |
#ifdef ASSERT |
|
847 |
out->cr(); |
|
848 |
out->cr(); |
|
849 |
out->print_cr("Internal statistics:"); |
|
850 |
out->cr(); |
|
851 |
out->print_cr("Number of allocations: " UINTX_FORMAT ".", g_internal_statistics.num_allocs); |
|
852 |
out->print_cr("Number of space births: " UINTX_FORMAT ".", g_internal_statistics.num_metaspace_births); |
|
853 |
out->print_cr("Number of space deaths: " UINTX_FORMAT ".", g_internal_statistics.num_metaspace_deaths); |
|
854 |
out->print_cr("Number of virtual space node births: " UINTX_FORMAT ".", g_internal_statistics.num_vsnodes_created); |
|
855 |
out->print_cr("Number of virtual space node deaths: " UINTX_FORMAT ".", g_internal_statistics.num_vsnodes_purged); |
|
856 |
out->print_cr("Number of times virtual space nodes were expanded: " UINTX_FORMAT ".", g_internal_statistics.num_committed_space_expanded); |
|
857 |
out->print_cr("Number of deallocations: " UINTX_FORMAT " (" UINTX_FORMAT " external).", g_internal_statistics.num_deallocs, g_internal_statistics.num_external_deallocs); |
|
858 |
out->print_cr("Allocations from deallocated blocks: " UINTX_FORMAT ".", g_internal_statistics.num_allocs_from_deallocated_blocks); |
|
53970 | 859 |
out->print_cr("Number of chunks added to freelist: " UINTX_FORMAT ".", |
860 |
g_internal_statistics.num_chunks_added_to_freelist); |
|
861 |
out->print_cr("Number of chunks removed from freelist: " UINTX_FORMAT ".", |
|
862 |
g_internal_statistics.num_chunks_removed_from_freelist); |
|
863 |
out->print_cr("Number of chunk merges: " UINTX_FORMAT ", split-ups: " UINTX_FORMAT ".", |
|
864 |
g_internal_statistics.num_chunk_merges, g_internal_statistics.num_chunk_splits); |
|
865 |
||
49980 | 866 |
out->cr(); |
867 |
#endif |
|
868 |
||
869 |
// Print some interesting settings |
|
870 |
out->cr(); |
|
871 |
out->cr(); |
|
54341
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
872 |
print_basic_switches(out, scale); |
0b47455de59b
8221480: jcmd VM.metaspace shall print limits in basic mode
stuefe
parents:
53970
diff
changeset
|
873 |
|
49980 | 874 |
out->cr(); |
875 |
out->print("InitialBootClassLoaderMetaspaceSize: "); |
|
876 |
print_human_readable_size(out, InitialBootClassLoaderMetaspaceSize, scale); |
|
877 |
||
878 |
out->cr(); |
|
879 |
out->cr(); |
|
880 |
||
881 |
} // MetaspaceUtils::print_report() |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
882 |
|
47808
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
883 |
// Prints an ASCII representation of the given space. |
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
884 |
void MetaspaceUtils::print_metaspace_map(outputStream* out, Metaspace::MetadataType mdtype) { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54341
diff
changeset
|
885 |
MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); |
47808
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
886 |
const bool for_class = mdtype == Metaspace::ClassType ? true : false; |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
887 |
VirtualSpaceList* const vsl = for_class ? Metaspace::class_space_list() : Metaspace::space_list(); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
888 |
if (vsl != NULL) { |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
889 |
if (for_class) { |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
890 |
if (!Metaspace::using_class_space()) { |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
891 |
out->print_cr("No Class Space."); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
892 |
return; |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
893 |
} |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
894 |
out->print_raw("---- Metaspace Map (Class Space) ----"); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
895 |
} else { |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
896 |
out->print_raw("---- Metaspace Map (Non-Class Space) ----"); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
897 |
} |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
898 |
// Print legend: |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
899 |
out->cr(); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
900 |
out->print_cr("Chunk Types (uppercase chunks are in use): x-specialized, s-small, m-medium, h-humongous."); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
901 |
out->cr(); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
902 |
VirtualSpaceList* const vsl = for_class ? Metaspace::class_space_list() : Metaspace::space_list(); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
903 |
vsl->print_map(out); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
904 |
out->cr(); |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
905 |
} |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
906 |
} |
57752bd5d1b4
8189864: Provide an ascii map to visualize metaspace fragmentation
stuefe
parents:
47802
diff
changeset
|
907 |
|
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
908 |
void MetaspaceUtils::verify_free_chunks() { |
53970 | 909 |
#ifdef ASSERT |
910 |
Metaspace::chunk_manager_metadata()->verify(false); |
|
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
911 |
if (Metaspace::using_class_space()) { |
53970 | 912 |
Metaspace::chunk_manager_class()->verify(false); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
913 |
} |
53970 | 914 |
#endif |
14474
4154f1817a75
7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java
mgerdin
parents:
14123
diff
changeset
|
915 |
} |
4154f1817a75
7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java
mgerdin
parents:
14123
diff
changeset
|
916 |
|
49980 | 917 |
void MetaspaceUtils::verify_metrics() { |
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
918 |
#ifdef ASSERT |
49980 | 919 |
// Please note: there are time windows where the internal counters are out of sync with |
920 |
// reality. For example, when a newly created ClassLoaderMetaspace creates its first chunk - |
|
921 |
// the ClassLoaderMetaspace is not yet attached to its ClassLoaderData object and hence will |
|
922 |
// not be counted when iterating the CLDG. So be careful when you call this method. |
|
923 |
ClassLoaderMetaspaceStatistics total_stat; |
|
924 |
collect_statistics(&total_stat); |
|
925 |
UsedChunksStatistics nonclass_chunk_stat = total_stat.nonclass_sm_stats().totals(); |
|
926 |
UsedChunksStatistics class_chunk_stat = total_stat.class_sm_stats().totals(); |
|
927 |
||
928 |
bool mismatch = false; |
|
929 |
for (int i = 0; i < Metaspace::MetadataTypeCount; i ++) { |
|
930 |
Metaspace::MetadataType mdtype = (Metaspace::MetadataType)i; |
|
931 |
UsedChunksStatistics chunk_stat = total_stat.sm_stats(mdtype).totals(); |
|
932 |
if (capacity_words(mdtype) != chunk_stat.cap() || |
|
933 |
used_words(mdtype) != chunk_stat.used() || |
|
934 |
overhead_words(mdtype) != chunk_stat.overhead()) { |
|
935 |
mismatch = true; |
|
936 |
tty->print_cr("MetaspaceUtils::verify_metrics: counter mismatch for mdtype=%u:", mdtype); |
|
937 |
tty->print_cr("Expected cap " SIZE_FORMAT ", used " SIZE_FORMAT ", overhead " SIZE_FORMAT ".", |
|
938 |
capacity_words(mdtype), used_words(mdtype), overhead_words(mdtype)); |
|
939 |
tty->print_cr("Got cap " SIZE_FORMAT ", used " SIZE_FORMAT ", overhead " SIZE_FORMAT ".", |
|
940 |
chunk_stat.cap(), chunk_stat.used(), chunk_stat.overhead()); |
|
941 |
tty->flush(); |
|
942 |
} |
|
943 |
} |
|
944 |
assert(mismatch == false, "MetaspaceUtils::verify_metrics: counter mismatch."); |
|
17109
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
945 |
#endif |
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
946 |
} |
90e6c31bbbe4
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
17101
diff
changeset
|
947 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
948 |
// Metaspace methods |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
949 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
950 |
size_t Metaspace::_first_chunk_word_size = 0; |
15086
2bfd799e9147
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
14842
diff
changeset
|
951 |
size_t Metaspace::_first_class_chunk_word_size = 0; |
2bfd799e9147
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
14842
diff
changeset
|
952 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
953 |
size_t Metaspace::_commit_alignment = 0; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
954 |
size_t Metaspace::_reserve_alignment = 0; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
955 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
956 |
VirtualSpaceList* Metaspace::_space_list = NULL; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
957 |
VirtualSpaceList* Metaspace::_class_space_list = NULL; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
958 |
|
20081
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
959 |
ChunkManager* Metaspace::_chunk_manager_metadata = NULL; |
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
960 |
ChunkManager* Metaspace::_chunk_manager_class = NULL; |
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
961 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
962 |
#define VIRTUALSPACEMULTIPLIER 2 |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
963 |
|
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
964 |
#ifdef _LP64 |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
965 |
static const uint64_t UnscaledClassSpaceMax = (uint64_t(max_juint) + 1); |
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
966 |
|
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
967 |
void Metaspace::set_narrow_klass_base_and_shift(address metaspace_base, address cds_base) { |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
968 |
assert(!DumpSharedSpaces, "narrow_klass is set by MetaspaceShared class."); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
969 |
// Figure out the narrow_klass_base and the narrow_klass_shift. The |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
970 |
// narrow_klass_base is the lower of the metaspace base and the cds base |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
971 |
// (if cds is enabled). The narrow_klass_shift depends on the distance |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
972 |
// between the lower base and higher address. |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
973 |
address lower_base; |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
974 |
address higher_address; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
975 |
#if INCLUDE_CDS |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
976 |
if (UseSharedSpaces) { |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
977 |
higher_address = MAX2((address)(cds_base + MetaspaceShared::core_spaces_size()), |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
978 |
(address)(metaspace_base + compressed_class_space_size())); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
979 |
lower_base = MIN2(metaspace_base, cds_base); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
980 |
} else |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
981 |
#endif |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
982 |
{ |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
983 |
higher_address = metaspace_base + compressed_class_space_size(); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
984 |
lower_base = metaspace_base; |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
985 |
|
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
986 |
uint64_t klass_encoding_max = UnscaledClassSpaceMax << LogKlassAlignmentInBytes; |
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
987 |
// If compressed class space fits in lower 32G, we don't need a base. |
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
988 |
if (higher_address <= (address)klass_encoding_max) { |
22551 | 989 |
lower_base = 0; // Effectively lower base is zero. |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
990 |
} |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
991 |
} |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
992 |
|
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
54623
diff
changeset
|
993 |
CompressedKlassPointers::set_base(lower_base); |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
994 |
|
47599
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
995 |
// CDS uses LogKlassAlignmentInBytes for narrow_klass_shift. See |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
996 |
// MetaspaceShared::initialize_dumptime_shared_and_meta_spaces() for |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
997 |
// how dump time narrow_klass_shift is set. Although, CDS can work |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
998 |
// with zero-shift mode also, to be consistent with AOT it uses |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
999 |
// LogKlassAlignmentInBytes for klass shift so archived java heap objects |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1000 |
// can be used at same time as AOT code. |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1001 |
if (!UseSharedSpaces |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1002 |
&& (uint64_t)(higher_address - lower_base) <= UnscaledClassSpaceMax) { |
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
54623
diff
changeset
|
1003 |
CompressedKlassPointers::set_shift(0); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1004 |
} else { |
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
54623
diff
changeset
|
1005 |
CompressedKlassPointers::set_shift(LogKlassAlignmentInBytes); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1006 |
} |
42650 | 1007 |
AOTLoader::set_narrow_klass_shift(); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1008 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1009 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
1010 |
#if INCLUDE_CDS |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1011 |
// Return TRUE if the specified metaspace_base and cds_base are close enough |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1012 |
// to work with compressed klass pointers. |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1013 |
bool Metaspace::can_use_cds_with_metaspace_addr(char* metaspace_base, address cds_base) { |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1014 |
assert(cds_base != 0 && UseSharedSpaces, "Only use with CDS"); |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19546
diff
changeset
|
1015 |
assert(UseCompressedClassPointers, "Only use with CompressedKlassPtrs"); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1016 |
address lower_base = MIN2((address)metaspace_base, cds_base); |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1017 |
address higher_address = MAX2((address)(cds_base + MetaspaceShared::core_spaces_size()), |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
1018 |
(address)(metaspace_base + compressed_class_space_size())); |
21518
067dd7967128
8027616: Off by one error in putback for compressed oops nashorn performance improvement
coleenp
parents:
21189
diff
changeset
|
1019 |
return ((uint64_t)(higher_address - lower_base) <= UnscaledClassSpaceMax); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1020 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
1021 |
#endif |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1022 |
|
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1023 |
// Try to allocate the metaspace at the requested addr. |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1024 |
void Metaspace::allocate_metaspace_compressed_klass_ptrs(char* requested_addr, address cds_base) { |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1025 |
assert(!DumpSharedSpaces, "compress klass space is allocated by MetaspaceShared class."); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1026 |
assert(using_class_space(), "called improperly"); |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19546
diff
changeset
|
1027 |
assert(UseCompressedClassPointers, "Only use with CompressedKlassPtrs"); |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
1028 |
assert(compressed_class_space_size() < KlassEncodingMetaspaceMax, |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1029 |
"Metaspace size is too big"); |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1030 |
assert_is_aligned(requested_addr, _reserve_alignment); |
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1031 |
assert_is_aligned(cds_base, _reserve_alignment); |
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1032 |
assert_is_aligned(compressed_class_space_size(), _reserve_alignment); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1033 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1034 |
// Don't use large pages for the class space. |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1035 |
bool large_pages = false; |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1036 |
|
39229
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1037 |
#if !(defined(AARCH64) || defined(AIX)) |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
1038 |
ReservedSpace metaspace_rs = ReservedSpace(compressed_class_space_size(), |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1039 |
_reserve_alignment, |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1040 |
large_pages, |
28372
ce0aad4b8c44
8064457: Introduce compressed oops mode disjoint base and improve compressed heap handling.
goetz
parents:
28163
diff
changeset
|
1041 |
requested_addr); |
29180 | 1042 |
#else // AARCH64 |
1043 |
ReservedSpace metaspace_rs; |
|
1044 |
||
1045 |
// Our compressed klass pointers may fit nicely into the lower 32 |
|
1046 |
// bits. |
|
1047 |
if ((uint64_t)requested_addr + compressed_class_space_size() < 4*G) { |
|
1048 |
metaspace_rs = ReservedSpace(compressed_class_space_size(), |
|
39229
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1049 |
_reserve_alignment, |
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1050 |
large_pages, |
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1051 |
requested_addr); |
29180 | 1052 |
} |
1053 |
||
1054 |
if (! metaspace_rs.is_reserved()) { |
|
39229
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1055 |
// Aarch64: Try to align metaspace so that we can decode a compressed |
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1056 |
// klass with a single MOVK instruction. We can do this iff the |
29180 | 1057 |
// compressed class base is a multiple of 4G. |
39229
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1058 |
// Aix: Search for a place where we can find memory. If we need to load |
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1059 |
// the base, 4G alignment is helpful, too. |
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1060 |
size_t increment = AARCH64_ONLY(4*)G; |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1061 |
for (char *a = align_up(requested_addr, increment); |
29180 | 1062 |
a < (char*)(1024*G); |
39229
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1063 |
a += increment) { |
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1064 |
if (a == (char *)(32*G)) { |
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1065 |
// Go faster from here on. Zero-based is no longer possible. |
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1066 |
increment = 4*G; |
8bfc00dd44b6
8159056: [aix] Compressed class space not allocated in lower regions
goetz
parents:
37267
diff
changeset
|
1067 |
} |
29180 | 1068 |
|
1069 |
#if INCLUDE_CDS |
|
1070 |
if (UseSharedSpaces |
|
1071 |
&& ! can_use_cds_with_metaspace_addr(a, cds_base)) { |
|
1072 |
// We failed to find an aligned base that will reach. Fall |
|
1073 |
// back to using our requested addr. |
|
1074 |
metaspace_rs = ReservedSpace(compressed_class_space_size(), |
|
1075 |
_reserve_alignment, |
|
1076 |
large_pages, |
|
29187 | 1077 |
requested_addr); |
29180 | 1078 |
break; |
1079 |
} |
|
1080 |
#endif |
|
1081 |
||
1082 |
metaspace_rs = ReservedSpace(compressed_class_space_size(), |
|
1083 |
_reserve_alignment, |
|
1084 |
large_pages, |
|
29187 | 1085 |
a); |
29180 | 1086 |
if (metaspace_rs.is_reserved()) |
1087 |
break; |
|
1088 |
} |
|
1089 |
} |
|
1090 |
||
1091 |
#endif // AARCH64 |
|
1092 |
||
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1093 |
if (!metaspace_rs.is_reserved()) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
1094 |
#if INCLUDE_CDS |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1095 |
if (UseSharedSpaces) { |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1096 |
size_t increment = align_up(1*G, _reserve_alignment); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1097 |
|
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1098 |
// Keep trying to allocate the metaspace, increasing the requested_addr |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1099 |
// by 1GB each time, until we reach an address that will no longer allow |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1100 |
// use of CDS with compressed klass pointers. |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1101 |
char *addr = requested_addr; |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1102 |
while (!metaspace_rs.is_reserved() && (addr + increment > addr) && |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1103 |
can_use_cds_with_metaspace_addr(addr + increment, cds_base)) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1104 |
addr = addr + increment; |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
1105 |
metaspace_rs = ReservedSpace(compressed_class_space_size(), |
28372
ce0aad4b8c44
8064457: Introduce compressed oops mode disjoint base and improve compressed heap handling.
goetz
parents:
28163
diff
changeset
|
1106 |
_reserve_alignment, large_pages, addr); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1107 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1108 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
1109 |
#endif |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1110 |
// If no successful allocation then try to allocate the space anywhere. If |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1111 |
// that fails then OOM doom. At this point we cannot try allocating the |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19546
diff
changeset
|
1112 |
// metaspace as if UseCompressedClassPointers is off because too much |
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19546
diff
changeset
|
1113 |
// initialization has happened that depends on UseCompressedClassPointers. |
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19546
diff
changeset
|
1114 |
// So, UseCompressedClassPointers cannot be turned off at this point. |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1115 |
if (!metaspace_rs.is_reserved()) { |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
1116 |
metaspace_rs = ReservedSpace(compressed_class_space_size(), |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1117 |
_reserve_alignment, large_pages); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1118 |
if (!metaspace_rs.is_reserved()) { |
29800
fa5f7a2bf717
8076073: shared: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
29697
diff
changeset
|
1119 |
vm_exit_during_initialization(err_msg("Could not allocate metaspace: " SIZE_FORMAT " bytes", |
21188
d053e4e8f901
8024927: Nashorn performance regression with CompressedOops
coleenp
parents:
21186
diff
changeset
|
1120 |
compressed_class_space_size())); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1121 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1122 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1123 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1124 |
|
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1125 |
// If we got here then the metaspace got allocated. |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1126 |
MemTracker::record_virtual_memory_type((address)metaspace_rs.base(), mtClass); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1127 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
1128 |
#if INCLUDE_CDS |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1129 |
// Verify that we can use shared spaces. Otherwise, turn off CDS. |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1130 |
if (UseSharedSpaces && !can_use_cds_with_metaspace_addr(metaspace_rs.base(), cds_base)) { |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1131 |
FileMapInfo::stop_sharing_and_unmap( |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1132 |
"Could not allocate metaspace at a compatible address"); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1133 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25055
diff
changeset
|
1134 |
#endif |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1135 |
set_narrow_klass_base_and_shift((address)metaspace_rs.base(), |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1136 |
UseSharedSpaces ? (address)cds_base : 0); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1137 |
|
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1138 |
initialize_class_space(metaspace_rs); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1139 |
|
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46674
diff
changeset
|
1140 |
LogTarget(Trace, gc, metaspace) lt; |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46674
diff
changeset
|
1141 |
if (lt.is_enabled()) { |
35061 | 1142 |
ResourceMark rm; |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46674
diff
changeset
|
1143 |
LogStream ls(lt); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46674
diff
changeset
|
1144 |
print_compressed_class_space(&ls, requested_addr); |
31335
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1145 |
} |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1146 |
} |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1147 |
|
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1148 |
void Metaspace::print_compressed_class_space(outputStream* st, const char* requested_addr) { |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1149 |
st->print_cr("Narrow klass base: " PTR_FORMAT ", Narrow klass shift: %d", |
54780
f8d182aedc92
8223136: Move compressed oops functions to CompressedOops class
stefank
parents:
54623
diff
changeset
|
1150 |
p2i(CompressedKlassPointers::base()), CompressedKlassPointers::shift()); |
31335
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1151 |
if (_class_space_list != NULL) { |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1152 |
address base = (address)_class_space_list->current_virtual_space()->bottom(); |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1153 |
st->print("Compressed class space size: " SIZE_FORMAT " Address: " PTR_FORMAT, |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1154 |
compressed_class_space_size(), p2i(base)); |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1155 |
if (requested_addr != 0) { |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1156 |
st->print(" Req Addr: " PTR_FORMAT, p2i(requested_addr)); |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1157 |
} |
60081f497e75
8035074: hs_err improvement: Add time zone information in the hs_err file
coleenp
parents:
31028
diff
changeset
|
1158 |
st->cr(); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1159 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1160 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1161 |
|
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19546
diff
changeset
|
1162 |
// For UseCompressedClassPointers the class space is reserved above the top of |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1163 |
// the Java heap. The argument passed in is at the base of the compressed space. |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1164 |
void Metaspace::initialize_class_space(ReservedSpace rs) { |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1165 |
// The reserved space size may be bigger because of alignment, esp with UseLargePages |
19979
ebe1dbb6e1aa
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
19546
diff
changeset
|
1166 |
assert(rs.size() >= CompressedClassSpaceSize, |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31374
diff
changeset
|
1167 |
SIZE_FORMAT " != " SIZE_FORMAT, rs.size(), CompressedClassSpaceSize); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1168 |
assert(using_class_space(), "Must be using class space"); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1169 |
_class_space_list = new VirtualSpaceList(rs); |
49365 | 1170 |
_chunk_manager_class = new ChunkManager(true/*is_class*/); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1171 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1172 |
if (!_class_space_list->initialization_succeeded()) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1173 |
vm_exit_during_initialization("Failed to setup compressed class space virtual space list."); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1174 |
} |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1175 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1176 |
|
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1177 |
#endif |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1178 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1179 |
void Metaspace::ergo_initialize() { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1180 |
if (DumpSharedSpaces) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1181 |
// Using large pages when dumping the shared archive is currently not implemented. |
54983
81becad91321
8224203: Remove need to specify type when using FLAG_SET macros
stefank
parents:
54927
diff
changeset
|
1182 |
FLAG_SET_ERGO(UseLargePagesInMetaspace, false); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1183 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1184 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1185 |
size_t page_size = os::vm_page_size(); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1186 |
if (UseLargePages && UseLargePagesInMetaspace) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1187 |
page_size = os::large_page_size(); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1188 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1189 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1190 |
_commit_alignment = page_size; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1191 |
_reserve_alignment = MAX2(page_size, (size_t)os::vm_allocation_granularity()); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1192 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1193 |
// Do not use FLAG_SET_ERGO to update MaxMetaspaceSize, since this will |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1194 |
// override if MaxMetaspaceSize was set on the command line or not. |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1195 |
// This information is needed later to conform to the specification of the |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1196 |
// java.lang.management.MemoryUsage API. |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1197 |
// |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1198 |
// Ideally, we would be able to set the default value of MaxMetaspaceSize in |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1199 |
// globals.hpp to the aligned value, but this is not possible, since the |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1200 |
// alignment depends on other flags being parsed. |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1201 |
MaxMetaspaceSize = align_down_bounded(MaxMetaspaceSize, _reserve_alignment); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1202 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1203 |
if (MetaspaceSize > MaxMetaspaceSize) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1204 |
MetaspaceSize = MaxMetaspaceSize; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1205 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1206 |
|
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1207 |
MetaspaceSize = align_down_bounded(MetaspaceSize, _commit_alignment); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1208 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1209 |
assert(MetaspaceSize <= MaxMetaspaceSize, "MetaspaceSize should be limited by MaxMetaspaceSize"); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1210 |
|
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1211 |
MinMetaspaceExpansion = align_down_bounded(MinMetaspaceExpansion, _commit_alignment); |
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1212 |
MaxMetaspaceExpansion = align_down_bounded(MaxMetaspaceExpansion, _commit_alignment); |
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1213 |
|
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1214 |
CompressedClassSpaceSize = align_down_bounded(CompressedClassSpaceSize, _reserve_alignment); |
47654
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1215 |
|
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1216 |
// Initial virtual space size will be calculated at global_initialize() |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1217 |
size_t min_metaspace_sz = |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1218 |
VIRTUALSPACEMULTIPLIER * InitialBootClassLoaderMetaspaceSize; |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1219 |
if (UseCompressedClassPointers) { |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1220 |
if ((min_metaspace_sz + CompressedClassSpaceSize) > MaxMetaspaceSize) { |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1221 |
if (min_metaspace_sz >= MaxMetaspaceSize) { |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1222 |
vm_exit_during_initialization("MaxMetaspaceSize is too small."); |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1223 |
} else { |
54983
81becad91321
8224203: Remove need to specify type when using FLAG_SET macros
stefank
parents:
54927
diff
changeset
|
1224 |
FLAG_SET_ERGO(CompressedClassSpaceSize, |
47654
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1225 |
MaxMetaspaceSize - min_metaspace_sz); |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1226 |
} |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1227 |
} |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1228 |
} else if (min_metaspace_sz >= MaxMetaspaceSize) { |
54983
81becad91321
8224203: Remove need to specify type when using FLAG_SET macros
stefank
parents:
54927
diff
changeset
|
1229 |
FLAG_SET_ERGO(InitialBootClassLoaderMetaspaceSize, |
47654
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1230 |
min_metaspace_sz); |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1231 |
} |
dbd1f4f276ba
8087291: InitialBootClassLoaderMetaspaceSize and CompressedClassSpaceSize should be checked consistent from MaxMetaspaceSize
ysuenaga
parents:
47634
diff
changeset
|
1232 |
|
48387
7daebcef2e0d
8193386: CompressedClassSize too large with MaxMetaspace
coleenp
parents:
48148
diff
changeset
|
1233 |
set_compressed_class_space_size(CompressedClassSpaceSize); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1234 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1235 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1236 |
void Metaspace::global_initialize() { |
24847
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
1237 |
MetaspaceGC::initialize(); |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
1238 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1239 |
#if INCLUDE_CDS |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1240 |
if (DumpSharedSpaces) { |
47599
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1241 |
MetaspaceShared::initialize_dumptime_shared_and_meta_spaces(); |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1242 |
} else if (UseSharedSpaces) { |
47599
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1243 |
// If any of the archived space fails to map, UseSharedSpaces |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1244 |
// is reset to false. Fall through to the |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1245 |
// (!DumpSharedSpaces && !UseSharedSpaces) case to set up class |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1246 |
// metaspace. |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1247 |
MetaspaceShared::initialize_runtime_shared_and_meta_spaces(); |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1248 |
} |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1249 |
|
54927 | 1250 |
if (DynamicDumpSharedSpaces && !UseSharedSpaces) { |
55348
d109188f6480
8224710: [TESTBUG] dynamicArchive/ExcludedClasses.java test failed in tier6 testing on Windows
ccheung
parents:
54983
diff
changeset
|
1251 |
vm_exit_during_initialization("DynamicDumpSharedSpaces is unsupported when base CDS archive is not loaded", NULL); |
54927 | 1252 |
} |
1253 |
||
47599
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1254 |
if (!DumpSharedSpaces && !UseSharedSpaces) |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1255 |
#endif // INCLUDE_CDS |
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1256 |
{ |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1257 |
#ifdef _LP64 |
47599
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1258 |
if (using_class_space()) { |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46618
diff
changeset
|
1259 |
char* base = (char*)align_up(Universe::heap()->reserved_region().end(), _reserve_alignment); |
31362
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
1260 |
allocate_metaspace_compressed_klass_ptrs(base, 0); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1261 |
} |
47599
0fb1d501c408
8174986: CDS archived java heap region may not compatible with AOT
jiangli
parents:
47553
diff
changeset
|
1262 |
#endif // _LP64 |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1263 |
} |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1264 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1265 |
// Initialize these before initializing the VirtualSpaceList |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1266 |
_first_chunk_word_size = InitialBootClassLoaderMetaspaceSize / BytesPerWord; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1267 |
_first_chunk_word_size = align_word_size_up(_first_chunk_word_size); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1268 |
// Make the first class chunk bigger than a medium chunk so it's not put |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1269 |
// on the medium chunk list. The next chunk will be small and progress |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1270 |
// from there. This size calculated by -version. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1271 |
_first_class_chunk_word_size = MIN2((size_t)MediumChunk*6, |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1272 |
(CompressedClassSpaceSize/BytesPerWord)*2); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1273 |
_first_class_chunk_word_size = align_word_size_up(_first_class_chunk_word_size); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1274 |
// Arbitrarily set the initial virtual space to a multiple |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1275 |
// of the boot class loader size. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1276 |
size_t word_size = VIRTUALSPACEMULTIPLIER * _first_chunk_word_size; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1277 |
word_size = align_up(word_size, Metaspace::reserve_alignment_words()); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1278 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1279 |
// Initialize the list of virtual spaces. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1280 |
_space_list = new VirtualSpaceList(word_size); |
49365 | 1281 |
_chunk_manager_metadata = new ChunkManager(false/*metaspace*/); |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1282 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1283 |
if (!_space_list->initialization_succeeded()) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1284 |
vm_exit_during_initialization("Unable to setup metadata virtual space list.", NULL); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1285 |
} |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1286 |
|
23465
14790e4d53ec
8036698: Add trace event for updates to metaspace gc threshold
ehelin
parents:
22884
diff
changeset
|
1287 |
_tracer = new MetaspaceTracer(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1288 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1289 |
|
24847
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
1290 |
void Metaspace::post_initialize() { |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
1291 |
MetaspaceGC::post_initialize(); |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
1292 |
} |
37c354b113fe
8042933: assert(capacity_until_gc >= committed_bytes) failed
ehelin
parents:
24665
diff
changeset
|
1293 |
|
42615
86c4562176fa
8170395: Metaspace initialization queries the wrong chunk freelist
stefank
parents:
42602
diff
changeset
|
1294 |
void Metaspace::verify_global_initialization() { |
86c4562176fa
8170395: Metaspace initialization queries the wrong chunk freelist
stefank
parents:
42602
diff
changeset
|
1295 |
assert(space_list() != NULL, "Metadata VirtualSpaceList has not been initialized"); |
86c4562176fa
8170395: Metaspace initialization queries the wrong chunk freelist
stefank
parents:
42602
diff
changeset
|
1296 |
assert(chunk_manager_metadata() != NULL, "Metadata ChunkManager has not been initialized"); |
86c4562176fa
8170395: Metaspace initialization queries the wrong chunk freelist
stefank
parents:
42602
diff
changeset
|
1297 |
|
86c4562176fa
8170395: Metaspace initialization queries the wrong chunk freelist
stefank
parents:
42602
diff
changeset
|
1298 |
if (using_class_space()) { |
86c4562176fa
8170395: Metaspace initialization queries the wrong chunk freelist
stefank
parents:
42602
diff
changeset
|
1299 |
assert(class_space_list() != NULL, "Class VirtualSpaceList has not been initialized"); |
86c4562176fa
8170395: Metaspace initialization queries the wrong chunk freelist
stefank
parents:
42602
diff
changeset
|
1300 |
assert(chunk_manager_class() != NULL, "Class ChunkManager has not been initialized"); |
86c4562176fa
8170395: Metaspace initialization queries the wrong chunk freelist
stefank
parents:
42602
diff
changeset
|
1301 |
} |
20081
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
1302 |
} |
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
1303 |
|
15086
2bfd799e9147
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
14842
diff
changeset
|
1304 |
size_t Metaspace::align_word_size_up(size_t word_size) { |
2bfd799e9147
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
14842
diff
changeset
|
1305 |
size_t byte_size = word_size * wordSize; |
2bfd799e9147
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
14842
diff
changeset
|
1306 |
return ReservedSpace::allocation_align_size_up(byte_size) / wordSize; |
2bfd799e9147
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
14842
diff
changeset
|
1307 |
} |
2bfd799e9147
8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders
jmasa
parents:
14842
diff
changeset
|
1308 |
|
20729 | 1309 |
MetaWord* Metaspace::allocate(ClassLoaderData* loader_data, size_t word_size, |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1310 |
MetaspaceObj::Type type, TRAPS) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46723
diff
changeset
|
1311 |
assert(!_frozen, "sanity"); |
52468
e0fd97beab7e
8213250: CDS archive creation aborts due to metaspace object allocation failure
iklam
parents:
52363
diff
changeset
|
1312 |
assert(!(DumpSharedSpaces && THREAD->is_VM_thread()), "sanity"); |
e0fd97beab7e
8213250: CDS archive creation aborts due to metaspace object allocation failure
iklam
parents:
52363
diff
changeset
|
1313 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1314 |
if (HAS_PENDING_EXCEPTION) { |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1315 |
assert(false, "Should not allocate with exception pending"); |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1316 |
return NULL; // caller does a CHECK_NULL too |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1317 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1318 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1319 |
assert(loader_data != NULL, "Should never pass around a NULL loader_data. " |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1320 |
"ClassLoaderData::the_null_class_loader_data() should have been used."); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1321 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1322 |
MetadataType mdtype = (type == MetaspaceObj::ClassType) ? ClassType : NonClassType; |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1323 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1324 |
// Try to allocate metadata. |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1325 |
MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1326 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1327 |
if (result == NULL) { |
23468
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1328 |
tracer()->report_metaspace_allocation_failure(loader_data, word_size, type, mdtype); |
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1329 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1330 |
// Allocation failed. |
52468
e0fd97beab7e
8213250: CDS archive creation aborts due to metaspace object allocation failure
iklam
parents:
52363
diff
changeset
|
1331 |
if (is_init_completed()) { |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1332 |
// Only start a GC if the bootstrapping has completed. |
52468
e0fd97beab7e
8213250: CDS archive creation aborts due to metaspace object allocation failure
iklam
parents:
52363
diff
changeset
|
1333 |
// Try to clean out some heap memory and retry. This can prevent premature |
e0fd97beab7e
8213250: CDS archive creation aborts due to metaspace object allocation failure
iklam
parents:
52363
diff
changeset
|
1334 |
// expansion of the metaspace. |
49045
9b556b613a07
8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents:
48971
diff
changeset
|
1335 |
result = Universe::heap()->satisfy_failed_metadata_allocation(loader_data, word_size, mdtype); |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1336 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1337 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1338 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1339 |
if (result == NULL) { |
49652
a74836b05c28
8200078: [Graal] runtime/appcds/GraalWithLimitedMetaspace.java crashes in visit_all_interfaces
ccheung
parents:
49601
diff
changeset
|
1340 |
if (DumpSharedSpaces) { |
a74836b05c28
8200078: [Graal] runtime/appcds/GraalWithLimitedMetaspace.java crashes in visit_all_interfaces
ccheung
parents:
49601
diff
changeset
|
1341 |
// CDS dumping keeps loading classes, so if we hit an OOM we probably will keep hitting OOM. |
a74836b05c28
8200078: [Graal] runtime/appcds/GraalWithLimitedMetaspace.java crashes in visit_all_interfaces
ccheung
parents:
49601
diff
changeset
|
1342 |
// We should abort to avoid generating a potentially bad archive. |
52300
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52014
diff
changeset
|
1343 |
vm_exit_during_cds_dumping(err_msg("Failed allocating metaspace object type %s of size " SIZE_FORMAT ". CDS dump aborted.", |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52014
diff
changeset
|
1344 |
MetaspaceObj::type_name(type), word_size * BytesPerWord), |
9e29d8388514
8209598: Clean up how messages are printed when CDS aborts start-up
ccheung
parents:
52014
diff
changeset
|
1345 |
err_msg("Please increase MaxMetaspaceSize (currently " SIZE_FORMAT " bytes).", MaxMetaspaceSize)); |
49652
a74836b05c28
8200078: [Graal] runtime/appcds/GraalWithLimitedMetaspace.java crashes in visit_all_interfaces
ccheung
parents:
49601
diff
changeset
|
1346 |
} |
51070 | 1347 |
report_metadata_oome(loader_data, word_size, type, mdtype, THREAD); |
1348 |
assert(HAS_PENDING_EXCEPTION, "sanity"); |
|
1349 |
return NULL; |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1350 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1351 |
|
20729 | 1352 |
// Zero initialize. |
35898
ddc274f0052f
8145628: hotspot metadata classes shouldn't use HeapWordSize or heap related macros like align_object_size
coleenp
parents:
35231
diff
changeset
|
1353 |
Copy::fill_to_words((HeapWord*)result, word_size, 0); |
20729 | 1354 |
|
1355 |
return result; |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1356 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1357 |
|
23469
0a4d02776968
8036701: Add trace event when a metaspace throws out of memory error
ehelin
parents:
23468
diff
changeset
|
1358 |
void Metaspace::report_metadata_oome(ClassLoaderData* loader_data, size_t word_size, MetaspaceObj::Type type, MetadataType mdtype, TRAPS) { |
0a4d02776968
8036701: Add trace event when a metaspace throws out of memory error
ehelin
parents:
23468
diff
changeset
|
1359 |
tracer()->report_metadata_oom(loader_data, word_size, type, mdtype); |
0a4d02776968
8036701: Add trace event when a metaspace throws out of memory error
ehelin
parents:
23468
diff
changeset
|
1360 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1361 |
// If result is still null, we are out of memory. |
50372 | 1362 |
Log(gc, metaspace, freelist, oom) log; |
41727
f1658e76a682
8164921: Memory leaked when instrumentation.retransformClasses() is called repeatedly
coleenp
parents:
41182
diff
changeset
|
1363 |
if (log.is_info()) { |
f1658e76a682
8164921: Memory leaked when instrumentation.retransformClasses() is called repeatedly
coleenp
parents:
41182
diff
changeset
|
1364 |
log.info("Metaspace (%s) allocation failed for size " SIZE_FORMAT, |
f1658e76a682
8164921: Memory leaked when instrumentation.retransformClasses() is called repeatedly
coleenp
parents:
41182
diff
changeset
|
1365 |
is_class_space_allocation(mdtype) ? "class" : "data", word_size); |
35061 | 1366 |
ResourceMark rm; |
46723
5c418c5fcade
8185262: Keep default logging for Metaspace OOM short and concise
stuefe
parents:
46709
diff
changeset
|
1367 |
if (log.is_debug()) { |
5c418c5fcade
8185262: Keep default logging for Metaspace OOM short and concise
stuefe
parents:
46709
diff
changeset
|
1368 |
if (loader_data->metaspace_or_null() != NULL) { |
5c418c5fcade
8185262: Keep default logging for Metaspace OOM short and concise
stuefe
parents:
46709
diff
changeset
|
1369 |
LogStream ls(log.debug()); |
49348
fde3feaaa4ed
8198926: Move ClassLoaderData::_dependencies to ClassLoaderData::_handles
coleenp
parents:
49045
diff
changeset
|
1370 |
loader_data->print_value_on(&ls); |
46723
5c418c5fcade
8185262: Keep default logging for Metaspace OOM short and concise
stuefe
parents:
46709
diff
changeset
|
1371 |
} |
5c418c5fcade
8185262: Keep default logging for Metaspace OOM short and concise
stuefe
parents:
46709
diff
changeset
|
1372 |
} |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46674
diff
changeset
|
1373 |
LogStream ls(log.info()); |
49980 | 1374 |
// In case of an OOM, log out a short but still useful report. |
1375 |
MetaspaceUtils::print_basic_report(&ls, 0); |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1376 |
} |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1377 |
|
21186
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1378 |
bool out_of_compressed_class_space = false; |
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1379 |
if (is_class_space_allocation(mdtype)) { |
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1380 |
ClassLoaderMetaspace* metaspace = loader_data->metaspace_non_null(); |
21186
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1381 |
out_of_compressed_class_space = |
49389
9ef2eee8ca7c
8199430: Rename MetaspaceAux to something more meaningful
stuefe
parents:
49386
diff
changeset
|
1382 |
MetaspaceUtils::committed_bytes(Metaspace::ClassType) + |
21186
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1383 |
(metaspace->class_chunk_size(word_size) * BytesPerWord) > |
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1384 |
CompressedClassSpaceSize; |
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1385 |
} |
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1386 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1387 |
// -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support |
21186
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1388 |
const char* space_string = out_of_compressed_class_space ? |
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1389 |
"Compressed class space" : "Metaspace"; |
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1390 |
|
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1391 |
report_java_out_of_memory(space_string); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1392 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1393 |
if (JvmtiExport::should_post_resource_exhausted()) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1394 |
JvmtiExport::post_resource_exhausted( |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1395 |
JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR, |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1396 |
space_string); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1397 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1398 |
|
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1399 |
if (!is_init_completed()) { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1400 |
vm_exit_during_initialization("OutOfMemoryError", space_string); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1401 |
} |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1402 |
|
21186
db851068711f
8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space
hseigel
parents:
20733
diff
changeset
|
1403 |
if (out_of_compressed_class_space) { |
20406
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1404 |
THROW_OOP(Universe::out_of_memory_error_class_metaspace()); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1405 |
} else { |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1406 |
THROW_OOP(Universe::out_of_memory_error_metaspace()); |
934f0b12daa9
8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces
stefank
parents:
20306
diff
changeset
|
1407 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1408 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1409 |
|
23468
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1410 |
const char* Metaspace::metadata_type_name(Metaspace::MetadataType mdtype) { |
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1411 |
switch (mdtype) { |
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1412 |
case Metaspace::ClassType: return "Class"; |
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1413 |
case Metaspace::NonClassType: return "Metadata"; |
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1414 |
default: |
33105
294e48b4f704
8080775: Better argument formatting for assert() and friends
david
parents:
31374
diff
changeset
|
1415 |
assert(false, "Got bad mdtype: %d", (int) mdtype); |
23468
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1416 |
return NULL; |
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1417 |
} |
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1418 |
} |
6bb416a59349
8036699: Add trace event when a metaspace allocation fails
ehelin
parents:
23465
diff
changeset
|
1419 |
|
20081
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
1420 |
void Metaspace::purge(MetadataType mdtype) { |
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
1421 |
get_space_list(mdtype)->purge(get_chunk_manager(mdtype)); |
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
1422 |
} |
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
1423 |
|
17101 | 1424 |
void Metaspace::purge() { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54341
diff
changeset
|
1425 |
MutexLocker cl(MetaspaceExpand_lock, |
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54341
diff
changeset
|
1426 |
Mutex::_no_safepoint_check_flag); |
20081
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
1427 |
purge(NonClassType); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1428 |
if (using_class_space()) { |
20081
e26536e86a5c
8025096: Move the ChunkManager instances out of the VirtualSpaceLists
stefank
parents:
20080
diff
changeset
|
1429 |
purge(ClassType); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1430 |
} |
17101 | 1431 |
} |
1432 |
||
22201
9c2ccfa3a5fe
8029178: Parallel class loading test anonymous-simple gets SIGSEGV in Metaspace::contains
coleenp
parents:
21569
diff
changeset
|
1433 |
bool Metaspace::contains(const void* ptr) { |
48794
ea0d0781c63c
8178351: Simplify MetaspaceShared::is_in_shared_space and MetaspaceObj::is_shared
iklam
parents:
48387
diff
changeset
|
1434 |
if (MetaspaceShared::is_in_shared_metaspace(ptr)) { |
24457
0e20b36df5c4
8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents:
24424
diff
changeset
|
1435 |
return true; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1436 |
} |
46324
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
42650
diff
changeset
|
1437 |
return contains_non_shared(ptr); |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
42650
diff
changeset
|
1438 |
} |
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
42650
diff
changeset
|
1439 |
|
8764956ec928
8005165: Remove CPU-dependent code in self-patching vtables
iklam
parents:
42650
diff
changeset
|
1440 |
bool Metaspace::contains_non_shared(const void* ptr) { |
24457
0e20b36df5c4
8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents:
24424
diff
changeset
|
1441 |
if (using_class_space() && get_space_list(ClassType)->contains(ptr)) { |
0e20b36df5c4
8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents:
24424
diff
changeset
|
1442 |
return true; |
0e20b36df5c4
8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents:
24424
diff
changeset
|
1443 |
} |
0e20b36df5c4
8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents:
24424
diff
changeset
|
1444 |
|
0e20b36df5c4
8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents:
24424
diff
changeset
|
1445 |
return get_space_list(NonClassType)->contains(ptr); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1446 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1447 |
|
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1448 |
// ClassLoaderMetaspace |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1449 |
|
49980 | 1450 |
ClassLoaderMetaspace::ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType type) |
51334
cc2c79d22508
8208671: Runtime, JFR, Serviceability changes to allow enabling -Wreorder
tschatzl
parents:
51070
diff
changeset
|
1451 |
: _space_type(type) |
cc2c79d22508
8208671: Runtime, JFR, Serviceability changes to allow enabling -Wreorder
tschatzl
parents:
51070
diff
changeset
|
1452 |
, _lock(lock) |
49980 | 1453 |
, _vsm(NULL) |
1454 |
, _class_vsm(NULL) |
|
1455 |
{ |
|
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1456 |
initialize(lock, type); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1457 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1458 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1459 |
ClassLoaderMetaspace::~ClassLoaderMetaspace() { |
52468
e0fd97beab7e
8213250: CDS archive creation aborts due to metaspace object allocation failure
iklam
parents:
52363
diff
changeset
|
1460 |
Metaspace::assert_not_frozen(); |
49980 | 1461 |
DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_metaspace_deaths)); |
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1462 |
delete _vsm; |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1463 |
if (Metaspace::using_class_space()) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1464 |
delete _class_vsm; |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1465 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1466 |
} |
49980 | 1467 |
|
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1468 |
void ClassLoaderMetaspace::initialize_first_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1469 |
Metachunk* chunk = get_initialization_chunk(type, mdtype); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1470 |
if (chunk != NULL) { |
49869
c71f40e37583
8202074: Metaspace: If humongous chunk is added to SpaceManager, previous current chunk may not get retired correctly.
stuefe
parents:
49852
diff
changeset
|
1471 |
// Add to this manager's list of chunks in use and make it the current_chunk(). |
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1472 |
get_space_manager(mdtype)->add_chunk(chunk, true); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1473 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1474 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1475 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1476 |
Metachunk* ClassLoaderMetaspace::get_initialization_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1477 |
size_t chunk_word_size = get_space_manager(mdtype)->get_initial_chunk_size(type); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1478 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1479 |
// Get a chunk from the chunk freelist |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1480 |
Metachunk* chunk = Metaspace::get_chunk_manager(mdtype)->chunk_freelist_allocate(chunk_word_size); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1481 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1482 |
if (chunk == NULL) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1483 |
chunk = Metaspace::get_space_list(mdtype)->get_new_chunk(chunk_word_size, |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1484 |
get_space_manager(mdtype)->medium_chunk_bunch()); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1485 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1486 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1487 |
return chunk; |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1488 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1489 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1490 |
void ClassLoaderMetaspace::initialize(Mutex* lock, Metaspace::MetaspaceType type) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1491 |
Metaspace::verify_global_initialization(); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1492 |
|
49980 | 1493 |
DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_metaspace_births)); |
1494 |
||
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1495 |
// Allocate SpaceManager for metadata objects. |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1496 |
_vsm = new SpaceManager(Metaspace::NonClassType, type, lock); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1497 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1498 |
if (Metaspace::using_class_space()) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1499 |
// Allocate SpaceManager for classes. |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1500 |
_class_vsm = new SpaceManager(Metaspace::ClassType, type, lock); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1501 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1502 |
|
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54341
diff
changeset
|
1503 |
MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag); |
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1504 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1505 |
// Allocate chunk for metadata objects |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1506 |
initialize_first_chunk(type, Metaspace::NonClassType); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1507 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1508 |
// Allocate chunk for class metadata objects |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1509 |
if (Metaspace::using_class_space()) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1510 |
initialize_first_chunk(type, Metaspace::ClassType); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1511 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1512 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1513 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1514 |
MetaWord* ClassLoaderMetaspace::allocate(size_t word_size, Metaspace::MetadataType mdtype) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1515 |
Metaspace::assert_not_frozen(); |
49980 | 1516 |
|
1517 |
DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_allocs)); |
|
1518 |
||
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1519 |
// Don't use class_vsm() unless UseCompressedClassPointers is true. |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1520 |
if (Metaspace::is_class_space_allocation(mdtype)) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1521 |
return class_vsm()->allocate(word_size); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1522 |
} else { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1523 |
return vsm()->allocate(word_size); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1524 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1525 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1526 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1527 |
MetaWord* ClassLoaderMetaspace::expand_and_allocate(size_t word_size, Metaspace::MetadataType mdtype) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1528 |
Metaspace::assert_not_frozen(); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1529 |
size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size * BytesPerWord); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1530 |
assert(delta_bytes > 0, "Must be"); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1531 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1532 |
size_t before = 0; |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1533 |
size_t after = 0; |
53602
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
1534 |
bool can_retry = true; |
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1535 |
MetaWord* res; |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1536 |
bool incremented; |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1537 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1538 |
// Each thread increments the HWM at most once. Even if the thread fails to increment |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1539 |
// the HWM, an allocation is still attempted. This is because another thread must then |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1540 |
// have incremented the HWM and therefore the allocation might still succeed. |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1541 |
do { |
53602
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
1542 |
incremented = MetaspaceGC::inc_capacity_until_GC(delta_bytes, &after, &before, &can_retry); |
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1543 |
res = allocate(word_size, mdtype); |
53602
d1282cd2c1fc
8217432: MetaspaceGC::_capacity_until_GC exceeds MaxMetaspaceSize
ysuenaga
parents:
53598
diff
changeset
|
1544 |
} while (!incremented && res == NULL && can_retry); |
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1545 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1546 |
if (incremented) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1547 |
Metaspace::tracer()->report_gc_threshold(before, after, |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1548 |
MetaspaceGCThresholdUpdater::ExpandAndAllocate); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1549 |
log_trace(gc, metaspace)("Increase capacity to GC from " SIZE_FORMAT " to " SIZE_FORMAT, before, after); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1550 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1551 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1552 |
return res; |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1553 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1554 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1555 |
size_t ClassLoaderMetaspace::allocated_blocks_bytes() const { |
49980 | 1556 |
return (vsm()->used_words() + |
1557 |
(Metaspace::using_class_space() ? class_vsm()->used_words() : 0)) * BytesPerWord; |
|
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1558 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1559 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1560 |
size_t ClassLoaderMetaspace::allocated_chunks_bytes() const { |
49980 | 1561 |
return (vsm()->capacity_words() + |
1562 |
(Metaspace::using_class_space() ? class_vsm()->capacity_words() : 0)) * BytesPerWord; |
|
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1563 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1564 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1565 |
void ClassLoaderMetaspace::deallocate(MetaWord* ptr, size_t word_size, bool is_class) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1566 |
Metaspace::assert_not_frozen(); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1567 |
assert(!SafepointSynchronize::is_at_safepoint() |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1568 |
|| Thread::current()->is_VM_thread(), "should be the VM thread"); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1569 |
|
49980 | 1570 |
DEBUG_ONLY(Atomic::inc(&g_internal_statistics.num_external_deallocs)); |
1571 |
||
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54341
diff
changeset
|
1572 |
MutexLocker ml(vsm()->lock(), Mutex::_no_safepoint_check_flag); |
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1573 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1574 |
if (is_class && Metaspace::using_class_space()) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1575 |
class_vsm()->deallocate(ptr, word_size); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1576 |
} else { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1577 |
vsm()->deallocate(ptr, word_size); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1578 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1579 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1580 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1581 |
size_t ClassLoaderMetaspace::class_chunk_size(size_t word_size) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1582 |
assert(Metaspace::using_class_space(), "Has to use class space"); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1583 |
return class_vsm()->calc_chunk_size(word_size); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1584 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1585 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1586 |
void ClassLoaderMetaspace::print_on(outputStream* out) const { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1587 |
// Print both class virtual space counts and metaspace. |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1588 |
if (Verbose) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1589 |
vsm()->print_on(out); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1590 |
if (Metaspace::using_class_space()) { |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1591 |
class_vsm()->print_on(out); |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1592 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1593 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1594 |
} |
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1595 |
|
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1596 |
void ClassLoaderMetaspace::verify() { |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1597 |
vsm()->verify(); |
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1598 |
if (Metaspace::using_class_space()) { |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1599 |
class_vsm()->verify(); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1600 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1601 |
} |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1602 |
|
49980 | 1603 |
void ClassLoaderMetaspace::add_to_statistics_locked(ClassLoaderMetaspaceStatistics* out) const { |
1604 |
assert_lock_strong(lock()); |
|
1605 |
vsm()->add_to_statistics_locked(&out->nonclass_sm_stats()); |
|
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1606 |
if (Metaspace::using_class_space()) { |
49980 | 1607 |
class_vsm()->add_to_statistics_locked(&out->class_sm_stats()); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18987
diff
changeset
|
1608 |
} |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
diff
changeset
|
1609 |
} |
19989
0fc247fb59bc
8024638: Count and expose the amount of committed memory in the metaspaces
stefank
parents:
19988
diff
changeset
|
1610 |
|
49980 | 1611 |
void ClassLoaderMetaspace::add_to_statistics(ClassLoaderMetaspaceStatistics* out) const { |
54623
1126f0607c70
8222811: Consolidate MutexLockerEx and MutexLocker
coleenp
parents:
54341
diff
changeset
|
1612 |
MutexLocker cl(lock(), Mutex::_no_safepoint_check_flag); |
49980 | 1613 |
add_to_statistics_locked(out); |
1614 |
} |
|
49401
0c71baee49a7
8199431: Split up class Metaspace into a static and a non-static part
stuefe
parents:
49395
diff
changeset
|
1615 |
|
19989
0fc247fb59bc
8024638: Count and expose the amount of committed memory in the metaspaces
stefank
parents:
19988
diff
changeset
|
1616 |
/////////////// Unit tests /////////////// |
0fc247fb59bc
8024638: Count and expose the amount of committed memory in the metaspaces
stefank
parents:
19988
diff
changeset
|
1617 |
|
49365 | 1618 |
struct chunkmanager_statistics_t { |
1619 |
int num_specialized_chunks; |
|
1620 |
int num_small_chunks; |
|
1621 |
int num_medium_chunks; |
|
1622 |
int num_humongous_chunks; |
|
1623 |
}; |
|
1624 |
||
1625 |
extern void test_metaspace_retrieve_chunkmanager_statistics(Metaspace::MetadataType mdType, chunkmanager_statistics_t* out) { |
|
1626 |
ChunkManager* const chunk_manager = Metaspace::get_chunk_manager(mdType); |
|
49980 | 1627 |
ChunkManagerStatistics stat; |
1628 |
chunk_manager->collect_statistics(&stat); |
|
1629 |
out->num_specialized_chunks = (int)stat.chunk_stats(SpecializedIndex).num(); |
|
1630 |
out->num_small_chunks = (int)stat.chunk_stats(SmallIndex).num(); |
|
1631 |
out->num_medium_chunks = (int)stat.chunk_stats(MediumIndex).num(); |
|
1632 |
out->num_humongous_chunks = (int)stat.chunk_stats(HumongousIndex).num(); |
|
49365 | 1633 |
} |
1634 |
||
1635 |
struct chunk_geometry_t { |
|
1636 |
size_t specialized_chunk_word_size; |
|
1637 |
size_t small_chunk_word_size; |
|
1638 |
size_t medium_chunk_word_size; |
|
1639 |
}; |
|
1640 |
||
1641 |
extern void test_metaspace_retrieve_chunk_geometry(Metaspace::MetadataType mdType, chunk_geometry_t* out) { |
|
1642 |
if (mdType == Metaspace::NonClassType) { |
|
1643 |
out->specialized_chunk_word_size = SpecializedChunk; |
|
1644 |
out->small_chunk_word_size = SmallChunk; |
|
1645 |
out->medium_chunk_word_size = MediumChunk; |
|
1646 |
} else { |
|
1647 |
out->specialized_chunk_word_size = ClassSpecializedChunk; |
|
1648 |
out->small_chunk_word_size = ClassSmallChunk; |
|
1649 |
out->medium_chunk_word_size = ClassMediumChunk; |
|
1650 |
} |
|
1651 |
} |