23 */ 24 25 #ifndef SHARE_VM_GC_SHARED_COLLECTEDHEAP_INLINE_HPP 26 #define SHARE_VM_GC_SHARED_COLLECTEDHEAP_INLINE_HPP 27 28 #include "classfile/javaClasses.hpp" 29 #include "gc/shared/allocTracer.hpp" 30 #include "gc/shared/collectedHeap.hpp" 31 #include "gc/shared/threadLocalAllocBuffer.inline.hpp" 32 #include "memory/universe.hpp" 33 #include "oops/arrayOop.hpp" 34 #include "oops/oop.inline.hpp" 35 #include "prims/jvmtiExport.hpp" 36 #include "runtime/sharedRuntime.hpp" 37 #include "runtime/thread.inline.hpp" 38 #include "services/lowMemoryDetector.hpp" 39 #include "utilities/copy.hpp" 40 41 // Inline allocation implementations. 42 43 void CollectedHeap::post_allocation_setup_common(KlassHandle klass, 44 HeapWord* obj_ptr) { 45 post_allocation_setup_no_klass_install(klass, obj_ptr); 46 oop obj = (oop)obj_ptr; 47 #if ! INCLUDE_ALL_GCS 48 obj->set_klass(klass()); 49 #else 50 // Need a release store to ensure array/class length, mark word, and 51 // object zeroing are visible before setting the klass non-NULL, for 52 // concurrent collectors. 53 obj->release_set_klass(klass()); 54 #endif 55 } 56 57 void CollectedHeap::post_allocation_setup_no_klass_install(KlassHandle klass, 58 HeapWord* obj_ptr) { 59 oop obj = (oop)obj_ptr; 60 61 assert(obj != NULL, "NULL object pointer"); 62 if (UseBiasedLocking && (klass() != NULL)) { 63 obj->set_mark(klass->prototype_header()); 64 } else { 65 // May be bootstrapping 66 obj->set_mark(markOopDesc::prototype()); 67 } 68 } 69 70 // Support for jvmti and dtrace 71 inline void post_allocation_notify(KlassHandle klass, oop obj, int size) { 72 // support low memory notifications (no-op if not enabled) 73 LowMemoryDetector::detect_low_memory_for_collected_pools(); 74 75 // support for JVMTI VMObjectAlloc event (no-op if not enabled) 76 JvmtiExport::vm_object_alloc_event_collector(obj); 77 78 if (DTraceAllocProbes) { 79 // support for Dtrace object alloc event (no-op most of the time) 80 if (klass() != NULL && klass()->name() != NULL) { 81 SharedRuntime::dtrace_object_alloc(obj, size); 82 } 83 } 84 } 85 86 void CollectedHeap::post_allocation_setup_obj(KlassHandle klass, 87 HeapWord* obj_ptr, 88 int size) { 89 post_allocation_setup_common(klass, obj_ptr); 90 oop obj = (oop)obj_ptr; 91 assert(Universe::is_bootstrapping() || 92 !obj->is_array(), "must not be an array"); 93 // notify jvmti and dtrace 94 post_allocation_notify(klass, obj, size); 95 } 96 97 void CollectedHeap::post_allocation_setup_class(KlassHandle klass, 98 HeapWord* obj_ptr, 99 int size) { 100 // Set oop_size field before setting the _klass field because a 101 // non-NULL _klass field indicates that the object is parsable by 102 // concurrent GC. 103 oop new_cls = (oop)obj_ptr; 104 assert(size > 0, "oop_size must be positive."); 105 java_lang_Class::set_oop_size(new_cls, size); 106 post_allocation_setup_common(klass, obj_ptr); 107 assert(Universe::is_bootstrapping() || 108 !new_cls->is_array(), "must not be an array"); 109 // notify jvmti and dtrace 110 post_allocation_notify(klass, new_cls, size); 111 } 112 113 void CollectedHeap::post_allocation_setup_array(KlassHandle klass, 114 HeapWord* obj_ptr, 115 int length) { 116 // Set array length before setting the _klass field because a 117 // non-NULL klass field indicates that the object is parsable by 118 // concurrent GC. 119 assert(length >= 0, "length should be non-negative"); 120 ((arrayOop)obj_ptr)->set_length(length); 121 post_allocation_setup_common(klass, obj_ptr); 122 oop new_obj = (oop)obj_ptr; 123 assert(new_obj->is_array(), "must be an array"); 124 // notify jvmti and dtrace (must be after length is set for dtrace) 125 post_allocation_notify(klass, new_obj, new_obj->size()); 126 } 127 128 HeapWord* CollectedHeap::common_mem_allocate_noinit(KlassHandle klass, size_t size, TRAPS) { 129 130 // Clear unhandled oops for memory allocation. Memory allocation might 131 // not take out a lock if from tlab, so clear here. 132 CHECK_UNHANDLED_OOPS_ONLY(THREAD->clear_unhandled_oops();) 133 134 if (HAS_PENDING_EXCEPTION) { 135 NOT_PRODUCT(guarantee(false, "Should not allocate with exception pending")); 136 return NULL; // caller does a CHECK_0 too 137 } 138 139 HeapWord* result = NULL; 140 if (UseTLAB) { 141 result = allocate_from_tlab(klass, THREAD, size); 142 if (result != NULL) { 143 assert(!HAS_PENDING_EXCEPTION, 144 "Unexpected exception, will result in uninitialized storage"); 145 return result; 146 } 147 } 148 bool gc_overhead_limit_was_exceeded = false; 169 JvmtiExport::post_resource_exhausted( 170 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP, 171 "Java heap space"); 172 } 173 174 THROW_OOP_0(Universe::out_of_memory_error_java_heap()); 175 } else { 176 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support 177 report_java_out_of_memory("GC overhead limit exceeded"); 178 179 if (JvmtiExport::should_post_resource_exhausted()) { 180 JvmtiExport::post_resource_exhausted( 181 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP, 182 "GC overhead limit exceeded"); 183 } 184 185 THROW_OOP_0(Universe::out_of_memory_error_gc_overhead_limit()); 186 } 187 } 188 189 HeapWord* CollectedHeap::common_mem_allocate_init(KlassHandle klass, size_t size, TRAPS) { 190 HeapWord* obj = common_mem_allocate_noinit(klass, size, CHECK_NULL); 191 init_obj(obj, size); 192 return obj; 193 } 194 195 HeapWord* CollectedHeap::allocate_from_tlab(KlassHandle klass, Thread* thread, size_t size) { 196 assert(UseTLAB, "should use UseTLAB"); 197 198 HeapWord* obj = thread->tlab().allocate(size); 199 if (obj != NULL) { 200 return obj; 201 } 202 // Otherwise... 203 return allocate_from_tlab_slow(klass, thread, size); 204 } 205 206 void CollectedHeap::init_obj(HeapWord* obj, size_t size) { 207 assert(obj != NULL, "cannot initialize NULL object"); 208 const size_t hs = oopDesc::header_size(); 209 assert(size >= hs, "unexpected object size"); 210 ((oop)obj)->set_klass_gap(0); 211 Copy::fill_to_aligned_words(obj + hs, size - hs); 212 } 213 214 oop CollectedHeap::obj_allocate(KlassHandle klass, int size, TRAPS) { 215 debug_only(check_for_valid_allocation_state()); 216 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 217 assert(size >= 0, "int won't convert to size_t"); 218 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL); 219 post_allocation_setup_obj(klass, obj, size); 220 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size)); 221 return (oop)obj; 222 } 223 224 oop CollectedHeap::class_allocate(KlassHandle klass, int size, TRAPS) { 225 debug_only(check_for_valid_allocation_state()); 226 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 227 assert(size >= 0, "int won't convert to size_t"); 228 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL); 229 post_allocation_setup_class(klass, obj, size); // set oop_size 230 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size)); 231 return (oop)obj; 232 } 233 234 oop CollectedHeap::array_allocate(KlassHandle klass, 235 int size, 236 int length, 237 TRAPS) { 238 debug_only(check_for_valid_allocation_state()); 239 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 240 assert(size >= 0, "int won't convert to size_t"); 241 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL); 242 post_allocation_setup_array(klass, obj, length); 243 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size)); 244 return (oop)obj; 245 } 246 247 oop CollectedHeap::array_allocate_nozero(KlassHandle klass, 248 int size, 249 int length, 250 TRAPS) { 251 debug_only(check_for_valid_allocation_state()); 252 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 253 assert(size >= 0, "int won't convert to size_t"); 254 HeapWord* obj = common_mem_allocate_noinit(klass, size, CHECK_NULL); 255 ((oop)obj)->set_klass_gap(0); 256 post_allocation_setup_array(klass, obj, length); 257 #ifndef PRODUCT 258 const size_t hs = oopDesc::header_size()+1; 259 Universe::heap()->check_for_non_bad_heap_word_value(obj+hs, size-hs); 260 #endif 261 return (oop)obj; 262 } 263 264 inline HeapWord* CollectedHeap::align_allocation_or_fail(HeapWord* addr, 265 HeapWord* end, 266 unsigned short alignment_in_bytes) { 267 if (alignment_in_bytes <= ObjectAlignmentInBytes) { | 23 */ 24 25 #ifndef SHARE_VM_GC_SHARED_COLLECTEDHEAP_INLINE_HPP 26 #define SHARE_VM_GC_SHARED_COLLECTEDHEAP_INLINE_HPP 27 28 #include "classfile/javaClasses.hpp" 29 #include "gc/shared/allocTracer.hpp" 30 #include "gc/shared/collectedHeap.hpp" 31 #include "gc/shared/threadLocalAllocBuffer.inline.hpp" 32 #include "memory/universe.hpp" 33 #include "oops/arrayOop.hpp" 34 #include "oops/oop.inline.hpp" 35 #include "prims/jvmtiExport.hpp" 36 #include "runtime/sharedRuntime.hpp" 37 #include "runtime/thread.inline.hpp" 38 #include "services/lowMemoryDetector.hpp" 39 #include "utilities/copy.hpp" 40 41 // Inline allocation implementations. 42 43 void CollectedHeap::post_allocation_setup_common(Klass* klass, 44 HeapWord* obj_ptr) { 45 post_allocation_setup_no_klass_install(klass, obj_ptr); 46 oop obj = (oop)obj_ptr; 47 #if ! INCLUDE_ALL_GCS 48 obj->set_klass(klass); 49 #else 50 // Need a release store to ensure array/class length, mark word, and 51 // object zeroing are visible before setting the klass non-NULL, for 52 // concurrent collectors. 53 obj->release_set_klass(klass); 54 #endif 55 } 56 57 void CollectedHeap::post_allocation_setup_no_klass_install(Klass* klass, 58 HeapWord* obj_ptr) { 59 oop obj = (oop)obj_ptr; 60 61 assert(obj != NULL, "NULL object pointer"); 62 if (UseBiasedLocking && (klass != NULL)) { 63 obj->set_mark(klass->prototype_header()); 64 } else { 65 // May be bootstrapping 66 obj->set_mark(markOopDesc::prototype()); 67 } 68 } 69 70 // Support for jvmti and dtrace 71 inline void post_allocation_notify(Klass* klass, oop obj, int size) { 72 // support low memory notifications (no-op if not enabled) 73 LowMemoryDetector::detect_low_memory_for_collected_pools(); 74 75 // support for JVMTI VMObjectAlloc event (no-op if not enabled) 76 JvmtiExport::vm_object_alloc_event_collector(obj); 77 78 if (DTraceAllocProbes) { 79 // support for Dtrace object alloc event (no-op most of the time) 80 if (klass != NULL && klass->name() != NULL) { 81 SharedRuntime::dtrace_object_alloc(obj, size); 82 } 83 } 84 } 85 86 void CollectedHeap::post_allocation_setup_obj(Klass* klass, 87 HeapWord* obj_ptr, 88 int size) { 89 post_allocation_setup_common(klass, obj_ptr); 90 oop obj = (oop)obj_ptr; 91 assert(Universe::is_bootstrapping() || 92 !obj->is_array(), "must not be an array"); 93 // notify jvmti and dtrace 94 post_allocation_notify(klass, obj, size); 95 } 96 97 void CollectedHeap::post_allocation_setup_class(Klass* klass, 98 HeapWord* obj_ptr, 99 int size) { 100 // Set oop_size field before setting the _klass field because a 101 // non-NULL _klass field indicates that the object is parsable by 102 // concurrent GC. 103 oop new_cls = (oop)obj_ptr; 104 assert(size > 0, "oop_size must be positive."); 105 java_lang_Class::set_oop_size(new_cls, size); 106 post_allocation_setup_common(klass, obj_ptr); 107 assert(Universe::is_bootstrapping() || 108 !new_cls->is_array(), "must not be an array"); 109 // notify jvmti and dtrace 110 post_allocation_notify(klass, new_cls, size); 111 } 112 113 void CollectedHeap::post_allocation_setup_array(Klass* klass, 114 HeapWord* obj_ptr, 115 int length) { 116 // Set array length before setting the _klass field because a 117 // non-NULL klass field indicates that the object is parsable by 118 // concurrent GC. 119 assert(length >= 0, "length should be non-negative"); 120 ((arrayOop)obj_ptr)->set_length(length); 121 post_allocation_setup_common(klass, obj_ptr); 122 oop new_obj = (oop)obj_ptr; 123 assert(new_obj->is_array(), "must be an array"); 124 // notify jvmti and dtrace (must be after length is set for dtrace) 125 post_allocation_notify(klass, new_obj, new_obj->size()); 126 } 127 128 HeapWord* CollectedHeap::common_mem_allocate_noinit(Klass* klass, size_t size, TRAPS) { 129 130 // Clear unhandled oops for memory allocation. Memory allocation might 131 // not take out a lock if from tlab, so clear here. 132 CHECK_UNHANDLED_OOPS_ONLY(THREAD->clear_unhandled_oops();) 133 134 if (HAS_PENDING_EXCEPTION) { 135 NOT_PRODUCT(guarantee(false, "Should not allocate with exception pending")); 136 return NULL; // caller does a CHECK_0 too 137 } 138 139 HeapWord* result = NULL; 140 if (UseTLAB) { 141 result = allocate_from_tlab(klass, THREAD, size); 142 if (result != NULL) { 143 assert(!HAS_PENDING_EXCEPTION, 144 "Unexpected exception, will result in uninitialized storage"); 145 return result; 146 } 147 } 148 bool gc_overhead_limit_was_exceeded = false; 169 JvmtiExport::post_resource_exhausted( 170 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP, 171 "Java heap space"); 172 } 173 174 THROW_OOP_0(Universe::out_of_memory_error_java_heap()); 175 } else { 176 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support 177 report_java_out_of_memory("GC overhead limit exceeded"); 178 179 if (JvmtiExport::should_post_resource_exhausted()) { 180 JvmtiExport::post_resource_exhausted( 181 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP, 182 "GC overhead limit exceeded"); 183 } 184 185 THROW_OOP_0(Universe::out_of_memory_error_gc_overhead_limit()); 186 } 187 } 188 189 HeapWord* CollectedHeap::common_mem_allocate_init(Klass* klass, size_t size, TRAPS) { 190 HeapWord* obj = common_mem_allocate_noinit(klass, size, CHECK_NULL); 191 init_obj(obj, size); 192 return obj; 193 } 194 195 HeapWord* CollectedHeap::allocate_from_tlab(Klass* klass, Thread* thread, size_t size) { 196 assert(UseTLAB, "should use UseTLAB"); 197 198 HeapWord* obj = thread->tlab().allocate(size); 199 if (obj != NULL) { 200 return obj; 201 } 202 // Otherwise... 203 return allocate_from_tlab_slow(klass, thread, size); 204 } 205 206 void CollectedHeap::init_obj(HeapWord* obj, size_t size) { 207 assert(obj != NULL, "cannot initialize NULL object"); 208 const size_t hs = oopDesc::header_size(); 209 assert(size >= hs, "unexpected object size"); 210 ((oop)obj)->set_klass_gap(0); 211 Copy::fill_to_aligned_words(obj + hs, size - hs); 212 } 213 214 oop CollectedHeap::obj_allocate(Klass* klass, int size, TRAPS) { 215 debug_only(check_for_valid_allocation_state()); 216 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 217 assert(size >= 0, "int won't convert to size_t"); 218 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL); 219 post_allocation_setup_obj(klass, obj, size); 220 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size)); 221 return (oop)obj; 222 } 223 224 oop CollectedHeap::class_allocate(Klass* klass, int size, TRAPS) { 225 debug_only(check_for_valid_allocation_state()); 226 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 227 assert(size >= 0, "int won't convert to size_t"); 228 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL); 229 post_allocation_setup_class(klass, obj, size); // set oop_size 230 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size)); 231 return (oop)obj; 232 } 233 234 oop CollectedHeap::array_allocate(Klass* klass, 235 int size, 236 int length, 237 TRAPS) { 238 debug_only(check_for_valid_allocation_state()); 239 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 240 assert(size >= 0, "int won't convert to size_t"); 241 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL); 242 post_allocation_setup_array(klass, obj, length); 243 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size)); 244 return (oop)obj; 245 } 246 247 oop CollectedHeap::array_allocate_nozero(Klass* klass, 248 int size, 249 int length, 250 TRAPS) { 251 debug_only(check_for_valid_allocation_state()); 252 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed"); 253 assert(size >= 0, "int won't convert to size_t"); 254 HeapWord* obj = common_mem_allocate_noinit(klass, size, CHECK_NULL); 255 ((oop)obj)->set_klass_gap(0); 256 post_allocation_setup_array(klass, obj, length); 257 #ifndef PRODUCT 258 const size_t hs = oopDesc::header_size()+1; 259 Universe::heap()->check_for_non_bad_heap_word_value(obj+hs, size-hs); 260 #endif 261 return (oop)obj; 262 } 263 264 inline HeapWord* CollectedHeap::align_allocation_or_fail(HeapWord* addr, 265 HeapWord* end, 266 unsigned short alignment_in_bytes) { 267 if (alignment_in_bytes <= ObjectAlignmentInBytes) { |