209 210 uint age = 0; 211 InCSetState dest_state = next_state(state, old_mark, age); 212 HeapWord* obj_ptr = _g1_par_allocator->plab_allocate(dest_state, word_sz, context); 213 214 // PLAB allocations should succeed most of the time, so we'll 215 // normally check against NULL once and that's it. 216 if (obj_ptr == NULL) { 217 obj_ptr = _g1_par_allocator->allocate_direct_or_new_plab(dest_state, word_sz, context); 218 if (obj_ptr == NULL) { 219 obj_ptr = allocate_in_next_plab(state, &dest_state, word_sz, context); 220 if (obj_ptr == NULL) { 221 // This will either forward-to-self, or detect that someone else has 222 // installed a forwarding pointer. 223 return _g1h->handle_evacuation_failure_par(this, old); 224 } 225 } 226 } 227 228 assert(obj_ptr != NULL, "when we get here, allocation should have succeeded"); 229 #ifndef PRODUCT 230 // Should this evacuation fail? 231 if (_g1h->evacuation_should_fail()) { 232 // Doing this after all the allocation attempts also tests the 233 // undo_allocation() method too. 234 _g1_par_allocator->undo_allocation(dest_state, obj_ptr, word_sz, context); 235 return _g1h->handle_evacuation_failure_par(this, old); 236 } 237 #endif // !PRODUCT 238 239 // We're going to allocate linearly, so might as well prefetch ahead. 240 Prefetch::write(obj_ptr, PrefetchCopyIntervalInBytes); 241 242 const oop obj = oop(obj_ptr); 243 const oop forward_ptr = old->forward_to_atomic(obj); 244 if (forward_ptr == NULL) { 245 Copy::aligned_disjoint_words((HeapWord*) old, obj_ptr, word_sz); 246 247 if (dest_state.is_young()) { 248 if (age < markOopDesc::max_age) { | 209 210 uint age = 0; 211 InCSetState dest_state = next_state(state, old_mark, age); 212 HeapWord* obj_ptr = _g1_par_allocator->plab_allocate(dest_state, word_sz, context); 213 214 // PLAB allocations should succeed most of the time, so we'll 215 // normally check against NULL once and that's it. 216 if (obj_ptr == NULL) { 217 obj_ptr = _g1_par_allocator->allocate_direct_or_new_plab(dest_state, word_sz, context); 218 if (obj_ptr == NULL) { 219 obj_ptr = allocate_in_next_plab(state, &dest_state, word_sz, context); 220 if (obj_ptr == NULL) { 221 // This will either forward-to-self, or detect that someone else has 222 // installed a forwarding pointer. 223 return _g1h->handle_evacuation_failure_par(this, old); 224 } 225 } 226 } 227 228 assert(obj_ptr != NULL, "when we get here, allocation should have succeeded"); 229 assert(_g1h->is_in_reserved(obj_ptr), "Allocated memory should be in the heap"); 230 231 #ifndef PRODUCT 232 // Should this evacuation fail? 233 if (_g1h->evacuation_should_fail()) { 234 // Doing this after all the allocation attempts also tests the 235 // undo_allocation() method too. 236 _g1_par_allocator->undo_allocation(dest_state, obj_ptr, word_sz, context); 237 return _g1h->handle_evacuation_failure_par(this, old); 238 } 239 #endif // !PRODUCT 240 241 // We're going to allocate linearly, so might as well prefetch ahead. 242 Prefetch::write(obj_ptr, PrefetchCopyIntervalInBytes); 243 244 const oop obj = oop(obj_ptr); 245 const oop forward_ptr = old->forward_to_atomic(obj); 246 if (forward_ptr == NULL) { 247 Copy::aligned_disjoint_words((HeapWord*) old, obj_ptr, word_sz); 248 249 if (dest_state.is_young()) { 250 if (age < markOopDesc::max_age) { |