1 | /* |
2 | * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved. |
3 | * Copyright (c) 2018, SAP. |
4 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
5 | * |
6 | * This code is free software; you can redistribute it and/or modify it |
7 | * under the terms of the GNU General Public License version 2 only, as |
8 | * published by the Free Software Foundation. |
9 | * |
10 | * This code is distributed in the hope that it will be useful, but WITHOUT |
11 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
12 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
13 | * version 2 for more details (a copy is included in the LICENSE file that |
14 | * accompanied this code). |
15 | * |
16 | * You should have received a copy of the GNU General Public License version |
17 | * 2 along with this work; if not, write to the Free Software Foundation, |
18 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
19 | * |
20 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
21 | * or visit www.oracle.com if you need additional information or have any |
22 | * questions. |
23 | */ |
24 | |
25 | #include "precompiled.hpp" |
26 | #include "memory/allocation.inline.hpp" |
27 | #include "memory/metaspace.hpp" |
28 | #include "runtime/mutex.hpp" |
29 | #include "runtime/mutexLocker.hpp" |
30 | #include "runtime/os.hpp" |
31 | #include "utilities/align.hpp" |
32 | #include "utilities/debug.hpp" |
33 | #include "utilities/globalDefinitions.hpp" |
34 | #include "utilities/ostream.hpp" |
35 | #include "unittest.hpp" |
36 | |
37 | #define NUM_PARALLEL_METASPACES 50 |
38 | #define MAX_PER_METASPACE_ALLOCATION_WORDSIZE (512 * K) |
39 | |
40 | //#define DEBUG_VERBOSE true |
41 | |
42 | #ifdef DEBUG_VERBOSE |
43 | |
44 | struct chunkmanager_statistics_t { |
45 | int num_specialized_chunks; |
46 | int num_small_chunks; |
47 | int num_medium_chunks; |
48 | int num_humongous_chunks; |
49 | }; |
50 | |
51 | extern void test_metaspace_retrieve_chunkmanager_statistics(Metaspace::MetadataType mdType, chunkmanager_statistics_t* out); |
52 | |
53 | static void print_chunkmanager_statistics(outputStream* st, Metaspace::MetadataType mdType) { |
54 | chunkmanager_statistics_t stat; |
55 | test_metaspace_retrieve_chunkmanager_statistics(mdType, &stat); |
56 | st->print_cr("free chunks: %d / %d / %d / %d" , stat.num_specialized_chunks, stat.num_small_chunks, |
57 | stat.num_medium_chunks, stat.num_humongous_chunks); |
58 | } |
59 | |
60 | #endif |
61 | |
62 | struct chunk_geometry_t { |
63 | size_t specialized_chunk_word_size; |
64 | size_t small_chunk_word_size; |
65 | size_t medium_chunk_word_size; |
66 | }; |
67 | |
68 | extern void test_metaspace_retrieve_chunk_geometry(Metaspace::MetadataType mdType, chunk_geometry_t* out); |
69 | |
70 | |
71 | class MetaspaceAllocationTest : public ::testing::Test { |
72 | protected: |
73 | |
74 | struct { |
75 | size_t allocated; |
76 | Mutex* lock; |
77 | ClassLoaderMetaspace* space; |
78 | bool is_empty() const { return allocated == 0; } |
79 | bool is_full() const { return allocated >= MAX_PER_METASPACE_ALLOCATION_WORDSIZE; } |
80 | } _spaces[NUM_PARALLEL_METASPACES]; |
81 | |
82 | chunk_geometry_t _chunk_geometry; |
83 | |
84 | virtual void SetUp() { |
85 | ::memset(_spaces, 0, sizeof(_spaces)); |
86 | test_metaspace_retrieve_chunk_geometry(Metaspace::NonClassType, &_chunk_geometry); |
87 | } |
88 | |
89 | virtual void TearDown() { |
90 | for (int i = 0; i < NUM_PARALLEL_METASPACES; i ++) { |
91 | if (_spaces[i].space != NULL) { |
92 | delete _spaces[i].space; |
93 | delete _spaces[i].lock; |
94 | } |
95 | } |
96 | } |
97 | |
98 | void create_space(int i) { |
99 | assert(i >= 0 && i < NUM_PARALLEL_METASPACES, "Sanity" ); |
100 | assert(_spaces[i].space == NULL && _spaces[i].allocated == 0, "Sanity" ); |
101 | if (_spaces[i].lock == NULL) { |
102 | _spaces[i].lock = new Mutex(Monitor::native, "gtest-MetaspaceAllocationTest-lock" , false, Monitor::_safepoint_check_never); |
103 | ASSERT_TRUE(_spaces[i].lock != NULL); |
104 | } |
105 | // Let every ~10th space be an unsafe anonymous one to test different allocation patterns. |
106 | const Metaspace::MetaspaceType msType = (os::random() % 100 < 10) ? |
107 | Metaspace::UnsafeAnonymousMetaspaceType : Metaspace::StandardMetaspaceType; |
108 | { |
109 | // Pull lock during space creation, since this is what happens in the VM too |
110 | // (see ClassLoaderData::metaspace_non_null(), which we mimick here). |
111 | MutexLocker ml(_spaces[i].lock, Mutex::_no_safepoint_check_flag); |
112 | _spaces[i].space = new ClassLoaderMetaspace(_spaces[i].lock, msType); |
113 | } |
114 | _spaces[i].allocated = 0; |
115 | ASSERT_TRUE(_spaces[i].space != NULL); |
116 | } |
117 | |
118 | // Returns the index of a random space where index is [0..metaspaces) and which is |
119 | // empty, non-empty or full. |
120 | // Returns -1 if no matching space exists. |
121 | enum fillgrade { fg_empty, fg_non_empty, fg_full }; |
122 | int get_random_matching_space(int metaspaces, fillgrade fg) { |
123 | const int start_index = os::random() % metaspaces; |
124 | int i = start_index; |
125 | do { |
126 | if (fg == fg_empty && _spaces[i].is_empty()) { |
127 | return i; |
128 | } else if ((fg == fg_full && _spaces[i].is_full()) || |
129 | (fg == fg_non_empty && !_spaces[i].is_full() && !_spaces[i].is_empty())) { |
130 | return i; |
131 | } |
132 | i ++; |
133 | if (i == metaspaces) { |
134 | i = 0; |
135 | } |
136 | } while (i != start_index); |
137 | return -1; |
138 | } |
139 | |
140 | int get_random_emtpy_space(int metaspaces) { return get_random_matching_space(metaspaces, fg_empty); } |
141 | int get_random_non_emtpy_space(int metaspaces) { return get_random_matching_space(metaspaces, fg_non_empty); } |
142 | int get_random_full_space(int metaspaces) { return get_random_matching_space(metaspaces, fg_full); } |
143 | |
144 | void do_test(Metaspace::MetadataType mdType, int metaspaces, int phases, int allocs_per_phase, |
145 | float probability_for_large_allocations // 0.0-1.0 |
146 | ) { |
147 | // Alternate between breathing in (allocating n blocks for a random Metaspace) and |
148 | // breathing out (deleting a random Metaspace). The intent is to stress the coalescation |
149 | // and splitting of free chunks. |
150 | int phases_done = 0; |
151 | bool allocating = true; |
152 | while (phases_done < phases) { |
153 | bool force_switch = false; |
154 | if (allocating) { |
155 | // Allocate space from metaspace, with a preference for completely empty spaces. This |
156 | // should provide a good mixture of metaspaces in the virtual space. |
157 | int index = get_random_emtpy_space(metaspaces); |
158 | if (index == -1) { |
159 | index = get_random_non_emtpy_space(metaspaces); |
160 | } |
161 | if (index == -1) { |
162 | // All spaces are full, switch to freeing. |
163 | force_switch = true; |
164 | } else { |
165 | // create space if it does not yet exist. |
166 | if (_spaces[index].space == NULL) { |
167 | create_space(index); |
168 | } |
169 | // Allocate a bunch of blocks from it. Mostly small stuff but mix in large allocations |
170 | // to force humongous chunk allocations. |
171 | int allocs_done = 0; |
172 | while (allocs_done < allocs_per_phase && !_spaces[index].is_full()) { |
173 | size_t size = 0; |
174 | int r = os::random() % 1000; |
175 | if ((float)r < probability_for_large_allocations * 1000.0) { |
176 | size = (os::random() % _chunk_geometry.medium_chunk_word_size) + _chunk_geometry.medium_chunk_word_size; |
177 | } else { |
178 | size = os::random() % 64; |
179 | } |
180 | // Note: In contrast to space creation, no need to lock here. ClassLoaderMetaspace::allocate() will lock itself. |
181 | MetaWord* const p = _spaces[index].space->allocate(size, mdType); |
182 | if (p == NULL) { |
183 | // We very probably did hit the metaspace "until-gc" limit. |
184 | #ifdef DEBUG_VERBOSE |
185 | tty->print_cr("OOM for " SIZE_FORMAT " words. " , size); |
186 | #endif |
187 | // Just switch to deallocation and resume tests. |
188 | force_switch = true; |
189 | break; |
190 | } else { |
191 | _spaces[index].allocated += size; |
192 | allocs_done ++; |
193 | } |
194 | } |
195 | } |
196 | } else { |
197 | // freeing: find a metaspace and delete it, with preference for completely filled spaces. |
198 | int index = get_random_full_space(metaspaces); |
199 | if (index == -1) { |
200 | index = get_random_non_emtpy_space(metaspaces); |
201 | } |
202 | if (index == -1) { |
203 | force_switch = true; |
204 | } else { |
205 | assert(_spaces[index].space != NULL && _spaces[index].allocated > 0, "Sanity" ); |
206 | // Note: do not lock here. In the "wild" (the VM), we do not so either (see ~ClassLoaderData()). |
207 | delete _spaces[index].space; |
208 | _spaces[index].space = NULL; |
209 | _spaces[index].allocated = 0; |
210 | } |
211 | } |
212 | |
213 | if (force_switch) { |
214 | allocating = !allocating; |
215 | } else { |
216 | // periodically switch between allocating and freeing, but prefer allocation because |
217 | // we want to intermingle allocations of multiple metaspaces. |
218 | allocating = os::random() % 5 < 4; |
219 | } |
220 | phases_done ++; |
221 | #ifdef DEBUG_VERBOSE |
222 | int metaspaces_in_use = 0; |
223 | size_t total_allocated = 0; |
224 | for (int i = 0; i < metaspaces; i ++) { |
225 | if (_spaces[i].allocated > 0) { |
226 | total_allocated += _spaces[i].allocated; |
227 | metaspaces_in_use ++; |
228 | } |
229 | } |
230 | tty->print("%u:\tspaces: %d total words: " SIZE_FORMAT "\t\t\t" , phases_done, metaspaces_in_use, total_allocated); |
231 | print_chunkmanager_statistics(tty, mdType); |
232 | #endif |
233 | } |
234 | #ifdef DEBUG_VERBOSE |
235 | tty->print_cr("Test finished. " ); |
236 | MetaspaceUtils::print_metaspace_map(tty, mdType); |
237 | print_chunkmanager_statistics(tty, mdType); |
238 | #endif |
239 | } |
240 | }; |
241 | |
242 | |
243 | |
244 | TEST_F(MetaspaceAllocationTest, chunk_geometry) { |
245 | ASSERT_GT(_chunk_geometry.specialized_chunk_word_size, (size_t) 0); |
246 | ASSERT_GT(_chunk_geometry.small_chunk_word_size, _chunk_geometry.specialized_chunk_word_size); |
247 | ASSERT_EQ(_chunk_geometry.small_chunk_word_size % _chunk_geometry.specialized_chunk_word_size, (size_t)0); |
248 | ASSERT_GT(_chunk_geometry.medium_chunk_word_size, _chunk_geometry.small_chunk_word_size); |
249 | ASSERT_EQ(_chunk_geometry.medium_chunk_word_size % _chunk_geometry.small_chunk_word_size, (size_t)0); |
250 | } |
251 | |
252 | |
253 | TEST_VM_F(MetaspaceAllocationTest, single_space_nonclass) { |
254 | do_test(Metaspace::NonClassType, 1, 1000, 100, 0); |
255 | } |
256 | |
257 | TEST_VM_F(MetaspaceAllocationTest, single_space_class) { |
258 | do_test(Metaspace::ClassType, 1, 1000, 100, 0); |
259 | } |
260 | |
261 | TEST_VM_F(MetaspaceAllocationTest, multi_space_nonclass) { |
262 | do_test(Metaspace::NonClassType, NUM_PARALLEL_METASPACES, 100, 1000, 0.0); |
263 | } |
264 | |
265 | TEST_VM_F(MetaspaceAllocationTest, multi_space_class) { |
266 | do_test(Metaspace::ClassType, NUM_PARALLEL_METASPACES, 100, 1000, 0.0); |
267 | } |
268 | |
269 | TEST_VM_F(MetaspaceAllocationTest, multi_space_nonclass_2) { |
270 | // many metaspaces, with humongous chunks mixed in. |
271 | do_test(Metaspace::NonClassType, NUM_PARALLEL_METASPACES, 100, 1000, .006f); |
272 | } |
273 | |
274 | |