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

*** 31,10 ***
--- 31,11 ---
  #include "gc/shenandoah/shenandoahNMethod.inline.hpp"
  #include "gc/shenandoah/shenandoahUtils.hpp"
  #include "memory/resourceArea.hpp"
  #include "memory/universe.hpp"
  #include "runtime/atomicAccess.hpp"
+ #include "utilities/events.hpp"
  #include "utilities/powerOfTwo.hpp"
  
  
  ShenandoahNMethodTable* ShenandoahCodeRoots::_nmethod_table;
  int ShenandoahCodeRoots::_disarmed_value = 1;

*** 52,17 ***
    assert_locked_or_safepoint(CodeCache_lock);
    _nmethod_table->unregister_nmethod(nm);
  }
  
  void ShenandoahCodeRoots::arm_nmethods() {
    BarrierSet::barrier_set()->barrier_set_nmethod()->arm_all_nmethods();
  }
  
  class ShenandoahDisarmNMethodClosure : public NMethodClosure {
  public:
    virtual void do_nmethod(nmethod* nm) {
!     ShenandoahNMethod::disarm_nmethod(nm);
    }
  };
  
  class ShenandoahDisarmNMethodsTask : public WorkerTask {
  private:
--- 53,38 ---
    assert_locked_or_safepoint(CodeCache_lock);
    _nmethod_table->unregister_nmethod(nm);
  }
  
  void ShenandoahCodeRoots::arm_nmethods() {
+   char gc_state = ShenandoahHeap::heap()->gc_state();
+   Events::log(Thread::current(), "Arming nmethods, 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 "    : ""
+   );
+   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 "    : ""
+   );
    BarrierSet::barrier_set()->barrier_set_nmethod()->arm_all_nmethods();
  }
  
  class ShenandoahDisarmNMethodClosure : public NMethodClosure {
  public:
    virtual void do_nmethod(nmethod* nm) {
!     ShenandoahNMethod::complete_and_disarm_nmethod(nm);
    }
  };
  
  class ShenandoahDisarmNMethodsTask : public WorkerTask {
  private:

*** 70,24 ***
    ShenandoahConcurrentNMethodIterator _iterator;
  
  public:
    ShenandoahDisarmNMethodsTask() :
      WorkerTask("Shenandoah Disarm NMethods"),
!     _iterator(ShenandoahCodeRoots::table()) {
-     assert(SafepointSynchronize::is_at_safepoint(), "Only at a safepoint");
-   }
  
    virtual void work(uint worker_id) {
      ShenandoahParallelWorkerSession worker_session(worker_id);
      _iterator.nmethods_do(&_cl);
    }
  };
  
  void ShenandoahCodeRoots::disarm_nmethods() {
    ShenandoahDisarmNMethodsTask task;
    ShenandoahHeap::heap()->workers()->run_task(&task);
  }
  
  class ShenandoahNMethodUnlinkClosure : public NMethodClosure {
  private:
    bool                      _unloading_occurred;
    ShenandoahHeap* const     _heap;
--- 92,60 ---
    ShenandoahConcurrentNMethodIterator _iterator;
  
  public:
    ShenandoahDisarmNMethodsTask() :
      WorkerTask("Shenandoah Disarm NMethods"),
!     _iterator(ShenandoahCodeRoots::table()) {}
  
    virtual void work(uint worker_id) {
      ShenandoahParallelWorkerSession worker_session(worker_id);
      _iterator.nmethods_do(&_cl);
    }
  };
  
  void ShenandoahCodeRoots::disarm_nmethods() {
+   Events::log(Thread::current(), "Disarming nmethod barriers");
+   log_info(gc)("Disarming nmethod barriers");
+ 
    ShenandoahDisarmNMethodsTask task;
    ShenandoahHeap::heap()->workers()->run_task(&task);
+ 
+   Events::log(Thread::current(), "Disarming nmethod barriers complete");
+   log_info(gc)("Disarming nmethod barriers complete");
+ }
+ 
+ #ifdef ASSERT
+ class ShenandoahCheckNMethodClosure : public NMethodClosure {
+   bool const _armed;
+ public:
+   ShenandoahCheckNMethodClosure(int armed) : _armed(armed) {}
+   virtual void do_nmethod(nmethod* nm) {
+     ShenandoahNMethod::assert_barriers(nm, _armed);
+   }
+ };
+ 
+ class ShenandoahCheckNMethodsTask : public WorkerTask {
+ private:
+   ShenandoahCheckNMethodClosure      _cl;
+   ShenandoahConcurrentNMethodIterator _iterator;
+ 
+ public:
+   ShenandoahCheckNMethodsTask() :
+     WorkerTask("Shenandoah Check NMethods"),
+     _cl(!ShenandoahHeap::heap()->is_idle()),
+     _iterator(ShenandoahCodeRoots::table()) {}
+ 
+   virtual void work(uint worker_id) {
+     _iterator.nmethods_do(&_cl);
+   }
+ };
+ 
+ void ShenandoahCodeRoots::check_barriers() {
+   ShenandoahCheckNMethodsTask task;
+   ShenandoahHeap::heap()->workers()->run_task(&task);
  }
+ #endif
  
  class ShenandoahNMethodUnlinkClosure : public NMethodClosure {
  private:
    bool                      _unloading_occurred;
    ShenandoahHeap* const     _heap;

*** 109,11 ***
        ShenandoahNMethodLocker locker(nm_data->lock());
        nm->unlink();
        return;
      }
  
!     {
        ShenandoahNMethodLocker locker(nm_data->lock());
  
        // Heal oops
        if (_bs->is_armed(nm)) {
          ShenandoahNMethod::heal_nmethod_metadata(nm_data);
--- 167,11 ---
        ShenandoahNMethodLocker locker(nm_data->lock());
        nm->unlink();
        return;
      }
  
!     if (_heap->is_evacuation_in_progress()) {
        ShenandoahNMethodLocker locker(nm_data->lock());
  
        // Heal oops
        if (_bs->is_armed(nm)) {
          ShenandoahNMethod::heal_nmethod_metadata(nm_data);