1 /*
2 * Copyright (c) 1997, 2018, 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 "gc/shared/genCollectedHeap.hpp"
27 #include "memory/allocation.hpp"
28 #include "memory/allocation.inline.hpp"
29 #include "memory/arena.hpp"
30 #include "memory/metaspaceShared.hpp"
31 #include "memory/resourceArea.hpp"
32 #include "memory/universe.hpp"
33 #include "runtime/atomic.hpp"
34 #include "runtime/os.hpp"
35 #include "runtime/task.hpp"
36 #include "runtime/threadCritical.hpp"
37 #include "services/memTracker.hpp"
38 #include "utilities/ostream.hpp"
39
40 void* MetaspaceObj::_shared_metaspace_base = NULL;
41 void* MetaspaceObj::_shared_metaspace_top = NULL;
42
43 void* StackObj::operator new(size_t size) throw() { ShouldNotCallThis(); return 0; }
44 void StackObj::operator delete(void* p) { ShouldNotCallThis(); }
45 void* StackObj::operator new [](size_t size) throw() { ShouldNotCallThis(); return 0; }
46 void StackObj::operator delete [](void* p) { ShouldNotCallThis(); }
47
48 void* _ValueObj::operator new(size_t size) throw() { ShouldNotCallThis(); return 0; }
49 void _ValueObj::operator delete(void* p) { ShouldNotCallThis(); }
50 void* _ValueObj::operator new [](size_t size) throw() { ShouldNotCallThis(); return 0; }
51 void _ValueObj::operator delete [](void* p) { ShouldNotCallThis(); }
52
53 void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data,
54 size_t word_size,
55 MetaspaceObj::Type type, TRAPS) throw() {
56 // Klass has it's own operator new
57 return Metaspace::allocate(loader_data, word_size, type, THREAD);
58 }
59
60 bool MetaspaceObj::is_metaspace_object() const {
61 return Metaspace::contains((void*)this);
62 }
63
64 void MetaspaceObj::print_address_on(outputStream* st) const {
65 st->print(" {" INTPTR_FORMAT "}", p2i(this));
66 }
67
68 void* ResourceObj::operator new(size_t size, Arena *arena) throw() {
69 address res = (address)arena->Amalloc(size);
70 DEBUG_ONLY(set_allocation_type(res, ARENA);)
71 return res;
72 }
73
74 void* ResourceObj::operator new [](size_t size, Arena *arena) throw() {
75 address res = (address)arena->Amalloc(size);
76 DEBUG_ONLY(set_allocation_type(res, ARENA);)
77 return res;
78 }
79
80 void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) throw() {
81 address res = NULL;
82 switch (type) {
83 case C_HEAP:
84 res = (address)AllocateHeap(size, flags, CALLER_PC);
85 DEBUG_ONLY(set_allocation_type(res, C_HEAP);)
86 break;
87 case RESOURCE_AREA:
88 // new(size) sets allocation type RESOURCE_AREA.
89 res = (address)operator new(size);
90 break;
91 default:
92 ShouldNotReachHere();
93 }
94 return res;
95 }
96
97 void* ResourceObj::operator new [](size_t size, allocation_type type, MEMFLAGS flags) throw() {
98 return (address) operator new(size, type, flags);
99 }
100
101 void* ResourceObj::operator new(size_t size, const std::nothrow_t& nothrow_constant,
102 allocation_type type, MEMFLAGS flags) throw() {
103 // should only call this with std::nothrow, use other operator new() otherwise
104 address res = NULL;
105 switch (type) {
106 case C_HEAP:
107 res = (address)AllocateHeap(size, flags, CALLER_PC, AllocFailStrategy::RETURN_NULL);
108 DEBUG_ONLY(if (res!= NULL) set_allocation_type(res, C_HEAP);)
109 break;
110 case RESOURCE_AREA:
111 // new(size) sets allocation type RESOURCE_AREA.
112 res = (address)operator new(size, std::nothrow);
113 break;
114 default:
115 ShouldNotReachHere();
116 }
117 return res;
118 }
119
120 void* ResourceObj::operator new [](size_t size, const std::nothrow_t& nothrow_constant,
121 allocation_type type, MEMFLAGS flags) throw() {
122 return (address)operator new(size, nothrow_constant, type, flags);
123 }
124
125 void ResourceObj::operator delete(void* p) {
126 assert(((ResourceObj *)p)->allocated_on_C_heap(),
127 "delete only allowed for C_HEAP objects");
128 DEBUG_ONLY(((ResourceObj *)p)->_allocation_t[0] = (uintptr_t)badHeapOopVal;)
129 FreeHeap(p);
130 }
131
132 void ResourceObj::operator delete [](void* p) {
133 operator delete(p);
134 }
135
136 #ifdef ASSERT
137 void ResourceObj::set_allocation_type(address res, allocation_type type) {
138 // Set allocation type in the resource object
139 uintptr_t allocation = (uintptr_t)res;
140 assert((allocation & allocation_mask) == 0, "address should be aligned to 4 bytes at least: " INTPTR_FORMAT, p2i(res));
141 assert(type <= allocation_mask, "incorrect allocation type");
142 ResourceObj* resobj = (ResourceObj *)res;
143 resobj->_allocation_t[0] = ~(allocation + type);
144 if (type != STACK_OR_EMBEDDED) {
145 // Called from operator new() and CollectionSetChooser(),
146 // set verification value.
147 resobj->_allocation_t[1] = (uintptr_t)&(resobj->_allocation_t[1]) + type;
148 }
149 }
150
151 ResourceObj::allocation_type ResourceObj::get_allocation_type() const {
152 assert(~(_allocation_t[0] | allocation_mask) == (uintptr_t)this, "lost resource object");
153 return (allocation_type)((~_allocation_t[0]) & allocation_mask);
154 }
155
156 bool ResourceObj::is_type_set() const {
157 allocation_type type = (allocation_type)(_allocation_t[1] & allocation_mask);
158 return get_allocation_type() == type &&
159 (_allocation_t[1] - type) == (uintptr_t)(&_allocation_t[1]);
160 }
161
162 ResourceObj::ResourceObj() { // default constructor
163 if (~(_allocation_t[0] | allocation_mask) != (uintptr_t)this) {
164 // Operator new() is not called for allocations
165 // on stack and for embedded objects.
166 set_allocation_type((address)this, STACK_OR_EMBEDDED);
167 } else if (allocated_on_stack()) { // STACK_OR_EMBEDDED
168 // For some reason we got a value which resembles
169 // an embedded or stack object (operator new() does not
170 // set such type). Keep it since it is valid value
171 // (even if it was garbage).
172 // Ignore garbage in other fields.
173 } else if (is_type_set()) {
174 // Operator new() was called and type was set.
175 assert(!allocated_on_stack(),
176 "not embedded or stack, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")",
177 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]);
178 } else {
179 // Operator new() was not called.
180 // Assume that it is embedded or stack object.
181 set_allocation_type((address)this, STACK_OR_EMBEDDED);
182 }
183 _allocation_t[1] = 0; // Zap verification value
184 }
185
186 ResourceObj::ResourceObj(const ResourceObj& r) { // default copy constructor
187 // Used in ClassFileParser::parse_constant_pool_entries() for ClassFileStream.
188 // Note: garbage may resembles valid value.
189 assert(~(_allocation_t[0] | allocation_mask) != (uintptr_t)this || !is_type_set(),
190 "embedded or stack only, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")",
191 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]);
192 set_allocation_type((address)this, STACK_OR_EMBEDDED);
193 _allocation_t[1] = 0; // Zap verification value
194 }
195
196 ResourceObj& ResourceObj::operator=(const ResourceObj& r) { // default copy assignment
197 // Used in InlineTree::ok_to_inline() for WarmCallInfo.
198 assert(allocated_on_stack(),
199 "copy only into local, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")",
200 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]);
201 // Keep current _allocation_t value;
202 return *this;
203 }
204
205 ResourceObj::~ResourceObj() {
206 // allocated_on_C_heap() also checks that encoded (in _allocation) address == this.
207 if (!allocated_on_C_heap()) { // ResourceObj::delete() will zap _allocation for C_heap.
208 _allocation_t[0] = (uintptr_t)badHeapOopVal; // zap type
209 }
210 }
211 #endif // ASSERT
212
213
214 void trace_heap_malloc(size_t size, const char* name, void* p) {
215 // A lock is not needed here - tty uses a lock internally
216 tty->print_cr("Heap malloc " INTPTR_FORMAT " " SIZE_FORMAT " %s", p2i(p), size, name == NULL ? "" : name);
217 }
218
219
220 void trace_heap_free(void* p) {
221 // A lock is not needed here - tty uses a lock internally
222 tty->print_cr("Heap free " INTPTR_FORMAT, p2i(p));
223 }
224
225 //--------------------------------------------------------------------------------------
226 // Non-product code
227
228 #ifndef PRODUCT
229 void AllocatedObj::print() const { print_on(tty); }
230 void AllocatedObj::print_value() const { print_value_on(tty); }
231
232 void AllocatedObj::print_on(outputStream* st) const {
233 st->print_cr("AllocatedObj(" INTPTR_FORMAT ")", p2i(this));
234 }
235
236 void AllocatedObj::print_value_on(outputStream* st) const {
237 st->print("AllocatedObj(" INTPTR_FORMAT ")", p2i(this));
238 }
239
240 AllocStats::AllocStats() {
241 start_mallocs = os::num_mallocs;
242 start_frees = os::num_frees;
243 start_malloc_bytes = os::alloc_bytes;
244 start_mfree_bytes = os::free_bytes;
245 start_res_bytes = Arena::_bytes_allocated;
246 }
247
248 julong AllocStats::num_mallocs() { return os::num_mallocs - start_mallocs; }
249 julong AllocStats::alloc_bytes() { return os::alloc_bytes - start_malloc_bytes; }
250 julong AllocStats::num_frees() { return os::num_frees - start_frees; }
251 julong AllocStats::free_bytes() { return os::free_bytes - start_mfree_bytes; }
252 julong AllocStats::resource_bytes() { return Arena::_bytes_allocated - start_res_bytes; }
253 void AllocStats::print() {
254 tty->print_cr(UINT64_FORMAT " mallocs (" UINT64_FORMAT "MB), "
255 UINT64_FORMAT " frees (" UINT64_FORMAT "MB), " UINT64_FORMAT "MB resrc",
256 num_mallocs(), alloc_bytes()/M, num_frees(), free_bytes()/M, resource_bytes()/M);
257 }
258
259 ReallocMark::ReallocMark() {
260 #ifdef ASSERT
261 Thread *thread = Thread::current();
262 _nesting = thread->resource_area()->nesting();
263 #endif
264 }
265
266 void ReallocMark::check() {
267 #ifdef ASSERT
268 if (_nesting != Thread::current()->resource_area()->nesting()) {
269 fatal("allocation bug: array could grow within nested ResourceMark");
270 }
271 #endif
272 }
273
274 #endif // Non-product