424 CardTableModRefBS::card_shift,
425 false /* in_resource_area*/),
426
427 _prevMarkBitMap(&_markBitMap1),
428 _nextMarkBitMap(&_markBitMap2),
429
430 _markStack(this),
431 // _finger set in set_non_marking_state
432
433 _max_worker_id(ParallelGCThreads),
434 // _active_tasks set in set_non_marking_state
435 // _tasks set inside the constructor
436 _task_queues(new G1CMTaskQueueSet((int) _max_worker_id)),
437 _terminator(ParallelTaskTerminator((int) _max_worker_id, _task_queues)),
438
439 _has_overflown(false),
440 _concurrent(false),
441 _has_aborted(false),
442 _restart_for_overflow(false),
443 _concurrent_marking_in_progress(false),
444 _concurrent_phase_started(false),
445
446 // _verbose_level set below
447
448 _init_times(),
449 _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
450 _cleanup_times(),
451 _total_counting_time(0.0),
452 _total_rs_scrub_time(0.0),
453
454 _parallel_workers(NULL),
455
456 _count_card_bitmaps(NULL),
457 _count_marked_bytes(NULL),
458 _completed_initialization(false) {
459
460 _markBitMap1.initialize(g1h->reserved_region(), prev_bitmap_storage);
461 _markBitMap2.initialize(g1h->reserved_region(), next_bitmap_storage);
462
463 // Create & start a ConcurrentMark thread.
464 _cmThread = new ConcurrentMarkThread(this);
991 assert(!has_aborted(), "Aborting before root region scanning is finished not supported.");
992 GCTraceConcTime(Info, gc) tt("Concurrent Root Region Scan");
993
994 _parallel_marking_threads = calc_parallel_marking_threads();
995 assert(parallel_marking_threads() <= max_parallel_marking_threads(),
996 "Maximum number of marking threads exceeded");
997 uint active_workers = MAX2(1U, parallel_marking_threads());
998
999 G1CMRootRegionScanTask task(this);
1000 _parallel_workers->set_active_workers(active_workers);
1001 _parallel_workers->run_task(&task);
1002
1003 // It's possible that has_aborted() is true here without actually
1004 // aborting the survivor scan earlier. This is OK as it's
1005 // mainly used for sanity checking.
1006 root_regions()->scan_finished();
1007 }
1008 }
1009
1010 void G1ConcurrentMark::register_concurrent_phase_start(const char* title) {
1011 assert(!_concurrent_phase_started, "Sanity");
1012 _concurrent_phase_started = true;
1013 _g1h->gc_timer_cm()->register_gc_concurrent_start(title);
1014 }
1015
1016 void G1ConcurrentMark::register_concurrent_phase_end() {
1017 if (_concurrent_phase_started) {
1018 _concurrent_phase_started = false;
1019 _g1h->gc_timer_cm()->register_gc_concurrent_end();
1020 }
1021 }
1022
1023 void G1ConcurrentMark::markFromRoots() {
1024 // we might be tempted to assert that:
1025 // assert(asynch == !SafepointSynchronize::is_at_safepoint(),
1026 // "inconsistent argument?");
1027 // However that wouldn't be right, because it's possible that
1028 // a safepoint is indeed in progress as a younger generation
1029 // stop-the-world GC happens even as we mark in this generation.
1030
1031 _restart_for_overflow = false;
1032
1033 // _g1h has _n_par_threads
1034 _parallel_marking_threads = calc_parallel_marking_threads();
1035 assert(parallel_marking_threads() <= max_parallel_marking_threads(),
1036 "Maximum number of marking threads exceeded");
1037
1038 uint active_workers = MAX2(1U, parallel_marking_threads());
1039 assert(active_workers > 0, "Should have been set");
1040
1041 // Parallel task terminator is set in "set_concurrency_and_phase()"
1042 set_concurrency_and_phase(active_workers, true /* concurrent */);
2587 // Clear the liveness counting data
2588 clear_all_count_data();
2589 // Empty mark stack
2590 reset_marking_state();
2591 for (uint i = 0; i < _max_worker_id; ++i) {
2592 _tasks[i]->clear_region_fields();
2593 }
2594 _first_overflow_barrier_sync.abort();
2595 _second_overflow_barrier_sync.abort();
2596 _has_aborted = true;
2597
2598 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
2599 satb_mq_set.abandon_partial_marking();
2600 // This can be called either during or outside marking, we'll read
2601 // the expected_active value from the SATB queue set.
2602 satb_mq_set.set_active_all_threads(
2603 false, /* new active value */
2604 satb_mq_set.is_active() /* expected_active */);
2605
2606 _g1h->trace_heap_after_concurrent_cycle();
2607
2608 // Close any open concurrent phase timing
2609 register_concurrent_phase_end();
2610
2611 _g1h->register_concurrent_cycle_end();
2612 }
2613
2614 static void print_ms_time_info(const char* prefix, const char* name,
2615 NumberSeq& ns) {
2616 log_trace(gc, marking)("%s%5d %12s: total time = %8.2f s (avg = %8.2f ms).",
2617 prefix, ns.num(), name, ns.sum()/1000.0, ns.avg());
2618 if (ns.num() > 0) {
2619 log_trace(gc, marking)("%s [std. dev = %8.2f ms, max = %8.2f ms]",
2620 prefix, ns.sd(), ns.maximum());
2621 }
2622 }
2623
2624 void G1ConcurrentMark::print_summary_info() {
2625 LogHandle(gc, marking) log;
2626 if (!log.is_trace()) {
2627 return;
2628 }
2629
|
424 CardTableModRefBS::card_shift,
425 false /* in_resource_area*/),
426
427 _prevMarkBitMap(&_markBitMap1),
428 _nextMarkBitMap(&_markBitMap2),
429
430 _markStack(this),
431 // _finger set in set_non_marking_state
432
433 _max_worker_id(ParallelGCThreads),
434 // _active_tasks set in set_non_marking_state
435 // _tasks set inside the constructor
436 _task_queues(new G1CMTaskQueueSet((int) _max_worker_id)),
437 _terminator(ParallelTaskTerminator((int) _max_worker_id, _task_queues)),
438
439 _has_overflown(false),
440 _concurrent(false),
441 _has_aborted(false),
442 _restart_for_overflow(false),
443 _concurrent_marking_in_progress(false),
444 _concurrent_phase_status(ConcPhaseNotStarted),
445
446 // _verbose_level set below
447
448 _init_times(),
449 _remark_times(), _remark_mark_times(), _remark_weak_ref_times(),
450 _cleanup_times(),
451 _total_counting_time(0.0),
452 _total_rs_scrub_time(0.0),
453
454 _parallel_workers(NULL),
455
456 _count_card_bitmaps(NULL),
457 _count_marked_bytes(NULL),
458 _completed_initialization(false) {
459
460 _markBitMap1.initialize(g1h->reserved_region(), prev_bitmap_storage);
461 _markBitMap2.initialize(g1h->reserved_region(), next_bitmap_storage);
462
463 // Create & start a ConcurrentMark thread.
464 _cmThread = new ConcurrentMarkThread(this);
991 assert(!has_aborted(), "Aborting before root region scanning is finished not supported.");
992 GCTraceConcTime(Info, gc) tt("Concurrent Root Region Scan");
993
994 _parallel_marking_threads = calc_parallel_marking_threads();
995 assert(parallel_marking_threads() <= max_parallel_marking_threads(),
996 "Maximum number of marking threads exceeded");
997 uint active_workers = MAX2(1U, parallel_marking_threads());
998
999 G1CMRootRegionScanTask task(this);
1000 _parallel_workers->set_active_workers(active_workers);
1001 _parallel_workers->run_task(&task);
1002
1003 // It's possible that has_aborted() is true here without actually
1004 // aborting the survivor scan earlier. This is OK as it's
1005 // mainly used for sanity checking.
1006 root_regions()->scan_finished();
1007 }
1008 }
1009
1010 void G1ConcurrentMark::register_concurrent_phase_start(const char* title) {
1011 uint old_val = 0;
1012 do {
1013 old_val = Atomic::cmpxchg(ConcPhaseStarted, &_concurrent_phase_status, ConcPhaseNotStarted);
1014 } while (old_val != ConcPhaseNotStarted);
1015 _g1h->gc_timer_cm()->register_gc_concurrent_start(title);
1016 }
1017
1018 void G1ConcurrentMark::register_concurrent_phase_end_common(bool end_timer) {
1019 if (_concurrent_phase_status == ConcPhaseNotStarted) {
1020 return;
1021 }
1022
1023 uint old_val = Atomic::cmpxchg(ConcPhaseStopping, &_concurrent_phase_status, ConcPhaseStarted);
1024 if (old_val == ConcPhaseStarted) {
1025 _g1h->gc_timer_cm()->register_gc_concurrent_end();
1026 // If 'end_timer' is true, we came here to end timer which needs concurrent phase ended.
1027 // We need to end it before changing the status to 'ConcPhaseNotStarted' to prevent
1028 // starting a new concurrent phase by 'ConcurrentMarkThread'.
1029 if (end_timer) {
1030 _g1h->gc_timer_cm()->register_gc_end();
1031 }
1032 old_val = Atomic::cmpxchg(ConcPhaseNotStarted, &_concurrent_phase_status, ConcPhaseStopping);
1033 assert(old_val == ConcPhaseStopping, "Should not have changed since we entered this scope.");
1034 } else {
1035 do {
1036 // Let other thread finish changing '_concurrent_phase_status' to 'ConcPhaseNotStarted'.
1037 os::naked_short_sleep(1);
1038 } while (_concurrent_phase_status != ConcPhaseNotStarted);
1039 }
1040 }
1041
1042 void G1ConcurrentMark::register_concurrent_phase_end() {
1043 register_concurrent_phase_end_common(false);
1044 }
1045
1046 void G1ConcurrentMark::register_concurrent_gc_end() {
1047 register_concurrent_phase_end_common(true);
1048 }
1049
1050 void G1ConcurrentMark::markFromRoots() {
1051 // we might be tempted to assert that:
1052 // assert(asynch == !SafepointSynchronize::is_at_safepoint(),
1053 // "inconsistent argument?");
1054 // However that wouldn't be right, because it's possible that
1055 // a safepoint is indeed in progress as a younger generation
1056 // stop-the-world GC happens even as we mark in this generation.
1057
1058 _restart_for_overflow = false;
1059
1060 // _g1h has _n_par_threads
1061 _parallel_marking_threads = calc_parallel_marking_threads();
1062 assert(parallel_marking_threads() <= max_parallel_marking_threads(),
1063 "Maximum number of marking threads exceeded");
1064
1065 uint active_workers = MAX2(1U, parallel_marking_threads());
1066 assert(active_workers > 0, "Should have been set");
1067
1068 // Parallel task terminator is set in "set_concurrency_and_phase()"
1069 set_concurrency_and_phase(active_workers, true /* concurrent */);
2614 // Clear the liveness counting data
2615 clear_all_count_data();
2616 // Empty mark stack
2617 reset_marking_state();
2618 for (uint i = 0; i < _max_worker_id; ++i) {
2619 _tasks[i]->clear_region_fields();
2620 }
2621 _first_overflow_barrier_sync.abort();
2622 _second_overflow_barrier_sync.abort();
2623 _has_aborted = true;
2624
2625 SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
2626 satb_mq_set.abandon_partial_marking();
2627 // This can be called either during or outside marking, we'll read
2628 // the expected_active value from the SATB queue set.
2629 satb_mq_set.set_active_all_threads(
2630 false, /* new active value */
2631 satb_mq_set.is_active() /* expected_active */);
2632
2633 _g1h->trace_heap_after_concurrent_cycle();
2634
2635 _g1h->register_concurrent_cycle_end();
2636 }
2637
2638 static void print_ms_time_info(const char* prefix, const char* name,
2639 NumberSeq& ns) {
2640 log_trace(gc, marking)("%s%5d %12s: total time = %8.2f s (avg = %8.2f ms).",
2641 prefix, ns.num(), name, ns.sum()/1000.0, ns.avg());
2642 if (ns.num() > 0) {
2643 log_trace(gc, marking)("%s [std. dev = %8.2f ms, max = %8.2f ms]",
2644 prefix, ns.sd(), ns.maximum());
2645 }
2646 }
2647
2648 void G1ConcurrentMark::print_summary_info() {
2649 LogHandle(gc, marking) log;
2650 if (!log.is_trace()) {
2651 return;
2652 }
2653
|