Mercurial > hg > truffle
annotate src/share/vm/memory/allocation.inline.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 | 833b0f92429a |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 20360 | 2 * Copyright (c) 1997, 2014, 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:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
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:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_MEMORY_ALLOCATION_INLINE_HPP |
| 26 #define SHARE_VM_MEMORY_ALLOCATION_INLINE_HPP | |
| 27 | |
|
8675
63e54c37ac64
8008959: Fix non-PCH build on Linux, Windows and MacOS X
simonis
parents:
6872
diff
changeset
|
28 #include "runtime/atomic.inline.hpp" |
| 1972 | 29 #include "runtime/os.hpp" |
| 20360 | 30 #include "services/memTracker.hpp" |
| 1972 | 31 |
| 0 | 32 // Explicit C-heap memory management |
| 33 | |
| 34 void trace_heap_malloc(size_t size, const char* name, void *p); | |
| 35 void trace_heap_free(void *p); | |
| 36 | |
| 2255 | 37 #ifndef PRODUCT |
| 2250 | 38 // Increments unsigned long value for statistics (not atomic on MP). |
| 39 inline void inc_stat_counter(volatile julong* dest, julong add_value) { | |
| 2255 | 40 #if defined(SPARC) || defined(X86) |
| 41 // Sparc and X86 have atomic jlong (8 bytes) instructions | |
| 2250 | 42 julong value = Atomic::load((volatile jlong*)dest); |
| 43 value += add_value; | |
| 44 Atomic::store((jlong)value, (volatile jlong*)dest); | |
| 2255 | 45 #else |
| 46 // possible word-tearing during load/store | |
| 47 *dest += add_value; | |
| 48 #endif | |
| 2250 | 49 } |
| 2255 | 50 #endif |
| 0 | 51 |
| 52 // allocate using malloc; will fail if no memory available | |
| 20360 | 53 inline char* AllocateHeap(size_t size, MEMFLAGS flags, |
| 54 const NativeCallStack& stack, | |
|
6872
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6842
diff
changeset
|
55 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) { |
| 20360 | 56 char* p = (char*) os::malloc(size, flags, stack); |
| 0 | 57 #ifdef ASSERT |
| 6197 | 58 if (PrintMallocFree) trace_heap_malloc(size, "AllocateHeap", p); |
| 0 | 59 #endif |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10135
diff
changeset
|
60 if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) { |
|
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10135
diff
changeset
|
61 vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "AllocateHeap"); |
|
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10135
diff
changeset
|
62 } |
| 6197 | 63 return p; |
| 64 } | |
| 20360 | 65 inline char* AllocateHeap(size_t size, MEMFLAGS flags, |
| 66 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) { | |
| 67 return AllocateHeap(size, flags, CURRENT_PC, alloc_failmode); | |
| 68 } | |
| 6197 | 69 |
| 20360 | 70 inline char* ReallocateHeap(char *old, size_t size, MEMFLAGS flag, |
|
6872
7b5885dadbdc
8000617: It should be possible to allocate memory without the VM dying.
nloodin
parents:
6842
diff
changeset
|
71 AllocFailType alloc_failmode = AllocFailStrategy::EXIT_OOM) { |
| 20360 | 72 char* p = (char*) os::realloc(old, size, flag, CURRENT_PC); |
| 6197 | 73 #ifdef ASSERT |
| 74 if (PrintMallocFree) trace_heap_malloc(size, "ReallocateHeap", p); | |
| 75 #endif | |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10135
diff
changeset
|
76 if (p == NULL && alloc_failmode == AllocFailStrategy::EXIT_OOM) { |
|
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10135
diff
changeset
|
77 vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "ReallocateHeap"); |
|
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10135
diff
changeset
|
78 } |
| 0 | 79 return p; |
| 80 } | |
| 81 | |
| 6197 | 82 inline void FreeHeap(void* p, MEMFLAGS memflags = mtInternal) { |
| 0 | 83 #ifdef ASSERT |
| 84 if (PrintMallocFree) trace_heap_free(p); | |
| 85 #endif | |
| 6197 | 86 os::free(p, memflags); |
| 0 | 87 } |
| 1972 | 88 |
| 6197 | 89 |
| 90 template <MEMFLAGS F> void* CHeapObj<F>::operator new(size_t size, | |
| 20360 | 91 const NativeCallStack& stack) throw() { |
| 92 void* p = (void*)AllocateHeap(size, F, stack); | |
| 93 #ifdef ASSERT | |
| 94 if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p); | |
| 95 #endif | |
| 96 return p; | |
| 97 } | |
| 98 | |
| 99 template <MEMFLAGS F> void* CHeapObj<F>::operator new(size_t size) throw() { | |
| 100 return CHeapObj<F>::operator new(size, CALLER_PC); | |
| 101 } | |
| 102 | |
| 103 template <MEMFLAGS F> void* CHeapObj<F>::operator new (size_t size, | |
| 104 const std::nothrow_t& nothrow_constant, const NativeCallStack& stack) throw() { | |
| 105 void* p = (void*)AllocateHeap(size, F, stack, | |
| 106 AllocFailStrategy::RETURN_NULL); | |
| 10135 | 107 #ifdef ASSERT |
| 6197 | 108 if (PrintMallocFree) trace_heap_malloc(size, "CHeapObj-new", p); |
|
10271
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
109 #endif |
| 10135 | 110 return p; |
| 6197 | 111 } |
| 112 | |
| 113 template <MEMFLAGS F> void* CHeapObj<F>::operator new (size_t size, | |
| 20360 | 114 const std::nothrow_t& nothrow_constant) throw() { |
| 115 return CHeapObj<F>::operator new(size, nothrow_constant, CALLER_PC); | |
|
10271
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
116 } |
|
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
117 |
|
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
118 template <MEMFLAGS F> void* CHeapObj<F>::operator new [](size_t size, |
| 20360 | 119 const NativeCallStack& stack) throw() { |
| 120 return CHeapObj<F>::operator new(size, stack); | |
| 121 } | |
| 122 | |
| 123 template <MEMFLAGS F> void* CHeapObj<F>::operator new [](size_t size) | |
| 124 throw() { | |
| 125 return CHeapObj<F>::operator new(size, CALLER_PC); | |
|
10271
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
126 } |
|
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
127 |
|
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
128 template <MEMFLAGS F> void* CHeapObj<F>::operator new [](size_t size, |
| 20360 | 129 const std::nothrow_t& nothrow_constant, const NativeCallStack& stack) throw() { |
| 130 return CHeapObj<F>::operator new(size, nothrow_constant, stack); | |
| 131 } | |
| 132 | |
| 133 template <MEMFLAGS F> void* CHeapObj<F>::operator new [](size_t size, | |
| 134 const std::nothrow_t& nothrow_constant) throw() { | |
| 135 return CHeapObj<F>::operator new(size, nothrow_constant, CALLER_PC); | |
| 6197 | 136 } |
| 137 | |
| 138 template <MEMFLAGS F> void CHeapObj<F>::operator delete(void* p){ | |
|
10271
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
139 FreeHeap(p, F); |
|
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
140 } |
|
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
141 |
|
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
142 template <MEMFLAGS F> void CHeapObj<F>::operator delete [](void* p){ |
|
f9be75d21404
8012902: remove use of global operator new - take 2
minqi
parents:
10221
diff
changeset
|
143 FreeHeap(p, F); |
| 6197 | 144 } |
| 145 | |
|
9073
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
146 template <class E, MEMFLAGS F> |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
147 E* ArrayAllocator<E, F>::allocate(size_t length) { |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
148 assert(_addr == NULL, "Already in use"); |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
149 |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
150 _size = sizeof(E) * length; |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
151 _use_malloc = _size < ArrayAllocatorMallocLimit; |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
152 |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
153 if (_use_malloc) { |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
154 _addr = AllocateHeap(_size, F); |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
155 if (_addr == NULL && _size >= (size_t)os::vm_allocation_granularity()) { |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
156 // malloc failed let's try with mmap instead |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
157 _use_malloc = false; |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
158 } else { |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
159 return (E*)_addr; |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
160 } |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
161 } |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
162 |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
163 int alignment = os::vm_allocation_granularity(); |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
164 _size = align_size_up(_size, alignment); |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
165 |
|
10221
c18152e0554e
8013120: NMT: Kitchensink crashes with assert(next_region == NULL || !next_region->is_committed_region()) failed: Sanity check
zgu
parents:
10161
diff
changeset
|
166 _addr = os::reserve_memory(_size, NULL, alignment, F); |
|
9073
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
167 if (_addr == NULL) { |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10135
diff
changeset
|
168 vm_exit_out_of_memory(_size, OOM_MMAP_ERROR, "Allocator (reserve)"); |
|
9073
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
169 } |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
170 |
|
10969
a837fa3d3f86
8013057: assert(_needs_gc || SafepointSynchronize::is_at_safepoint()) failed: only read at safepoint
dcubed
parents:
10271
diff
changeset
|
171 os::commit_memory_or_exit(_addr, _size, !ExecMem, "Allocator (commit)"); |
|
9073
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
172 |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
173 return (E*)_addr; |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
174 } |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
175 |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
176 template<class E, MEMFLAGS F> |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
177 void ArrayAllocator<E, F>::free() { |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
178 if (_addr != NULL) { |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
179 if (_use_malloc) { |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
180 FreeHeap(_addr, F); |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
181 } else { |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
182 os::release_memory(_addr, _size); |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
183 } |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
184 _addr = NULL; |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
185 } |
|
83f27710f5f7
7197666: java -d64 -version core dumps in a box with lots of memory
brutisso
parents:
8675
diff
changeset
|
186 } |
| 6197 | 187 |
| 1972 | 188 #endif // SHARE_VM_MEMORY_ALLOCATION_INLINE_HPP |