Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/allocation.hpp @ 8804:91bf0bdae37b
8008217: CDS: Class data sharing limits the malloc heap on Solaris
Summary: In 64bit VM move CDS archive address to 32G on all platforms using new flag SharedBaseAddress. In 32bit VM set CDS archive address to 3Gb on Linux and let other OSs pick the address.
Reviewed-by: kvn, dcubed, zgu, hseigel
| author | coleenp |
|---|---|
| date | Wed, 20 Mar 2013 08:04:54 -0400 |
| parents | 4102b59539ce |
| children | 5fc51c1ecdeb 83f27710f5f7 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 6197 | 2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_MEMORY_ALLOCATION_HPP |
| 26 #define SHARE_VM_MEMORY_ALLOCATION_HPP | |
| 27 | |
| 28 #include "runtime/globals.hpp" | |
| 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 | 31 #ifdef COMPILER1 |
| 32 #include "c1/c1_globals.hpp" | |
| 33 #endif | |
| 34 #ifdef COMPILER2 | |
| 35 #include "opto/c2_globals.hpp" | |
| 36 #endif | |
| 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 | 40 #define ARENA_ALIGN_M1 (((size_t)(ARENA_AMALLOC_ALIGNMENT)) - 1) |
| 41 #define ARENA_ALIGN_MASK (~((size_t)ARENA_ALIGN_M1)) | |
| 42 #define ARENA_ALIGN(x) ((((size_t)(x)) + ARENA_ALIGN_M1) & ARENA_ALIGN_MASK) | |
| 43 | |
| 6197 | 44 |
| 45 // noinline attribute | |
| 46 #ifdef _WINDOWS | |
| 47 #define _NOINLINE_ __declspec(noinline) | |
| 48 #else | |
| 49 #if __GNUC__ < 3 // gcc 2.x does not support noinline attribute | |
| 50 #define _NOINLINE_ | |
| 51 #else | |
| 52 #define _NOINLINE_ __attribute__ ((noinline)) | |
| 53 #endif | |
| 54 #endif | |
| 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 | 62 // All classes in the virtual machine must be subclassed |
| 63 // by one of the following allocation classes: | |
| 64 // | |
| 65 // For objects allocated in the resource area (see resourceArea.hpp). | |
| 66 // - ResourceObj | |
| 67 // | |
| 68 // For objects allocated in the C-heap (managed by: free & malloc). | |
| 69 // - CHeapObj | |
| 70 // | |
| 71 // For objects allocated on the stack. | |
| 72 // - StackObj | |
| 73 // | |
| 74 // For embedded objects. | |
| 75 // - ValueObj | |
| 76 // | |
| 77 // For classes used as name spaces. | |
| 78 // - AllStatic | |
| 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 | 83 // The printable subclasses are used for debugging and define virtual |
| 84 // member functions for printing. Classes that avoid allocating the | |
| 85 // vtbl entries in the objects should therefore not be the printable | |
| 86 // subclasses. | |
| 87 // | |
| 88 // The following macros and function should be used to allocate memory | |
| 89 // directly in the resource area or in the C-heap: | |
| 90 // | |
| 91 // NEW_RESOURCE_ARRAY(type,size) | |
| 92 // NEW_RESOURCE_OBJ(type) | |
| 93 // NEW_C_HEAP_ARRAY(type,size) | |
| 94 // NEW_C_HEAP_OBJ(type) | |
| 95 // char* AllocateHeap(size_t size, const char* name); | |
| 96 // void FreeHeap(void* p); | |
| 97 // | |
| 98 // C-heap allocation can be traced using +PrintHeapAllocation. | |
| 99 // malloc and free should therefore never called directly. | |
| 100 | |
| 101 // Base class for objects allocated in the C-heap. | |
| 102 | |
| 103 // In non product mode we introduce a super class for all allocation classes | |
| 104 // that supports printing. | |
| 105 // We avoid the superclass in product mode since some C++ compilers add | |
| 106 // a word overhead for empty super classes. | |
| 107 | |
| 108 #ifdef PRODUCT | |
| 109 #define ALLOCATION_SUPER_CLASS_SPEC | |
| 110 #else | |
| 111 #define ALLOCATION_SUPER_CLASS_SPEC : public AllocatedObj | |
| 112 class AllocatedObj { | |
| 113 public: | |
| 114 // Printing support | |
| 115 void print() const; | |
| 116 void print_value() const; | |
| 117 | |
| 118 virtual void print_on(outputStream* st) const; | |
| 119 virtual void print_value_on(outputStream* st) const; | |
| 120 }; | |
| 121 #endif | |
| 122 | |
| 6197 | 123 |
| 124 /* | |
| 125 * MemoryType bitmap layout: | |
| 126 * | 16 15 14 13 12 11 10 09 | 08 07 06 05 | 04 03 02 01 | | |
| 127 * | memory type | object | reserved | | |
| 128 * | | type | | | |
| 129 */ | |
| 130 enum MemoryType { | |
| 131 // Memory type by sub systems. It occupies lower byte. | |
| 132 mtNone = 0x0000, // undefined | |
| 133 mtClass = 0x0100, // memory class for Java classes | |
| 134 mtThread = 0x0200, // memory for thread objects | |
| 135 mtThreadStack = 0x0300, | |
| 136 mtCode = 0x0400, // memory for generated code | |
| 137 mtGC = 0x0500, // memory for GC | |
| 138 mtCompiler = 0x0600, // memory for compiler | |
| 139 mtInternal = 0x0700, // memory used by VM, but does not belong to | |
| 140 // any of above categories, and not used for | |
| 141 // native memory tracking | |
| 142 mtOther = 0x0800, // memory not used by VM | |
| 143 mtSymbol = 0x0900, // symbol | |
| 144 mtNMT = 0x0A00, // memory used by native memory tracking | |
| 145 mtChunk = 0x0B00, // chunk that holds content of arenas | |
| 146 mtJavaHeap = 0x0C00, // Java heap | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6872
diff
changeset
|
147 mtClassShared = 0x0D00, // class data sharing |
|
7971
4102b59539ce
8005012: Add WB APIs to better support NMT testing
ctornqvi
parents:
7434
diff
changeset
|
148 mtTest = 0x0E00, // Test type for verifying NMT |
|
4102b59539ce
8005012: Add WB APIs to better support NMT testing
ctornqvi
parents:
7434
diff
changeset
|
149 mt_number_of_types = 0x000E, // number of memory types (mtDontTrack |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6872
diff
changeset
|
150 // is not included as validate type) |
|
7971
4102b59539ce
8005012: Add WB APIs to better support NMT testing
ctornqvi
parents:
7434
diff
changeset
|
151 mtDontTrack = 0x0F00, // memory we do not or cannot track |
| 6197 | 152 mt_masks = 0x7F00, |
| 153 | |
| 154 // object type mask | |
| 155 otArena = 0x0010, // an arena object | |
| 156 otNMTRecorder = 0x0020, // memory recorder object | |
| 157 ot_masks = 0x00F0 | |
| 158 }; | |
| 159 | |
| 160 #define IS_MEMORY_TYPE(flags, type) ((flags & mt_masks) == type) | |
| 161 #define HAS_VALID_MEMORY_TYPE(flags)((flags & mt_masks) != mtNone) | |
| 162 #define FLAGS_TO_MEMORY_TYPE(flags) (flags & mt_masks) | |
| 163 | |
| 164 #define IS_ARENA_OBJ(flags) ((flags & ot_masks) == otArena) | |
| 165 #define IS_NMT_RECORDER(flags) ((flags & ot_masks) == otNMTRecorder) | |
| 166 #define NMT_CAN_TRACK(flags) (!IS_NMT_RECORDER(flags) && !(IS_MEMORY_TYPE(flags, mtDontTrack))) | |
| 167 | |
| 168 typedef unsigned short MEMFLAGS; | |
| 169 | |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
170 #if INCLUDE_NMT |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
171 |
| 6197 | 172 extern bool NMT_track_callsite; |
| 173 | |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
174 #else |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
175 |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
176 const bool NMT_track_callsite = false; |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
177 |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
178 #endif // INCLUDE_NMT |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
179 |
| 6197 | 180 // debug build does not inline |
| 181 #if defined(_DEBUG_) | |
| 182 #define CURRENT_PC (NMT_track_callsite ? os::get_caller_pc(1) : 0) | |
| 183 #define CALLER_PC (NMT_track_callsite ? os::get_caller_pc(2) : 0) | |
| 184 #define CALLER_CALLER_PC (NMT_track_callsite ? os::get_caller_pc(3) : 0) | |
| 185 #else | |
| 186 #define CURRENT_PC (NMT_track_callsite? os::get_caller_pc(0) : 0) | |
| 187 #define CALLER_PC (NMT_track_callsite ? os::get_caller_pc(1) : 0) | |
| 188 #define CALLER_CALLER_PC (NMT_track_callsite ? os::get_caller_pc(2) : 0) | |
| 189 #endif | |
| 190 | |
| 191 | |
| 192 | |
| 193 template <MEMFLAGS F> class CHeapObj ALLOCATION_SUPER_CLASS_SPEC { | |
| 0 | 194 public: |
| 6197 | 195 _NOINLINE_ void* operator new(size_t size, address caller_pc = 0); |
| 196 _NOINLINE_ void* operator new (size_t size, const std::nothrow_t& nothrow_constant, | |
| 197 address caller_pc = 0); | |
| 198 | |
| 0 | 199 void operator delete(void* p); |
| 200 }; | |
| 201 | |
| 202 // Base class for objects allocated on the stack only. | |
| 203 // Calling new or delete will result in fatal error. | |
| 204 | |
| 205 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
|
206 private: |
| 0 | 207 void* operator new(size_t size); |
| 208 void operator delete(void* p); | |
| 209 }; | |
| 210 | |
| 211 // Base class for objects used as value objects. | |
| 212 // Calling new or delete will result in fatal error. | |
| 213 // | |
| 214 // Portability note: Certain compilers (e.g. gcc) will | |
| 215 // always make classes bigger if it has a superclass, even | |
| 216 // if the superclass does not have any virtual methods or | |
| 217 // instance fields. The HotSpot implementation relies on this | |
| 218 // not to happen. So never make a ValueObj class a direct subclass | |
| 219 // of this object, but use the VALUE_OBJ_CLASS_SPEC class instead, e.g., | |
| 220 // like this: | |
| 221 // | |
| 222 // class A VALUE_OBJ_CLASS_SPEC { | |
| 223 // ... | |
| 224 // } | |
| 225 // | |
| 226 // With gcc and possible other compilers the VALUE_OBJ_CLASS_SPEC can | |
| 227 // be defined as a an empty string "". | |
| 228 // | |
| 229 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
|
230 private: |
| 0 | 231 void* operator new(size_t size); |
| 232 void operator delete(void* p); | |
| 233 }; | |
| 234 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
235 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
236 // Base class for objects stored in Metaspace. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
237 // Calling delete will result in fatal error. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
238 // |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
239 // 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
|
240 // 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
|
241 // and shared read-write classes. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
242 // |
|
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 class ClassLoaderData; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
245 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
246 class MetaspaceObj { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
247 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
248 bool is_metadata() const; |
|
7176
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6882
diff
changeset
|
249 bool is_metaspace_object() const; // more specific test but slower |
|
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 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
253 void* operator new(size_t size, ClassLoaderData* loader_data, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
254 size_t word_size, bool read_only, Thread* thread); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
255 // can't use TRAPS from this header file. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
256 void operator delete(void* p) { ShouldNotCallThis(); } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
257 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
258 |
| 0 | 259 // Base class for classes that constitute name spaces. |
| 260 | |
| 261 class AllStatic { | |
| 262 public: | |
| 263 AllStatic() { ShouldNotCallThis(); } | |
| 264 ~AllStatic() { ShouldNotCallThis(); } | |
| 265 }; | |
| 266 | |
| 267 | |
| 268 //------------------------------Chunk------------------------------------------ | |
| 269 // Linked list of raw memory chunks | |
| 6197 | 270 class Chunk: CHeapObj<mtChunk> { |
| 3939 | 271 friend class VMStructs; |
| 272 | |
| 0 | 273 protected: |
| 274 Chunk* _next; // Next Chunk in list | |
| 275 const size_t _len; // Size of this Chunk | |
| 276 public: | |
| 277 void* operator new(size_t size, size_t length); | |
| 278 void operator delete(void* p); | |
| 279 Chunk(size_t length); | |
| 280 | |
| 281 enum { | |
| 282 // default sizes; make them slightly smaller than 2**k to guard against | |
| 283 // buddy-system style malloc implementations | |
| 284 #ifdef _LP64 | |
| 285 slack = 40, // [RGV] Not sure if this is right, but make it | |
| 286 // a multiple of 8. | |
| 287 #else | |
| 288 slack = 20, // suspected sizeof(Chunk) + internal malloc headers | |
| 289 #endif | |
| 290 | |
| 291 init_size = 1*K - slack, // Size of first chunk | |
| 292 medium_size= 10*K - slack, // Size of medium-sized chunk | |
| 293 size = 32*K - slack, // Default size of an Arena chunk (following the first) | |
| 294 non_pool_size = init_size + 32 // An initial size which is not one of above | |
| 295 }; | |
| 296 | |
| 297 void chop(); // Chop this chunk | |
| 298 void next_chop(); // Chop next chunk | |
| 299 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
|
300 static size_t aligned_overhead_size(size_t byte_size) { return ARENA_ALIGN(byte_size); } |
| 0 | 301 |
| 302 size_t length() const { return _len; } | |
| 303 Chunk* next() const { return _next; } | |
| 304 void set_next(Chunk* n) { _next = n; } | |
| 305 // Boundaries of data area (possibly unused) | |
| 306 char* bottom() const { return ((char*) this) + aligned_overhead_size(); } | |
| 307 char* top() const { return bottom() + _len; } | |
| 308 bool contains(char* p) const { return bottom() <= p && p <= top(); } | |
| 309 | |
| 310 // Start the chunk_pool cleaner task | |
| 311 static void start_chunk_pool_cleaner_task(); | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
312 |
|
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
313 static void clean_chunk_pool(); |
| 0 | 314 }; |
| 315 | |
| 316 //------------------------------Arena------------------------------------------ | |
| 317 // Fast allocation of memory | |
| 6197 | 318 class Arena : public CHeapObj<mtNone|otArena> { |
| 0 | 319 protected: |
| 320 friend class ResourceMark; | |
| 321 friend class HandleMark; | |
| 322 friend class NoHandleMark; | |
| 3939 | 323 friend class VMStructs; |
| 324 | |
| 0 | 325 Chunk *_first; // First chunk |
| 326 Chunk *_chunk; // current chunk | |
| 327 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
|
328 // 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
|
329 void* grow(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
| 6197 | 330 size_t _size_in_bytes; // Size of arena (used for native memory tracking) |
| 331 | |
| 2250 | 332 NOT_PRODUCT(static julong _bytes_allocated;) // total #bytes allocated since start |
| 0 | 333 friend class AllocStats; |
| 334 debug_only(void* malloc(size_t size);) | |
| 335 debug_only(void* internal_malloc_4(size_t x);) | |
| 2250 | 336 NOT_PRODUCT(void inc_bytes_allocated(size_t x);) |
|
2307
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
337 |
|
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
338 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
|
339 |
|
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
340 void check_for_overflow(size_t request, const char* whence) const { |
|
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
341 if (UINTPTR_MAX - request < (uintptr_t)_hwm) { |
|
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
342 signal_out_of_memory(request, whence); |
|
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
343 } |
|
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
344 } |
|
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
345 |
| 0 | 346 public: |
| 347 Arena(); | |
| 348 Arena(size_t init_size); | |
| 349 ~Arena(); | |
| 350 void destruct_contents(); | |
| 351 char* hwm() const { return _hwm; } | |
| 352 | |
| 6197 | 353 // new operators |
| 354 void* operator new (size_t size); | |
| 355 void* operator new (size_t size, const std::nothrow_t& nothrow_constant); | |
| 356 | |
| 357 // dynamic memory type tagging | |
| 358 void* operator new(size_t size, MEMFLAGS flags); | |
| 359 void* operator new(size_t size, const std::nothrow_t& nothrow_constant, MEMFLAGS flags); | |
| 360 void operator delete(void* p); | |
| 361 | |
| 0 | 362 // 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
|
363 void* Amalloc(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) { |
| 0 | 364 assert(is_power_of_2(ARENA_AMALLOC_ALIGNMENT) , "should be a power of 2"); |
| 365 x = ARENA_ALIGN(x); | |
| 366 debug_only(if (UseMallocOnly) return malloc(x);) | |
|
2307
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
367 check_for_overflow(x, "Arena::Amalloc"); |
| 2250 | 368 NOT_PRODUCT(inc_bytes_allocated(x);) |
| 0 | 369 if (_hwm + x > _max) { |
|
6872
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
370 return grow(x, alloc_failmode); |
| 0 | 371 } else { |
| 372 char *old = _hwm; | |
| 373 _hwm += x; | |
| 374 return old; | |
| 375 } | |
| 376 } | |
| 377 // 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
|
378 void *Amalloc_4(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) { |
| 0 | 379 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" ); |
| 380 debug_only(if (UseMallocOnly) return malloc(x);) | |
|
2307
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
381 check_for_overflow(x, "Arena::Amalloc_4"); |
| 2250 | 382 NOT_PRODUCT(inc_bytes_allocated(x);) |
| 0 | 383 if (_hwm + x > _max) { |
|
6872
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
384 return grow(x, alloc_failmode); |
| 0 | 385 } else { |
| 386 char *old = _hwm; | |
| 387 _hwm += x; | |
| 388 return old; | |
| 389 } | |
| 390 } | |
| 391 | |
| 392 // Allocate with 'double' alignment. It is 8 bytes on sparc. | |
| 393 // 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
|
394 void* Amalloc_D(size_t x, AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) { |
| 0 | 395 assert( (x&(sizeof(char*)-1)) == 0, "misaligned size" ); |
| 396 debug_only(if (UseMallocOnly) return malloc(x);) | |
| 397 #if defined(SPARC) && !defined(_LP64) | |
| 398 #define DALIGN_M1 7 | |
| 399 size_t delta = (((size_t)_hwm + DALIGN_M1) & ~DALIGN_M1) - (size_t)_hwm; | |
| 400 x += delta; | |
| 401 #endif | |
|
2307
4a9604cd7c5f
6878713: Verifier heap corruption, relating to backward jsrs
kamg
parents:
2250
diff
changeset
|
402 check_for_overflow(x, "Arena::Amalloc_D"); |
| 2250 | 403 NOT_PRODUCT(inc_bytes_allocated(x);) |
| 0 | 404 if (_hwm + x > _max) { |
|
6872
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
405 return grow(x, alloc_failmode); // grow() returns a result aligned >= 8 bytes. |
| 0 | 406 } else { |
| 407 char *old = _hwm; | |
| 408 _hwm += x; | |
| 409 #if defined(SPARC) && !defined(_LP64) | |
| 410 old += delta; // align to 8-bytes | |
| 411 #endif | |
| 412 return old; | |
| 413 } | |
| 414 } | |
| 415 | |
| 416 // Fast delete in area. Common case is: NOP (except for storage reclaimed) | |
| 417 void Afree(void *ptr, size_t size) { | |
| 418 #ifdef ASSERT | |
| 419 if (ZapResourceArea) memset(ptr, badResourceValue, size); // zap freed memory | |
| 420 if (UseMallocOnly) return; | |
| 421 #endif | |
| 422 if (((char*)ptr) + size == _hwm) _hwm = (char*)ptr; | |
| 423 } | |
| 424 | |
|
6872
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
425 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
|
426 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
| 0 | 427 |
| 428 // Move contents of this arena into an empty arena | |
| 429 Arena *move_contents(Arena *empty_arena); | |
| 430 | |
| 431 // Determine if pointer belongs to this Arena or not. | |
| 432 bool contains( const void *ptr ) const; | |
| 433 | |
| 434 // Total of all chunks in use (not thread-safe) | |
| 435 size_t used() const; | |
| 436 | |
| 437 // Total # of bytes used | |
| 6197 | 438 size_t size_in_bytes() const { return _size_in_bytes; }; |
| 439 void set_size_in_bytes(size_t size); | |
| 440 | |
| 0 | 441 static void free_malloced_objects(Chunk* chunk, char* hwm, char* max, char* hwm2) PRODUCT_RETURN; |
| 442 static void free_all(char** start, char** end) PRODUCT_RETURN; | |
| 443 | |
| 6197 | 444 // how many arena instances |
| 445 NOT_PRODUCT(static volatile jint _instance_count;) | |
| 0 | 446 private: |
| 447 // Reset this Arena to empty, access will trigger grow if necessary | |
| 448 void reset(void) { | |
| 449 _first = _chunk = NULL; | |
| 450 _hwm = _max = NULL; | |
| 6197 | 451 set_size_in_bytes(0); |
| 0 | 452 } |
| 453 }; | |
| 454 | |
| 455 // One of the following macros must be used when allocating | |
| 456 // an array or object from an arena | |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1689
diff
changeset
|
457 #define NEW_ARENA_ARRAY(arena, type, size) \ |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1689
diff
changeset
|
458 (type*) (arena)->Amalloc((size) * sizeof(type)) |
| 0 | 459 |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1689
diff
changeset
|
460 #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
|
461 (type*) (arena)->Arealloc((char*)(old), (old_size) * sizeof(type), \ |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1689
diff
changeset
|
462 (new_size) * sizeof(type) ) |
| 0 | 463 |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1689
diff
changeset
|
464 #define FREE_ARENA_ARRAY(arena, type, old, size) \ |
|
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1689
diff
changeset
|
465 (arena)->Afree((char*)(old), (size) * sizeof(type)) |
| 0 | 466 |
|
1836
894b1d7c7e01
6423256: GC stacks should use a better data structure
jcoomes
parents:
1689
diff
changeset
|
467 #define NEW_ARENA_OBJ(arena, type) \ |
| 0 | 468 NEW_ARENA_ARRAY(arena, type, 1) |
| 469 | |
| 470 | |
| 471 //%note allocation_1 | |
|
6872
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
472 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
|
473 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
|
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
474 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
|
475 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
|
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
476 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
|
477 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM); |
| 0 | 478 extern void resource_free_bytes( char *old, size_t size ); |
| 479 | |
| 480 //---------------------------------------------------------------------- | |
| 481 // Base class for objects allocated in the resource area per default. | |
| 482 // Optionally, objects may be allocated on the C heap with | |
| 483 // new(ResourceObj::C_HEAP) Foo(...) or in an Arena with new (&arena) | |
| 484 // ResourceObj's can be allocated within other objects, but don't use | |
| 485 // new or delete (allocation_type is unknown). If new is used to allocate, | |
| 486 // use delete to deallocate. | |
| 487 class ResourceObj ALLOCATION_SUPER_CLASS_SPEC { | |
| 488 public: | |
| 1685 | 489 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
|
490 static void set_allocation_type(address res, allocation_type type) NOT_DEBUG_RETURN; |
| 0 | 491 #ifdef ASSERT |
| 492 private: | |
| 1685 | 493 // When this object is allocated on stack the new() operator is not |
| 494 // called but garbage on stack may look like a valid allocation_type. | |
| 495 // 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
|
496 // 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
|
497 uintptr_t _allocation_t[2]; |
|
79d8657be916
6993125: runThese crashes with assert(Thread::current()->on_local_stack((address)this))
kvn
parents:
1972
diff
changeset
|
498 bool is_type_set() const; |
| 0 | 499 public: |
|
1688
2dfd013a7465
6975078: assert(allocated_on_res_area() || allocated_on_C_heap() || allocated_on_arena()
kvn
parents:
1685
diff
changeset
|
500 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
|
501 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
|
502 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
|
503 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
|
504 bool allocated_on_arena() const { return get_allocation_type() == ARENA; } |
| 1685 | 505 ResourceObj(); // default construtor |
| 506 ResourceObj(const ResourceObj& r); // default copy construtor | |
| 507 ResourceObj& operator=(const ResourceObj& r); // default copy assignment | |
| 508 ~ResourceObj(); | |
| 0 | 509 #endif // ASSERT |
| 510 | |
| 511 public: | |
| 6197 | 512 void* operator new(size_t size, allocation_type type, MEMFLAGS flags); |
|
6872
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
513 void* operator new(size_t size, const std::nothrow_t& nothrow_constant, |
|
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
514 allocation_type type, MEMFLAGS flags); |
| 0 | 515 void* operator new(size_t size, Arena *arena) { |
| 516 address res = (address)arena->Amalloc(size); | |
| 1685 | 517 DEBUG_ONLY(set_allocation_type(res, ARENA);) |
| 0 | 518 return res; |
| 519 } | |
| 520 void* operator new(size_t size) { | |
| 521 address res = (address)resource_allocate_bytes(size); | |
| 1685 | 522 DEBUG_ONLY(set_allocation_type(res, RESOURCE_AREA);) |
| 0 | 523 return res; |
| 524 } | |
|
6872
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
525 |
|
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
526 void* operator new(size_t size, const std::nothrow_t& nothrow_constant) { |
|
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
527 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
|
528 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
|
529 return res; |
|
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
530 } |
|
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6854
diff
changeset
|
531 |
| 0 | 532 void operator delete(void* p); |
| 533 }; | |
| 534 | |
| 535 // One of the following macros must be used when allocating an array | |
| 536 // or object to determine whether it should reside in the C heap on in | |
| 537 // the resource area. | |
| 538 | |
| 539 #define NEW_RESOURCE_ARRAY(type, size)\ | |
| 540 (type*) resource_allocate_bytes((size) * sizeof(type)) | |
| 541 | |
| 542 #define NEW_RESOURCE_ARRAY_IN_THREAD(thread, type, size)\ | |
| 543 (type*) resource_allocate_bytes(thread, (size) * sizeof(type)) | |
| 544 | |
| 545 #define REALLOC_RESOURCE_ARRAY(type, old, old_size, new_size)\ | |
| 546 (type*) resource_reallocate_bytes((char*)(old), (old_size) * sizeof(type), (new_size) * sizeof(type) ) | |
| 547 | |
| 548 #define FREE_RESOURCE_ARRAY(type, old, size)\ | |
| 549 resource_free_bytes((char*)(old), (size) * sizeof(type)) | |
| 550 | |
| 551 #define FREE_FAST(old)\ | |
| 552 /* nop */ | |
| 553 | |
| 554 #define NEW_RESOURCE_OBJ(type)\ | |
| 555 NEW_RESOURCE_ARRAY(type, 1) | |
| 556 | |
| 6197 | 557 #define NEW_C_HEAP_ARRAY(type, size, memflags)\ |
| 558 (type*) (AllocateHeap((size) * sizeof(type), memflags)) | |
| 0 | 559 |
| 6197 | 560 #define REALLOC_C_HEAP_ARRAY(type, old, size, memflags)\ |
| 561 (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags)) | |
| 562 | |
| 563 #define FREE_C_HEAP_ARRAY(type,old,memflags) \ | |
| 564 FreeHeap((char*)(old), memflags) | |
| 0 | 565 |
| 6197 | 566 #define NEW_C_HEAP_OBJ(type, memflags)\ |
| 567 NEW_C_HEAP_ARRAY(type, 1, memflags) | |
| 568 | |
| 569 | |
| 570 #define NEW_C_HEAP_ARRAY2(type, size, memflags, pc)\ | |
| 571 (type*) (AllocateHeap((size) * sizeof(type), memflags, pc)) | |
| 0 | 572 |
| 6197 | 573 #define REALLOC_C_HEAP_ARRAY2(type, old, size, memflags, pc)\ |
| 574 (type*) (ReallocateHeap((char*)old, (size) * sizeof(type), memflags, pc)) | |
| 575 | |
| 576 #define NEW_C_HEAP_OBJ2(type, memflags, pc)\ | |
| 577 NEW_C_HEAP_ARRAY2(type, 1, memflags, pc) | |
| 578 | |
| 0 | 579 |
| 580 extern bool warn_new_operator; | |
| 581 | |
| 582 // for statistics | |
| 583 #ifndef PRODUCT | |
| 584 class AllocStats : StackObj { | |
| 2250 | 585 julong start_mallocs, start_frees; |
| 586 julong start_malloc_bytes, start_mfree_bytes, start_res_bytes; | |
| 0 | 587 public: |
| 588 AllocStats(); | |
| 589 | |
| 2250 | 590 julong num_mallocs(); // since creation of receiver |
| 591 julong alloc_bytes(); | |
| 592 julong num_frees(); | |
| 593 julong free_bytes(); | |
| 594 julong resource_bytes(); | |
| 0 | 595 void print(); |
| 596 }; | |
| 597 #endif | |
| 598 | |
| 599 | |
| 600 //------------------------------ReallocMark--------------------------------- | |
| 601 // Code which uses REALLOC_RESOURCE_ARRAY should check an associated | |
| 602 // ReallocMark, which is declared in the same scope as the reallocated | |
| 603 // pointer. Any operation that could __potentially__ cause a reallocation | |
| 604 // should check the ReallocMark. | |
| 605 class ReallocMark: public StackObj { | |
| 606 protected: | |
| 607 NOT_PRODUCT(int _nesting;) | |
| 608 | |
| 609 public: | |
| 610 ReallocMark() PRODUCT_RETURN; | |
| 611 void check() PRODUCT_RETURN; | |
| 612 }; | |
| 1972 | 613 |
| 614 #endif // SHARE_VM_MEMORY_ALLOCATION_HPP |