jdk-sandbox: comparison src/hotspot/share/gc/g1/g1ConcurrentMark.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #include "gc/g1/g1OopClosures.inline.hpp"
 #include "gc/g1/g1Policy.hpp"
 #include "gc/g1/g1RegionMarkStatsCache.inline.hpp"
 #include "gc/g1/g1StringDedup.hpp"
 #include "gc/g1/g1ThreadLocalData.hpp"
+#include "gc/g1/g1Trace.hpp"
 #include "gc/g1/heapRegion.inline.hpp"
 #include "gc/g1/heapRegionRemSet.hpp"
 #include "gc/g1/heapRegionSet.inline.hpp"
 #include "gc/shared/gcId.hpp"
 #include "gc/shared/gcTimer.hpp"
-#include "gc/shared/gcTrace.hpp"
 #include "gc/shared/gcTraceTime.inline.hpp"
 #include "gc/shared/gcVMOperations.hpp"
 #include "gc/shared/genOopClosures.inline.hpp"
 #include "gc/shared/referencePolicy.hpp"
 #include "gc/shared/strongRootsScope.hpp"
 _hwm = 0;
 _chunk_list = NULL;
 _free_list = NULL;
 }
-G1CMRootRegions::G1CMRootRegions(uint const max_regions) :
+G1CMRootMemRegions::G1CMRootMemRegions(uint const max_regions) :
-_root_regions(NEW_C_HEAP_ARRAY(HeapRegion*, max_regions, mtGC)),
+_root_regions(NULL),
 _max_regions(max_regions),
 _num_root_regions(0),
 _claimed_root_regions(0),
 _scan_in_progress(false),
