src/share/vm/gc/g1/g1ConcurrentMark.cpp

rev 10464 : imported patch 8151126-clean-up-duplicate-code-for-clearing-bitmaps
rev 10465 : [mq]: 8151614-improve-concurrent-mark-logging

*** 850,860 ****
        // not clear the overflow flag since we rely on it being true when
        // we exit this method to abort the pause and restart concurrent
        // marking.
        reset_marking_state(true /* clear_overflow */);
  
!       log_info(gc)("Concurrent Mark reset for overflow");
      }
    }
  
    // after this, each task should reset its own data structures then
    // then go into the second barrier
--- 850,860 ----
        // not clear the overflow flag since we rely on it being true when
        // we exit this method to abort the pause and restart concurrent
        // marking.
        reset_marking_state(true /* clear_overflow */);
  
!       log_info(gc, marking)("Concurrent Mark reset for overflow");
      }
    }
  
    // after this, each task should reset its own data structures then
    // then go into the second barrier
*** 985,1001 ****
        hr = root_regions->claim_next();
      }
    }
  };
  
! void G1ConcurrentMark::scanRootRegions() {
    // scan_in_progress() will have been set to true only if there was
    // at least one root region to scan. So, if it's false, we
    // should not attempt to do any further work.
    if (root_regions()->scan_in_progress()) {
      assert(!has_aborted(), "Aborting before root region scanning is finished not supported.");
-     GCTraceConcTime(Info, gc) tt("Concurrent Root Region Scan");
  
      _parallel_marking_threads = calc_parallel_marking_threads();
      assert(parallel_marking_threads() <= max_parallel_marking_threads(),
             "Maximum number of marking threads exceeded");
      uint active_workers = MAX2(1U, parallel_marking_threads());
--- 985,1000 ----
        hr = root_regions->claim_next();
      }
    }
  };
  
! void G1ConcurrentMark::scan_root_regions() {
    // scan_in_progress() will have been set to true only if there was
    // at least one root region to scan. So, if it's false, we
    // should not attempt to do any further work.
    if (root_regions()->scan_in_progress()) {
      assert(!has_aborted(), "Aborting before root region scanning is finished not supported.");
  
      _parallel_marking_threads = calc_parallel_marking_threads();
      assert(parallel_marking_threads() <= max_parallel_marking_threads(),
             "Maximum number of marking threads exceeded");
      uint active_workers = MAX2(1U, parallel_marking_threads());
*** 1049,1059 ****
  
  void G1ConcurrentMark::register_concurrent_gc_end_and_stop_timer() {
    register_concurrent_phase_end_common(true);
  }
  
! void G1ConcurrentMark::markFromRoots() {
    // we might be tempted to assert that:
    // assert(asynch == !SafepointSynchronize::is_at_safepoint(),
    //        "inconsistent argument?");
    // However that wouldn't be right, because it's possible that
    // a safepoint is indeed in progress as a younger generation
--- 1048,1058 ----
  
  void G1ConcurrentMark::register_concurrent_gc_end_and_stop_timer() {
    register_concurrent_phase_end_common(true);
  }
  
! void G1ConcurrentMark::mark_from_roots() {
    // we might be tempted to assert that:
    // assert(asynch == !SafepointSynchronize::is_at_safepoint(),
    //        "inconsistent argument?");
    // However that wouldn't be right, because it's possible that
    // a safepoint is indeed in progress as a younger generation
*** 1112,1122 ****
    weakRefsWork(clear_all_soft_refs);
  
    if (has_overflown()) {
      // Oops.  We overflowed.  Restart concurrent marking.
      _restart_for_overflow = true;
-     log_develop_trace(gc)("Remark led to restart for overflow.");
  
      // Verify the heap w.r.t. the previous marking bitmap.
      if (VerifyDuringGC) {
        HandleMark hm;  // handle scope
        g1h->prepare_for_verify();
--- 1111,1120 ----
*** 1758,1768 ****
    g1h->allocation_context_stats().update_after_mark();
  
    g1h->trace_heap_after_concurrent_cycle();
  }
  
! void G1ConcurrentMark::completeCleanup() {
    if (has_aborted()) return;
  
    G1CollectedHeap* g1h = G1CollectedHeap::heap();
  
    _cleanup_list.verify_optional();
--- 1756,1766 ----
    g1h->allocation_context_stats().update_after_mark();
  
    g1h->trace_heap_after_concurrent_cycle();
  }
  
! void G1ConcurrentMark::complete_cleanup() {
    if (has_aborted()) return;
  
    G1CollectedHeap* g1h = G1CollectedHeap::heap();
  
    _cleanup_list.verify_optional();