gcOverheadReporter.cpp

/*
 * 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/_gcOverheadReporter.cpp.incl"

class COReportingThread : public ConcurrentGCThread {
private:
  GCOverheadReporter* _reporter;

public:
  COReportingThread(GCOverheadReporter* reporter) : _reporter(reporter) {
    guarantee( _reporter != NULL, "precondition" );
    create_and_start();
  }

  virtual void run() {
    initialize_in_thread();
    wait_for_universe_init();

    int period_ms = GCOverheadReportingPeriodMS;

    while ( true ) {
      os::sleep(Thread::current(), period_ms, false);

      _sts.join();
      double now_sec = os::elapsedTime();
      _reporter->collect_and_record_conc_overhead(now_sec);
      _sts.leave();
    }

    terminate();
  }
};

GCOverheadReporter* GCOverheadReporter::_reporter = NULL;

GCOverheadReporter::GCOverheadReporter(size_t group_num,
                                       const char* group_names[],
                                       size_t length)
    : _group_num(group_num), _prev_end_sec(0.0) {
  guarantee( 0 <= group_num && group_num <= MaxGCOverheadGroupNum,
             "precondition" );

  _base = NEW_C_HEAP_ARRAY(GCOverheadReporterEntry, length);
  _top  = _base + length;
  _curr = _base;

  for (size_t i = 0; i < group_num; ++i) {
    guarantee( group_names[i] != NULL, "precondition" );
    _group_names[i] = group_names[i];
  }
}

void
GCOverheadReporter::add(double start_sec, double end_sec,
                        double* conc_overhead,
                        double stw_overhead) {
  assert( _curr <= _top, "invariant" );

  if (_curr == _top) {
    guarantee( false, "trace full" );
    return;
  }

  _curr->_start_sec       = start_sec;
  _curr->_end_sec         = end_sec;
  for (size_t i = 0; i < _group_num; ++i) {
    _curr->_conc_overhead[i] =
      (conc_overhead != NULL) ? conc_overhead[i] : 0.0;
  }
  _curr->_stw_overhead    = stw_overhead;

  ++_curr;
}

void
GCOverheadReporter::collect_and_record_conc_overhead(double end_sec) {
  double start_sec = _prev_end_sec;
  guarantee( end_sec > start_sec, "invariant" );

  double conc_overhead[MaxGCOverheadGroupNum];
  COTracker::totalConcOverhead(end_sec, _group_num, conc_overhead);
  add_conc_overhead(start_sec, end_sec, conc_overhead);
  _prev_end_sec = end_sec;
}

void
GCOverheadReporter::record_stw_start(double start_sec) {
  guarantee( start_sec > _prev_end_sec, "invariant" );
  collect_and_record_conc_overhead(start_sec);
}

void
GCOverheadReporter::record_stw_end(double end_sec) {
  double start_sec = _prev_end_sec;
  COTracker::updateAllForSTW(start_sec, end_sec);
  add_stw_overhead(start_sec, end_sec, 1.0);

  _prev_end_sec = end_sec;
}

void
GCOverheadReporter::print() const {
  tty->print_cr("");
  tty->print_cr("GC Overhead (%d entries)", _curr - _base);
  tty->print_cr("");
  GCOverheadReporterEntry* curr = _base;
  while (curr < _curr) {
    double total = curr->_stw_overhead;
    for (size_t i = 0; i < _group_num; ++i)
      total += curr->_conc_overhead[i];

    tty->print("OVERHEAD %12.8lf %12.8lf ",
               curr->_start_sec, curr->_end_sec);

    for (size_t i = 0; i < _group_num; ++i)
      tty->print("%s %12.8lf ", _group_names[i], curr->_conc_overhead[i]);

    tty->print_cr("STW %12.8lf TOT %12.8lf", curr->_stw_overhead, total);
    ++curr;
  }
  tty->print_cr("");
}

// statics

void
GCOverheadReporter::initGCOverheadReporter(size_t group_num,
                                           const char* group_names[]) {
  guarantee( _reporter == NULL, "should only be called once" );
  guarantee( 0 <= group_num && group_num <= MaxGCOverheadGroupNum,
             "precondition" );
  guarantee( group_names != NULL, "pre-condition" );

  if (GCOverheadReporting) {
    _reporter = new GCOverheadReporter(group_num, group_names);
    new COReportingThread(_reporter);
  }
}

void
GCOverheadReporter::recordSTWStart(double start_sec) {
  if (_reporter != NULL)
    _reporter->record_stw_start(start_sec);
}

void
GCOverheadReporter::recordSTWEnd(double end_sec) {
  if (_reporter != NULL)
    _reporter->record_stw_end(end_sec);
}

void
GCOverheadReporter::printGCOverhead() {
  if (_reporter != NULL)
    _reporter->print();
}