/*

 * Copyright 2001-2007 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

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

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

 * published by the Free Software Foundation.

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_coTracker.cpp.incl"

COTracker* COTracker::_head = NULL;

double COTracker::_cpu_number = -1.0;

void

COTracker::resetPeriod(double now_sec, double vnow_sec) {

  guarantee( _enabled, "invariant" );

  _period_start_time_sec  = now_sec;

  _period_start_vtime_sec = vnow_sec;

}

void

COTracker::setConcOverhead(double time_stamp_sec,

                           double conc_overhead) {

  guarantee( _enabled, "invariant" );

  _conc_overhead  = conc_overhead;

  _time_stamp_sec = time_stamp_sec;

  if (conc_overhead > 0.001)

    _conc_overhead_seq.add(conc_overhead);

}

void

COTracker::reset(double starting_conc_overhead) {

  guarantee( _enabled, "invariant" );

  double now_sec = os::elapsedTime();

  setConcOverhead(now_sec, starting_conc_overhead);

}

void

COTracker::start() {

  guarantee( _enabled, "invariant" );

  resetPeriod(os::elapsedTime(), os::elapsedVTime());

}

void

COTracker::update(bool force_end) {

  assert( _enabled, "invariant" );

  double end_time_sec = os::elapsedTime();

  double elapsed_time_sec = end_time_sec - _period_start_time_sec;

  if (force_end || elapsed_time_sec > _update_period_sec) {

    // reached the end of the period

    double end_vtime_sec = os::elapsedVTime();

    double elapsed_vtime_sec = end_vtime_sec - _period_start_vtime_sec;

    double conc_overhead = elapsed_vtime_sec / elapsed_time_sec;

    setConcOverhead(end_time_sec, conc_overhead);

    resetPeriod(end_time_sec, end_vtime_sec);

  }

}

void

COTracker::updateForSTW(double start_sec, double end_sec) {

  if (!_enabled)

    return;

  // During a STW pause, no concurrent GC thread has done any

  // work. So, we can safely adjust the start of the current period by

  // adding the duration of the STW pause to it, so that the STW pause

  // doesn't affect the reading of the concurrent overhead (it's

  // basically like excluding the time of the STW pause from the

  // concurrent overhead calculation).

  double stw_duration_sec = end_sec - start_sec;

  guarantee( stw_duration_sec > 0.0, "invariant" );

  if (outOfDate(start_sec))

    _conc_overhead = 0.0;

  else

    _time_stamp_sec = end_sec;

  _period_start_time_sec += stw_duration_sec;

  _conc_overhead_seq = NumberSeq();

  guarantee( os::elapsedTime() > _period_start_time_sec, "invariant" );

}

double

COTracker::predConcOverhead() {

  if (_enabled) {

    // tty->print(" %1.2lf", _conc_overhead_seq.maximum());

    return _conc_overhead_seq.maximum();

  } else {

    // tty->print(" DD");

    return 0.0;

  }

}

void

COTracker::resetPred() {

  _conc_overhead_seq = NumberSeq();

}

COTracker::COTracker(int group)

    : _enabled(false),

      _group(group),

      _period_start_time_sec(-1.0),

      _period_start_vtime_sec(-1.0),

      _conc_overhead(-1.0),

      _time_stamp_sec(-1.0),

      _next(NULL) {

  // GCOverheadReportingPeriodMS indicates how frequently the

  // concurrent overhead will be recorded by the GC Overhead

  // Reporter. We want to take readings less often than that. If we

  // took readings more often than some of them might be lost.

  _update_period_sec = ((double) GCOverheadReportingPeriodMS) / 1000.0 * 1.25;

  _next = _head;

  _head = this;

  if (_cpu_number < 0.0)

    _cpu_number = (double) os::processor_count();

}

// statics

void

COTracker::updateAllForSTW(double start_sec, double end_sec) {

  for (COTracker* curr = _head; curr != NULL; curr = curr->_next) {

    curr->updateForSTW(start_sec, end_sec);

  }

}

double

COTracker::totalConcOverhead(double now_sec) {

  double total_conc_overhead = 0.0;

  for (COTracker* curr = _head; curr != NULL; curr = curr->_next) {

    double conc_overhead = curr->concOverhead(now_sec);

    total_conc_overhead += conc_overhead;

  }

  return total_conc_overhead;

}

double

COTracker::totalConcOverhead(double now_sec,

                             size_t group_num,

                             double* co_per_group) {

  double total_conc_overhead = 0.0;

  for (size_t i = 0; i < group_num; ++i)

    co_per_group[i] = 0.0;

  for (COTracker* curr = _head; curr != NULL; curr = curr->_next) {

    size_t group = curr->_group;

    assert( 0 <= group && group < group_num, "invariant" );

    double conc_overhead = curr->concOverhead(now_sec);

    co_per_group[group] += conc_overhead;

    total_conc_overhead += conc_overhead;

  }

  return total_conc_overhead;

}

double

COTracker::totalPredConcOverhead() {

  double total_pred_conc_overhead = 0.0;

  for (COTracker* curr = _head; curr != NULL; curr = curr->_next) {

    total_pred_conc_overhead += curr->predConcOverhead();

    curr->resetPred();

  }

  return total_pred_conc_overhead / _cpu_number;

}