51 #include "gc/g1/heapRegionRemSet.hpp"

    51 #include "gc/g1/heapRegionRemSet.hpp"

    52 #include "gc/g1/heapRegionSet.inline.hpp"

    52 #include "gc/g1/heapRegionSet.inline.hpp"

    53 #include "gc/g1/suspendibleThreadSet.hpp"

    53 #include "gc/g1/suspendibleThreadSet.hpp"

    54 #include "gc/g1/vm_operations_g1.hpp"

    54 #include "gc/g1/vm_operations_g1.hpp"

    55 #include "gc/shared/gcHeapSummary.hpp"

    55 #include "gc/shared/gcHeapSummary.hpp"

    56 #include "gc/shared/gcLocker.inline.hpp"

    57 #include "gc/shared/gcLocker.inline.hpp"

    57 #include "gc/shared/gcTimer.hpp"

    58 #include "gc/shared/gcTimer.hpp"

    58 #include "gc/shared/gcTrace.hpp"

    59 #include "gc/shared/gcTrace.hpp"

    59 #include "gc/shared/gcTraceTime.hpp"

    60 #include "gc/shared/gcTraceTime.hpp"

    60 #include "gc/shared/generationSpec.hpp"

    61 #include "gc/shared/generationSpec.hpp"

  1448 

  1449 

  1449   STWGCTimer* gc_timer = G1MarkSweep::gc_timer();

  1450   STWGCTimer* gc_timer = G1MarkSweep::gc_timer();

  1450   gc_timer->register_gc_start();

  1451   gc_timer->register_gc_start();

  1451 

  1452 

  1452   SerialOldTracer* gc_tracer = G1MarkSweep::gc_tracer();

  1453   SerialOldTracer* gc_tracer = G1MarkSweep::gc_tracer();

  1453   gc_tracer->report_gc_start(gc_cause(), gc_timer->gc_start());

  1455   gc_tracer->report_gc_start(gc_cause(), gc_timer->gc_start());

  1454 

  1456 

  1455   SvcGCMarker sgcm(SvcGCMarker::FULL);

  1457   SvcGCMarker sgcm(SvcGCMarker::FULL);

  1456   ResourceMark rm;

  1458   ResourceMark rm;

  1457 

  1459 

  1474     // Timing

  1476     // Timing

  1475     assert(!GCCause::is_user_requested_gc(gc_cause()) || explicit_gc, "invariant");

  1477     assert(!GCCause::is_user_requested_gc(gc_cause()) || explicit_gc, "invariant");

  1476     TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty);

  1478     TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty);

  1477 

  1479 

  1478     {

  1480     {

  1480       TraceCollectorStats tcs(g1mm()->full_collection_counters());

  1482       TraceCollectorStats tcs(g1mm()->full_collection_counters());

  1481       TraceMemoryManagerStats tms(true /* fullGC */, gc_cause());

  1483       TraceMemoryManagerStats tms(true /* fullGC */, gc_cause());

  1482 

  1484 

  1483       g1_policy()->record_full_collection_start();

  1485       g1_policy()->record_full_collection_start();

  1484 

  1486 

  3892 void G1CollectedHeap::log_gc_header() {

  3894 void G1CollectedHeap::log_gc_header() {

  3893   if (!G1Log::fine()) {

  3895   if (!G1Log::fine()) {

  3894     return;

  3896     return;

  3895   }

  3897   }

  3896 

  3898 

  3898 

  3900 

  3899   GCCauseString gc_cause_str = GCCauseString("GC pause", gc_cause())

  3901   GCCauseString gc_cause_str = GCCauseString("GC pause", gc_cause())

  3900     .append(collector_state()->gcs_are_young() ? "(young)" : "(mixed)")

  3902     .append(collector_state()->gcs_are_young() ? "(young)" : "(mixed)")

  3901     .append(collector_state()->during_initial_mark_pause() ? " (initial-mark)" : "");

  3903     .append(collector_state()->during_initial_mark_pause() ? " (initial-mark)" : "");

  3902 

  3904 

  3950     return false;

  3952     return false;

  3951   }

  3953   }

  3952 

  3954 

  3953   _gc_timer_stw->register_gc_start();

  3955   _gc_timer_stw->register_gc_start();

  3954 

  3956 

  3955   _gc_tracer_stw->report_gc_start(gc_cause(), _gc_timer_stw->gc_start());

  3958   _gc_tracer_stw->report_gc_start(gc_cause(), _gc_timer_stw->gc_start());

  3956 

  3959 

  3957   SvcGCMarker sgcm(SvcGCMarker::MINOR);

  3960   SvcGCMarker sgcm(SvcGCMarker::MINOR);

  3958   ResourceMark rm;

  3961   ResourceMark rm;

  3959 

  3962 

  5499     // Serial reference processing...

  5502     // Serial reference processing...

  5500     stats = rp->process_discovered_references(&is_alive,

  5503     stats = rp->process_discovered_references(&is_alive,

  5501                                               &keep_alive,

  5504                                               &keep_alive,

  5502                                               &drain_queue,

  5505                                               &drain_queue,

  5503                                               NULL,

  5506                                               NULL,

  5506   } else {

  5508   } else {

  5507     // Parallel reference processing

  5509     // Parallel reference processing

  5508     assert(rp->num_q() == no_of_gc_workers, "sanity");

  5510     assert(rp->num_q() == no_of_gc_workers, "sanity");

  5509     assert(no_of_gc_workers <= rp->max_num_q(), "sanity");

  5511     assert(no_of_gc_workers <= rp->max_num_q(), "sanity");

  5510 

  5512 

  5511     G1STWRefProcTaskExecutor par_task_executor(this, per_thread_states, workers(), _task_queues, no_of_gc_workers);

  5513     G1STWRefProcTaskExecutor par_task_executor(this, per_thread_states, workers(), _task_queues, no_of_gc_workers);

  5512     stats = rp->process_discovered_references(&is_alive,

  5514     stats = rp->process_discovered_references(&is_alive,

  5513                                               &keep_alive,

  5515                                               &keep_alive,

  5514                                               &drain_queue,

  5516                                               &drain_queue,

  5515                                               &par_task_executor,

  5517                                               &par_task_executor,

  5518   }

  5519   }

  5519 

  5520 

  5520   _gc_tracer_stw->report_gc_reference_stats(stats);

  5521   _gc_tracer_stw->report_gc_reference_stats(stats);

  5521 

  5522 

  5522   // We have completed copying any necessary live referent objects.

  5523   // We have completed copying any necessary live referent objects.