-_should_abort(false) { }
+_should_abort(false) {
+_root_regions = new MemRegion[_max_regions];
-G1CMRootRegions::~G1CMRootRegions() {
+if (_root_regions == NULL) {
-FREE_C_HEAP_ARRAY(HeapRegion*, _max_regions);
+vm_exit_during_initialization("Could not allocate root MemRegion set.");
 }
+}
-void G1CMRootRegions::reset() {
+G1CMRootMemRegions::~G1CMRootMemRegions() {
+delete[] _root_regions;
+}
+void G1CMRootMemRegions::reset() {
 _num_root_regions = 0;
 }
-void G1CMRootRegions::add(HeapRegion* hr) {
+void G1CMRootMemRegions::add(HeapWord* start, HeapWord* end) {
 assert_at_safepoint();
 size_t idx = Atomic::add((size_t)1, &_num_root_regions) - 1;
-assert(idx < _max_regions, "Trying to add more root regions than there is space " SIZE_FORMAT, _max_regions);
+assert(idx < _max_regions, "Trying to add more root MemRegions than there is space " SIZE_FORMAT, _max_regions);
-_root_regions[idx] = hr;
+assert(start != NULL && end != NULL && start <= end, "Start (" PTR_FORMAT ") should be less or equal to "
-}
+"end (" PTR_FORMAT ")", p2i(start), p2i(end));
+_root_regions[idx].set_start(start);
-void G1CMRootRegions::prepare_for_scan() {
+_root_regions[idx].set_end(end);
+}
+void G1CMRootMemRegions::prepare_for_scan() {
 assert(!scan_in_progress(), "pre-condition");
 _scan_in_progress = _num_root_regions > 0;
 _claimed_root_regions = 0;
 _should_abort = false;
 }
-HeapRegion* G1CMRootRegions::claim_next() {
+const MemRegion* G1CMRootMemRegions::claim_next() {
 if (_should_abort) {
 // If someone has set the should_abort flag, we return NULL to
 // force the caller to bail out of their loop.
 return NULL;
 }
 return NULL;
 }
 size_t claimed_index = Atomic::add((size_t)1, &_claimed_root_regions) - 1;
 if (claimed_index < _num_root_regions) {
-return _root_regions[claimed_index];
+return &_root_regions[claimed_index];
 }
 return NULL;
 }
-uint G1CMRootRegions::num_root_regions() const {
+uint G1CMRootMemRegions::num_root_regions() const {
 return (uint)_num_root_regions;
 }
-void G1CMRootRegions::notify_scan_done() {
+void G1CMRootMemRegions::notify_scan_done() {
 MutexLocker x(RootRegionScan_lock, Mutex::_no_safepoint_check_flag);
 _scan_in_progress = false;
 RootRegionScan_lock->notify_all();
 }
-void G1CMRootRegions::cancel_scan() {
+void G1CMRootMemRegions::cancel_scan() {
 notify_scan_done();
 }
-void G1CMRootRegions::scan_finished() {
+void G1CMRootMemRegions::scan_finished() {
 assert(scan_in_progress(), "pre-condition");
 if (!_should_abort) {
 assert(_claimed_root_regions >= num_root_regions(),
 "we should have claimed all root regions, claimed " SIZE_FORMAT ", length = %u",
 }
 notify_scan_done();
 }
-bool G1CMRootRegions::wait_until_scan_finished() {
+bool G1CMRootMemRegions::wait_until_scan_finished() {
 if (!scan_in_progress()) {
 return false;
 }
 {
 "Calculated number of marking workers must be larger than zero and at most the maximum %u, but is %u",
 _max_concurrent_workers, result);
 return result;
 }
-void G1ConcurrentMark::scan_root_region(HeapRegion* hr, uint worker_id) {
+void G1ConcurrentMark::scan_root_region(const MemRegion* region, uint worker_id) {
-assert(hr->is_old() || (hr->is_survivor() && hr->next_top_at_mark_start() == hr->bottom()),
+#ifdef ASSERT
-"Root regions must be old or survivor but region %u is %s", hr->hrm_index(), hr->get_type_str());
+HeapWord* last = region->last();
+HeapRegion* hr = _g1h->heap_region_containing(last);
+assert(hr->is_old() || hr->next_top_at_mark_start() == hr->bottom(),
+"Root regions must be old or survivor/eden but region %u is %s", hr->hrm_index(), hr->get_type_str());
+assert(hr->next_top_at_mark_start() == region->start(),
+"MemRegion start should be equal to nTAMS");
+#endif
 G1RootRegionScanClosure cl(_g1h, this, worker_id);
 const uintx interval = PrefetchScanIntervalInBytes;
-HeapWord* curr = hr->next_top_at_mark_start();
+HeapWord* curr = region->start();
-const HeapWord* end = hr->top();
+const HeapWord* end = region->end();
 while (curr < end) {
 Prefetch::read(curr, interval);
 oop obj = oop(curr);
 int size = obj->oop_iterate_size(&cl);
 assert(size == obj->size(), "sanity");
 void work(uint worker_id) {
 assert(Thread::current()->is_ConcurrentGC_thread(),
 "this should only be done by a conc GC thread");
-G1CMRootRegions* root_regions = _cm->root_regions();
+G1CMRootMemRegions* root_regions = _cm->root_regions();
-HeapRegion* hr = root_regions->claim_next();
+const MemRegion* region = root_regions->claim_next();
-while (hr != NULL) {
+while (region != NULL) {
-_cm->scan_root_region(hr, worker_id);
+_cm->scan_root_region(region, worker_id);
-hr = root_regions->claim_next();
+region = root_regions->claim_next();
 }
 }
 };
 void G1ConcurrentMark::scan_root_regions() {
 while (!has_aborted() &&
 satb_mq_set.apply_closure_to_completed_buffer(&satb_cl)) {
 abort_marking_if_regular_check_fail();
 }
+// Can't assert qset is empty here, even if not aborted.  If concurrent,
+// some other thread might be adding to the queue.  If not concurrent,
+// some other thread might have won the race for the last buffer, but
+// has not yet decremented the count.
 _draining_satb_buffers = false;
-assert(has_aborted() ||
-_cm->concurrent() ||
-satb_mq_set.completed_buffers_num() == 0, "invariant");
 // again, this was a potentially expensive operation, decrease the
 // limits to get the regular clock call early
 decrease_limits();
 }
 // steal work from the other G1CMTasks. It only makes sense to
 // enable stealing when the termination protocol is enabled
 // and do_marking_step() is not being called serially.
 bool do_stealing = do_termination && !is_serial;
-double diff_prediction_ms = _g1h->policy()->predictor().get_new_prediction(&_marking_step_diffs_ms);
+double diff_prediction_ms = _g1h->policy()->predictor().get_new_prediction(&_marking_step_diff_ms);
 _time_target_ms = time_target_ms - diff_prediction_ms;
 // set up the variables that are used in the work-based scheme to
 // call the regular clock method
 _words_scanned = 0;
 if (_has_timed_out) {
 double diff_ms = elapsed_time_ms - _time_target_ms;
 // Keep statistics of how well we did with respect to hitting
 // our target only if we actually timed out (if we aborted for
 // other reasons, then the results might get skewed).
-_marking_step_diffs_ms.add(diff_ms);
+_marking_step_diff_ms.add(diff_ms);
 }
 if (_cm->has_overflown()) {
 // This is the interesting one. We aborted because a global
 // overflow was raised. This means we have to restart the
 _draining_satb_buffers(false),
 _step_times_ms(),
 _elapsed_time_ms(0.0),
 _termination_time_ms(0.0),
 _termination_start_time_ms(0.0),
-_marking_step_diffs_ms()
+_marking_step_diff_ms()
 {
 guarantee(task_queue != NULL, "invariant");
-_marking_step_diffs_ms.add(0.5);
+_marking_step_diff_ms.add(0.5);
 }
 // These are formatting macros that are used below to ensure
 // consistent formatting. The *_H_* versions are used to format the
 // header for a particular value and they should be kept consistent

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54983	81becad91321
child 58679	9c3209ff7550