src/hotspot/share/gc/shared/oopStorageSetParState.inline.hpp

@@ -26,21 +26,80 @@
  #define SHARE_GC_SHARED_OOPSTORAGESETPARSTATE_INLINE_HPP
  
  #include "gc/shared/oopStorageParState.inline.hpp"
  #include "gc/shared/oopStorageSet.hpp"
  #include "gc/shared/oopStorageSetParState.hpp"
+ #include "memory/iterator.hpp"
+ #include "runtime/atomic.hpp"
+ #include "utilities/debug.hpp"
  
  template <bool concurrent, bool is_const>
  OopStorageSetStrongParState<concurrent, is_const>::OopStorageSetStrongParState() :
      _par_states(OopStorageSet::strong_iterator()) {
  }
  
  template <bool concurrent, bool is_const>
- template <typename Closure>
- void OopStorageSetStrongParState<concurrent, is_const>::oops_do(Closure* cl) {
+ template <typename ClosureType>
+ void OopStorageSetStrongParState<concurrent, is_const>::oops_do(ClosureType* cl) {
    for (int i = 0; i < _par_states.count(); i++) {
      _par_states.at(i)->oops_do(cl);
    }
  }
  
+ template <bool concurrent, bool is_const>
+ OopStorageSetWeakParState<concurrent, is_const>::OopStorageSetWeakParState() :
+     _par_states(OopStorageSet::weak_iterator()) {
+ }
+ 
+ template <typename ClosureType>
+ class DeadCounterClosure : public OopClosure {
+ private:
+   ClosureType* const _cl;
+   size_t             _num_dead;
+ 
+ public:
+   DeadCounterClosure(ClosureType* cl) :
+       _cl(cl),
+       _num_dead(0) {}
+ 
+   virtual void do_oop(oop* p) {
+     if (Atomic::load(p) != NULL) {
+       _cl->do_oop(p);
+       if (Atomic::load(p) == NULL) {
+         _num_dead++;
+       }
+     }
+   }
+ 
+   virtual void do_oop(narrowOop* p) {
+     ShouldNotReachHere();
+   }
+ 
+   size_t num_dead() const {
+     return _num_dead;
+   }
+ };
+ 
+ template <bool concurrent, bool is_const>
+ template <typename ClosureType>
+ void OopStorageSetWeakParState<concurrent, is_const>::oops_do(ClosureType* cl) {
+   for (int i = 0; i < _par_states.count(); i++) {
+     ParStateType* state = _par_states.at(i);
+     if (state->storage()->can_notify()) {
+       DeadCounterClosure<ClosureType> counting_cl(cl);
+       state->oops_do(&counting_cl);
+       state->increment_dead_counter(counting_cl.num_dead());
+     } else {
+       state->oops_do(cl);
+     }
+   }
+ }
+ 
+ template <bool concurrent, bool is_const>
+ void OopStorageSetWeakParState<concurrent, is_const>::notify() {
+   for (int i = 0; i < _par_states.count(); i++) {
+     ParStateType* state = _par_states.at(i);
+     state->storage()->notify(state->num_dead());
+   }
+ }
  
  #endif // SHARE_GC_SHARED_OOPSTORAGESETPARSTATE_INLINE_HPP