3117       assert(closure.source() < end_addr, "sanity");
3118       HeapWord* const obj_beg = closure.source();
3119       HeapWord* const range_end = MIN2(obj_beg + closure.words_remaining(),
3120                                        src_space_top);
3121       HeapWord* const obj_end = bitmap->find_obj_end(obj_beg, range_end);
3122       if (obj_end < range_end) {
3123         // The end was found; the entire object will fit.
3124         status = closure.do_addr(obj_beg, bitmap->obj_size(obj_beg, obj_end));
3125         assert(status != ParMarkBitMap::would_overflow, "sanity");
3126       } else {
3127         // The end was not found; the object will not fit.
3128         assert(range_end < src_space_top, "obj cannot cross space boundary");
3129         status = ParMarkBitMap::would_overflow;
3130       }
3131     }
3132 
3133     if (status == ParMarkBitMap::would_overflow) {
3134       // The last object did not fit.  Note that interior oop updates were
3135       // deferred, then copy enough of the object to fill the region.
3136       region_ptr->set_deferred_obj_addr(closure.destination());
3137 
3138       status = closure.copy_until_full(); // copies from closure.source()
3139 
3140       decrement_destination_counts(cm, src_space_id, src_region_idx,
3141                                    closure.source());
3142       closure.complete_region(cm, dest_addr, region_ptr);
3143       return;
3144     }
3145 
3146     if (status == ParMarkBitMap::full) {
3147       decrement_destination_counts(cm, src_space_id, src_region_idx,
3148                                    closure.source());
3149       region_ptr->set_deferred_obj_addr(NULL);
3150       closure.complete_region(cm, dest_addr, region_ptr);
3151       return;
3152     }
3153 
3154     decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr);
3155 
3156     // Move to the next source region, possibly switching spaces as well.  All
3157     // args except end_addr may be modified.
3158     src_region_idx = next_src_region(closure, src_space_id, src_space_top,
3159                                      end_addr);
3160   } while (true);
3161 }
3162 
3163 void PSParallelCompact::fill_and_update_region(ParCompactionManager* cm, size_t region_idx)
3164 {
3165   MoveAndUpdateClosure cl(mark_bitmap(), cm, region_idx);
3166   fill_region(cm, cl, region_idx);
3167 }
3168 
3169 void PSParallelCompact::fill_and_update_shadow_region(ParCompactionManager* cm, size_t region_idx)
3170 {
3171   // Get a shadow region first
3172   ParallelCompactData& sd = summary_data();
3173   RegionData* const region_ptr = sd.region(region_idx);
3174   size_t shadow_region = cm->pop_shadow_region_mt_safe(region_ptr);
3175   // The InvalidShadow return value indicates the corresponding heap region is available,
3176   // so use MoveAndUpdateClosure to fill the normal region. Otherwise, use
3177   // MoveAndUpdateShadowClosure to fill the acquired shadow region.
3178   if (shadow_region == cm->InvalidShadow) {
3179     MoveAndUpdateClosure cl(mark_bitmap(), cm, region_idx);
3180     region_ptr->shadow_to_normal();
3181     return fill_region(cm, cl, region_idx);
3182   } else {
3183     MoveAndUpdateShadowClosure cl(mark_bitmap(), cm, region_idx, shadow_region);
3184     return fill_region(cm, cl, region_idx);
3185   }
3186 }
3187 
3188 void PSParallelCompact::copy_back(HeapWord *shadow_addr, HeapWord *region_addr)
3189 {
3190   Copy::aligned_conjoint_words(shadow_addr, region_addr, _summary_data.RegionSize);
3191 }
3192 
3193 bool PSParallelCompact::steal_unavailable_region(ParCompactionManager* cm, size_t &region_idx)
3194 {

3335 {
3336   size_t words = words_remaining();
3337 
3338   HeapWord* const range_end = MIN2(source() + words, bitmap()->region_end());
3339   HeapWord* const end_addr = bitmap()->find_obj_end(source(), range_end);
3340   if (end_addr < range_end) {
3341     words = bitmap()->obj_size(source(), end_addr);
3342   }
3343 
3344   // This test is necessary; if omitted, the pointer updates to a partial object
3345   // that crosses the dense prefix boundary could be overwritten.
3346   if (source() != copy_destination()) {
3347     DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
3348     Copy::aligned_conjoint_words(source(), copy_destination(), words);
3349   }
3350   update_state(words);
3351 }
3352 
3353 void MoveAndUpdateClosure::complete_region(ParCompactionManager *cm, HeapWord *dest_addr,
3354                                            PSParallelCompact::RegionData *region_ptr) {
3355   assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::FinishedShadow, "Region should be finished");
3356   region_ptr->set_completed();
3357 }
3358 
3359 ParMarkBitMapClosure::IterationStatus
3360 MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
3361   assert(destination() != NULL, "sanity");
3362   assert(bitmap()->obj_size(addr) == words, "bad size");
3363 
3364   _source = addr;
3365   assert(PSParallelCompact::summary_data().calc_new_pointer(source(), compaction_manager()) ==
3366          destination(), "wrong destination");
3367 
3368   if (words > words_remaining()) {
3369     return ParMarkBitMap::would_overflow;
3370   }
3371 
3372   // The start_array must be updated even if the object is not moving.
3373   if (_start_array != NULL) {
3374     _start_array->allocate_block(destination());
3375   }
3376 
3377   if (copy_destination() != source()) {
3378     DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
3379     Copy::aligned_conjoint_words(source(), copy_destination(), words);
3380   }
3381 
3382   oop moved_oop = (oop) copy_destination();
3383   compaction_manager()->update_contents(moved_oop);
3384   assert(oopDesc::is_oop_or_null(moved_oop), "Expected an oop or NULL at " PTR_FORMAT, p2i(moved_oop));
3385 
3386   update_state(words);
3387   assert(copy_destination() == (HeapWord*)moved_oop + moved_oop->size(), "sanity");
3388   return is_full() ? ParMarkBitMap::full : ParMarkBitMap::incomplete;
3389 }
3390 
3391 void MoveAndUpdateShadowClosure::complete_region(ParCompactionManager *cm, HeapWord *dest_addr,
3392                                                  PSParallelCompact::RegionData *region_ptr) {
3393   assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::Shadow, "Region should be shadow");
3394   // Record the shadow region index
3395   region_ptr->set_shadow_region(_shadow);
3396   // Mark the shadow region as filled to indicate the data is ready to be
3397   // copied back
3398   region_ptr->mark_filled();
3399   // Try to copy the content of the shadow region back to its corresponding
3400   // heap region if available; the GC thread that decreases the destination
3401   // count to zero will do the copying otherwise (see
3402   // PSParallelCompact::decrement_destination_counts).
3403   if (((region_ptr->available() && region_ptr->claim()) || region_ptr->claimed()) && region_ptr->mark_copied()) {
3404     region_ptr->set_completed();
3405     PSParallelCompact::copy_back(PSParallelCompact::summary_data().region_to_addr(_shadow), dest_addr);
3406     cm->push_shadow_region_mt_safe(_shadow);
3407   }
3408 }
3409 
3410 UpdateOnlyClosure::UpdateOnlyClosure(ParMarkBitMap* mbm,
3411                                      ParCompactionManager* cm,
3412                                      PSParallelCompact::SpaceId space_id) :
3413   ParMarkBitMapClosure(mbm, cm),

