jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/shared/coTracker.cpp@06df86c2ec37 (annotated)

src/share/vm/gc_implementation/shared/coTracker.cpp@06df86c2ec37 (annotated)

src/share/vm/gc_implementation/shared/coTracker.cpp

Sat, 27 Sep 2008 00:33:13 -0700

author: iveresov
date: Sat, 27 Sep 2008 00:33:13 -0700
changeset 808: 06df86c2ec37
parent 777: 37f87013dfd8
permissions: -rw-r--r--

6740923: NUMA allocator: Ensure the progress of adaptive chunk resizing
Summary: Treat a chuck where the allocation has failed as fully used.
Reviewed-by: ysr

 /*
  * 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;
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/gc_implementation/shared/coTracker.cpp@06df86c2ec37 (annotated)

src/share/vm/gc_implementation/shared/coTracker.cpp