1 /* 2 * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved. 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 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_VM_GC_INTERFACE_COLLECTEDHEAP_INLINE_HPP 26 #define SHARE_VM_GC_INTERFACE_COLLECTEDHEAP_INLINE_HPP 27 28 #include "gc_interface/allocTracer.hpp" 29 #include "gc_interface/collectedHeap.hpp" 30 #include "memory/threadLocalAllocBuffer.inline.hpp" 31 #include "memory/universe.hpp" 32 #include "oops/arrayOop.hpp" 33 #include "prims/jvmtiExport.hpp" 34 #include "runtime/sharedRuntime.hpp" 35 #include "runtime/thread.inline.hpp" 36 #include "services/lowMemoryDetector.hpp" 37 #include "utilities/copy.hpp" 38 39 // Inline allocation implementations. 40 41 void CollectedHeap::post_allocation_setup_common(KlassHandle klass, 42 HeapWord* obj) { 43 post_allocation_setup_no_klass_install(klass, obj); 44 post_allocation_install_obj_klass(klass, oop(obj)); 45 } 46 47 void CollectedHeap::post_allocation_setup_no_klass_install(KlassHandle klass, 48 HeapWord* objPtr) { 49 oop obj = (oop)objPtr; 50 51 assert(obj != NULL, "NULL object pointer"); 52 if (UseBiasedLocking && (klass() != NULL)) { 53 obj->set_mark(klass->prototype_header()); 54 } else { 55 // May be bootstrapping 56 obj->set_mark(markOopDesc::prototype()); 57 } 58 } 59 60 void CollectedHeap::post_allocation_install_obj_klass(KlassHandle klass, 61 oop obj) { 62 // These asserts are kind of complicated because of klassKlass 63 // and the beginning of the world. 64 assert(klass() != NULL || !Universe::is_fully_initialized(), "NULL klass"); 65 assert(klass() == NULL || klass()->is_klass(), "not a klass"); 66 assert(obj != NULL, "NULL object pointer"); 67 obj->set_klass(klass()); 68 assert(!Universe::is_fully_initialized() || obj->klass() != NULL, 69 "missing klass"); 70 } 71 72 // Support for jvmti and dtrace 73 inline void post_allocation_notify(KlassHandle klass, oop obj) { 74 // support low memory notifications (no-op if not enabled) 75 LowMemoryDetector::detect_low_memory_for_collected_pools(); 76 77 // support for JVMTI VMObjectAlloc event (no-op if not enabled) 78 JvmtiExport::vm_object_alloc_event_collector(obj); 79 80 if (DTraceAllocProbes) { 81 // support for Dtrace object alloc event (no-op most of the time) 82 if (klass() != NULL && klass()->name() != NULL) { 83 SharedRuntime::dtrace_object_alloc(obj); 84 } 85 } 86 } 87 88 void CollectedHeap::post_allocation_setup_obj(KlassHandle klass, 89 HeapWord* obj) { 90 post_allocation_setup_common(klass, obj); 91 assert(Universe::is_bootstrapping() || 92 !((oop)obj)->is_array(), "must not be an array"); 93 // notify jvmti and dtrace 94 post_allocation_notify(klass, (oop)obj); 95 } 96 97 void CollectedHeap::post_allocation_setup_array(KlassHandle klass, 98 HeapWord* obj, 99 int length) { 100 // Set array length before setting the _klass field 101 // in post_allocation_setup_common() because the klass field 102 // indicates that the object is parsable by concurrent GC. 103 assert(length >= 0, "length should be non-negative"); 104 ((arrayOop)obj)->set_length(length); 105 post_allocation_setup_common(klass, obj); 106 assert(((oop)obj)->is_array(), "must be an array"); 107 // notify jvmti and dtrace (must be after length is set for dtrace) 108 post_allocation_notify(klass, (oop)obj); 109 } 110 111 HeapWord* CollectedHeap::common_mem_allocate_noinit(KlassHandle klass, size_t size, TRAPS) { 112 113 // Clear unhandled oops for memory allocation. Memory allocation might 114 // not take out a lock if from tlab, so clear here. 115 CHECK_UNHANDLED_OOPS_ONLY(THREAD->clear_unhandled_oops();) 116 117 if (HAS_PENDING_EXCEPTION) { 118 NOT_PRODUCT(guarantee(false, "Should not allocate with exception pending")); 119 return NULL; // caller does a CHECK_0 too 120 } 121 122 HeapWord* result = NULL; 123 if (UseTLAB) { 124 result = allocate_from_tlab(klass, THREAD, size); 125 if (result != NULL) { 126 assert(!HAS_PENDING_EXCEPTION, 127 "Unexpected exception, will result in uninitialized storage"); 128 return result; 129 } 130 } 131 bool gc_overhead_limit_was_exceeded = false; 132 result = Universe::heap()->mem_allocate(size, 133 &gc_overhead_limit_was_exceeded); 134 if (result != NULL) { 135 NOT_PRODUCT(Universe::heap()-> 136 check_for_non_bad_heap_word_value(result, size)); 137 assert(!HAS_PENDING_EXCEPTION, 138 "Unexpected exception, will result in uninitialized storage"); 139 THREAD->incr_allocated_bytes(size * HeapWordSize); 140 141 AllocTracer::send_allocation_outside_tlab_event(klass, size * HeapWordSize); 142 143 return result; 144 } 145 146 147 if (!gc_overhead_limit_was_exceeded) { 148 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support 149 report_java_out_of_memory("Java heap space"); 150 151 if (JvmtiExport::should_post_resource_exhausted()) { 152 JvmtiExport::post_resource_exhausted( 153 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP, 154 "Java heap space"); 155 } 156 157 THROW_OOP_0(Universe::out_of_memory_error_java_heap()); 158 } else { 159 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support 160 report_java_out_of_memory("GC overhead limit exceeded"); 161 162 if (JvmtiExport::should_post_resource_exhausted()) { 163 JvmtiExport::post_resource_exhausted( 164 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP, 165 "GC overhead limit exceeded"); 166 } 167 168 THROW_OOP_0(Universe::out_of_memory_error_gc_overhead_limit()); 169 } 170 } 171 172 HeapWord* CollectedHeap::common_mem_allocate_init(KlassHandle klass, size_t size, TRAPS) { 173 HeapWord* obj = common_mem_allocate_noinit(klass, size, CHECK_NULL); 174 init_obj(obj, size); 175 return obj; 176 } 177 178 HeapWord* CollectedHeap::allocate_from_tlab(KlassHandle klass, Thread* thread, size_t size) { 179 assert(UseTLAB, "should use UseTLAB"); 180 181 HeapWord* obj = thread->tlab().allocate(size); 182 if (obj != NULL) { 183 return obj; 184 } 185 // Otherwise... 186 return allocate_from_tlab_slow(klass, thread, size); 187 } 188 189 void CollectedHeap::init_obj(HeapWord* obj, size_t size) { 190 assert(obj != NULL, "cannot initialize NULL object"); 191 const size_t hs = oopDesc::header_size(); 192 assert(size >= hs, "unexpected object size"); 193 ((oop)obj)->set_klass_gap(0); 194 Copy::fill_to_aligned_words(obj + hs, size - hs); 195 } 196 197 oop CollectedHeap::obj_allocate(KlassHandle klass, int size, TRAPS) { 198 debug_only(check_for_valid_allocation_state()); 199 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 200 assert(size >= 0, "int won't convert to size_t"); 201 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL); 202 post_allocation_setup_obj(klass, obj); 203 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size)); 204 return (oop)obj; 205 } 206 207 oop CollectedHeap::array_allocate(KlassHandle klass, 208 int size, 209 int length, 210 TRAPS) { 211 debug_only(check_for_valid_allocation_state()); 212 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 213 assert(size >= 0, "int won't convert to size_t"); 214 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL); 215 post_allocation_setup_array(klass, obj, length); 216 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size)); 217 return (oop)obj; 218 } 219 220 oop CollectedHeap::array_allocate_nozero(KlassHandle klass, 221 int size, 222 int length, 223 TRAPS) { 224 debug_only(check_for_valid_allocation_state()); 225 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 226 assert(size >= 0, "int won't convert to size_t"); 227 HeapWord* obj = common_mem_allocate_noinit(klass, size, CHECK_NULL); 228 ((oop)obj)->set_klass_gap(0); 229 post_allocation_setup_array(klass, obj, length); 230 #ifndef PRODUCT 231 const size_t hs = oopDesc::header_size()+1; 232 Universe::heap()->check_for_non_bad_heap_word_value(obj+hs, size-hs); 233 #endif 234 return (oop)obj; 235 } 236 237 inline void CollectedHeap::oop_iterate_no_header(OopClosure* cl) { 238 NoHeaderExtendedOopClosure no_header_cl(cl); 239 oop_iterate(&no_header_cl); 240 } 241 242 #ifndef PRODUCT 243 244 inline bool 245 CollectedHeap::promotion_should_fail(volatile size_t* count) { 246 // Access to count is not atomic; the value does not have to be exact. 247 if (PromotionFailureALot) { 248 const size_t gc_num = total_collections(); 249 const size_t elapsed_gcs = gc_num - _promotion_failure_alot_gc_number; 250 if (elapsed_gcs >= PromotionFailureALotInterval) { 251 // Test for unsigned arithmetic wrap-around. 252 if (++*count >= PromotionFailureALotCount) { 253 *count = 0; 254 return true; 255 } 256 } 257 } 258 return false; 259 } 260 261 inline bool CollectedHeap::promotion_should_fail() { 262 return promotion_should_fail(&_promotion_failure_alot_count); 263 } 264 265 inline void CollectedHeap::reset_promotion_should_fail(volatile size_t* count) { 266 if (PromotionFailureALot) { 267 _promotion_failure_alot_gc_number = total_collections(); 268 *count = 0; 269 } 270 } 271 272 inline void CollectedHeap::reset_promotion_should_fail() { 273 reset_promotion_should_fail(&_promotion_failure_alot_count); 274 } 275 #endif // #ifndef PRODUCT 276 277 #endif // SHARE_VM_GC_INTERFACE_COLLECTEDHEAP_INLINE_HPP