1256 inline bool PSParallelCompact::is_marked(oop obj) {

  1257   return mark_bitmap()->is_marked(obj);

  1258 }

  1259 

  1260 inline double PSParallelCompact::normal_distribution(double density) {

  1261   assert(_dwl_initialized, "uninitialized");

  1262   const double squared_term = (density - _dwl_mean) / _dwl_std_dev;

  1263   return _dwl_first_term * exp(-0.5 * squared_term * squared_term);

  1264 }

  1265 

  1266 inline bool

  1267 PSParallelCompact::dead_space_crosses_boundary(const RegionData* region,

  1268                                                idx_t bit)

  1269 {

  1270   assert(bit > 0, "cannot call this for the first bit/region");

  1271   assert(_summary_data.region_to_addr(region) == _mark_bitmap.bit_to_addr(bit),

  1272          "sanity check");

  1273 

  1274   // Dead space crosses the boundary if (1) a partial object does not extend

  1275   // onto the region, (2) an object does not start at the beginning of the

  1276   // region, and (3) an object does not end at the end of the prior region.

  1277   return region->partial_obj_size() == 0 &&

  1278     !_mark_bitmap.is_obj_beg(bit) &&

  1279     !_mark_bitmap.is_obj_end(bit - 1);

  1280 }

  1281 

  1282 inline bool

  1283 PSParallelCompact::is_in(HeapWord* p, HeapWord* beg_addr, HeapWord* end_addr) {

  1284   return p >= beg_addr && p < end_addr;

  1285 }

  1286 

  1287 inline bool

  1288 PSParallelCompact::is_in(oop* p, HeapWord* beg_addr, HeapWord* end_addr) {

  1289   return is_in((HeapWord*)p, beg_addr, end_addr);

  1290 }

  1291 

  1292 inline MutableSpace* PSParallelCompact::space(SpaceId id) {

  1293   assert(id < last_space_id, "id out of range");

  1294   return _space_info[id].space();

  1295 }

  1296 

  1297 inline HeapWord* PSParallelCompact::new_top(SpaceId id) {

  1298   assert(id < last_space_id, "id out of range");

  1299   return _space_info[id].new_top();

  1300 }

  1301 

  1302 inline HeapWord* PSParallelCompact::dense_prefix(SpaceId id) {

  1303   assert(id < last_space_id, "id out of range");

  1304   return _space_info[id].dense_prefix();

  1305 }

  1306 

  1307 inline ObjectStartArray* PSParallelCompact::start_array(SpaceId id) {

  1308   assert(id < last_space_id, "id out of range");

  1309   return _space_info[id].start_array();

  1310 }

  1311 

  1312 #ifdef ASSERT

  1313 inline void

  1314 PSParallelCompact::check_new_location(HeapWord* old_addr, HeapWord* new_addr)

  1315 {

  1316   assert(old_addr >= new_addr || space_id(old_addr) != space_id(new_addr),

  1317          "must move left or to a different space");

  1318   assert(is_object_aligned((intptr_t)old_addr) && is_object_aligned((intptr_t)new_addr),

  1319          "checking alignment");

  1320 }

  1321 #endif // ASSERT

  1322