erik allocation
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;
149 result = Universe::heap()->mem_allocate(size,
150 &gc_overhead_limit_was_exceeded);
151 if (result != NULL) {
152 NOT_PRODUCT(Universe::heap()->
153 check_for_non_bad_heap_word_value(result, size));
154 assert(!HAS_PENDING_EXCEPTION,
155 "Unexpected exception, will result in uninitialized storage");
156 THREAD->incr_allocated_bytes(size * HeapWordSize);
157
158 AllocTracer::send_allocation_outside_tlab(klass, result, size * HeapWordSize, THREAD);
159
160 return result;
161 }
162
163
164 if (!gc_overhead_limit_was_exceeded) {
165 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
166 report_java_out_of_memory("Java heap space");
167
168 if (JvmtiExport::should_post_resource_exhausted()) {
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 }
|
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 bool gc_overhead_limit_was_exceeded = false;
140 CollectedHeap* heap = Universe::heap();
141 HeapWord* result = heap->obj_allocate_raw(klass, size, &gc_overhead_limit_was_exceeded, THREAD);
142
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 if (!gc_overhead_limit_was_exceeded) {
156 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
157 report_java_out_of_memory("Java heap space");
158
159 if (JvmtiExport::should_post_resource_exhausted()) {
160 JvmtiExport::post_resource_exhausted(
161 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP,
162 "Java heap space");
163 }
164
165 THROW_OOP_0(Universe::out_of_memory_error_java_heap());
166 } else {
167 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
168 report_java_out_of_memory("GC overhead limit exceeded");
169
170 if (JvmtiExport::should_post_resource_exhausted()) {
171 JvmtiExport::post_resource_exhausted(
172 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_JAVA_HEAP,
173 "GC overhead limit exceeded");
174 }
175
176 THROW_OOP_0(Universe::out_of_memory_error_gc_overhead_limit());
177 }
178 }
179
180 HeapWord* CollectedHeap::common_mem_allocate_init(Klass* klass, size_t size, TRAPS) {
181 HeapWord* obj = common_mem_allocate_noinit(klass, size, CHECK_NULL);
182 init_obj(obj, size);
183 return obj;
184 }
185
186 HeapWord* CollectedHeap::allocate_from_tlab(Klass* klass, size_t size, TRAPS) {
187 assert(UseTLAB, "should use UseTLAB");
188
189 HeapWord* obj = THREAD->tlab().allocate(size);
190 if (obj != NULL) {
191 return obj;
192 }
193 // Otherwise...
194 obj = allocate_from_tlab_slow(klass, size, THREAD);
195 assert(obj == NULL || !HAS_PENDING_EXCEPTION,
196 "Unexpected exception, will result in uninitialized storage");
197 return obj;
198 }
199
200 void CollectedHeap::init_obj(HeapWord* obj, size_t size) {
201 assert(obj != NULL, "cannot initialize NULL object");
202 const size_t hs = oopDesc::header_size();
203 assert(size >= hs, "unexpected object size");
204 ((oop)obj)->set_klass_gap(0);
205 Copy::fill_to_aligned_words(obj + hs, size - hs);
206 }
207
208 oop CollectedHeap::obj_allocate(Klass* klass, int size, TRAPS) {
209 debug_only(check_for_valid_allocation_state());
210 assert(!Universe::heap()->is_gc_active(), "Allocation during gc not allowed");
211 assert(size >= 0, "int won't convert to size_t");
212 HeapWord* obj = common_mem_allocate_init(klass, size, CHECK_NULL);
213 post_allocation_setup_obj(klass, obj, size);
214 NOT_PRODUCT(Universe::heap()->check_for_bad_heap_word_value(obj, size));
215 return (oop)obj;
216 }
|