1 /*
2 * Copyright (c) 1997, 2014, 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/genCollectedHeap.hpp"
29 #include "memory/metaspaceShared.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "memory/universe.hpp"
32 #include "runtime/atomic.inline.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 void* StackObj::operator new(size_t size) throw() { ShouldNotCallThis(); return 0; }
40 void StackObj::operator delete(void* p) { ShouldNotCallThis(); }
41 void* StackObj::operator new [](size_t size) throw() { ShouldNotCallThis(); return 0; }
42 void StackObj::operator delete [](void* p) { ShouldNotCallThis(); }
43
44 void* _ValueObj::operator new(size_t size) throw() { ShouldNotCallThis(); return 0; }
45 void _ValueObj::operator delete(void* p) { ShouldNotCallThis(); }
46 void* _ValueObj::operator new [](size_t size) throw() { ShouldNotCallThis(); return 0; }
47 void _ValueObj::operator delete [](void* p) { ShouldNotCallThis(); }
48
49 void* MetaspaceObj::operator new(size_t size, ClassLoaderData* loader_data,
50 size_t word_size, bool read_only,
51 MetaspaceObj::Type type, TRAPS) throw() {
52 // Klass has it's own operator new
53 return Metaspace::allocate(loader_data, word_size, read_only,
54 type, CHECK_NULL);
55 }
56
57 bool MetaspaceObj::is_shared() const {
58 return MetaspaceShared::is_in_shared_space(this);
59 }
60
61 bool MetaspaceObj::is_metaspace_object() const {
62 return Metaspace::contains((void*)this);
63 }
64
65 void MetaspaceObj::print_address_on(outputStream* st) const {
66 st->print(" {" INTPTR_FORMAT "}", p2i(this));
67 }
68
69 void* ResourceObj::operator new(size_t size, allocation_type type, MEMFLAGS flags) throw() {
70 address res;
71 switch (type) {
72 case C_HEAP:
73 res = (address)AllocateHeap(size, flags, CALLER_PC);
74 DEBUG_ONLY(set_allocation_type(res, C_HEAP);)
75 break;
76 case RESOURCE_AREA:
77 // new(size) sets allocation type RESOURCE_AREA.
78 res = (address)operator new(size);
79 break;
80 default:
81 ShouldNotReachHere();
82 }
83 return res;
84 }
85
86 void* ResourceObj::operator new [](size_t size, allocation_type type, MEMFLAGS flags) throw() {
87 return (address) operator new(size, type, flags);
88 }
89
90 void* ResourceObj::operator new(size_t size, const std::nothrow_t& nothrow_constant,
91 allocation_type type, MEMFLAGS flags) throw() {
92 //should only call this with std::nothrow, use other operator new() otherwise
93 address res;
94 switch (type) {
95 case C_HEAP:
96 res = (address)AllocateHeap(size, flags, CALLER_PC, AllocFailStrategy::RETURN_NULL);
97 DEBUG_ONLY(if (res!= NULL) set_allocation_type(res, C_HEAP);)
98 break;
99 case RESOURCE_AREA:
100 // new(size) sets allocation type RESOURCE_AREA.
101 res = (address)operator new(size, std::nothrow);
102 break;
103 default:
104 ShouldNotReachHere();
105 }
106 return res;
107 }
108
109 void* ResourceObj::operator new [](size_t size, const std::nothrow_t& nothrow_constant,
110 allocation_type type, MEMFLAGS flags) throw() {
111 return (address)operator new(size, nothrow_constant, type, flags);
112 }
113
114 void ResourceObj::operator delete(void* p) {
115 assert(((ResourceObj *)p)->allocated_on_C_heap(),
116 "delete only allowed for C_HEAP objects");
117 DEBUG_ONLY(((ResourceObj *)p)->_allocation_t[0] = (uintptr_t)badHeapOopVal;)
118 FreeHeap(p);
119 }
120
121 void ResourceObj::operator delete [](void* p) {
122 operator delete(p);
123 }
124
125 #ifdef ASSERT
126 void ResourceObj::set_allocation_type(address res, allocation_type type) {
127 // Set allocation type in the resource object
128 uintptr_t allocation = (uintptr_t)res;
129 assert((allocation & allocation_mask) == 0, err_msg("address should be aligned to 4 bytes at least: " INTPTR_FORMAT, p2i(res)));
130 assert(type <= allocation_mask, "incorrect allocation type");
131 ResourceObj* resobj = (ResourceObj *)res;
132 resobj->_allocation_t[0] = ~(allocation + type);
133 if (type != STACK_OR_EMBEDDED) {
134 // Called from operator new() and CollectionSetChooser(),
135 // set verification value.
136 resobj->_allocation_t[1] = (uintptr_t)&(resobj->_allocation_t[1]) + type;
137 }
138 }
139
140 ResourceObj::allocation_type ResourceObj::get_allocation_type() const {
141 assert(~(_allocation_t[0] | allocation_mask) == (uintptr_t)this, "lost resource object");
142 return (allocation_type)((~_allocation_t[0]) & allocation_mask);
143 }
144
145 bool ResourceObj::is_type_set() const {
146 allocation_type type = (allocation_type)(_allocation_t[1] & allocation_mask);
147 return get_allocation_type() == type &&
148 (_allocation_t[1] - type) == (uintptr_t)(&_allocation_t[1]);
149 }
150
151 ResourceObj::ResourceObj() { // default constructor
152 if (~(_allocation_t[0] | allocation_mask) != (uintptr_t)this) {
153 // Operator new() is not called for allocations
154 // on stack and for embedded objects.
155 set_allocation_type((address)this, STACK_OR_EMBEDDED);
156 } else if (allocated_on_stack()) { // STACK_OR_EMBEDDED
157 // For some reason we got a value which resembles
158 // an embedded or stack object (operator new() does not
159 // set such type). Keep it since it is valid value
160 // (even if it was garbage).
161 // Ignore garbage in other fields.
162 } else if (is_type_set()) {
163 // Operator new() was called and type was set.
164 assert(!allocated_on_stack(),
165 err_msg("not embedded or stack, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")",
166 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]));
167 } else {
168 // Operator new() was not called.
169 // Assume that it is embedded or stack object.
170 set_allocation_type((address)this, STACK_OR_EMBEDDED);
171 }
172 _allocation_t[1] = 0; // Zap verification value
173 }
174
175 ResourceObj::ResourceObj(const ResourceObj& r) { // default copy constructor
176 // Used in ClassFileParser::parse_constant_pool_entries() for ClassFileStream.
177 // Note: garbage may resembles valid value.
178 assert(~(_allocation_t[0] | allocation_mask) != (uintptr_t)this || !is_type_set(),
179 err_msg("embedded or stack only, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")",
180 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]));
181 set_allocation_type((address)this, STACK_OR_EMBEDDED);
182 _allocation_t[1] = 0; // Zap verification value
183 }
184
185 ResourceObj& ResourceObj::operator=(const ResourceObj& r) { // default copy assignment
186 // Used in InlineTree::ok_to_inline() for WarmCallInfo.
187 assert(allocated_on_stack(),
188 err_msg("copy only into local, this(" PTR_FORMAT ") type %d a[0]=(" PTR_FORMAT ") a[1]=(" PTR_FORMAT ")",
189 p2i(this), get_allocation_type(), _allocation_t[0], _allocation_t[1]));
190 // Keep current _allocation_t value;
191 return *this;
192 }
193
194 ResourceObj::~ResourceObj() {
195 // allocated_on_C_heap() also checks that encoded (in _allocation) address == this.
196 if (!allocated_on_C_heap()) { // ResourceObj::delete() will zap _allocation for C_heap.
197 _allocation_t[0] = (uintptr_t)badHeapOopVal; // zap type
198 }
199 }
200 #endif // ASSERT
201
202
203 void trace_heap_malloc(size_t size, const char* name, void* p) {
204 // A lock is not needed here - tty uses a lock internally
205 tty->print_cr("Heap malloc " INTPTR_FORMAT " " SIZE_FORMAT " %s", p2i(p), size, name == NULL ? "" : name);
206 }
207
208
209 void trace_heap_free(void* p) {
210 // A lock is not needed here - tty uses a lock internally
211 tty->print_cr("Heap free " INTPTR_FORMAT, p2i(p));
212 }
213
214 //--------------------------------------------------------------------------------------
215 // ChunkPool implementation
216
217 // MT-safe pool of chunks to reduce malloc/free thrashing
218 // NB: not using Mutex because pools are used before Threads are initialized
219 class ChunkPool: public CHeapObj<mtInternal> {
220 Chunk* _first; // first cached Chunk; its first word points to next chunk
221 size_t _num_chunks; // number of unused chunks in pool
222 size_t _num_used; // number of chunks currently checked out
223 const size_t _size; // size of each chunk (must be uniform)
224
225 // Our four static pools
226 static ChunkPool* _large_pool;
227 static ChunkPool* _medium_pool;
228 static ChunkPool* _small_pool;
229 static ChunkPool* _tiny_pool;
230
231 // return first element or null
232 void* get_first() {
233 Chunk* c = _first;
234 if (_first) {
235 _first = _first->next();
236 _num_chunks--;
237 }
238 return c;
239 }
240
241 public:
242 // All chunks in a ChunkPool has the same size
243 ChunkPool(size_t size) : _size(size) { _first = NULL; _num_chunks = _num_used = 0; }
244
245 // Allocate a new chunk from the pool (might expand the pool)
246 _NOINLINE_ void* allocate(size_t bytes, AllocFailType alloc_failmode) {
247 assert(bytes == _size, "bad size");
248 void* p = NULL;
249 // No VM lock can be taken inside ThreadCritical lock, so os::malloc
250 // should be done outside ThreadCritical lock due to NMT
251 { ThreadCritical tc;
252 _num_used++;
253 p = get_first();
254 }
255 if (p == NULL) p = os::malloc(bytes, mtChunk, CURRENT_PC);
256 if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
257 vm_exit_out_of_memory(bytes, OOM_MALLOC_ERROR, "ChunkPool::allocate");
258 }
259 return p;
260 }
261
262 // Return a chunk to the pool
263 void free(Chunk* chunk) {
264 assert(chunk->length() + Chunk::aligned_overhead_size() == _size, "bad size");
265 ThreadCritical tc;
266 _num_used--;
267
268 // Add chunk to list
269 chunk->set_next(_first);
270 _first = chunk;
271 _num_chunks++;
272 }
273
274 // Prune the pool
275 void free_all_but(size_t n) {
276 Chunk* cur = NULL;
277 Chunk* next;
278 {
279 // if we have more than n chunks, free all of them
280 ThreadCritical tc;
281 if (_num_chunks > n) {
282 // free chunks at end of queue, for better locality
283 cur = _first;
284 for (size_t i = 0; i < (n - 1) && cur != NULL; i++) cur = cur->next();
285
286 if (cur != NULL) {
287 next = cur->next();
288 cur->set_next(NULL);
289 cur = next;
290
291 _num_chunks = n;
292 }
293 }
294 }
295
296 // Free all remaining chunks, outside of ThreadCritical
297 // to avoid deadlock with NMT
298 while(cur != NULL) {
299 next = cur->next();
300 os::free(cur, mtChunk);
301 cur = next;
302 }
303 }
304
305 // Accessors to preallocated pool's
306 static ChunkPool* large_pool() { assert(_large_pool != NULL, "must be initialized"); return _large_pool; }
307 static ChunkPool* medium_pool() { assert(_medium_pool != NULL, "must be initialized"); return _medium_pool; }
308 static ChunkPool* small_pool() { assert(_small_pool != NULL, "must be initialized"); return _small_pool; }
309 static ChunkPool* tiny_pool() { assert(_tiny_pool != NULL, "must be initialized"); return _tiny_pool; }
310
311 static void initialize() {
312 _large_pool = new ChunkPool(Chunk::size + Chunk::aligned_overhead_size());
313 _medium_pool = new ChunkPool(Chunk::medium_size + Chunk::aligned_overhead_size());
314 _small_pool = new ChunkPool(Chunk::init_size + Chunk::aligned_overhead_size());
315 _tiny_pool = new ChunkPool(Chunk::tiny_size + Chunk::aligned_overhead_size());
316 }
317
318 static void clean() {
319 enum { BlocksToKeep = 5 };
320 _tiny_pool->free_all_but(BlocksToKeep);
321 _small_pool->free_all_but(BlocksToKeep);
322 _medium_pool->free_all_but(BlocksToKeep);
323 _large_pool->free_all_but(BlocksToKeep);
324 }
325 };
326
327 ChunkPool* ChunkPool::_large_pool = NULL;
328 ChunkPool* ChunkPool::_medium_pool = NULL;
329 ChunkPool* ChunkPool::_small_pool = NULL;
330 ChunkPool* ChunkPool::_tiny_pool = NULL;
331
332 void chunkpool_init() {
333 ChunkPool::initialize();
334 }
335
336 void
337 Chunk::clean_chunk_pool() {
338 ChunkPool::clean();
339 }
340
341
342 //--------------------------------------------------------------------------------------
343 // ChunkPoolCleaner implementation
344 //
345
346 class ChunkPoolCleaner : public PeriodicTask {
347 enum { CleaningInterval = 5000 }; // cleaning interval in ms
348
349 public:
350 ChunkPoolCleaner() : PeriodicTask(CleaningInterval) {}
351 void task() {
352 ChunkPool::clean();
353 }
354 };
355
356 //--------------------------------------------------------------------------------------
357 // Chunk implementation
358
359 void* Chunk::operator new (size_t requested_size, AllocFailType alloc_failmode, size_t length) throw() {
360 // requested_size is equal to sizeof(Chunk) but in order for the arena
361 // allocations to come out aligned as expected the size must be aligned
362 // to expected arena alignment.
363 // expect requested_size but if sizeof(Chunk) doesn't match isn't proper size we must align it.
364 assert(ARENA_ALIGN(requested_size) == aligned_overhead_size(), "Bad alignment");
365 size_t bytes = ARENA_ALIGN(requested_size) + length;
366 switch (length) {
367 case Chunk::size: return ChunkPool::large_pool()->allocate(bytes, alloc_failmode);
368 case Chunk::medium_size: return ChunkPool::medium_pool()->allocate(bytes, alloc_failmode);
369 case Chunk::init_size: return ChunkPool::small_pool()->allocate(bytes, alloc_failmode);
370 case Chunk::tiny_size: return ChunkPool::tiny_pool()->allocate(bytes, alloc_failmode);
371 default: {
372 void* p = os::malloc(bytes, mtChunk, CALLER_PC);
373 if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) {
374 vm_exit_out_of_memory(bytes, OOM_MALLOC_ERROR, "Chunk::new");
375 }
376 return p;
377 }
378 }
379 }
380
381 void Chunk::operator delete(void* p) {
382 Chunk* c = (Chunk*)p;
383 switch (c->length()) {
384 case Chunk::size: ChunkPool::large_pool()->free(c); break;
385 case Chunk::medium_size: ChunkPool::medium_pool()->free(c); break;
386 case Chunk::init_size: ChunkPool::small_pool()->free(c); break;
387 case Chunk::tiny_size: ChunkPool::tiny_pool()->free(c); break;
388 default: os::free(c, mtChunk);
389 }
390 }
391
392 Chunk::Chunk(size_t length) : _len(length) {
393 _next = NULL; // Chain on the linked list
394 }
395
396
397 void Chunk::chop() {
398 Chunk *k = this;
399 while( k ) {
400 Chunk *tmp = k->next();
401 // clear out this chunk (to detect allocation bugs)
402 if (ZapResourceArea) memset(k->bottom(), badResourceValue, k->length());
403 delete k; // Free chunk (was malloc'd)
404 k = tmp;
405 }
406 }
407
408 void Chunk::next_chop() {
409 _next->chop();
410 _next = NULL;
411 }
412
413
414 void Chunk::start_chunk_pool_cleaner_task() {
415 #ifdef ASSERT
416 static bool task_created = false;
417 assert(!task_created, "should not start chuck pool cleaner twice");
418 task_created = true;
419 #endif
420 ChunkPoolCleaner* cleaner = new ChunkPoolCleaner();
421 cleaner->enroll();
422 }
423
424 //------------------------------Arena------------------------------------------
425
426 Arena::Arena(MEMFLAGS flag, size_t init_size) : _flags(flag), _size_in_bytes(0) {
427 size_t round_size = (sizeof (char *)) - 1;
428 init_size = (init_size+round_size) & ~round_size;
429 _first = _chunk = new (AllocFailStrategy::EXIT_OOM, init_size) Chunk(init_size);
430 _hwm = _chunk->bottom(); // Save the cached hwm, max
431 _max = _chunk->top();
432 MemTracker::record_new_arena(flag);
433 set_size_in_bytes(init_size);
434 }
435
436 Arena::Arena(MEMFLAGS flag) : _flags(flag), _size_in_bytes(0) {
437 _first = _chunk = new (AllocFailStrategy::EXIT_OOM, Chunk::init_size) Chunk(Chunk::init_size);
438 _hwm = _chunk->bottom(); // Save the cached hwm, max
439 _max = _chunk->top();
440 MemTracker::record_new_arena(flag);
441 set_size_in_bytes(Chunk::init_size);
442 }
443
444 Arena *Arena::move_contents(Arena *copy) {
445 copy->destruct_contents();
446 copy->_chunk = _chunk;
447 copy->_hwm = _hwm;
448 copy->_max = _max;
449 copy->_first = _first;
450
451 // workaround rare racing condition, which could double count
452 // the arena size by native memory tracking
453 size_t size = size_in_bytes();
454 set_size_in_bytes(0);
455 copy->set_size_in_bytes(size);
456 // Destroy original arena
457 reset();
458 return copy; // Return Arena with contents
459 }
460
461 Arena::~Arena() {
462 destruct_contents();
463 MemTracker::record_arena_free(_flags);
464 }
465
466 void* Arena::operator new(size_t size) throw() {
467 assert(false, "Use dynamic memory type binding");
468 return NULL;
469 }
470
471 void* Arena::operator new (size_t size, const std::nothrow_t& nothrow_constant) throw() {
472 assert(false, "Use dynamic memory type binding");
473 return NULL;
474 }
475
476 // dynamic memory type binding
477 void* Arena::operator new(size_t size, MEMFLAGS flags) throw() {
478 #ifdef ASSERT
479 void* p = (void*)AllocateHeap(size, flags, CALLER_PC);
480 if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p);
481 return p;
482 #else
483 return (void *) AllocateHeap(size, flags, CALLER_PC);
484 #endif
485 }
486
487 void* Arena::operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags) throw() {
488 #ifdef ASSERT
489 void* p = os::malloc(size, flags, CALLER_PC);
490 if (PrintMallocFree) trace_heap_malloc(size, "Arena-new", p);
491 return p;
492 #else
493 return os::malloc(size, flags, CALLER_PC);
494 #endif
495 }
496
497 void Arena::operator delete(void* p) {
498 FreeHeap(p);
499 }
500
501 // Destroy this arenas contents and reset to empty
502 void Arena::destruct_contents() {
503 if (UseMallocOnly && _first != NULL) {
504 char* end = _first->next() ? _first->top() : _hwm;
505 free_malloced_objects(_first, _first->bottom(), end, _hwm);
506 }
507 // reset size before chop to avoid a rare racing condition
508 // that can have total arena memory exceed total chunk memory
509 set_size_in_bytes(0);
510 _first->chop();
511 reset();
512 }
513
514 // This is high traffic method, but many calls actually don't
515 // change the size
516 void Arena::set_size_in_bytes(size_t size) {
517 if (_size_in_bytes != size) {
518 long delta = (long)(size - size_in_bytes());
519 _size_in_bytes = size;
520 MemTracker::record_arena_size_change(delta, _flags);
521 }
522 }
523
524 // Total of all Chunks in arena
525 size_t Arena::used() const {
526 size_t sum = _chunk->length() - (_max-_hwm); // Size leftover in this Chunk
527 register Chunk *k = _first;
528 while( k != _chunk) { // Whilst have Chunks in a row
529 sum += k->length(); // Total size of this Chunk
530 k = k->next(); // Bump along to next Chunk
531 }
532 return sum; // Return total consumed space.
533 }
534
535 void Arena::signal_out_of_memory(size_t sz, const char* whence) const {
536 vm_exit_out_of_memory(sz, OOM_MALLOC_ERROR, whence);
537 }
538
539 // Grow a new Chunk
540 void* Arena::grow(size_t x, AllocFailType alloc_failmode) {
541 // Get minimal required size. Either real big, or even bigger for giant objs
542 size_t len = MAX2(x, (size_t) Chunk::size);
543
544 Chunk *k = _chunk; // Get filled-up chunk address
545 _chunk = new (alloc_failmode, len) Chunk(len);
546
547 if (_chunk == NULL) {
548 _chunk = k; // restore the previous value of _chunk
549 return NULL;
550 }
551 if (k) k->set_next(_chunk); // Append new chunk to end of linked list
552 else _first = _chunk;
553 _hwm = _chunk->bottom(); // Save the cached hwm, max
554 _max = _chunk->top();
555 set_size_in_bytes(size_in_bytes() + len);
556 void* result = _hwm;
557 _hwm += x;
558 return result;
559 }
560
561
562
563 // Reallocate storage in Arena.
564 void *Arena::Arealloc(void* old_ptr, size_t old_size, size_t new_size, AllocFailType alloc_failmode) {
565 assert(new_size >= 0, "bad size");
566 if (new_size == 0) return NULL;
567 #ifdef ASSERT
568 if (UseMallocOnly) {
569 // always allocate a new object (otherwise we'll free this one twice)
570 char* copy = (char*)Amalloc(new_size, alloc_failmode);
571 if (copy == NULL) {
572 return NULL;
573 }
574 size_t n = MIN2(old_size, new_size);
575 if (n > 0) memcpy(copy, old_ptr, n);
576 Afree(old_ptr,old_size); // Mostly done to keep stats accurate
577 return copy;
578 }
579 #endif
580 char *c_old = (char*)old_ptr; // Handy name
581 // Stupid fast special case
582 if( new_size <= old_size ) { // Shrink in-place
583 if( c_old+old_size == _hwm) // Attempt to free the excess bytes
584 _hwm = c_old+new_size; // Adjust hwm
585 return c_old;
586 }
587
588 // make sure that new_size is legal
589 size_t corrected_new_size = ARENA_ALIGN(new_size);
590
591 // See if we can resize in-place
592 if( (c_old+old_size == _hwm) && // Adjusting recent thing
593 (c_old+corrected_new_size <= _max) ) { // Still fits where it sits
594 _hwm = c_old+corrected_new_size; // Adjust hwm
595 return c_old; // Return old pointer
596 }
597
598 // Oops, got to relocate guts
599 void *new_ptr = Amalloc(new_size, alloc_failmode);
600 if (new_ptr == NULL) {
601 return NULL;
602 }
603 memcpy( new_ptr, c_old, old_size );
604 Afree(c_old,old_size); // Mostly done to keep stats accurate
605 return new_ptr;
606 }
607
608
609 // Determine if pointer belongs to this Arena or not.
610 bool Arena::contains( const void *ptr ) const {
611 #ifdef ASSERT
612 if (UseMallocOnly) {
613 // really slow, but not easy to make fast
614 if (_chunk == NULL) return false;
615 char** bottom = (char**)_chunk->bottom();
616 for (char** p = (char**)_hwm - 1; p >= bottom; p--) {
617 if (*p == ptr) return true;
618 }
619 for (Chunk *c = _first; c != NULL; c = c->next()) {
620 if (c == _chunk) continue; // current chunk has been processed
621 char** bottom = (char**)c->bottom();
622 for (char** p = (char**)c->top() - 1; p >= bottom; p--) {
623 if (*p == ptr) return true;
624 }
625 }
626 return false;
627 }
628 #endif
629 if( (void*)_chunk->bottom() <= ptr && ptr < (void*)_hwm )
630 return true; // Check for in this chunk
631 for (Chunk *c = _first; c; c = c->next()) {
632 if (c == _chunk) continue; // current chunk has been processed
633 if ((void*)c->bottom() <= ptr && ptr < (void*)c->top()) {
634 return true; // Check for every chunk in Arena
635 }
636 }
637 return false; // Not in any Chunk, so not in Arena
638 }
639
640
641 #ifdef ASSERT
642 void* Arena::malloc(size_t size) {
643 assert(UseMallocOnly, "shouldn't call");
644 // use malloc, but save pointer in res. area for later freeing
645 char** save = (char**)internal_malloc_4(sizeof(char*));
646 return (*save = (char*)os::malloc(size, mtChunk));
647 }
648
649 // for debugging with UseMallocOnly
650 void* Arena::internal_malloc_4(size_t x) {
651 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" );
652 check_for_overflow(x, "Arena::internal_malloc_4");
653 if (_hwm + x > _max) {
654 return grow(x);
655 } else {
656 char *old = _hwm;
657 _hwm += x;
658 return old;
659 }
660 }
661 #endif
662
663
664 //--------------------------------------------------------------------------------------
665 // Non-product code
666
667 #ifndef PRODUCT
668 // The global operator new should never be called since it will usually indicate
669 // a memory leak. Use CHeapObj as the base class of such objects to make it explicit
670 // that they're allocated on the C heap.
671 // Commented out in product version to avoid conflicts with third-party C++ native code.
672 //
673 // In C++98/03 the throwing new operators are defined with the following signature:
674 //
675 // void* operator new(std::size_tsize) throw(std::bad_alloc);
676 // void* operator new[](std::size_tsize) throw(std::bad_alloc);
677 //
678 // while all the other (non-throwing) new and delete operators are defined with an empty
679 // throw clause (i.e. "operator delete(void* p) throw()") which means that they do not
680 // throw any exceptions (see section 18.4 of the C++ standard).
681 //
682 // In the new C++11/14 standard, the signature of the throwing new operators was changed
683 // by completely omitting the throw clause (which effectively means they could throw any
684 // exception) while all the other new/delete operators where changed to have a 'nothrow'
685 // clause instead of an empty throw clause.
686 //
687 // Unfortunately, the support for exception specifications among C++ compilers is still
688 // very fragile. While some more strict compilers like AIX xlC or HP aCC reject to
689 // override the default throwing new operator with a user operator with an empty throw()
690 // clause, the MS Visual C++ compiler warns for every non-empty throw clause like
691 // throw(std::bad_alloc) that it will ignore the exception specification. The following
692 // operator definitions have been checked to correctly work with all currently supported
693 // compilers and they should be upwards compatible with C++11/14. Therefore
694 // PLEASE BE CAREFUL if you change the signature of the following operators!
695
696 static void * zero = (void *) 0;
697
698 void* operator new(size_t size) /* throw(std::bad_alloc) */ {
699 fatal("Should not call global operator new");
700 return zero;
701 }
702
703 void* operator new [](size_t size) /* throw(std::bad_alloc) */ {
704 fatal("Should not call global operator new[]");
705 return zero;
706 }
707
708 void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {
709 fatal("Should not call global operator new");
710 return 0;
711 }
712
713 void* operator new [](size_t size, std::nothrow_t& nothrow_constant) throw() {
714 fatal("Should not call global operator new[]");
715 return 0;
716 }
717
718 void operator delete(void* p) throw() {
719 fatal("Should not call global delete");
720 }
721
722 void operator delete [](void* p) throw() {
723 fatal("Should not call global delete []");
724 }
725
726 void AllocatedObj::print() const { print_on(tty); }
727 void AllocatedObj::print_value() const { print_value_on(tty); }
728
729 void AllocatedObj::print_on(outputStream* st) const {
730 st->print_cr("AllocatedObj(" INTPTR_FORMAT ")", p2i(this));
731 }
732
733 void AllocatedObj::print_value_on(outputStream* st) const {
734 st->print("AllocatedObj(" INTPTR_FORMAT ")", p2i(this));
735 }
736
737 julong Arena::_bytes_allocated = 0;
738
739 void Arena::inc_bytes_allocated(size_t x) { inc_stat_counter(&_bytes_allocated, x); }
740
741 AllocStats::AllocStats() {
742 start_mallocs = os::num_mallocs;
743 start_frees = os::num_frees;
744 start_malloc_bytes = os::alloc_bytes;
745 start_mfree_bytes = os::free_bytes;
746 start_res_bytes = Arena::_bytes_allocated;
747 }
748
749 julong AllocStats::num_mallocs() { return os::num_mallocs - start_mallocs; }
750 julong AllocStats::alloc_bytes() { return os::alloc_bytes - start_malloc_bytes; }
751 julong AllocStats::num_frees() { return os::num_frees - start_frees; }
752 julong AllocStats::free_bytes() { return os::free_bytes - start_mfree_bytes; }
753 julong AllocStats::resource_bytes() { return Arena::_bytes_allocated - start_res_bytes; }
754 void AllocStats::print() {
755 tty->print_cr(UINT64_FORMAT " mallocs (" UINT64_FORMAT "MB), "
756 UINT64_FORMAT" frees (" UINT64_FORMAT "MB), " UINT64_FORMAT "MB resrc",
757 num_mallocs(), alloc_bytes()/M, num_frees(), free_bytes()/M, resource_bytes()/M);
758 }
759
760
761 // debugging code
762 inline void Arena::free_all(char** start, char** end) {
763 for (char** p = start; p < end; p++) if (*p) os::free(*p);
764 }
765
766 void Arena::free_malloced_objects(Chunk* chunk, char* hwm, char* max, char* hwm2) {
767 assert(UseMallocOnly, "should not call");
768 // free all objects malloced since resource mark was created; resource area
769 // contains their addresses
770 if (chunk->next()) {
771 // this chunk is full, and some others too
772 for (Chunk* c = chunk->next(); c != NULL; c = c->next()) {
773 char* top = c->top();
774 if (c->next() == NULL) {
775 top = hwm2; // last junk is only used up to hwm2
776 assert(c->contains(hwm2), "bad hwm2");
777 }
778 free_all((char**)c->bottom(), (char**)top);
779 }
780 assert(chunk->contains(hwm), "bad hwm");
781 assert(chunk->contains(max), "bad max");
782 free_all((char**)hwm, (char**)max);
783 } else {
784 // this chunk was partially used
785 assert(chunk->contains(hwm), "bad hwm");
786 assert(chunk->contains(hwm2), "bad hwm2");
787 free_all((char**)hwm, (char**)hwm2);
788 }
789 }
790
791
792 ReallocMark::ReallocMark() {
793 #ifdef ASSERT
794 Thread *thread = ThreadLocalStorage::get_thread_slow();
795 _nesting = thread->resource_area()->nesting();
796 #endif
797 }
798
799 void ReallocMark::check() {
800 #ifdef ASSERT
801 if (_nesting != Thread::current()->resource_area()->nesting()) {
802 fatal("allocation bug: array could grow within nested ResourceMark");
803 }
804 #endif
805 }
806
807 #endif // Non-product