truffle: src/share/vm/memory/allocation.hpp annotate

annotate src/share/vm/memory/allocation.hpp @ 20375:6e0cb14ce59b

8046070: Class Data Sharing clean up and refactoring Summary: Cleaned up CDS to be more configurable, maintainable and extensible Reviewed-by: dholmes, coleenp, acorn, mchung

author	iklam
date	Thu, 21 Aug 2014 13:57:51 -0700
parents	833b0f92429a
children	7848fc12602b

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 342 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 342 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 342 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	25 #ifndef SHARE_VM_MEMORY_ALLOCATION_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	26 #define SHARE_VM_MEMORY_ALLOCATION_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	28 #include "runtime/globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	29 #include "utilities/globalDefinitions.hpp"
6854 fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	30 #include "utilities/macros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	31 #ifdef COMPILER1
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	32 #include "c1/c1_globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	33 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	34 #ifdef COMPILER2
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	35 #include "opto/c2_globals.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	36 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	37
3302 2a3da7eaf4a6 7036747: 7017009 reappeared, problem with ElfStringTable zgu parents: 2307 diff changeset	38 #include <new>
2a3da7eaf4a6 7036747: 7017009 reappeared, problem with ElfStringTable zgu parents: 2307 diff changeset	39
0 a61af66fc99e Initial load duke parents: diff changeset	40 #define ARENA_ALIGN_M1 (((size_t)(ARENA_AMALLOC_ALIGNMENT)) - 1)
a61af66fc99e Initial load duke parents: diff changeset	41 #define ARENA_ALIGN_MASK (~((size_t)ARENA_ALIGN_M1))
a61af66fc99e Initial load duke parents: diff changeset	42 #define ARENA_ALIGN(x) ((((size_t)(x)) + ARENA_ALIGN_M1) & ARENA_ALIGN_MASK)
a61af66fc99e Initial load duke parents: diff changeset	43
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	44
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	45 // noinline attribute
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	46 #ifdef _WINDOWS
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	47 #define _NOINLINE_ __declspec(noinline)
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	48 #else
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	49 #if __GNUC__ < 3 // gcc 2.x does not support noinline attribute
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	50 #define _NOINLINE_
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	51 #else
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	52 #define _NOINLINE_ __attribute__ ((noinline))
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	53 #endif
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	54 #endif
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	55
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	56 class AllocFailStrategy {
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	57 public:
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	58 enum AllocFailEnum { EXIT_OOM, RETURN_NULL };
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	59 };
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	60 typedef AllocFailStrategy::AllocFailEnum AllocFailType;
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	61
0 a61af66fc99e Initial load duke parents: diff changeset	62 // All classes in the virtual machine must be subclassed
a61af66fc99e Initial load duke parents: diff changeset	63 // by one of the following allocation classes:
a61af66fc99e Initial load duke parents: diff changeset	64 //
a61af66fc99e Initial load duke parents: diff changeset	65 // For objects allocated in the resource area (see resourceArea.hpp).
a61af66fc99e Initial load duke parents: diff changeset	66 // - ResourceObj
a61af66fc99e Initial load duke parents: diff changeset	67 //
a61af66fc99e Initial load duke parents: diff changeset	68 // For objects allocated in the C-heap (managed by: free & malloc).
a61af66fc99e Initial load duke parents: diff changeset	69 // - CHeapObj
a61af66fc99e Initial load duke parents: diff changeset	70 //
a61af66fc99e Initial load duke parents: diff changeset	71 // For objects allocated on the stack.
a61af66fc99e Initial load duke parents: diff changeset	72 // - StackObj
a61af66fc99e Initial load duke parents: diff changeset	73 //
a61af66fc99e Initial load duke parents: diff changeset	74 // For embedded objects.
a61af66fc99e Initial load duke parents: diff changeset	75 // - ValueObj
a61af66fc99e Initial load duke parents: diff changeset	76 //
a61af66fc99e Initial load duke parents: diff changeset	77 // For classes used as name spaces.
a61af66fc99e Initial load duke parents: diff changeset	78 // - AllStatic
a61af66fc99e Initial load duke parents: diff changeset	79 //
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	80 // For classes in Metaspace (class data)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	81 // - MetaspaceObj
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	82 //
0 a61af66fc99e Initial load duke parents: diff changeset	83 // The printable subclasses are used for debugging and define virtual
a61af66fc99e Initial load duke parents: diff changeset	84 // member functions for printing. Classes that avoid allocating the
a61af66fc99e Initial load duke parents: diff changeset	85 // vtbl entries in the objects should therefore not be the printable
a61af66fc99e Initial load duke parents: diff changeset	86 // subclasses.
a61af66fc99e Initial load duke parents: diff changeset	87 //
a61af66fc99e Initial load duke parents: diff changeset	88 // The following macros and function should be used to allocate memory
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	89 // directly in the resource area or in the C-heap, The _OBJ variants
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	90 // of the NEW/FREE_C_HEAP macros are used for alloc/dealloc simple
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	91 // objects which are not inherited from CHeapObj, note constructor and
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	92 // destructor are not called. The preferable way to allocate objects
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	93 // is using the new operator.
0 a61af66fc99e Initial load duke parents: diff changeset	94 //
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	95 // WARNING: The array variant must only be used for a homogenous array
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	96 // where all objects are of the exact type specified. If subtypes are
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	97 // stored in the array then must pay attention to calling destructors
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	98 // at needed.
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	99 //
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	100 // NEW_RESOURCE_ARRAY(type, size)
0 a61af66fc99e Initial load duke parents: diff changeset	101 // NEW_RESOURCE_OBJ(type)
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	102 // NEW_C_HEAP_ARRAY(type, size)
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	103 // NEW_C_HEAP_OBJ(type, memflags)
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	104 // FREE_C_HEAP_ARRAY(type, old, memflags)
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	105 // FREE_C_HEAP_OBJ(objname, type, memflags)
0 a61af66fc99e Initial load duke parents: diff changeset	106 // char* AllocateHeap(size_t size, const char* name);
a61af66fc99e Initial load duke parents: diff changeset	107 // void FreeHeap(void* p);
a61af66fc99e Initial load duke parents: diff changeset	108 //
a61af66fc99e Initial load duke parents: diff changeset	109 // C-heap allocation can be traced using +PrintHeapAllocation.
a61af66fc99e Initial load duke parents: diff changeset	110 // malloc and free should therefore never called directly.
a61af66fc99e Initial load duke parents: diff changeset	111
a61af66fc99e Initial load duke parents: diff changeset	112 // Base class for objects allocated in the C-heap.
a61af66fc99e Initial load duke parents: diff changeset	113
a61af66fc99e Initial load duke parents: diff changeset	114 // In non product mode we introduce a super class for all allocation classes
a61af66fc99e Initial load duke parents: diff changeset	115 // that supports printing.
a61af66fc99e Initial load duke parents: diff changeset	116 // We avoid the superclass in product mode since some C++ compilers add
a61af66fc99e Initial load duke parents: diff changeset	117 // a word overhead for empty super classes.
a61af66fc99e Initial load duke parents: diff changeset	118
a61af66fc99e Initial load duke parents: diff changeset	119 #ifdef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	120 #define ALLOCATION_SUPER_CLASS_SPEC
a61af66fc99e Initial load duke parents: diff changeset	121 #else
a61af66fc99e Initial load duke parents: diff changeset	122 #define ALLOCATION_SUPER_CLASS_SPEC : public AllocatedObj
a61af66fc99e Initial load duke parents: diff changeset	123 class AllocatedObj {
a61af66fc99e Initial load duke parents: diff changeset	124 public:
a61af66fc99e Initial load duke parents: diff changeset	125 // Printing support
a61af66fc99e Initial load duke parents: diff changeset	126 void print() const;
a61af66fc99e Initial load duke parents: diff changeset	127 void print_value() const;
a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129 virtual void print_on(outputStream* st) const;
a61af66fc99e Initial load duke parents: diff changeset	130 virtual void print_value_on(outputStream* st) const;
a61af66fc99e Initial load duke parents: diff changeset	131 };
a61af66fc99e Initial load duke parents: diff changeset	132 #endif
a61af66fc99e Initial load duke parents: diff changeset	133
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	134
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	135 /*
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	136 * Memory types
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	137 */
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	138 enum MemoryType {
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	139 // Memory type by sub systems. It occupies lower byte.
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	140 mtJavaHeap = 0x00, // Java heap
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	141 mtClass = 0x01, // memory class for Java classes
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	142 mtThread = 0x02, // memory for thread objects
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	143 mtThreadStack = 0x03,
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	144 mtCode = 0x04, // memory for generated code
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	145 mtGC = 0x05, // memory for GC
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	146 mtCompiler = 0x06, // memory for compiler
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	147 mtInternal = 0x07, // memory used by VM, but does not belong to
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	148 // any of above categories, and not used for
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	149 // native memory tracking
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	150 mtOther = 0x08, // memory not used by VM
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	151 mtSymbol = 0x09, // symbol
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	152 mtNMT = 0x0A, // memory used by native memory tracking
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	153 mtClassShared = 0x0B, // class data sharing
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	154 mtChunk = 0x0C, // chunk that holds content of arenas
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	155 mtTest = 0x0D, // Test type for verifying NMT
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	156 mtTracing = 0x0E, // memory used for Tracing
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	157 mtNone = 0x0F, // undefined
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	158 mt_number_of_types = 0x10 // number of memory types (mtDontTrack
6882 716c64bda5ba 7199092: NMT: NMT needs to deal overlapped virtual memory ranges zgu parents: 6872 diff changeset	159 // is not included as validate type)
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	160 };
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	161
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	162 typedef MemoryType MEMFLAGS;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	163
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	164
6854 fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	165 #if INCLUDE_NMT
fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	166
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	167 extern bool NMT_track_callsite;
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	168
6854 fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	169 #else
fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	170
fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	171 const bool NMT_track_callsite = false;
fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	172
fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	173 #endif // INCLUDE_NMT
fb19af007ffc 7189254: Change makefiles for more flexibility to override defaults jprovino parents: 6725 diff changeset	174
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	175 class NativeCallStack;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	176
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	177
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	178 template <MEMFLAGS F> class CHeapObj ALLOCATION_SUPER_CLASS_SPEC {
0 a61af66fc99e Initial load duke parents: diff changeset	179 public:
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	180 _NOINLINE_ void* operator new(size_t size, const NativeCallStack& stack) throw();
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	181 _NOINLINE_ void* operator new(size_t size) throw();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	182 _NOINLINE_ void* operator new (size_t size, const std::nothrow_t& nothrow_constant,
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	183 const NativeCallStack& stack) throw();
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	184 _NOINLINE_ void* operator new (size_t size, const std::nothrow_t& nothrow_constant)
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	185 throw();
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	186 _NOINLINE_ void* operator new [](size_t size, const NativeCallStack& stack) throw();
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	187 _NOINLINE_ void* operator new [](size_t size) throw();
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	188 _NOINLINE_ void* operator new [](size_t size, const std::nothrow_t& nothrow_constant,
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	189 const NativeCallStack& stack) throw();
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	190 _NOINLINE_ void* operator new [](size_t size, const std::nothrow_t& nothrow_constant)
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	191 throw();
0 a61af66fc99e Initial load duke parents: diff changeset	192 void operator delete(void* p);
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	193 void operator delete [] (void* p);
0 a61af66fc99e Initial load duke parents: diff changeset	194 };
a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 // Base class for objects allocated on the stack only.
a61af66fc99e Initial load duke parents: diff changeset	197 // Calling new or delete will result in fatal error.
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 class StackObj ALLOCATION_SUPER_CLASS_SPEC {
7434 32164d89fe9c 8004845: Catch incorrect usage of new and delete during compile time for value objects and stack objects brutisso parents: 7176 diff changeset	200 private:
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	201 void* operator new(size_t size) throw();
14422 2b8e28fdf503 Merge kvn parents: 14412 12146 diff changeset	202 void* operator new [](size_t size) throw();
14411 bdd155477289 8023033: PPC64 (part 13): basic changes for AIX goetz parents: 11095 diff changeset	203 #ifdef __IBMCPP__
bdd155477289 8023033: PPC64 (part 13): basic changes for AIX goetz parents: 11095 diff changeset	204 public:
bdd155477289 8023033: PPC64 (part 13): basic changes for AIX goetz parents: 11095 diff changeset	205 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	206 void operator delete(void* p);
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	207 void operator delete [](void* p);
0 a61af66fc99e Initial load duke parents: diff changeset	208 };
a61af66fc99e Initial load duke parents: diff changeset	209
a61af66fc99e Initial load duke parents: diff changeset	210 // Base class for objects used as value objects.
a61af66fc99e Initial load duke parents: diff changeset	211 // Calling new or delete will result in fatal error.
a61af66fc99e Initial load duke parents: diff changeset	212 //
a61af66fc99e Initial load duke parents: diff changeset	213 // Portability note: Certain compilers (e.g. gcc) will
a61af66fc99e Initial load duke parents: diff changeset	214 // always make classes bigger if it has a superclass, even
a61af66fc99e Initial load duke parents: diff changeset	215 // if the superclass does not have any virtual methods or
a61af66fc99e Initial load duke parents: diff changeset	216 // instance fields. The HotSpot implementation relies on this
a61af66fc99e Initial load duke parents: diff changeset	217 // not to happen. So never make a ValueObj class a direct subclass
a61af66fc99e Initial load duke parents: diff changeset	218 // of this object, but use the VALUE_OBJ_CLASS_SPEC class instead, e.g.,
a61af66fc99e Initial load duke parents: diff changeset	219 // like this:
a61af66fc99e Initial load duke parents: diff changeset	220 //
a61af66fc99e Initial load duke parents: diff changeset	221 // class A VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load duke parents: diff changeset	222 // ...
a61af66fc99e Initial load duke parents: diff changeset	223 // }
a61af66fc99e Initial load duke parents: diff changeset	224 //
a61af66fc99e Initial load duke parents: diff changeset	225 // With gcc and possible other compilers the VALUE_OBJ_CLASS_SPEC can
a61af66fc99e Initial load duke parents: diff changeset	226 // be defined as a an empty string "".
a61af66fc99e Initial load duke parents: diff changeset	227 //
a61af66fc99e Initial load duke parents: diff changeset	228 class _ValueObj {
7434 32164d89fe9c 8004845: Catch incorrect usage of new and delete during compile time for value objects and stack objects brutisso parents: 7176 diff changeset	229 private:
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	230 void* operator new(size_t size) throw();
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	231 void operator delete(void* p);
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	232 void* operator new [](size_t size) throw();
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	233 void operator delete [](void* p);
0 a61af66fc99e Initial load duke parents: diff changeset	234 };
a61af66fc99e Initial load duke parents: diff changeset	235
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	236
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	237 // Base class for objects stored in Metaspace.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	238 // Calling delete will result in fatal error.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	239 //
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	240 // Do not inherit from something with a vptr because this class does
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	241 // not introduce one. This class is used to allocate both shared read-only
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	242 // and shared read-write classes.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	243 //
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	244
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	245 class ClassLoaderData;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	246
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	247 class MetaspaceObj {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	248 public:
17663 40353abd7984 8029178: Parallel class loading test anonymous-simple gets SIGSEGV in Metaspace::contains coleenp parents: 12146 diff changeset	249 bool is_metaspace_object() const;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	250 bool is_shared() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	251 void print_address_on(outputStream* st) const; // nonvirtual address printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	252
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	253 #define METASPACE_OBJ_TYPES_DO(f) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	254 f(Unknown) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	255 f(Class) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	256 f(Symbol) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	257 f(TypeArrayU1) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	258 f(TypeArrayU2) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	259 f(TypeArrayU4) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	260 f(TypeArrayU8) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	261 f(TypeArrayOther) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	262 f(Method) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	263 f(ConstMethod) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	264 f(MethodData) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	265 f(ConstantPool) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	266 f(ConstantPoolCache) \
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	267 f(Annotation) \
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20360 diff changeset	268 f(MethodCounters) \
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20360 diff changeset	269 f(Deallocated)
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	270
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	271 #define METASPACE_OBJ_TYPE_DECLARE(name) name ## Type,
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	272 #define METASPACE_OBJ_TYPE_NAME_CASE(name) case name ## Type: return #name;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	273
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	274 enum Type {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	275 // Types are MetaspaceObj::ClassType, MetaspaceObj::SymbolType, etc
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	276 METASPACE_OBJ_TYPES_DO(METASPACE_OBJ_TYPE_DECLARE)
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	277 _number_of_types
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	278 };
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	279
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	280 static const char * type_name(Type type) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	281 switch(type) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	282 METASPACE_OBJ_TYPES_DO(METASPACE_OBJ_TYPE_NAME_CASE)
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	283 default:
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	284 ShouldNotReachHere();
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	285 return NULL;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	286 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	287 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	288
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	289 static MetaspaceObj::Type array_type(size_t elem_size) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	290 switch (elem_size) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	291 case 1: return TypeArrayU1Type;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	292 case 2: return TypeArrayU2Type;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	293 case 4: return TypeArrayU4Type;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	294 case 8: return TypeArrayU8Type;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	295 default:
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	296 return TypeArrayOtherType;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	297 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	298 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	299
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	300 void* operator new(size_t size, ClassLoaderData* loader_data,
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10271 diff changeset	301 size_t word_size, bool read_only,
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	302 Type type, Thread* thread) throw();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	303 // can't use TRAPS from this header file.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	304 void operator delete(void* p) { ShouldNotCallThis(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	305 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	306
0 a61af66fc99e Initial load duke parents: diff changeset	307 // Base class for classes that constitute name spaces.
a61af66fc99e Initial load duke parents: diff changeset	308
a61af66fc99e Initial load duke parents: diff changeset	309 class AllStatic {
a61af66fc99e Initial load duke parents: diff changeset	310 public:
a61af66fc99e Initial load duke parents: diff changeset	311 AllStatic() { ShouldNotCallThis(); }
a61af66fc99e Initial load duke parents: diff changeset	312 ~AllStatic() { ShouldNotCallThis(); }
a61af66fc99e Initial load duke parents: diff changeset	313 };
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315
a61af66fc99e Initial load duke parents: diff changeset	316 //------------------------------Chunk------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	317 // Linked list of raw memory chunks
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	318 class Chunk: CHeapObj<mtChunk> {
3939 f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3302 diff changeset	319 friend class VMStructs;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3302 diff changeset	320
0 a61af66fc99e Initial load duke parents: diff changeset	321 protected:
a61af66fc99e Initial load duke parents: diff changeset	322 Chunk* _next; // Next Chunk in list
a61af66fc99e Initial load duke parents: diff changeset	323 const size_t _len; // Size of this Chunk
a61af66fc99e Initial load duke parents: diff changeset	324 public:
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	325 void* operator new(size_t size, AllocFailType alloc_failmode, size_t length) throw();
0 a61af66fc99e Initial load duke parents: diff changeset	326 void operator delete(void* p);
a61af66fc99e Initial load duke parents: diff changeset	327 Chunk(size_t length);
a61af66fc99e Initial load duke parents: diff changeset	328
a61af66fc99e Initial load duke parents: diff changeset	329 enum {
a61af66fc99e Initial load duke parents: diff changeset	330 // default sizes; make them slightly smaller than 2**k to guard against
a61af66fc99e Initial load duke parents: diff changeset	331 // buddy-system style malloc implementations
a61af66fc99e Initial load duke parents: diff changeset	332 #ifdef _LP64
a61af66fc99e Initial load duke parents: diff changeset	333 slack = 40, // [RGV] Not sure if this is right, but make it
a61af66fc99e Initial load duke parents: diff changeset	334 // a multiple of 8.
a61af66fc99e Initial load duke parents: diff changeset	335 #else
a61af66fc99e Initial load duke parents: diff changeset	336 slack = 20, // suspected sizeof(Chunk) + internal malloc headers
a61af66fc99e Initial load duke parents: diff changeset	337 #endif
a61af66fc99e Initial load duke parents: diff changeset	338
11095 cf9d71d3e474 8016903: Thread::_handle_area initial size too big iklam parents: 11048 diff changeset	339 tiny_size = 256 - slack, // Size of first chunk (tiny)
cf9d71d3e474 8016903: Thread::_handle_area initial size too big iklam parents: 11048 diff changeset	340 init_size = 1*K - slack, // Size of first chunk (normal aka small)
0 a61af66fc99e Initial load duke parents: diff changeset	341 medium_size= 10*K - slack, // Size of medium-sized chunk
a61af66fc99e Initial load duke parents: diff changeset	342 size = 32*K - slack, // Default size of an Arena chunk (following the first)
a61af66fc99e Initial load duke parents: diff changeset	343 non_pool_size = init_size + 32 // An initial size which is not one of above
a61af66fc99e Initial load duke parents: diff changeset	344 };
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346 void chop(); // Chop this chunk
a61af66fc99e Initial load duke parents: diff changeset	347 void next_chop(); // Chop next chunk
a61af66fc99e Initial load duke parents: diff changeset	348 static size_t aligned_overhead_size(void) { return ARENA_ALIGN(sizeof(Chunk)); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	349 static size_t aligned_overhead_size(size_t byte_size) { return ARENA_ALIGN(byte_size); }
0 a61af66fc99e Initial load duke parents: diff changeset	350
a61af66fc99e Initial load duke parents: diff changeset	351 size_t length() const { return _len; }
a61af66fc99e Initial load duke parents: diff changeset	352 Chunk* next() const { return _next; }
a61af66fc99e Initial load duke parents: diff changeset	353 void set_next(Chunk* n) { _next = n; }
a61af66fc99e Initial load duke parents: diff changeset	354 // Boundaries of data area (possibly unused)
a61af66fc99e Initial load duke parents: diff changeset	355 char* bottom() const { return ((char*) this) + aligned_overhead_size(); }
a61af66fc99e Initial load duke parents: diff changeset	356 char* top() const { return bottom() + _len; }
a61af66fc99e Initial load duke parents: diff changeset	357 bool contains(char* p) const { return bottom() <= p && p <= top(); }
a61af66fc99e Initial load duke parents: diff changeset	358
a61af66fc99e Initial load duke parents: diff changeset	359 // Start the chunk_pool cleaner task
a61af66fc99e Initial load duke parents: diff changeset	360 static void start_chunk_pool_cleaner_task();
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1552 diff changeset	361
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1552 diff changeset	362 static void clean_chunk_pool();
0 a61af66fc99e Initial load duke parents: diff changeset	363 };
a61af66fc99e Initial load duke parents: diff changeset	364
a61af66fc99e Initial load duke parents: diff changeset	365 //------------------------------Arena------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	366 // Fast allocation of memory
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	367 class Arena : public CHeapObj<mtNone> {
0 a61af66fc99e Initial load duke parents: diff changeset	368 protected:
a61af66fc99e Initial load duke parents: diff changeset	369 friend class ResourceMark;
a61af66fc99e Initial load duke parents: diff changeset	370 friend class HandleMark;
a61af66fc99e Initial load duke parents: diff changeset	371 friend class NoHandleMark;
3939 f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3302 diff changeset	372 friend class VMStructs;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3302 diff changeset	373
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	374 MEMFLAGS _flags; // Memory tracking flags
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	375
0 a61af66fc99e Initial load duke parents: diff changeset	376 Chunk *_first; // First chunk
a61af66fc99e Initial load duke parents: diff changeset	377 Chunk *_chunk; // current chunk
a61af66fc99e Initial load duke parents: diff changeset	378 char _hwm, _max; // High water mark and max in current chunk
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	379 // Get a new Chunk of at least size x
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	380 void* grow(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	381 size_t _size_in_bytes; // Size of arena (used for native memory tracking)
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	382
2250 f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	383 NOT_PRODUCT(static julong _bytes_allocated;) // total #bytes allocated since start
0 a61af66fc99e Initial load duke parents: diff changeset	384 friend class AllocStats;
a61af66fc99e Initial load duke parents: diff changeset	385 debug_only(void* malloc(size_t size);)
a61af66fc99e Initial load duke parents: diff changeset	386 debug_only(void* internal_malloc_4(size_t x);)
2250 f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	387 NOT_PRODUCT(void inc_bytes_allocated(size_t x);)
2307 4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs kamg parents: 2250 diff changeset	388
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs kamg parents: 2250 diff changeset	389 void signal_out_of_memory(size_t request, const char* whence) const;
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs kamg parents: 2250 diff changeset	390
11009 f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	391 bool check_for_overflow(size_t request, const char* whence,
f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	392 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) const {
2307 4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs kamg parents: 2250 diff changeset	393 if (UINTPTR_MAX - request < (uintptr_t)_hwm) {
11009 f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	394 if (alloc_failmode == AllocFailStrategy::RETURN_NULL) {
f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	395 return false;
f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	396 }
2307 4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs kamg parents: 2250 diff changeset	397 signal_out_of_memory(request, whence);
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs kamg parents: 2250 diff changeset	398 }
11009 f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	399 return true;
2307 4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs kamg parents: 2250 diff changeset	400 }
4a9604cd7c5f 6878713: Verifier heap corruption, relating to backward jsrs kamg parents: 2250 diff changeset	401
0 a61af66fc99e Initial load duke parents: diff changeset	402 public:
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	403 Arena(MEMFLAGS memflag);
833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	404 Arena(MEMFLAGS memflag, size_t init_size);
0 a61af66fc99e Initial load duke parents: diff changeset	405 ~Arena();
a61af66fc99e Initial load duke parents: diff changeset	406 void destruct_contents();
a61af66fc99e Initial load duke parents: diff changeset	407 char* hwm() const { return _hwm; }
a61af66fc99e Initial load duke parents: diff changeset	408
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	409 // new operators
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	410 void* operator new (size_t size) throw();
9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	411 void* operator new (size_t size, const std::nothrow_t& nothrow_constant) throw();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	412
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	413 // dynamic memory type tagging
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	414 void* operator new(size_t size, MEMFLAGS flags) throw();
9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	415 void* operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags) throw();
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	416 void operator delete(void* p);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	417
0 a61af66fc99e Initial load duke parents: diff changeset	418 // Fast allocate in the arena. Common case is: pointer test + increment.
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	419 void* Amalloc(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
0 a61af66fc99e Initial load duke parents: diff changeset	420 assert(is_power_of_2(ARENA_AMALLOC_ALIGNMENT) , "should be a power of 2");
a61af66fc99e Initial load duke parents: diff changeset	421 x = ARENA_ALIGN(x);
a61af66fc99e Initial load duke parents: diff changeset	422 debug_only(if (UseMallocOnly) return malloc(x);)
11009 f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	423 if (!check_for_overflow(x, "Arena::Amalloc", alloc_failmode))
f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	424 return NULL;
2250 f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	425 NOT_PRODUCT(inc_bytes_allocated(x);)
0 a61af66fc99e Initial load duke parents: diff changeset	426 if (_hwm + x > _max) {
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	427 return grow(x, alloc_failmode);
0 a61af66fc99e Initial load duke parents: diff changeset	428 } else {
a61af66fc99e Initial load duke parents: diff changeset	429 char *old = _hwm;
a61af66fc99e Initial load duke parents: diff changeset	430 _hwm += x;
a61af66fc99e Initial load duke parents: diff changeset	431 return old;
a61af66fc99e Initial load duke parents: diff changeset	432 }
a61af66fc99e Initial load duke parents: diff changeset	433 }
a61af66fc99e Initial load duke parents: diff changeset	434 // Further assume size is padded out to words
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	435 void *Amalloc_4(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
0 a61af66fc99e Initial load duke parents: diff changeset	436 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" );
a61af66fc99e Initial load duke parents: diff changeset	437 debug_only(if (UseMallocOnly) return malloc(x);)
11009 f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	438 if (!check_for_overflow(x, "Arena::Amalloc_4", alloc_failmode))
f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	439 return NULL;
2250 f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	440 NOT_PRODUCT(inc_bytes_allocated(x);)
0 a61af66fc99e Initial load duke parents: diff changeset	441 if (_hwm + x > _max) {
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	442 return grow(x, alloc_failmode);
0 a61af66fc99e Initial load duke parents: diff changeset	443 } else {
a61af66fc99e Initial load duke parents: diff changeset	444 char *old = _hwm;
a61af66fc99e Initial load duke parents: diff changeset	445 _hwm += x;
a61af66fc99e Initial load duke parents: diff changeset	446 return old;
a61af66fc99e Initial load duke parents: diff changeset	447 }
a61af66fc99e Initial load duke parents: diff changeset	448 }
a61af66fc99e Initial load duke parents: diff changeset	449
a61af66fc99e Initial load duke parents: diff changeset	450 // Allocate with 'double' alignment. It is 8 bytes on sparc.
a61af66fc99e Initial load duke parents: diff changeset	451 // In other cases Amalloc_D() should be the same as Amalloc_4().
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	452 void* Amalloc_D(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) {
0 a61af66fc99e Initial load duke parents: diff changeset	453 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" );
a61af66fc99e Initial load duke parents: diff changeset	454 debug_only(if (UseMallocOnly) return malloc(x);)
a61af66fc99e Initial load duke parents: diff changeset	455 #if defined(SPARC) && !defined(_LP64)
a61af66fc99e Initial load duke parents: diff changeset	456 #define DALIGN_M1 7
a61af66fc99e Initial load duke parents: diff changeset	457 size_t delta = (((size_t)_hwm + DALIGN_M1) & ~DALIGN_M1) - (size_t)_hwm;
a61af66fc99e Initial load duke parents: diff changeset	458 x += delta;
a61af66fc99e Initial load duke parents: diff changeset	459 #endif
11009 f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	460 if (!check_for_overflow(x, "Arena::Amalloc_D", alloc_failmode))
f75faf51e8c4 7158805: Better rewriting of nested subroutine calls hseigel parents: 9073 diff changeset	461 return NULL;
2250 f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	462 NOT_PRODUCT(inc_bytes_allocated(x);)
0 a61af66fc99e Initial load duke parents: diff changeset	463 if (_hwm + x > _max) {
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	464 return grow(x, alloc_failmode); // grow() returns a result aligned >= 8 bytes.
0 a61af66fc99e Initial load duke parents: diff changeset	465 } else {
a61af66fc99e Initial load duke parents: diff changeset	466 char *old = _hwm;
a61af66fc99e Initial load duke parents: diff changeset	467 _hwm += x;
a61af66fc99e Initial load duke parents: diff changeset	468 #if defined(SPARC) && !defined(_LP64)
a61af66fc99e Initial load duke parents: diff changeset	469 old += delta; // align to 8-bytes
a61af66fc99e Initial load duke parents: diff changeset	470 #endif
a61af66fc99e Initial load duke parents: diff changeset	471 return old;
a61af66fc99e Initial load duke parents: diff changeset	472 }
a61af66fc99e Initial load duke parents: diff changeset	473 }
a61af66fc99e Initial load duke parents: diff changeset	474
a61af66fc99e Initial load duke parents: diff changeset	475 // Fast delete in area. Common case is: NOP (except for storage reclaimed)
a61af66fc99e Initial load duke parents: diff changeset	476 void Afree(void *ptr, size_t size) {
a61af66fc99e Initial load duke parents: diff changeset	477 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	478 if (ZapResourceArea) memset(ptr, badResourceValue, size); // zap freed memory
a61af66fc99e Initial load duke parents: diff changeset	479 if (UseMallocOnly) return;
a61af66fc99e Initial load duke parents: diff changeset	480 #endif
a61af66fc99e Initial load duke parents: diff changeset	481 if (((char)ptr) + size == _hwm) _hwm = (char)ptr;
a61af66fc99e Initial load duke parents: diff changeset	482 }
a61af66fc99e Initial load duke parents: diff changeset	483
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	484 void Arealloc( void old_ptr, size_t old_size, size_t new_size,
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	485 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
0 a61af66fc99e Initial load duke parents: diff changeset	486
a61af66fc99e Initial load duke parents: diff changeset	487 // Move contents of this arena into an empty arena
a61af66fc99e Initial load duke parents: diff changeset	488 Arena move_contents(Arena empty_arena);
a61af66fc99e Initial load duke parents: diff changeset	489
a61af66fc99e Initial load duke parents: diff changeset	490 // Determine if pointer belongs to this Arena or not.
a61af66fc99e Initial load duke parents: diff changeset	491 bool contains( const void *ptr ) const;
a61af66fc99e Initial load duke parents: diff changeset	492
a61af66fc99e Initial load duke parents: diff changeset	493 // Total of all chunks in use (not thread-safe)
a61af66fc99e Initial load duke parents: diff changeset	494 size_t used() const;
a61af66fc99e Initial load duke parents: diff changeset	495
a61af66fc99e Initial load duke parents: diff changeset	496 // Total # of bytes used
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	497 size_t size_in_bytes() const { return _size_in_bytes; };
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	498 void set_size_in_bytes(size_t size);
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	499
0 a61af66fc99e Initial load duke parents: diff changeset	500 static void free_malloced_objects(Chunk* chunk, char* hwm, char* max, char* hwm2) PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	501 static void free_all(char start, char end) PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	502
a61af66fc99e Initial load duke parents: diff changeset	503 private:
a61af66fc99e Initial load duke parents: diff changeset	504 // Reset this Arena to empty, access will trigger grow if necessary
a61af66fc99e Initial load duke parents: diff changeset	505 void reset(void) {
a61af66fc99e Initial load duke parents: diff changeset	506 _first = _chunk = NULL;
a61af66fc99e Initial load duke parents: diff changeset	507 _hwm = _max = NULL;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	508 set_size_in_bytes(0);
0 a61af66fc99e Initial load duke parents: diff changeset	509 }
a61af66fc99e Initial load duke parents: diff changeset	510 };
a61af66fc99e Initial load duke parents: diff changeset	511
a61af66fc99e Initial load duke parents: diff changeset	512 // One of the following macros must be used when allocating
a61af66fc99e Initial load duke parents: diff changeset	513 // an array or object from an arena
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1689 diff changeset	514 #define NEW_ARENA_ARRAY(arena, type, size) \
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1689 diff changeset	515 (type) (arena)->Amalloc((size) sizeof(type))
0 a61af66fc99e Initial load duke parents: diff changeset	516
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1689 diff changeset	517 #define REALLOC_ARENA_ARRAY(arena, type, old, old_size, new_size) \
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1689 diff changeset	518 (type) (arena)->Arealloc((char)(old), (old_size) * sizeof(type), \
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1689 diff changeset	519 (new_size) * sizeof(type) )
0 a61af66fc99e Initial load duke parents: diff changeset	520
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1689 diff changeset	521 #define FREE_ARENA_ARRAY(arena, type, old, size) \
894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1689 diff changeset	522 (arena)->Afree((char)(old), (size) sizeof(type))
0 a61af66fc99e Initial load duke parents: diff changeset	523
1836 894b1d7c7e01 6423256: GC stacks should use a better data structure jcoomes parents: 1689 diff changeset	524 #define NEW_ARENA_OBJ(arena, type) \
0 a61af66fc99e Initial load duke parents: diff changeset	525 NEW_ARENA_ARRAY(arena, type, 1)
a61af66fc99e Initial load duke parents: diff changeset	526
a61af66fc99e Initial load duke parents: diff changeset	527
a61af66fc99e Initial load duke parents: diff changeset	528 //%note allocation_1
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	529 extern char* resource_allocate_bytes(size_t size,
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	530 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	531 extern char* resource_allocate_bytes(Thread* thread, size_t size,
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	532 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	533 extern char* resource_reallocate_bytes( char *old, size_t old_size, size_t new_size,
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	534 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM);
0 a61af66fc99e Initial load duke parents: diff changeset	535 extern void resource_free_bytes( char *old, size_t size );
a61af66fc99e Initial load duke parents: diff changeset	536
a61af66fc99e Initial load duke parents: diff changeset	537 //----------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	538 // Base class for objects allocated in the resource area per default.
a61af66fc99e Initial load duke parents: diff changeset	539 // Optionally, objects may be allocated on the C heap with
a61af66fc99e Initial load duke parents: diff changeset	540 // new(ResourceObj::C_HEAP) Foo(...) or in an Arena with new (&arena)
a61af66fc99e Initial load duke parents: diff changeset	541 // ResourceObj's can be allocated within other objects, but don't use
a61af66fc99e Initial load duke parents: diff changeset	542 // new or delete (allocation_type is unknown). If new is used to allocate,
a61af66fc99e Initial load duke parents: diff changeset	543 // use delete to deallocate.
a61af66fc99e Initial load duke parents: diff changeset	544 class ResourceObj ALLOCATION_SUPER_CLASS_SPEC {
a61af66fc99e Initial load duke parents: diff changeset	545 public:
1685 0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	546 enum allocation_type { STACK_OR_EMBEDDED = 0, RESOURCE_AREA, C_HEAP, ARENA, allocation_mask = 0x3 };
1688 2dfd013a7465 6975078: assert(allocated_on_res_area() \|\| allocated_on_C_heap() \|\| allocated_on_arena() kvn parents: 1685 diff changeset	547 static void set_allocation_type(address res, allocation_type type) NOT_DEBUG_RETURN;
0 a61af66fc99e Initial load duke parents: diff changeset	548 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	549 private:
1685 0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	550 // When this object is allocated on stack the new() operator is not
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	551 // called but garbage on stack may look like a valid allocation_type.
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	552 // Store negated 'this' pointer when new() is called to distinguish cases.
2015 79d8657be916 6993125: runThese crashes with assert(Thread::current()->on_local_stack((address)this)) kvn parents: 1972 diff changeset	553 // Use second array's element for verification value to distinguish garbage.
79d8657be916 6993125: runThese crashes with assert(Thread::current()->on_local_stack((address)this)) kvn parents: 1972 diff changeset	554 uintptr_t _allocation_t[2];
79d8657be916 6993125: runThese crashes with assert(Thread::current()->on_local_stack((address)this)) kvn parents: 1972 diff changeset	555 bool is_type_set() const;
0 a61af66fc99e Initial load duke parents: diff changeset	556 public:
1688 2dfd013a7465 6975078: assert(allocated_on_res_area() \|\| allocated_on_C_heap() \|\| allocated_on_arena() kvn parents: 1685 diff changeset	557 allocation_type get_allocation_type() const;
2dfd013a7465 6975078: assert(allocated_on_res_area() \|\| allocated_on_C_heap() \|\| allocated_on_arena() kvn parents: 1685 diff changeset	558 bool allocated_on_stack() const { return get_allocation_type() == STACK_OR_EMBEDDED; }
2dfd013a7465 6975078: assert(allocated_on_res_area() \|\| allocated_on_C_heap() \|\| allocated_on_arena() kvn parents: 1685 diff changeset	559 bool allocated_on_res_area() const { return get_allocation_type() == RESOURCE_AREA; }
2dfd013a7465 6975078: assert(allocated_on_res_area() \|\| allocated_on_C_heap() \|\| allocated_on_arena() kvn parents: 1685 diff changeset	560 bool allocated_on_C_heap() const { return get_allocation_type() == C_HEAP; }
2dfd013a7465 6975078: assert(allocated_on_res_area() \|\| allocated_on_C_heap() \|\| allocated_on_arena() kvn parents: 1685 diff changeset	561 bool allocated_on_arena() const { return get_allocation_type() == ARENA; }
1685 0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	562 ResourceObj(); // default construtor
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	563 ResourceObj(const ResourceObj& r); // default copy construtor
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	564 ResourceObj& operator=(const ResourceObj& r); // default copy assignment
0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	565 ~ResourceObj();
0 a61af66fc99e Initial load duke parents: diff changeset	566 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	567
a61af66fc99e Initial load duke parents: diff changeset	568 public:
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	569 void* operator new(size_t size, allocation_type type, MEMFLAGS flags) throw();
9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	570 void* operator new [](size_t size, allocation_type type, MEMFLAGS flags) throw();
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	571 void* operator new(size_t size, const std::nothrow_t& nothrow_constant,
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	572 allocation_type type, MEMFLAGS flags) throw();
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	573 void* operator new [](size_t size, const std::nothrow_t& nothrow_constant,
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	574 allocation_type type, MEMFLAGS flags) throw();
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	575
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	576 void* operator new(size_t size, Arena *arena) throw() {
0 a61af66fc99e Initial load duke parents: diff changeset	577 address res = (address)arena->Amalloc(size);
1685 0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	578 DEBUG_ONLY(set_allocation_type(res, ARENA);)
0 a61af66fc99e Initial load duke parents: diff changeset	579 return res;
a61af66fc99e Initial load duke parents: diff changeset	580 }
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	581
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	582 void* operator new [](size_t size, Arena *arena) throw() {
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	583 address res = (address)arena->Amalloc(size);
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	584 DEBUG_ONLY(set_allocation_type(res, ARENA);)
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	585 return res;
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	586 }
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	587
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	588 void* operator new(size_t size) throw() {
0 a61af66fc99e Initial load duke parents: diff changeset	589 address res = (address)resource_allocate_bytes(size);
1685 0e35fa8ebccd 6973963: SEGV in ciBlock::start_bci() with EA kvn parents: 1552 diff changeset	590 DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);)
0 a61af66fc99e Initial load duke parents: diff changeset	591 return res;
a61af66fc99e Initial load duke parents: diff changeset	592 }
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	593
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	594 void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {
6872 7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	595 address res = (address)resource_allocate_bytes(size, AllocFailStrategy::RETURN_NULL);
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	596 DEBUG_ONLY(if (res != NULL) set_allocation_type(res, RESOURCE_AREA);)
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	597 return res;
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	598 }
7b5885dadbdc 8000617: It should be possible to allocate memory without the VM dying. nloodin parents: 6854 diff changeset	599
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	600 void* operator new [](size_t size) throw() {
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	601 address res = (address)resource_allocate_bytes(size);
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	602 DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);)
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	603 return res;
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	604 }
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	605
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12109 diff changeset	606 void* operator new [](size_t size, const std::nothrow_t& nothrow_constant) throw() {
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	607 address res = (address)resource_allocate_bytes(size, AllocFailStrategy::RETURN_NULL);
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	608 DEBUG_ONLY(if (res != NULL) set_allocation_type(res, RESOURCE_AREA);)
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	609 return res;
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	610 }
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	611
0 a61af66fc99e Initial load duke parents: diff changeset	612 void operator delete(void* p);
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	613 void operator delete [](void* p);
0 a61af66fc99e Initial load duke parents: diff changeset	614 };
a61af66fc99e Initial load duke parents: diff changeset	615
a61af66fc99e Initial load duke parents: diff changeset	616 // One of the following macros must be used when allocating an array
a61af66fc99e Initial load duke parents: diff changeset	617 // or object to determine whether it should reside in the C heap on in
a61af66fc99e Initial load duke parents: diff changeset	618 // the resource area.
a61af66fc99e Initial load duke parents: diff changeset	619
a61af66fc99e Initial load duke parents: diff changeset	620 #define NEW_RESOURCE_ARRAY(type, size)\
a61af66fc99e Initial load duke parents: diff changeset	621 (type) resource_allocate_bytes((size) sizeof(type))
a61af66fc99e Initial load duke parents: diff changeset	622
10155 f258c5828eb8 8011773: Some tests on Interned String crashed JVM with OOM hseigel parents: 10136 diff changeset	623 #define NEW_RESOURCE_ARRAY_RETURN_NULL(type, size)\
f258c5828eb8 8011773: Some tests on Interned String crashed JVM with OOM hseigel parents: 10136 diff changeset	624 (type) resource_allocate_bytes((size) sizeof(type), AllocFailStrategy::RETURN_NULL)
f258c5828eb8 8011773: Some tests on Interned String crashed JVM with OOM hseigel parents: 10136 diff changeset	625
0 a61af66fc99e Initial load duke parents: diff changeset	626 #define NEW_RESOURCE_ARRAY_IN_THREAD(thread, type, size)\
a61af66fc99e Initial load duke parents: diff changeset	627 (type) resource_allocate_bytes(thread, (size) sizeof(type))
a61af66fc99e Initial load duke parents: diff changeset	628
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	629 #define NEW_RESOURCE_ARRAY_IN_THREAD_RETURN_NULL(thread, type, size)\
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	630 (type) resource_allocate_bytes(thread, (size) sizeof(type), AllocFailStrategy::RETURN_NULL)
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	631
0 a61af66fc99e Initial load duke parents: diff changeset	632 #define REALLOC_RESOURCE_ARRAY(type, old, old_size, new_size)\
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	633 (type) resource_reallocate_bytes((char)(old), (old_size) * sizeof(type), (new_size) * sizeof(type))
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	634
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	635 #define REALLOC_RESOURCE_ARRAY_RETURN_NULL(type, old, old_size, new_size)\
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	636 (type) resource_reallocate_bytes((char)(old), (old_size) * sizeof(type),\
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	637 (new_size) * sizeof(type), AllocFailStrategy::RETURN_NULL)
0 a61af66fc99e Initial load duke parents: diff changeset	638
a61af66fc99e Initial load duke parents: diff changeset	639 #define FREE_RESOURCE_ARRAY(type, old, size)\
a61af66fc99e Initial load duke parents: diff changeset	640 resource_free_bytes((char)(old), (size) sizeof(type))
a61af66fc99e Initial load duke parents: diff changeset	641
a61af66fc99e Initial load duke parents: diff changeset	642 #define FREE_FAST(old)\
a61af66fc99e Initial load duke parents: diff changeset	643 /* nop */
a61af66fc99e Initial load duke parents: diff changeset	644
a61af66fc99e Initial load duke parents: diff changeset	645 #define NEW_RESOURCE_OBJ(type)\
a61af66fc99e Initial load duke parents: diff changeset	646 NEW_RESOURCE_ARRAY(type, 1)
a61af66fc99e Initial load duke parents: diff changeset	647
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	648 #define NEW_RESOURCE_OBJ_RETURN_NULL(type)\
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	649 NEW_RESOURCE_ARRAY_RETURN_NULL(type, 1)
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	650
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	651 #define NEW_C_HEAP_ARRAY3(type, size, memflags, pc, allocfail)\
12109 faf2631b9334 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM dsimms parents: 11095 diff changeset	652 (type) AllocateHeap((size) sizeof(type), memflags, pc, allocfail)
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	653
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	654 #define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	655 (type) (AllocateHeap((size) sizeof(type), memflags, pc))
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	656
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	657 #define NEW_C_HEAP_ARRAY(type, size, memflags)\
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	658 (type) (AllocateHeap((size) sizeof(type), memflags))
0 a61af66fc99e Initial load duke parents: diff changeset	659
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	660 #define NEW_C_HEAP_ARRAY2_RETURN_NULL(type, size, memflags, pc)\
12109 faf2631b9334 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM dsimms parents: 11095 diff changeset	661 NEW_C_HEAP_ARRAY3(type, (size), memflags, pc, AllocFailStrategy::RETURN_NULL)
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	662
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	663 #define NEW_C_HEAP_ARRAY_RETURN_NULL(type, size, memflags)\
20360 833b0f92429a 8046598: Scalable Native memory tracking development zgu parents: 17799 diff changeset	664 NEW_C_HEAP_ARRAY3(type, (size), memflags, CURRENT_PC, AllocFailStrategy::RETURN_NULL)
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	665
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	666 #define REALLOC_C_HEAP_ARRAY(type, old, size, memflags)\
12109 faf2631b9334 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM dsimms parents: 11095 diff changeset	667 (type) (ReallocateHeap((char)(old), (size) * sizeof(type), memflags))
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	668
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	669 #define REALLOC_C_HEAP_ARRAY_RETURN_NULL(type, old, size, memflags)\
12109 faf2631b9334 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM dsimms parents: 11095 diff changeset	670 (type) (ReallocateHeap((char)(old), (size) * sizeof(type), memflags, AllocFailStrategy::RETURN_NULL))
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	671
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	672 #define FREE_C_HEAP_ARRAY(type, old, memflags) \
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 3939 diff changeset	673 FreeHeap((char*)(old), memflags)
0 a61af66fc99e Initial load duke parents: diff changeset	674
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	675 // allocate type in heap without calling ctor
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	676 #define NEW_C_HEAP_OBJ(type, memflags)\
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	677 NEW_C_HEAP_ARRAY(type, 1, memflags)
0 a61af66fc99e Initial load duke parents: diff changeset	678
10983 abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	679 #define NEW_C_HEAP_OBJ_RETURN_NULL(type, memflags)\
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	680 NEW_C_HEAP_ARRAY_RETURN_NULL(type, 1, memflags)
abbd5c660b48 8016105: Add complementary RETURN_NULL allocation macros in allocation.hpp mgronlun parents: 10405 diff changeset	681
10271 f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	682 // deallocate obj of type in heap without calling dtor
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	683 #define FREE_C_HEAP_OBJ(objname, memflags)\
f9be75d21404 8012902: remove use of global operator new - take 2 minqi parents: 10155 diff changeset	684 FreeHeap((char*)objname, memflags);
0 a61af66fc99e Initial load duke parents: diff changeset	685
a61af66fc99e Initial load duke parents: diff changeset	686 // for statistics
a61af66fc99e Initial load duke parents: diff changeset	687 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	688 class AllocStats : StackObj {
2250 f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	689 julong start_mallocs, start_frees;
f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	690 julong start_malloc_bytes, start_mfree_bytes, start_res_bytes;
0 a61af66fc99e Initial load duke parents: diff changeset	691 public:
a61af66fc99e Initial load duke parents: diff changeset	692 AllocStats();
a61af66fc99e Initial load duke parents: diff changeset	693
2250 f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	694 julong num_mallocs(); // since creation of receiver
f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	695 julong alloc_bytes();
f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	696 julong num_frees();
f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	697 julong free_bytes();
f7de3327c683 7017124: Fix some VM stats to avoid 32-bit overflow kvn parents: 2015 diff changeset	698 julong resource_bytes();
0 a61af66fc99e Initial load duke parents: diff changeset	699 void print();
a61af66fc99e Initial load duke parents: diff changeset	700 };
a61af66fc99e Initial load duke parents: diff changeset	701 #endif
a61af66fc99e Initial load duke parents: diff changeset	702
a61af66fc99e Initial load duke parents: diff changeset	703
a61af66fc99e Initial load duke parents: diff changeset	704 //------------------------------ReallocMark---------------------------------
a61af66fc99e Initial load duke parents: diff changeset	705 // Code which uses REALLOC_RESOURCE_ARRAY should check an associated
a61af66fc99e Initial load duke parents: diff changeset	706 // ReallocMark, which is declared in the same scope as the reallocated
a61af66fc99e Initial load duke parents: diff changeset	707 // pointer. Any operation that could __potentially__ cause a reallocation
a61af66fc99e Initial load duke parents: diff changeset	708 // should check the ReallocMark.
a61af66fc99e Initial load duke parents: diff changeset	709 class ReallocMark: public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	710 protected:
a61af66fc99e Initial load duke parents: diff changeset	711 NOT_PRODUCT(int _nesting;)
a61af66fc99e Initial load duke parents: diff changeset	712
a61af66fc99e Initial load duke parents: diff changeset	713 public:
a61af66fc99e Initial load duke parents: diff changeset	714 ReallocMark() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	715 void check() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	716 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	717
9073 83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	718 // Helper class to allocate arrays that may become large.
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	719 // Uses the OS malloc for allocations smaller than ArrayAllocatorMallocLimit
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	720 // and uses mapped memory for larger allocations.
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	721 // Most OS mallocs do something similar but Solaris malloc does not revert
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	722 // to mapped memory for large allocations. By default ArrayAllocatorMallocLimit
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	723 // is set so that we always use malloc except for Solaris where we set the
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	724 // limit to get mapped memory.
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	725 template <class E, MEMFLAGS F>
10992 b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	726 class ArrayAllocator VALUE_OBJ_CLASS_SPEC {
9073 83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	727 char* _addr;
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	728 bool _use_malloc;
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	729 size_t _size;
10992 b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	730 bool _free_in_destructor;
9073 83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	731 public:
10992 b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	732 ArrayAllocator(bool free_in_destructor = true) :
b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	733 _addr(NULL), _use_malloc(false), _size(0), _free_in_destructor(free_in_destructor) { }
b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	734
b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	735 ~ArrayAllocator() {
b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	736 if (_free_in_destructor) {
b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	737 free();
b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	738 }
b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	739 }
b9d151496930 8016556: G1: Use ArrayAllocator for BitMaps brutisso parents: 10405 diff changeset	740
9073 83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	741 E* allocate(size_t length);
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	742 void free();
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	743 };
83f27710f5f7 7197666: java -d64 -version core dumps in a box with lots of memory brutisso parents: 7971 diff changeset	744
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1836 diff changeset	745 #endif // SHARE_VM_MEMORY_ALLOCATION_HPP

Mercurial > hg > truffle

annotate src/share/vm/memory/allocation.hpp @ 20375:6e0cb14ce59b