313 friend class VMStructs; |
319 friend class VMStructs; |
314 |
320 |
315 Chunk *_first; // First chunk |
321 Chunk *_first; // First chunk |
316 Chunk *_chunk; // current chunk |
322 Chunk *_chunk; // current chunk |
317 char *_hwm, *_max; // High water mark and max in current chunk |
323 char *_hwm, *_max; // High water mark and max in current chunk |
318 void* grow(size_t x); // Get a new Chunk of at least size x |
324 // Get a new Chunk of at least size x |
|
325 void* grow(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
319 size_t _size_in_bytes; // Size of arena (used for native memory tracking) |
326 size_t _size_in_bytes; // Size of arena (used for native memory tracking) |
320 |
327 |
321 NOT_PRODUCT(static julong _bytes_allocated;) // total #bytes allocated since start |
328 NOT_PRODUCT(static julong _bytes_allocated;) // total #bytes allocated since start |
322 friend class AllocStats; |
329 friend class AllocStats; |
323 debug_only(void* malloc(size_t size);) |
330 debug_only(void* malloc(size_t size);) |
348 void* operator new(size_t size, MEMFLAGS flags); |
355 void* operator new(size_t size, MEMFLAGS flags); |
349 void* operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags); |
356 void* operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags); |
350 void operator delete(void* p); |
357 void operator delete(void* p); |
351 |
358 |
352 // Fast allocate in the arena. Common case is: pointer test + increment. |
359 // Fast allocate in the arena. Common case is: pointer test + increment. |
353 void* Amalloc(size_t x) { |
360 void* Amalloc(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) { |
354 assert(is_power_of_2(ARENA_AMALLOC_ALIGNMENT) , "should be a power of 2"); |
361 assert(is_power_of_2(ARENA_AMALLOC_ALIGNMENT) , "should be a power of 2"); |
355 x = ARENA_ALIGN(x); |
362 x = ARENA_ALIGN(x); |
356 debug_only(if (UseMallocOnly) return malloc(x);) |
363 debug_only(if (UseMallocOnly) return malloc(x);) |
357 check_for_overflow(x, "Arena::Amalloc"); |
364 check_for_overflow(x, "Arena::Amalloc"); |
358 NOT_PRODUCT(inc_bytes_allocated(x);) |
365 NOT_PRODUCT(inc_bytes_allocated(x);) |
359 if (_hwm + x > _max) { |
366 if (_hwm + x > _max) { |
360 return grow(x); |
367 return grow(x, alloc_failmode); |
361 } else { |
368 } else { |
362 char *old = _hwm; |
369 char *old = _hwm; |
363 _hwm += x; |
370 _hwm += x; |
364 return old; |
371 return old; |
365 } |
372 } |
366 } |
373 } |
367 // Further assume size is padded out to words |
374 // Further assume size is padded out to words |
368 void *Amalloc_4(size_t x) { |
375 void *Amalloc_4(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) { |
369 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" ); |
376 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" ); |
370 debug_only(if (UseMallocOnly) return malloc(x);) |
377 debug_only(if (UseMallocOnly) return malloc(x);) |
371 check_for_overflow(x, "Arena::Amalloc_4"); |
378 check_for_overflow(x, "Arena::Amalloc_4"); |
372 NOT_PRODUCT(inc_bytes_allocated(x);) |
379 NOT_PRODUCT(inc_bytes_allocated(x);) |
373 if (_hwm + x > _max) { |
380 if (_hwm + x > _max) { |
374 return grow(x); |
381 return grow(x, alloc_failmode); |
375 } else { |
382 } else { |
376 char *old = _hwm; |
383 char *old = _hwm; |
377 _hwm += x; |
384 _hwm += x; |
378 return old; |
385 return old; |
379 } |
386 } |
380 } |
387 } |
381 |
388 |
382 // Allocate with 'double' alignment. It is 8 bytes on sparc. |
389 // Allocate with 'double' alignment. It is 8 bytes on sparc. |
383 // In other cases Amalloc_D() should be the same as Amalloc_4(). |
390 // In other cases Amalloc_D() should be the same as Amalloc_4(). |
384 void* Amalloc_D(size_t x) { |
391 void* Amalloc_D(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) { |
385 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" ); |
392 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" ); |
386 debug_only(if (UseMallocOnly) return malloc(x);) |
393 debug_only(if (UseMallocOnly) return malloc(x);) |
387 #if defined(SPARC) && !defined(_LP64) |
394 #if defined(SPARC) && !defined(_LP64) |
388 #define DALIGN_M1 7 |
395 #define DALIGN_M1 7 |
389 size_t delta = (((size_t)_hwm + DALIGN_M1) & ~DALIGN_M1) - (size_t)_hwm; |
396 size_t delta = (((size_t)_hwm + DALIGN_M1) & ~DALIGN_M1) - (size_t)_hwm; |
390 x += delta; |
397 x += delta; |
391 #endif |
398 #endif |
392 check_for_overflow(x, "Arena::Amalloc_D"); |
399 check_for_overflow(x, "Arena::Amalloc_D"); |
393 NOT_PRODUCT(inc_bytes_allocated(x);) |
400 NOT_PRODUCT(inc_bytes_allocated(x);) |
394 if (_hwm + x > _max) { |
401 if (_hwm + x > _max) { |
395 return grow(x); // grow() returns a result aligned >= 8 bytes. |
402 return grow(x, alloc_failmode); // grow() returns a result aligned >= 8 bytes. |
396 } else { |
403 } else { |
397 char *old = _hwm; |
404 char *old = _hwm; |
398 _hwm += x; |
405 _hwm += x; |
399 #if defined(SPARC) && !defined(_LP64) |
406 #if defined(SPARC) && !defined(_LP64) |
400 old += delta; // align to 8-bytes |
407 old += delta; // align to 8-bytes |
410 if (UseMallocOnly) return; |
417 if (UseMallocOnly) return; |
411 #endif |
418 #endif |
412 if (((char*)ptr) + size == _hwm) _hwm = (char*)ptr; |
419 if (((char*)ptr) + size == _hwm) _hwm = (char*)ptr; |
413 } |
420 } |
414 |
421 |
415 void *Arealloc( void *old_ptr, size_t old_size, size_t new_size ); |
422 void *Arealloc( void *old_ptr, size_t old_size, size_t new_size, |
|
423 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
416 |
424 |
417 // Move contents of this arena into an empty arena |
425 // Move contents of this arena into an empty arena |
418 Arena *move_contents(Arena *empty_arena); |
426 Arena *move_contents(Arena *empty_arena); |
419 |
427 |
420 // Determine if pointer belongs to this Arena or not. |
428 // Determine if pointer belongs to this Arena or not. |
456 #define NEW_ARENA_OBJ(arena, type) \ |
464 #define NEW_ARENA_OBJ(arena, type) \ |
457 NEW_ARENA_ARRAY(arena, type, 1) |
465 NEW_ARENA_ARRAY(arena, type, 1) |
458 |
466 |
459 |
467 |
460 //%note allocation_1 |
468 //%note allocation_1 |
461 extern char* resource_allocate_bytes(size_t size); |
469 extern char* resource_allocate_bytes(size_t size, |
462 extern char* resource_allocate_bytes(Thread* thread, size_t size); |
470 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
463 extern char* resource_reallocate_bytes( char *old, size_t old_size, size_t new_size); |
471 extern char* resource_allocate_bytes(Thread* thread, size_t size, |
|
472 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
|
473 extern char* resource_reallocate_bytes( char *old, size_t old_size, size_t new_size, |
|
474 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
464 extern void resource_free_bytes( char *old, size_t size ); |
475 extern void resource_free_bytes( char *old, size_t size ); |
465 |
476 |
466 //---------------------------------------------------------------------- |
477 //---------------------------------------------------------------------- |
467 // Base class for objects allocated in the resource area per default. |
478 // Base class for objects allocated in the resource area per default. |
468 // Optionally, objects may be allocated on the C heap with |
479 // Optionally, objects may be allocated on the C heap with |
494 ~ResourceObj(); |
505 ~ResourceObj(); |
495 #endif // ASSERT |
506 #endif // ASSERT |
496 |
507 |
497 public: |
508 public: |
498 void* operator new(size_t size, allocation_type type, MEMFLAGS flags); |
509 void* operator new(size_t size, allocation_type type, MEMFLAGS flags); |
|
510 void* operator new(size_t size, const std::nothrow_t& nothrow_constant, |
|
511 allocation_type type, MEMFLAGS flags); |
499 void* operator new(size_t size, Arena *arena) { |
512 void* operator new(size_t size, Arena *arena) { |
500 address res = (address)arena->Amalloc(size); |
513 address res = (address)arena->Amalloc(size); |
501 DEBUG_ONLY(set_allocation_type(res, ARENA);) |
514 DEBUG_ONLY(set_allocation_type(res, ARENA);) |
502 return res; |
515 return res; |
503 } |
516 } |
504 void* operator new(size_t size) { |
517 void* operator new(size_t size) { |
505 address res = (address)resource_allocate_bytes(size); |
518 address res = (address)resource_allocate_bytes(size); |
506 DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);) |
519 DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);) |
507 return res; |
520 return res; |
508 } |
521 } |
|
522 |
|
523 void* operator new(size_t size, const std::nothrow_t& nothrow_constant) { |
|
524 address res = (address)resource_allocate_bytes(size, AllocFailStrategy::RETURN_NULL); |
|
525 DEBUG_ONLY(if (res != NULL) set_allocation_type(res, RESOURCE_AREA);) |
|
526 return res; |
|
527 } |
|
528 |
509 void operator delete(void* p); |
529 void operator delete(void* p); |
510 }; |
530 }; |
511 |
531 |
512 // One of the following macros must be used when allocating an array |
532 // One of the following macros must be used when allocating an array |
513 // or object to determine whether it should reside in the C heap on in |
533 // or object to determine whether it should reside in the C heap on in |