3044 
3045           src_space_id = SpaceId(space_id);
3046           src_space_top = space->top();
3047           const size_t src_region_idx = sd.region(src_cp);
3048           closure.set_source(sd.region_to_addr(src_region_idx));
3049           return src_region_idx;
3050         } else {
3051           assert(src_cp->data_size() == 0, "sanity");
3052         }
3053       }
3054     }
3055   } while (++space_id < last_space_id);
3056 
3057   assert(false, "no source region was found");
3058   return 0;
3059 }
3060 
3061 void PSParallelCompact::fill_region(ParCompactionManager* cm, MoveAndUpdateClosure& closure, size_t region_idx)
3062 {
3063   typedef ParMarkBitMap::IterationStatus IterationStatus;
3064   const size_t RegionSize = ParallelCompactData::RegionSize;
3065   ParMarkBitMap* const bitmap = mark_bitmap();
3066   ParallelCompactData& sd = summary_data();
3067   RegionData* const region_ptr = sd.region(region_idx);
3068 
3069   // Get the source region and related info.
3070   size_t src_region_idx = region_ptr->source_region();
3071   SpaceId src_space_id = space_id(sd.region_to_addr(src_region_idx));
3072   HeapWord* src_space_top = _space_info[src_space_id].space()->top();
3073   HeapWord* dest_addr = sd.region_to_addr(region_idx);
3074 
3075   closure.set_source(first_src_addr(dest_addr, src_space_id, src_region_idx));
3076 
3077   // Adjust src_region_idx to prepare for decrementing destination counts (the
3078   // destination count is not decremented when a region is copied to itself).
3079   if (src_region_idx == region_idx) {
3080     src_region_idx += 1;
3081   }
3082 
3083   if (bitmap->is_unmarked(closure.source())) {
3084     // The first source word is in the middle of an object; copy the remainder

3156 
3157     // Move to the next source region, possibly switching spaces as well.  All
3158     // args except end_addr may be modified.
3159     src_region_idx = next_src_region(closure, src_space_id, src_space_top,
3160                                      end_addr);
3161   } while (true);
3162 }
3163 
3164 void PSParallelCompact::fill_and_update_region(ParCompactionManager* cm, size_t region_idx)
3165 {
3166   MoveAndUpdateClosure cl(mark_bitmap(), cm, region_idx);
3167   fill_region(cm, cl, region_idx);
3168 }
3169 
3170 void PSParallelCompact::fill_and_update_shadow_region(ParCompactionManager* cm, size_t region_idx)
3171 {
3172   // Get a shadow region first
3173   ParallelCompactData& sd = summary_data();
3174   RegionData* const region_ptr = sd.region(region_idx);
3175   size_t shadow_region = cm->pop_shadow_region_mt_safe(region_ptr);
3176   // The zero return value indicates the corresponding heap region is available,
3177   // so use MoveAndUpdateClosure to fill the normal region. Otherwise, use
3178   // MoveAndUpdateShadowClosure to fill the acquired shadow region.
3179   if (shadow_region == 0) {
3180     MoveAndUpdateClosure cl(mark_bitmap(), cm, region_idx);
3181     region_ptr->shadow_to_normal();
3182     return fill_region(cm, cl, region_idx);
3183   } else {
3184     MoveAndUpdateShadowClosure cl(mark_bitmap(), cm, region_idx, shadow_region);
3185     return fill_region(cm, cl, region_idx);
3186   }
3187 }
3188 
3189 void PSParallelCompact::copy_back(HeapWord *shadow_addr, HeapWord *region_addr)
3190 {
3191   Copy::aligned_conjoint_words(shadow_addr, region_addr, _summary_data.RegionSize);
3192 }
3193 
3194 bool PSParallelCompact::steal_unavailable_region(ParCompactionManager* cm, size_t &region_idx)
3195 {
3196   size_t next = cm->next_shadow_region();
3197   ParallelCompactData& sd = summary_data();
3198   size_t old_new_top = sd.addr_to_region_idx(_space_info[old_space_id].new_top());
3199   uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers();

3044 
3045           src_space_id = SpaceId(space_id);
3046           src_space_top = space->top();
3047           const size_t src_region_idx = sd.region(src_cp);
3048           closure.set_source(sd.region_to_addr(src_region_idx));
3049           return src_region_idx;
3050         } else {
3051           assert(src_cp->data_size() == 0, "sanity");
3052         }
3053       }
3054     }
3055   } while (++space_id < last_space_id);
3056 
3057   assert(false, "no source region was found");
3058   return 0;
3059 }
3060 
3061 void PSParallelCompact::fill_region(ParCompactionManager* cm, MoveAndUpdateClosure& closure, size_t region_idx)
3062 {
3063   typedef ParMarkBitMap::IterationStatus IterationStatus;

3064   ParMarkBitMap* const bitmap = mark_bitmap();
3065   ParallelCompactData& sd = summary_data();
3066   RegionData* const region_ptr = sd.region(region_idx);
3067 
3068   // Get the source region and related info.
3069   size_t src_region_idx = region_ptr->source_region();
3070   SpaceId src_space_id = space_id(sd.region_to_addr(src_region_idx));
3071   HeapWord* src_space_top = _space_info[src_space_id].space()->top();
3072   HeapWord* dest_addr = sd.region_to_addr(region_idx);
3073 
3074   closure.set_source(first_src_addr(dest_addr, src_space_id, src_region_idx));
3075 
3076   // Adjust src_region_idx to prepare for decrementing destination counts (the
3077   // destination count is not decremented when a region is copied to itself).
3078   if (src_region_idx == region_idx) {
3079     src_region_idx += 1;
3080   }
3081 
3082   if (bitmap->is_unmarked(closure.source())) {
3083     // The first source word is in the middle of an object; copy the remainder

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 {
3195   size_t next = cm->next_shadow_region();
3196   ParallelCompactData& sd = summary_data();
3197   size_t old_new_top = sd.addr_to_region_idx(_space_info[old_space_id].new_top());
3198   uint active_gc_threads = ParallelScavengeHeap::heap()->workers().active_workers();