120 assert(length >= 0, "length should be non-negative");
121 ((arrayOop)obj_ptr)->set_length(length);
122 post_allocation_setup_common(klass, obj_ptr);
123 oop new_obj = (oop)obj_ptr;
124 assert(new_obj->is_array(), "must be an array");
125 // notify jvmti and dtrace (must be after length is set for dtrace)
126 post_allocation_notify(klass, new_obj, new_obj->size());
127 }
128
129 HeapWord* CollectedHeap::common_mem_allocate_noinit(Klass* klass, size_t size, TRAPS) {
130
131 // Clear unhandled oops for memory allocation. Memory allocation might
132 // not take out a lock if from tlab, so clear here.
133 CHECK_UNHANDLED_OOPS_ONLY(THREAD->clear_unhandled_oops();)
134
135 if (HAS_PENDING_EXCEPTION) {
136 NOT_PRODUCT(guarantee(false, "Should not allocate with exception pending"));
137 return NULL; // caller does a CHECK_0 too
138 }
139
140 HeapWord* result = NULL;
141 if (UseTLAB) {
142 result = allocate_from_tlab(klass, THREAD, size);
143 if (result != NULL) {
144 assert(!HAS_PENDING_EXCEPTION,
145 "Unexpected exception, will result in uninitialized storage");
146 return result;
147 }
148 }
149 bool gc_overhead_limit_was_exceeded = false;
150 result = Universe::heap()->mem_allocate(size,
151 &gc_overhead_limit_was_exceeded);
152 if (result != NULL) {
153 NOT_PRODUCT(Universe::heap()->
154 check_for_non_bad_heap_word_value(result, size));
155 assert(!HAS_PENDING_EXCEPTION,
156 "Unexpected exception, will result in uninitialized storage");
157 THREAD->incr_allocated_bytes(size * HeapWordSize);
158
159 AllocTracer::send_allocation_outside_tlab(klass, result, size * HeapWordSize, THREAD);
160
161 return result;
162 }
163
164
165 if (!gc_overhead_limit_was_exceeded) {
166 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
167 report_java_out_of_memory("Java heap space");
168
169 if (JvmtiExport::should_post_resource_exhausted()) {
170 JvmtiExport::post_resource_exhausted(
177 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
178 report_java_out_of_memory("GC overhead limit exceeded");
179
180 if (JvmtiExport::should_post_resource_exhausted()) {
181 JvmtiExport::post_resource_exhausted(
182 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP,
183 "GC overhead limit exceeded");
184 }
185
186 THROW_OOP_0(Universe::out_of_memory_error_gc_overhead_limit());
187 }
188 }
189
190 HeapWord* CollectedHeap::common_mem_allocate_init(Klass* klass, size_t size, TRAPS) {
191 HeapWord* obj = common_mem_allocate_noinit(klass, size, CHECK_NULL);
192 init_obj(obj, size);
193 return obj;
194 }
195
196 HeapWord* CollectedHeap::allocate_from_tlab(Klass* klass, Thread* thread, size_t size) {
197 assert(UseTLAB, "should use UseTLAB");
198
199 size += Universe::heap()->oop_extra_words();
200 HeapWord* obj = thread->tlab().allocate(size);
201 if (obj != NULL) {
202 obj = Universe::heap()->tlab_post_allocation_setup(obj);
203 return obj;
204 }
205 // Otherwise...
206 return allocate_from_tlab_slow(klass, thread, size);
207 }
208
209 void CollectedHeap::init_obj(HeapWord* obj, size_t size) {
210 assert(obj != NULL, "cannot initialize NULL object");
211 const size_t hs = oopDesc::header_size();
212 assert(size >= hs, "unexpected object size");
213 ((oop)obj)->set_klass_gap(0);
214 Copy::fill_to_aligned_words(obj + hs, size - hs);
215 }
216
217 oop CollectedHeap::obj_allocate(Klass* klass, int size, TRAPS) {
218 debug_only(check_for_valid_allocation_state());
219 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed");
220 assert(size >= 0, "int won't convert to size_t");
221 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL);
222 post_allocation_setup_obj(klass, obj, size);
223 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size));
224 return (oop)obj;
225 }
226
|
120 assert(length >= 0, "length should be non-negative");
121 ((arrayOop)obj_ptr)->set_length(length);
122 post_allocation_setup_common(klass, obj_ptr);
123 oop new_obj = (oop)obj_ptr;
124 assert(new_obj->is_array(), "must be an array");
125 // notify jvmti and dtrace (must be after length is set for dtrace)
126 post_allocation_notify(klass, new_obj, new_obj->size());
127 }
128
129 HeapWord* CollectedHeap::common_mem_allocate_noinit(Klass* klass, size_t size, TRAPS) {
130
131 // Clear unhandled oops for memory allocation. Memory allocation might
132 // not take out a lock if from tlab, so clear here.
133 CHECK_UNHANDLED_OOPS_ONLY(THREAD->clear_unhandled_oops();)
134
135 if (HAS_PENDING_EXCEPTION) {
136 NOT_PRODUCT(guarantee(false, "Should not allocate with exception pending"));
137 return NULL; // caller does a CHECK_0 too
138 }
139
140 bool gc_overhead_limit_was_exceeded = false;
141 HeapWord* result = Universe::heap()->mem_allocate(size, klass, THREAD,
142 &gc_overhead_limit_was_exceeded);
143 if (result != NULL) {
144 NOT_PRODUCT(Universe::heap()->
145 check_for_non_bad_heap_word_value(result, size));
146 assert(!HAS_PENDING_EXCEPTION,
147 "Unexpected exception, will result in uninitialized storage");
148 THREAD->incr_allocated_bytes(size * HeapWordSize);
149
150 AllocTracer::send_allocation_outside_tlab(klass, result, size * HeapWordSize, THREAD);
151
152 return result;
153 }
154
155
156 if (!gc_overhead_limit_was_exceeded) {
157 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
158 report_java_out_of_memory("Java heap space");
159
160 if (JvmtiExport::should_post_resource_exhausted()) {
161 JvmtiExport::post_resource_exhausted(
168 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
169 report_java_out_of_memory("GC overhead limit exceeded");
170
171 if (JvmtiExport::should_post_resource_exhausted()) {
172 JvmtiExport::post_resource_exhausted(
173 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP,
174 "GC overhead limit exceeded");
175 }
176
177 THROW_OOP_0(Universe::out_of_memory_error_gc_overhead_limit());
178 }
179 }
180
181 HeapWord* CollectedHeap::common_mem_allocate_init(Klass* klass, size_t size, TRAPS) {
182 HeapWord* obj = common_mem_allocate_noinit(klass, size, CHECK_NULL);
183 init_obj(obj, size);
184 return obj;
185 }
186
187 HeapWord* CollectedHeap::allocate_from_tlab(Klass* klass, Thread* thread, size_t size) {
188 if (UseTLAB) {
189 HeapWord* obj = thread->tlab().allocate(size);
190 if (obj != NULL) {
191 assert(!thread->has_pending_exception(),
192 "Unexpected exception, will result in uninitialized storage");
193 return obj;
194 }
195 // Otherwise...
196 obj = allocate_from_tlab_slow(klass, thread, size);
197 if (obj != NULL) {
198 assert(!thread->has_pending_exception(),
199 "Unexpected exception, will result in uninitialized storage");
200 }
201 return obj;
202 }
203 return NULL;
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
|