3117       assert(closure.source() < end_addr, "sanity");
3118       HeapWord* const obj_beg = closure.source();
3119       HeapWord* const range_end = MIN2(obj_beg + closure.words_remaining(),
3120                                        src_space_top);
3121       HeapWord* const obj_end = bitmap->find_obj_end(obj_beg, range_end);
3122       if (obj_end < range_end) {
3123         // The end was found; the entire object will fit.
3124         status = closure.do_addr(obj_beg, bitmap->obj_size(obj_beg, obj_end));
3125         assert(status != ParMarkBitMap::would_overflow, "sanity");
3126       } else {
3127         // The end was not found; the object will not fit.
3128         assert(range_end < src_space_top, "obj cannot cross space boundary");
3129         status = ParMarkBitMap::would_overflow;
3130       }
3131     }
3132 
3133     if (status == ParMarkBitMap::would_overflow) {
3134       // The last object did not fit.  Note that interior oop updates were
3135       // deferred, then copy enough of the object to fill the region.
3136       region_ptr->set_deferred_obj_addr(closure.destination());

3137       status = closure.copy_until_full(); // copies from closure.source()
3138 
3139       decrement_destination_counts(cm, src_space_id, src_region_idx,
3140                                    closure.source());
3141       closure.complete_region(cm, dest_addr, region_ptr);
3142       return;
3143     }
3144 
3145     if (status == ParMarkBitMap::full) {
3146       decrement_destination_counts(cm, src_space_id, src_region_idx,
3147                                    closure.source());
3148       region_ptr->set_deferred_obj_addr(NULL);
3149       closure.complete_region(cm, dest_addr, region_ptr);
3150       return;
3151     }
3152 
3153     decrement_destination_counts(cm, src_space_id, src_region_idx, end_addr);
3154 
3155     // Move to the next source region, possibly switching spaces as well.  All
3156     // args except end_addr may be modified.
3157     src_region_idx = next_src_region(closure, src_space_id, src_space_top,
3158                                      end_addr);
3159   } while (true);
3160 }
3161 
3162 void PSParallelCompact::fill_and_update_region(ParCompactionManager* cm, size_t region_idx)
3163 {
3164   MoveAndUpdateClosure cl(mark_bitmap(), cm, region_idx);
3165   fill_region(cm, cl, region_idx);
3166 }
3167 
3168 void PSParallelCompact::fill_and_update_shadow_region(ParCompactionManager* cm, size_t region_idx)
3169 {
3170   // Get a shadow region first
3171   ParallelCompactData& sd = summary_data();
3172   RegionData* const region_ptr = sd.region(region_idx);
3173   size_t shadow_region = ParCompactionManager::pop_shadow_region_mt_safe(region_ptr);
3174   // The InvalidShadow return value indicates the corresponding heap region is available,
3175   // so use MoveAndUpdateClosure to fill the normal region. Otherwise, use
3176   // MoveAndUpdateShadowClosure to fill the acquired shadow region.
3177   if (shadow_region == cm->InvalidShadow) {
3178     MoveAndUpdateClosure cl(mark_bitmap(), cm, region_idx);
3179     region_ptr->shadow_to_normal();
3180     return fill_region(cm, cl, region_idx);
3181   } else {
3182     MoveAndUpdateShadowClosure cl(mark_bitmap(), cm, region_idx, shadow_region);
3183     return fill_region(cm, cl, region_idx);
3184   }
3185 }
3186 
3187 void PSParallelCompact::copy_back(HeapWord *shadow_addr, HeapWord *region_addr)
3188 {
3189   Copy::aligned_conjoint_words(shadow_addr, region_addr, _summary_data.RegionSize);
3190 }
3191 
3192 bool PSParallelCompact::steal_unavailable_region(ParCompactionManager* cm, size_t &region_idx)
3193 {

3334 {
3335   size_t words = words_remaining();
3336 
3337   HeapWord* const range_end = MIN2(source() + words, bitmap()->region_end());
3338   HeapWord* const end_addr = bitmap()->find_obj_end(source(), range_end);
3339   if (end_addr < range_end) {
3340     words = bitmap()->obj_size(source(), end_addr);
3341   }
3342 
3343   // This test is necessary; if omitted, the pointer updates to a partial object
3344   // that crosses the dense prefix boundary could be overwritten.
3345   if (source() != copy_destination()) {
3346     DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
3347     Copy::aligned_conjoint_words(source(), copy_destination(), words);
3348   }
3349   update_state(words);
3350 }
3351 
3352 void MoveAndUpdateClosure::complete_region(ParCompactionManager *cm, HeapWord *dest_addr,
3353                                            PSParallelCompact::RegionData *region_ptr) {
3354   assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::NormalRegion, "Region should be finished");
3355   region_ptr->set_completed();
3356 }
3357 
3358 ParMarkBitMapClosure::IterationStatus
3359 MoveAndUpdateClosure::do_addr(HeapWord* addr, size_t words) {
3360   assert(destination() != NULL, "sanity");
3361   assert(bitmap()->obj_size(addr) == words, "bad size");
3362 
3363   _source = addr;
3364   assert(PSParallelCompact::summary_data().calc_new_pointer(source(), compaction_manager()) ==
3365          destination(), "wrong destination");
3366 
3367   if (words > words_remaining()) {
3368     return ParMarkBitMap::would_overflow;
3369   }
3370 
3371   // The start_array must be updated even if the object is not moving.
3372   if (_start_array != NULL) {
3373     _start_array->allocate_block(destination());
3374   }
3375 
3376   if (copy_destination() != source()) {
3377     DEBUG_ONLY(PSParallelCompact::check_new_location(source(), destination());)
3378     Copy::aligned_conjoint_words(source(), copy_destination(), words);
3379   }
3380 
3381   oop moved_oop = (oop) copy_destination();
3382   compaction_manager()->update_contents(moved_oop);
3383   assert(oopDesc::is_oop_or_null(moved_oop), "Expected an oop or NULL at " PTR_FORMAT, p2i(moved_oop));
3384 
3385   update_state(words);
3386   assert(copy_destination() == (HeapWord*)moved_oop + moved_oop->size(), "sanity");
3387   return is_full() ? ParMarkBitMap::full : ParMarkBitMap::incomplete;
3388 }
3389 
3390 void MoveAndUpdateShadowClosure::complete_region(ParCompactionManager *cm, HeapWord *dest_addr,
3391                                                  PSParallelCompact::RegionData *region_ptr) {
3392   assert(region_ptr->shadow_state() == ParallelCompactData::RegionData::ShadowRegion, "Region should be shadow");
3393   // Record the shadow region index
3394   region_ptr->set_shadow_region(_shadow);
3395   // Mark the shadow region as filled to indicate the data is ready to be
3396   // copied back
3397   region_ptr->mark_filled();
3398   // Try to copy the content of the shadow region back to its corresponding
3399   // heap region if available; the GC thread that decreases the destination
3400   // count to zero will do the copying otherwise (see
3401   // PSParallelCompact::decrement_destination_counts).
3402   if (((region_ptr->available() && region_ptr->claim()) || region_ptr->claimed()) && region_ptr->mark_copied()) {
3403     region_ptr->set_completed();
3404     PSParallelCompact::copy_back(PSParallelCompact::summary_data().region_to_addr(_shadow), dest_addr);
3405     cm->push_shadow_region_mt_safe(_shadow);
3406   }
3407 }
3408 
3409 UpdateOnlyClosure::UpdateOnlyClosure(ParMarkBitMap* mbm,
3410                                      ParCompactionManager* cm,
3411                                      PSParallelCompact::SpaceId space_id) :
3412   ParMarkBitMapClosure(mbm, cm),