1198   assert(0 <= v && v <= max_jlong, "value should fit: %f", v);
1199   return (jlong)v;
1200 }
1201 
1202 void ShenandoahHeap::prepare_for_verify() {
1203   if (SafepointSynchronize::is_at_safepoint() && UseTLAB) {
1204     labs_make_parsable();
1205   }
1206 }
1207 
1208 void ShenandoahHeap::gc_threads_do(ThreadClosure* tcl) const {
1209   workers()->threads_do(tcl);
1210   if (_safepoint_workers != NULL) {
1211     _safepoint_workers->threads_do(tcl);
1212   }
1213   if (ShenandoahStringDedup::is_enabled()) {
1214     ShenandoahStringDedup::threads_do(tcl);
1215   }
1216 }
1217 




1218 void ShenandoahHeap::print_tracing_info() const {
1219   LogTarget(Info, gc, stats) lt;
1220   if (lt.is_enabled()) {
1221     ResourceMark rm;
1222     LogStream ls(lt);
1223 
1224     phase_timings()->print_global_on(&ls);
1225 
1226     ls.cr();
1227     ls.cr();
1228 
1229     shenandoah_policy()->print_gc_stats(&ls);
1230 
1231     ls.cr();
1232     ls.cr();
1233   }
1234 }
1235 
1236 void ShenandoahHeap::verify(VerifyOption vo) {
1237   if (ShenandoahSafepoint::is_at_shenandoah_safepoint()) {

1324     // This populates the work stack with initial objects.
1325     // It is important to relinquish the associated locks before diving
1326     // into heap dumper.
1327     ShenandoahHeapIterationRootScanner rp;
1328     rp.roots_do(&oops);
1329   }
1330 
1331   // Work through the oop stack to traverse heap.
1332   while (! oop_stack.is_empty()) {
1333     oop obj = oop_stack.pop();
1334     assert(oopDesc::is_oop(obj), "must be a valid oop");
1335     cl->do_object(obj);
1336     obj->oop_iterate(&oops);
1337   }
1338 
1339   assert(oop_stack.is_empty(), "should be empty");
1340 
1341   if (!_aux_bitmap_region_special && !os::uncommit_memory((char*)_aux_bitmap_region.start(), _aux_bitmap_region.byte_size())) {
1342     log_warning(gc)("Could not uncommit native memory for auxiliary marking bitmap for heap iteration");
1343   }
1344 }
1345 
1346 void ShenandoahHeap::run_task(AbstractGangTask* task) {
1347   workers()->run_task(task, workers()->active_workers());
1348 }
1349 
1350 // Keep alive an object that was loaded with AS_NO_KEEPALIVE.
1351 void ShenandoahHeap::keep_alive(oop obj) {
1352   if (is_concurrent_mark_in_progress()) {
1353     ShenandoahBarrierSet::barrier_set()->enqueue(obj);
1354   }
1355 }
1356 
1357 void ShenandoahHeap::heap_region_iterate(ShenandoahHeapRegionClosure* blk) const {
1358   for (size_t i = 0; i < num_regions(); i++) {
1359     ShenandoahHeapRegion* current = get_region(i);
1360     blk->heap_region_do(current);
1361   }
1362 }
1363 
1364 class ShenandoahParallelHeapRegionTask : public AbstractGangTask {
1365 private:
1366   ShenandoahHeap* const _heap;
1367   ShenandoahHeapRegionClosure* const _blk;

1198   assert(0 <= v && v <= max_jlong, "value should fit: %f", v);
1199   return (jlong)v;
1200 }
1201 
1202 void ShenandoahHeap::prepare_for_verify() {
1203   if (SafepointSynchronize::is_at_safepoint() && UseTLAB) {
1204     labs_make_parsable();
1205   }
1206 }
1207 
1208 void ShenandoahHeap::gc_threads_do(ThreadClosure* tcl) const {
1209   workers()->threads_do(tcl);
1210   if (_safepoint_workers != NULL) {
1211     _safepoint_workers->threads_do(tcl);
1212   }
1213   if (ShenandoahStringDedup::is_enabled()) {
1214     ShenandoahStringDedup::threads_do(tcl);
1215   }
1216 }
1217 
1218 void ShenandoahHeap::run_task(AbstractGangTask* task) {
1219   workers()->run_task(task, workers()->active_workers());
1220 }
1221 
1222 void ShenandoahHeap::print_tracing_info() const {
1223   LogTarget(Info, gc, stats) lt;
1224   if (lt.is_enabled()) {
1225     ResourceMark rm;
1226     LogStream ls(lt);
1227 
1228     phase_timings()->print_global_on(&ls);
1229 
1230     ls.cr();
1231     ls.cr();
1232 
1233     shenandoah_policy()->print_gc_stats(&ls);
1234 
1235     ls.cr();
1236     ls.cr();
1237   }
1238 }
1239 
1240 void ShenandoahHeap::verify(VerifyOption vo) {
1241   if (ShenandoahSafepoint::is_at_shenandoah_safepoint()) {

1328     // This populates the work stack with initial objects.
1329     // It is important to relinquish the associated locks before diving
1330     // into heap dumper.
1331     ShenandoahHeapIterationRootScanner rp;
1332     rp.roots_do(&oops);
1333   }
1334 
1335   // Work through the oop stack to traverse heap.
1336   while (! oop_stack.is_empty()) {
1337     oop obj = oop_stack.pop();
1338     assert(oopDesc::is_oop(obj), "must be a valid oop");
1339     cl->do_object(obj);
1340     obj->oop_iterate(&oops);
1341   }
1342 
1343   assert(oop_stack.is_empty(), "should be empty");
1344 
1345   if (!_aux_bitmap_region_special && !os::uncommit_memory((char*)_aux_bitmap_region.start(), _aux_bitmap_region.byte_size())) {
1346     log_warning(gc)("Could not uncommit native memory for auxiliary marking bitmap for heap iteration");
1347   }




1348 }
1349 
1350 // Keep alive an object that was loaded with AS_NO_KEEPALIVE.
1351 void ShenandoahHeap::keep_alive(oop obj) {
1352   if (is_concurrent_mark_in_progress()) {
1353     ShenandoahBarrierSet::barrier_set()->enqueue(obj);
1354   }
1355 }
1356 
1357 void ShenandoahHeap::heap_region_iterate(ShenandoahHeapRegionClosure* blk) const {
1358   for (size_t i = 0; i < num_regions(); i++) {
1359     ShenandoahHeapRegion* current = get_region(i);
1360     blk->heap_region_do(current);
1361   }
1362 }
1363 
1364 class ShenandoahParallelHeapRegionTask : public AbstractGangTask {
1365 private:
1366   ShenandoahHeap* const _heap;
1367   ShenandoahHeapRegionClosure* const _blk;