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 "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() and CollectionSetChooser(), 173 // set verification value. 174 resobj->_allocation_t[1] = (uintptr_t)&(resobj->_allocation_t[1]) + type; 175 } 176 } 177 178 ResourceObj::allocation_type ResourceObj::get_allocation_type() const { 179 assert(~(_allocation_t[0] | allocation_mask) == (uintptr_t)this, "lost resource object"); 180 return (allocation_type)((~_allocation_t[0]) & allocation_mask); 181 } 182 183 bool ResourceObj::is_type_set() const { 184 allocation_type type = (allocation_type)(_allocation_t[1] & allocation_mask); 185 return get_allocation_type() == type && 186 (_allocation_t[1] - type) == (uintptr_t)(&_allocation_t[1]); 187 } 188 189 // This whole business of passing information from ResourceObj::operator new 190 // to the ResourceObj constructor via fields in the "object" is technically UB. 191 // But it seems to work within the limitations of HotSpot usage (such as no 192 // multiple inheritance) with the compilers and compiler options we're using. 193 // And it gives some possibly useful checking for misuse of ResourceObj. 194 void ResourceObj::initialize_allocation_info() { 195 if (~(_allocation_t[0] | allocation_mask) != (uintptr_t)this) { 196 // Operator new() is not called for allocations 197 // on stack and for embedded objects. 198 set_allocation_type((address)this, STACK_OR_EMBEDDED); 199 } else if (allocated_on_stack()) { // STACK_OR_EMBEDDED 200 // For some reason we got a value which resembles 201 // an embedded or stack object (operator new() does not 202 // set such type). Keep it since it is valid value 203 // (even if it was garbage). 204 // Ignore garbage in other fields. 205 } else if (is_type_set()) { 206 // Operator new() was called and type was set. 207 assert(!allocated_on_stack(), 208 "not embedded or stack, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")", 209 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]); 210 } else { 211 // Operator new() was not called. 212 // Assume that it is embedded or stack object. 213 set_allocation_type((address)this, STACK_OR_EMBEDDED); 214 } 215 _allocation_t[1] = 0; // Zap verification value 216 } 217 218 ResourceObj::ResourceObj() { 219 initialize_allocation_info(); 220 } 221 222 ResourceObj::ResourceObj(const ResourceObj&) { 223 // Initialize _allocation_t as a new object, ignoring object being copied. 224 initialize_allocation_info(); 225 } 226 227 ResourceObj& ResourceObj::operator=(const ResourceObj& r) { 228 assert(allocated_on_stack(), 229 "copy only into local, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")", 230 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]); 231 // Keep current _allocation_t value; 232 return *this; 233 } 234 235 ResourceObj::~ResourceObj() { 236 // allocated_on_C_heap() also checks that encoded (in _allocation) address == this. 237 if (!allocated_on_C_heap()) { // ResourceObj::delete() will zap _allocation for C_heap. 238 _allocation_t[0] = (uintptr_t)badHeapOopVal; // zap type 239 } 240 } 241 #endif // ASSERT 242 243 //-------------------------------------------------------------------------------------- 244 // Non-product code 245 246 #ifndef PRODUCT 247 void AllocatedObj::print() const { print_on(tty); } 248 void AllocatedObj::print_value() const { print_value_on(tty); } 249 250 void AllocatedObj::print_on(outputStream* st) const { 251 st->print_cr("AllocatedObj(" INTPTR_FORMAT ")", p2i(this)); 252 } 253 254 void AllocatedObj::print_value_on(outputStream* st) const { 255 st->print("AllocatedObj(" INTPTR_FORMAT ")", p2i(this)); 256 } 257 258 AllocStats::AllocStats() { 259 start_mallocs = os::num_mallocs; 260 start_frees = os::num_frees; 261 start_malloc_bytes = os::alloc_bytes; 262 start_mfree_bytes = os::free_bytes; 263 start_res_bytes = Arena::_bytes_allocated; 264 } 265 266 julong AllocStats::num_mallocs() { return os::num_mallocs - start_mallocs; } 267 julong AllocStats::alloc_bytes() { return os::alloc_bytes - start_malloc_bytes; } 268 julong AllocStats::num_frees() { return os::num_frees - start_frees; } 269 julong AllocStats::free_bytes() { return os::free_bytes - start_mfree_bytes; } 270 julong AllocStats::resource_bytes() { return Arena::_bytes_allocated - start_res_bytes; } 271 void AllocStats::print() { 272 tty->print_cr(UINT64_FORMAT " mallocs (" UINT64_FORMAT "MB), " 273 UINT64_FORMAT " frees (" UINT64_FORMAT "MB), " UINT64_FORMAT "MB resrc", 274 num_mallocs(), alloc_bytes()/M, num_frees(), free_bytes()/M, resource_bytes()/M); 275 } 276 277 ReallocMark::ReallocMark() { 278 #ifdef ASSERT 279 Thread *thread = Thread::current(); 280 _nesting = thread->resource_area()->nesting(); 281 #endif 282 } 283 284 void ReallocMark::check() { 285 #ifdef ASSERT 286 if (_nesting != Thread::current()->resource_area()->nesting()) { 287 fatal("allocation bug: array could grow within nested ResourceMark"); 288 } 289 #endif 290 } 291 292 #endif // Non-product