src/share/vm/gc_implementation/g1/concurrentMark.cpp

rev 7970 : imported patch inc1

*** 2976,2985 ****
--- 2976,2986 ----
  };
  
  class VerifyNoCSetOopsClosure : public OopClosure, public ObjectClosure  {
  private:
    G1CollectedHeap* _g1h;
+   ConcurrentMark* _cm;
    VerifyNoCSetOopsPhase _phase;
    int _info;
  
    const char* phase_str() {
      switch (_phase) {
*** 2991,3007 ****
      }
      return NULL;
    }
  
    void do_object_work(oop obj) {
      guarantee(!_g1h->obj_in_cs(obj),
                err_msg("obj: "PTR_FORMAT" in CSet, phase: %s, info: %d",
                        p2i((void*) obj), phase_str(), _info));
    }
  
  public:
!   VerifyNoCSetOopsClosure() : _g1h(G1CollectedHeap::heap()) { }
  
    void set_phase(VerifyNoCSetOopsPhase phase, int info = -1) {
      _phase = phase;
      _info = info;
    }
--- 2992,3017 ----
      }
      return NULL;
    }
  
    void do_object_work(oop obj) {
+     switch (_phase) {
+     case VerifyNoCSetOopsStack:
+     case VerifyNoCSetOopsQueues:
+       // Ignore reclaimed humongous object entries in mark stack and
+       // thread queues.
+       if (_cm->is_stale_humongous_marked_entry(obj)) break;
+     default:
        guarantee(!_g1h->obj_in_cs(obj),
                  err_msg("obj: "PTR_FORMAT" in CSet, phase: %s, info: %d",
                          p2i((void*) obj), phase_str(), _info));
      }
+   }
  
  public:
!   VerifyNoCSetOopsClosure(G1CollectedHeap* g1h, ConcurrentMark* cm)
!     : _g1h(g1h), _cm(cm) { }
  
    void set_phase(VerifyNoCSetOopsPhase phase, int info = -1) {
      _phase = phase;
      _info = info;
    }
*** 3029,3039 ****
    assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint");
    if (!G1CollectedHeap::heap()->mark_in_progress()) {
      return;
    }
  
!   VerifyNoCSetOopsClosure cl;
  
    if (verify_stacks) {
      // Verify entries on the global mark stack
      cl.set_phase(VerifyNoCSetOopsStack);
      _markStack.oops_do(&cl);
--- 3039,3049 ----
    assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint");
    if (!G1CollectedHeap::heap()->mark_in_progress()) {
      return;
    }
  
!   VerifyNoCSetOopsClosure cl(_g1h, this);
  
    if (verify_stacks) {
      // Verify entries on the global mark stack
      cl.set_phase(VerifyNoCSetOopsStack);
      _markStack.oops_do(&cl);
*** 3404,3413 ****
--- 3414,3424 ----
  }
  #endif
  
  void CMTask::scan_object(oop obj) {
    assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant");
+   assert(!_g1h->is_on_master_free_list(_g1h->heap_region_containing(obj)), "invariant");
  
    if (_cm->verbose_high()) {
      gclog_or_tty->print_cr("[%u] we're scanning object "PTR_FORMAT,
                             _worker_id, p2i((void*) obj));
    }
*** 3816,3834 ****
        if (_cm->verbose_high()) {
          gclog_or_tty->print_cr("[%u] popped "PTR_FORMAT, _worker_id,
                                 p2i((void*) obj));
        }
  
!       assert(_g1h->is_in_g1_reserved((HeapWord*) obj), "invariant" );
! 
!       if (is_stale_humongous_queue_entry(obj)) {
!         statsOnly( ++stale_humongous_queue_entries );
!       } else {
!         assert(!_g1h->is_on_master_free_list(
!                  _g1h->heap_region_containing(obj)), "invariant");
!         scan_object(obj);
!       }
  
        if (_task_queue->size() <= target_size || has_aborted()) {
          ret = false;
        } else {
          ret = _task_queue->pop_local(obj);
--- 3827,3837 ----
        if (_cm->verbose_high()) {
          gclog_or_tty->print_cr("[%u] popped "PTR_FORMAT, _worker_id,
                                 p2i((void*) obj));
        }
  
!       process_queue_entry(obj);
  
        if (_task_queue->size() <= target_size || has_aborted()) {
          ret = false;
        } else {
          ret = _task_queue->pop_local(obj);
*** 4328,4345 ****
            gclog_or_tty->print_cr("[%u] stolen "PTR_FORMAT" successfully",
                                   _worker_id, p2i((void*) obj));
          }
  
          statsOnly( ++_steals );
! 
!         if (is_stale_humongous_queue_entry(obj)) {
!           statsOnly( ++stale_humongous_queue_entries );
!         } else {
!           assert(_nextMarkBitMap->isMarked((HeapWord*) obj),
!                  "any stolen object should be marked");
!           scan_object(obj);
!         }
  
          // And since we're towards the end, let's totally drain the
          // local queue and global stack.
          drain_local_queue(false);
          drain_global_stack(false);
--- 4331,4341 ----
            gclog_or_tty->print_cr("[%u] stolen "PTR_FORMAT" successfully",
                                   _worker_id, p2i((void*) obj));
          }
  
          statsOnly( ++_steals );
!         process_queue_entry(obj);
  
          // And since we're towards the end, let's totally drain the
          // local queue and global stack.
          drain_local_queue(false);
          drain_global_stack(false);