1 /*

     2  * Copyright (c) 2018, Red Hat, Inc. All rights reserved.

     3  *

     4  * This code is free software; you can redistribute it and/or modify it

     5  * under the terms of the GNU General Public License version 2 only, as

     6  * published by the Free Software Foundation.

     7  *

     8  * This code is distributed in the hope that it will be useful, but WITHOUT

     9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    11  * version 2 for more details (a copy is included in the LICENSE file that

    12  * accompanied this code).

    13  *

    14  * You should have received a copy of the GNU General Public License version

    15  * 2 along with this work; if not, write to the Free Software Foundation,

    16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    17  *

    18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    19  * or visit www.oracle.com if you need additional information or have any

    20  * questions.

    21  *

    22  */

    23 

    24 #include "precompiled.hpp"

    25 

    26 #include "gc/shenandoah/shenandoahHeap.hpp"

    27 #include "gc/shenandoah/shenandoahPhaseTimings.hpp"

    28 #include "gc/shenandoah/shenandoahTimingTracker.hpp"

    29 #include "gc/shenandoah/shenandoahUtils.hpp"

    30 #include "runtime/os.hpp"

    31 

    32 

    33 ShenandoahPhaseTimings::Phase ShenandoahTerminationTracker::_current_termination_phase = ShenandoahPhaseTimings::_num_phases;

    34 

    35 ShenandoahWorkerTimingsTracker::ShenandoahWorkerTimingsTracker(ShenandoahWorkerTimings* worker_times,

    36                                                               ShenandoahPhaseTimings::GCParPhases phase, uint worker_id) :

    37   _phase(phase), _worker_times(worker_times), _worker_id(worker_id) {

    38   if (_worker_times != NULL) {

    39     _start_time = os::elapsedTime();

    40   }

    41 }

    42 

    43 ShenandoahWorkerTimingsTracker::~ShenandoahWorkerTimingsTracker() {

    44   if (_worker_times != NULL) {

    45     _worker_times->record_time_secs(_phase, _worker_id, os::elapsedTime() - _start_time);

    46   }

    47 

    48   if (ShenandoahGCPhase::is_root_work_phase()) {

    49     ShenandoahPhaseTimings::Phase root_phase = ShenandoahGCPhase::current_phase();

    50     ShenandoahPhaseTimings::Phase cur_phase = (ShenandoahPhaseTimings::Phase)((int)root_phase + (int)_phase + 1);

    51     _event.commit(GCId::current(), _worker_id, ShenandoahPhaseTimings::phase_name(cur_phase));

    52   }

    53 }

    54 

    55 ShenandoahTerminationTimingsTracker::ShenandoahTerminationTimingsTracker(uint worker_id) :

    56   _worker_id(worker_id)  {

    57   if (ShenandoahTerminationTrace) {

    58     _start_time = os::elapsedTime();

    59   }

    60 }

    61 

    62 ShenandoahTerminationTimingsTracker::~ShenandoahTerminationTimingsTracker() {

    63   if (ShenandoahTerminationTrace) {

    64     ShenandoahHeap::heap()->phase_timings()->termination_times()->record_time_secs(_worker_id, os::elapsedTime() - _start_time);

    65   }

    66 }

    67 

    68 ShenandoahTerminationTracker::ShenandoahTerminationTracker(ShenandoahPhaseTimings::Phase phase) : _phase(phase) {

    69   assert(_current_termination_phase == ShenandoahPhaseTimings::_num_phases, "Should be invalid");

    70   assert(phase == ShenandoahPhaseTimings::termination ||

    71          phase == ShenandoahPhaseTimings::final_traversal_gc_termination ||

    72          phase == ShenandoahPhaseTimings::full_gc_mark_termination ||

    73          phase == ShenandoahPhaseTimings::conc_termination ||

    74          phase == ShenandoahPhaseTimings::conc_traversal_termination ||

    75          phase == ShenandoahPhaseTimings::weakrefs_termination ||

    76          phase == ShenandoahPhaseTimings::full_gc_weakrefs_termination,

    77          "Only these phases");

    78 

    79   assert(Thread::current()->is_VM_thread() || Thread::current()->is_ConcurrentGC_thread(),

    80     "Called from wrong thread");

    81   _current_termination_phase = phase;

    82   ShenandoahHeap::heap()->phase_timings()->termination_times()->reset();

    83 }

    84 

    85 ShenandoahTerminationTracker::~ShenandoahTerminationTracker() {

    86   assert(_phase == _current_termination_phase, "Can not change phase");

    87   ShenandoahPhaseTimings* phase_times = ShenandoahHeap::heap()->phase_timings();

    88 

    89   double t = phase_times->termination_times()->average();

    90   phase_times->record_phase_time(_phase, t);

    91   debug_only(_current_termination_phase = ShenandoahPhaseTimings::_num_phases;)

    92 }