src/hotspot/share/gc/shenandoah/shenandoahCodeRoots.cpp

@@ -38,24 +38,10 @@
  
  
  ShenandoahNMethodTable* ShenandoahCodeRoots::_nmethod_table;
  int ShenandoahCodeRoots::_disarmed_value = 1;
  
- bool ShenandoahCodeRoots::use_nmethod_barriers_for_mark() {
-   // Continuations need nmethod barriers for scanning stack chunk nmethods.
-   if (Continuations::enabled()) return true;
- 
-   // Concurrent class unloading needs nmethod barriers.
-   // When a nmethod is about to be executed, we need to make sure that all its
-   // metadata are marked. The alternative is to remark thread roots at final mark
-   // pause, which would cause latency issues.
-   if (ShenandoahHeap::heap()->unload_classes()) return true;
- 
-   // Otherwise, we can go without nmethod barriers.
-   return false;
- }
- 
  void ShenandoahCodeRoots::initialize() {
    _nmethod_table = new ShenandoahNMethodTable();
  }
  
  void ShenandoahCodeRoots::register_nmethod(nmethod* nm) {

@@ -66,31 +52,31 @@
  void ShenandoahCodeRoots::unregister_nmethod(nmethod* nm) {
    assert_locked_or_safepoint(CodeCache_lock);
    _nmethod_table->unregister_nmethod(nm);
  }
  
- void ShenandoahCodeRoots::arm_nmethods_for_mark() {
-   if (use_nmethod_barriers_for_mark()) {
-     BarrierSet::barrier_set()->barrier_set_nmethod()->arm_all_nmethods();
+ void ShenandoahCodeRoots::arm_nmethods() {
+   if (ShenandoahGCStateCheckHotpatch) {
+     char gc_state = ShenandoahHeap::heap()->gc_state();
+     log_info(gc)("Arming nmethods with GC state: %d [%s%s%s%s%s%s%s]",
+          gc_state,
+          ((gc_state & ShenandoahHeap::HAS_FORWARDED) > 0) ? "HAS_FORWARDED "  : "",
+          ((gc_state & ShenandoahHeap::MARKING) > 0)       ? "MARKING "        : "",
+          ((gc_state & ShenandoahHeap::EVACUATION) > 0)    ? "EVACUATION "     : "",
+          ((gc_state & ShenandoahHeap::UPDATE_REFS) > 0)   ? "UPDATE_REFS "    : "",
+          ((gc_state & ShenandoahHeap::WEAK_ROOTS) > 0)    ? "WEAK_ROOTS "     : "",
+          ((gc_state & ShenandoahHeap::YOUNG_MARKING) > 0) ? "YOUNG_MARKING "  : "",
+          ((gc_state & ShenandoahHeap::OLD_MARKING) > 0)   ? "OLD_MARKING "    : ""
+     );
    }
- }
- 
- void ShenandoahCodeRoots::arm_nmethods_for_evac() {
    BarrierSet::barrier_set()->barrier_set_nmethod()->arm_all_nmethods();
  }
  
  class ShenandoahDisarmNMethodClosure : public NMethodClosure {
- private:
-   BarrierSetNMethod* const _bs;
- 
  public:
-   ShenandoahDisarmNMethodClosure() :
-     _bs(BarrierSet::barrier_set()->barrier_set_nmethod()) {
-   }
- 
    virtual void do_nmethod(nmethod* nm) {
-     _bs->disarm(nm);
+     ShenandoahNMethod::disarm_nmethod(nm);
    }
  };
  
  class ShenandoahDisarmNMethodsTask : public WorkerTask {
  private:

@@ -98,25 +84,21 @@
    ShenandoahConcurrentNMethodIterator _iterator;
  
  public:
    ShenandoahDisarmNMethodsTask() :
      WorkerTask("Shenandoah Disarm NMethods"),
-     _iterator(ShenandoahCodeRoots::table()) {
-     assert(SafepointSynchronize::is_at_safepoint(), "Only at a safepoint");
-   }
+     _iterator(ShenandoahCodeRoots::table()) {}
  
    virtual void work(uint worker_id) {
      ShenandoahParallelWorkerSession worker_session(worker_id);
      _iterator.nmethods_do(&_cl);
    }
  };
  
  void ShenandoahCodeRoots::disarm_nmethods() {
-   if (use_nmethod_barriers_for_mark()) {
-     ShenandoahDisarmNMethodsTask task;
-     ShenandoahHeap::heap()->workers()->run_task(&task);
-   }
+   ShenandoahDisarmNMethodsTask task;
+   ShenandoahHeap::heap()->workers()->run_task(&task);
  }
  
  class ShenandoahNMethodUnlinkClosure : public NMethodClosure {
  private:
    bool                      _unloading_occurred;