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

annotate src/share/vm/memory/allocation.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	6e0cb14ce59b
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 @ 20543:e7d0505c8a30