< prev index next >

src/hotspot/share/gc/z/zRootsIterator.cpp

Print this page
rev 50503 : ZGC: The Z Garbage Collector v92
rev 50504 : imported patch ZGC_Concurrent_cleaning_of_StringTable
rev 50506 : imported patch 8204613-stringtable-cleaning-zgc


 290   } else {
 291     if (visit_jvmti_weak_export) {
 292       _jvmti_weak_export.oops_do(cl);
 293     }
 294   }
 295 }
 296 
 297 ZWeakRootsIterator::ZWeakRootsIterator() :
 298     _vm_weak_handles_iter(SystemDictionary::vm_weak_oop_storage()),
 299     _jni_weak_handles_iter(JNIHandles::weak_global_handles()),
 300     _string_table_iter(StringTable::weak_storage()),
 301     _jvmti_weak_export(this),
 302     _jfr_weak(this),
 303     _vm_weak_handles(this),
 304     _jni_weak_handles(this),
 305     _symbol_table(this),
 306     _string_table(this) {
 307   assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint");
 308   ZStatTimer timer(ZSubPhasePauseWeakRootsSetup);
 309   SymbolTable::clear_parallel_claimed_index();

 310 }
 311 
 312 ZWeakRootsIterator::~ZWeakRootsIterator() {
 313   ZStatTimer timer(ZSubPhasePauseWeakRootsTeardown);

 314 }
 315 
 316 void ZWeakRootsIterator::do_vm_weak_handles(BoolObjectClosure* is_alive, OopClosure* cl) {
 317   ZStatTimer timer(ZSubPhasePauseWeakRootsVMWeakHandles);
 318   _vm_weak_handles_iter.weak_oops_do(is_alive, cl);
 319 }
 320 
 321 void ZWeakRootsIterator::do_jni_weak_handles(BoolObjectClosure* is_alive, OopClosure* cl) {
 322   ZStatTimer timer(ZSubPhasePauseWeakRootsJNIWeakHandles);
 323   _jni_weak_handles_iter.weak_oops_do(is_alive, cl);
 324 }
 325 
 326 void ZWeakRootsIterator::do_jvmti_weak_export(BoolObjectClosure* is_alive, OopClosure* cl) {
 327   ZStatTimer timer(ZSubPhasePauseWeakRootsJVMTIWeakExport);
 328   JvmtiExport::weak_oops_do(is_alive, cl);
 329 }
 330 
 331 void ZWeakRootsIterator::do_jfr_weak(BoolObjectClosure* is_alive, OopClosure* cl) {
 332 #if INCLUDE_JFR
 333   ZStatTimer timer(ZSubPhasePauseWeakRootsJFRWeak);
 334   Jfr::weak_oops_do(is_alive, cl);
 335 #endif
 336 }
 337 
 338 void ZWeakRootsIterator::do_symbol_table(BoolObjectClosure* is_alive, OopClosure* cl) {
 339   ZStatTimer timer(ZSubPhasePauseWeakRootsSymbolTable);
 340   int dummy;
 341   SymbolTable::possibly_parallel_unlink(&dummy, &dummy);
 342 }
 343 
























 344 void ZWeakRootsIterator::do_string_table(BoolObjectClosure* is_alive, OopClosure* cl) {
 345   ZStatTimer timer(ZSubPhasePauseWeakRootsStringTable);
 346   _string_table_iter.weak_oops_do(is_alive, cl);

 347 }
 348 
 349 void ZWeakRootsIterator::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* cl) {
 350   ZStatTimer timer(ZSubPhasePauseWeakRoots);
 351   if (ZSymbolTableUnloading) {
 352     _symbol_table.weak_oops_do(is_alive, cl);
 353   }
 354   if (ZWeakRoots) {
 355     _jvmti_weak_export.weak_oops_do(is_alive, cl);
 356     _jfr_weak.weak_oops_do(is_alive, cl);
 357     if (!ZConcurrentVMWeakHandles) {
 358       _vm_weak_handles.weak_oops_do(is_alive, cl);
 359     }
 360     if (!ZConcurrentJNIWeakGlobalHandles) {
 361       _jni_weak_handles.weak_oops_do(is_alive, cl);
 362     }
 363     if (!ZConcurrentStringTable) {
 364       _string_table.weak_oops_do(is_alive, cl);
 365     }
 366   }
 367 }
 368 
 369 void ZWeakRootsIterator::oops_do(OopClosure* cl) {
 370   AlwaysTrueClosure always_alive;
 371   weak_oops_do(&always_alive, cl);
 372 }
 373 
 374 ZConcurrentWeakRootsIterator::ZConcurrentWeakRootsIterator() :
 375     _vm_weak_handles_iter(SystemDictionary::vm_weak_oop_storage()),
 376     _jni_weak_handles_iter(JNIHandles::weak_global_handles()),
 377     _string_table_iter(StringTable::weak_storage()),
 378     _vm_weak_handles(this),
 379     _jni_weak_handles(this),
 380     _string_table(this) {}






 381 
 382 void ZConcurrentWeakRootsIterator::do_vm_weak_handles(OopClosure* cl) {
 383   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsVMWeakHandles);
 384   _vm_weak_handles_iter.oops_do(cl);
 385 }
 386 
 387 void ZConcurrentWeakRootsIterator::do_jni_weak_handles(OopClosure* cl) {
 388   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsJNIWeakHandles);
 389   _jni_weak_handles_iter.oops_do(cl);
 390 }
 391 


























 392 void ZConcurrentWeakRootsIterator::do_string_table(OopClosure* cl) {
 393   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsStringTable);
 394   _string_table_iter.oops_do(cl);

 395 }
 396 
 397 void ZConcurrentWeakRootsIterator::oops_do(OopClosure* cl) {
 398   ZStatTimer timer(ZSubPhaseConcurrentWeakRoots);
 399   if (ZWeakRoots) {
 400     if (ZConcurrentVMWeakHandles) {
 401       _vm_weak_handles.oops_do(cl);
 402     }
 403     if (ZConcurrentJNIWeakGlobalHandles) {
 404       _jni_weak_handles.oops_do(cl);
 405     }
 406     if (ZConcurrentStringTable) {
 407       _string_table.oops_do(cl);
 408     }
 409   }
 410 }
 411 
 412 ZThreadRootsIterator::ZThreadRootsIterator() :
 413     _threads(this) {
 414   assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint");


 290   } else {
 291     if (visit_jvmti_weak_export) {
 292       _jvmti_weak_export.oops_do(cl);
 293     }
 294   }
 295 }
 296 
 297 ZWeakRootsIterator::ZWeakRootsIterator() :
 298     _vm_weak_handles_iter(SystemDictionary::vm_weak_oop_storage()),
 299     _jni_weak_handles_iter(JNIHandles::weak_global_handles()),
 300     _string_table_iter(StringTable::weak_storage()),
 301     _jvmti_weak_export(this),
 302     _jfr_weak(this),
 303     _vm_weak_handles(this),
 304     _jni_weak_handles(this),
 305     _symbol_table(this),
 306     _string_table(this) {
 307   assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint");
 308   ZStatTimer timer(ZSubPhasePauseWeakRootsSetup);
 309   SymbolTable::clear_parallel_claimed_index();
 310   StringTable::reset_dead_counter();
 311 }
 312 
 313 ZWeakRootsIterator::~ZWeakRootsIterator() {
 314   ZStatTimer timer(ZSubPhasePauseWeakRootsTeardown);
 315   StringTable::finish_dead_counter();
 316 }
 317 
 318 void ZWeakRootsIterator::do_vm_weak_handles(BoolObjectClosure* is_alive, OopClosure* cl) {
 319   ZStatTimer timer(ZSubPhasePauseWeakRootsVMWeakHandles);
 320   _vm_weak_handles_iter.weak_oops_do(is_alive, cl);
 321 }
 322 
 323 void ZWeakRootsIterator::do_jni_weak_handles(BoolObjectClosure* is_alive, OopClosure* cl) {
 324   ZStatTimer timer(ZSubPhasePauseWeakRootsJNIWeakHandles);
 325   _jni_weak_handles_iter.weak_oops_do(is_alive, cl);
 326 }
 327 
 328 void ZWeakRootsIterator::do_jvmti_weak_export(BoolObjectClosure* is_alive, OopClosure* cl) {
 329   ZStatTimer timer(ZSubPhasePauseWeakRootsJVMTIWeakExport);
 330   JvmtiExport::weak_oops_do(is_alive, cl);
 331 }
 332 
 333 void ZWeakRootsIterator::do_jfr_weak(BoolObjectClosure* is_alive, OopClosure* cl) {
 334 #if INCLUDE_JFR
 335   ZStatTimer timer(ZSubPhasePauseWeakRootsJFRWeak);
 336   Jfr::weak_oops_do(is_alive, cl);
 337 #endif
 338 }
 339 
 340 void ZWeakRootsIterator::do_symbol_table(BoolObjectClosure* is_alive, OopClosure* cl) {
 341   ZStatTimer timer(ZSubPhasePauseWeakRootsSymbolTable);
 342   int dummy;
 343   SymbolTable::possibly_parallel_unlink(&dummy, &dummy);
 344 }
 345 
 346 class ZStringTableDeadCounterBoolObjectClosure : public BoolObjectClosure  {
 347 private:
 348   BoolObjectClosure* const _cl;
 349   size_t                   _ndead;
 350 
 351 public:
 352   ZStringTableDeadCounterBoolObjectClosure(BoolObjectClosure* cl) :
 353       _cl(cl),
 354       _ndead(0) {}
 355 
 356   ~ZStringTableDeadCounterBoolObjectClosure() {
 357     StringTable::inc_dead_counter(_ndead);
 358   }
 359 
 360   virtual bool do_object_b(oop obj) {
 361     if (_cl->do_object_b(obj)) {
 362       return true;
 363     }
 364 
 365     _ndead++;
 366     return false;
 367   }
 368 };
 369 
 370 void ZWeakRootsIterator::do_string_table(BoolObjectClosure* is_alive, OopClosure* cl) {
 371   ZStatTimer timer(ZSubPhasePauseWeakRootsStringTable);
 372   ZStringTableDeadCounterBoolObjectClosure counter_is_alive(is_alive);
 373   _string_table_iter.weak_oops_do(&counter_is_alive, cl);
 374 }
 375 
 376 void ZWeakRootsIterator::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* cl) {
 377   ZStatTimer timer(ZSubPhasePauseWeakRoots);
 378   if (ZSymbolTableUnloading) {
 379     _symbol_table.weak_oops_do(is_alive, cl);
 380   }
 381   if (ZWeakRoots) {
 382     _jvmti_weak_export.weak_oops_do(is_alive, cl);
 383     _jfr_weak.weak_oops_do(is_alive, cl);
 384     if (!ZConcurrentVMWeakHandles) {
 385       _vm_weak_handles.weak_oops_do(is_alive, cl);
 386     }
 387     if (!ZConcurrentJNIWeakGlobalHandles) {
 388       _jni_weak_handles.weak_oops_do(is_alive, cl);
 389     }
 390     if (!ZConcurrentStringTable) {
 391       _string_table.weak_oops_do(is_alive, cl);
 392     }
 393   }
 394 }
 395 
 396 void ZWeakRootsIterator::oops_do(OopClosure* cl) {
 397   AlwaysTrueClosure always_alive;
 398   weak_oops_do(&always_alive, cl);
 399 }
 400 
 401 ZConcurrentWeakRootsIterator::ZConcurrentWeakRootsIterator() :
 402     _vm_weak_handles_iter(SystemDictionary::vm_weak_oop_storage()),
 403     _jni_weak_handles_iter(JNIHandles::weak_global_handles()),
 404     _string_table_iter(StringTable::weak_storage()),
 405     _vm_weak_handles(this),
 406     _jni_weak_handles(this),
 407     _string_table(this) {
 408   StringTable::reset_dead_counter();
 409 }
 410 
 411 ZConcurrentWeakRootsIterator::~ZConcurrentWeakRootsIterator() {
 412   StringTable::finish_dead_counter();
 413 }
 414 
 415 void ZConcurrentWeakRootsIterator::do_vm_weak_handles(OopClosure* cl) {
 416   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsVMWeakHandles);
 417   _vm_weak_handles_iter.oops_do(cl);
 418 }
 419 
 420 void ZConcurrentWeakRootsIterator::do_jni_weak_handles(OopClosure* cl) {
 421   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsJNIWeakHandles);
 422   _jni_weak_handles_iter.oops_do(cl);
 423 }
 424 
 425 class ZStringTableDeadCounterOopClosure : public OopClosure  {
 426 private:
 427   OopClosure* const _cl;
 428   size_t            _ndead;
 429 
 430 public:
 431   ZStringTableDeadCounterOopClosure(OopClosure* cl) :
 432       _cl(cl),
 433       _ndead(0) {}
 434 
 435   ~ZStringTableDeadCounterOopClosure() {
 436     StringTable::inc_dead_counter(_ndead);
 437   }
 438 
 439   virtual void do_oop(oop* p) {
 440     _cl->do_oop(p);
 441     if (*p == NULL) {
 442       _ndead++;
 443     }
 444   }
 445 
 446   virtual void do_oop(narrowOop* p) {
 447     ShouldNotReachHere();
 448   }
 449 };
 450 
 451 void ZConcurrentWeakRootsIterator::do_string_table(OopClosure* cl) {
 452   ZStatTimer timer(ZSubPhaseConcurrentWeakRootsStringTable);
 453   ZStringTableDeadCounterOopClosure counter_cl(cl);
 454   _string_table_iter.oops_do(&counter_cl);
 455 }
 456 
 457 void ZConcurrentWeakRootsIterator::oops_do(OopClosure* cl) {
 458   ZStatTimer timer(ZSubPhaseConcurrentWeakRoots);
 459   if (ZWeakRoots) {
 460     if (ZConcurrentVMWeakHandles) {
 461       _vm_weak_handles.oops_do(cl);
 462     }
 463     if (ZConcurrentJNIWeakGlobalHandles) {
 464       _jni_weak_handles.oops_do(cl);
 465     }
 466     if (ZConcurrentStringTable) {
 467       _string_table.oops_do(cl);
 468     }
 469   }
 470 }
 471 
 472 ZThreadRootsIterator::ZThreadRootsIterator() :
 473     _threads(this) {
 474   assert(SafepointSynchronize::is_at_safepoint(), "Should be at safepoint");
< prev index next >