1 /*
2 * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "memory/allocation.hpp"
27 #include "memory/allocation.inline.hpp"
28 #include "memory/arena.hpp"
29 #include "memory/metaspaceShared.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "memory/universe.hpp"
32 #include "runtime/atomic.hpp"
33 #include "runtime/os.hpp"
34 #include "runtime/task.hpp"
35 #include "runtime/threadCritical.hpp"
36 #include "services/memTracker.hpp"
37 #include "utilities/ostream.hpp"
38
39 // allocate using malloc; will fail if no memory available
40 char* AllocateHeap(size_t size,
41 MEMFLAGS flags,
42 const NativeCallStack& stack,
43 AllocFailType alloc_failmode /* = AllocFailStrategy::EXIT_OOM*/) {
44 char* p = (char*) os::malloc(size, flags, stack);
45 if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
46 vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "AllocateHeap");
47 }
48 return p;
49 }
50
51 char* AllocateHeap(size_t size,
52 MEMFLAGS flags,
53 AllocFailType alloc_failmode /* = AllocFailStrategy::EXIT_OOM*/) {
54 return AllocateHeap(size, flags, CALLER_PC);
55 }
56
57 char* ReallocateHeap(char *old,
58 size_t size,
59 MEMFLAGS flag,
60 AllocFailType alloc_failmode) {
61 char* p = (char*) os::realloc(old, size, flag, CALLER_PC);
62 if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
63 vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "ReallocateHeap");
64 }
65 return p;
66 }
67
68 void FreeHeap(void* p) {
69 os::free(p);
70 }
71
72 void* MetaspaceObj::_shared_metaspace_base = NULL;
73 void* MetaspaceObj::_shared_metaspace_top = NULL;
74
75 void* StackObj::operator new(size_t size) throw() { ShouldNotCallThis(); return 0; }
76 void StackObj::operator delete(void* p) { ShouldNotCallThis(); }
77 void* StackObj::operator new [](size_t size) throw() { ShouldNotCallThis(); return 0; }
78 void StackObj::operator delete [](void* p) { ShouldNotCallThis(); }
79
80 void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data,
81 size_t word_size,
82 MetaspaceObj::Type type, TRAPS) throw() {
83 // Klass has it's own operator new
84 return Metaspace::allocate(loader_data, word_size, type, THREAD);
85 }
86
87 bool MetaspaceObj::is_metaspace_object() const {
88 return Metaspace::contains((void*)this);
89 }
90
91 void MetaspaceObj::print_address_on(outputStream* st) const {
92 st->print(" {" INTPTR_FORMAT "}", p2i(this));
93 }
94
95 void* ResourceObj::operator new(size_t size, Arena *arena) throw() {
96 address res = (address)arena->Amalloc(size);
97 DEBUG_ONLY(set_allocation_type(res, ARENA);)
98 return res;
99 }
100
101 void* ResourceObj::operator new [](size_t size, Arena *arena) throw() {
102 address res = (address)arena->Amalloc(size);
103 DEBUG_ONLY(set_allocation_type(res, ARENA);)
104 return res;
105 }
106
107 void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) throw() {
108 address res = NULL;
109 switch (type) {
110 case C_HEAP:
111 res = (address)AllocateHeap(size, flags, CALLER_PC);
112 DEBUG_ONLY(set_allocation_type(res, C_HEAP);)
113 break;
114 case RESOURCE_AREA:
115 // new(size) sets allocation type RESOURCE_AREA.
116 res = (address)operator new(size);
117 break;
118 default:
119 ShouldNotReachHere();
120 }
121 return res;
122 }
123
124 void* ResourceObj::operator new [](size_t size, allocation_type type, MEMFLAGS flags) throw() {
125 return (address) operator new(size, type, flags);
126 }
127
128 void* ResourceObj::operator new(size_t size, const std::nothrow_t& nothrow_constant,
129 allocation_type type, MEMFLAGS flags) throw() {
130 // should only call this with std::nothrow, use other operator new() otherwise
131 address res = NULL;
132 switch (type) {
133 case C_HEAP:
134 res = (address)AllocateHeap(size, flags, CALLER_PC, AllocFailStrategy::RETURN_NULL);
135 DEBUG_ONLY(if (res!= NULL) set_allocation_type(res, C_HEAP);)
136 break;
137 case RESOURCE_AREA:
138 // new(size) sets allocation type RESOURCE_AREA.
139 res = (address)operator new(size, std::nothrow);
140 break;
141 default:
142 ShouldNotReachHere();
143 }
144 return res;
145 }
146
147 void* ResourceObj::operator new [](size_t size, const std::nothrow_t& nothrow_constant,
148 allocation_type type, MEMFLAGS flags) throw() {
149 return (address)operator new(size, nothrow_constant, type, flags);
150 }
151
152 void ResourceObj::operator delete(void* p) {
153 assert(((ResourceObj *)p)->allocated_on_C_heap(),
154 "delete only allowed for C_HEAP objects");
155 DEBUG_ONLY(((ResourceObj *)p)->_allocation_t[0] = (uintptr_t)badHeapOopVal;)
156 FreeHeap(p);
157 }
158
159 void ResourceObj::operator delete [](void* p) {
160 operator delete(p);
161 }
162
163 #ifdef ASSERT
164 void ResourceObj::set_allocation_type(address res, allocation_type type) {
165 // Set allocation type in the resource object
166 uintptr_t allocation = (uintptr_t)res;
167 assert((allocation & allocation_mask) == 0, "address should be aligned to 4 bytes at least: " INTPTR_FORMAT, p2i(res));
168 assert(type <= allocation_mask, "incorrect allocation type");
169 ResourceObj* resobj = (ResourceObj *)res;
170 resobj->_allocation_t[0] = ~(allocation + type);
171 if (type != STACK_OR_EMBEDDED) {
172 // Called from operator new(), set verification value.
173 resobj->_allocation_t[1] = (uintptr_t)&(resobj->_allocation_t[1]) + type;
174 }
175 }
176
177 ResourceObj::allocation_type ResourceObj::get_allocation_type() const {
178 assert(~(_allocation_t[0] | allocation_mask) == (uintptr_t)this, "lost resource object");
179 return (allocation_type)((~_allocation_t[0]) & allocation_mask);
180 }
181
182 bool ResourceObj::is_type_set() const {
183 allocation_type type = (allocation_type)(_allocation_t[1] & allocation_mask);
184 return get_allocation_type() == type &&
185 (_allocation_t[1] - type) == (uintptr_t)(&_allocation_t[1]);
186 }
187
188 // This whole business of passing information from ResourceObj::operator new
189 // to the ResourceObj constructor via fields in the "object" is technically UB.
190 // But it seems to work within the limitations of HotSpot usage (such as no
191 // multiple inheritance) with the compilers and compiler options we're using.
192 // And it gives some possibly useful checking for misuse of ResourceObj.
193 void ResourceObj::initialize_allocation_info() {
194 if (~(_allocation_t[0] | allocation_mask) != (uintptr_t)this) {
195 // Operator new() is not called for allocations
196 // on stack and for embedded objects.
197 set_allocation_type((address)this, STACK_OR_EMBEDDED);
198 } else if (allocated_on_stack()) { // STACK_OR_EMBEDDED
199 // For some reason we got a value which resembles
200 // an embedded or stack object (operator new() does not
201 // set such type). Keep it since it is valid value
202 // (even if it was garbage).
203 // Ignore garbage in other fields.
204 } else if (is_type_set()) {
205 // Operator new() was called and type was set.
206 assert(!allocated_on_stack(),
207 "not embedded or stack, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")",
208 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]);
209 } else {
210 // Operator new() was not called.
211 // Assume that it is embedded or stack object.
212 set_allocation_type((address)this, STACK_OR_EMBEDDED);
213 }
214 _allocation_t[1] = 0; // Zap verification value
215 }
216
217 ResourceObj::ResourceObj() {
218 initialize_allocation_info();
219 }
220
221 ResourceObj::ResourceObj(const ResourceObj&) {
222 // Initialize _allocation_t as a new object, ignoring object being copied.
223 initialize_allocation_info();
224 }
225
226 ResourceObj& ResourceObj::operator=(const ResourceObj& r) {
227 assert(allocated_on_stack(),
228 "copy only into local, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")",
229 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]);
230 // Keep current _allocation_t value;
231 return *this;
232 }
233
234 ResourceObj::~ResourceObj() {
235 // allocated_on_C_heap() also checks that encoded (in _allocation) address == this.
236 if (!allocated_on_C_heap()) { // ResourceObj::delete() will zap _allocation for C_heap.
237 _allocation_t[0] = (uintptr_t)badHeapOopVal; // zap type
238 }
239 }
240 #endif // ASSERT
241
242 //--------------------------------------------------------------------------------------
243 // Non-product code
244
245 #ifndef PRODUCT
246 void AllocatedObj::print() const { print_on(tty); }
247 void AllocatedObj::print_value() const { print_value_on(tty); }
248
249 void AllocatedObj::print_on(outputStream* st) const {
250 st->print_cr("AllocatedObj(" INTPTR_FORMAT ")", p2i(this));
251 }
252
253 void AllocatedObj::print_value_on(outputStream* st) const {
254 st->print("AllocatedObj(" INTPTR_FORMAT ")", p2i(this));
255 }
256
257 AllocStats::AllocStats() {
258 start_mallocs = os::num_mallocs;
259 start_frees = os::num_frees;
260 start_malloc_bytes = os::alloc_bytes;
261 start_mfree_bytes = os::free_bytes;
262 start_res_bytes = Arena::_bytes_allocated;
263 }
264
265 julong AllocStats::num_mallocs() { return os::num_mallocs - start_mallocs; }
266 julong AllocStats::alloc_bytes() { return os::alloc_bytes - start_malloc_bytes; }
267 julong AllocStats::num_frees() { return os::num_frees - start_frees; }
268 julong AllocStats::free_bytes() { return os::free_bytes - start_mfree_bytes; }
269 julong AllocStats::resource_bytes() { return Arena::_bytes_allocated - start_res_bytes; }
270 void AllocStats::print() {
271 tty->print_cr(UINT64_FORMAT " mallocs (" UINT64_FORMAT "MB), "
272 UINT64_FORMAT " frees (" UINT64_FORMAT "MB), " UINT64_FORMAT "MB resrc",
273 num_mallocs(), alloc_bytes()/M, num_frees(), free_bytes()/M, resource_bytes()/M);
274 }
275
276 ReallocMark::ReallocMark() {
277 #ifdef ASSERT
278 Thread *thread = Thread::current();
279 _nesting = thread->resource_area()->nesting();
280 #endif
281 }
282
283 void ReallocMark::check() {
284 #ifdef ASSERT
285 if (_nesting != Thread::current()->resource_area()->nesting()) {
286 fatal("allocation bug: array could grow within nested ResourceMark");
287 }
288 #endif
289 }
290
291 #endif // Non-product