truffle: src/share/vm/gc_implementation/shared/gcUtil.hpp annotate

annotate src/share/vm/gc_implementation/shared/gcUtil.hpp @ 12146:9758d9f36299

8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced Summary: declare all user-defined operator new()s within Hotspot code with the empty throw() exception specification Reviewed-by: coleenp, twisti, dholmes, hseigel, dcubed, kvn, ccheung Contributed-by: lois.foltan@oracle.com

author	coleenp
date	Thu, 29 Aug 2013 18:56:29 -0400
parents	b9a9ed0f8eeb
children	63a4eb8bcd23

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 6842 diff changeset	2 * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1145 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1145 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1145 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	25 #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_GCUTIL_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define SHARE_VM_GC_IMPLEMENTATION_SHARED_GCUTIL_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	28 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "runtime/timer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	30 #include "utilities/debug.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "utilities/globalDefinitions.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "utilities/ostream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33
0 a61af66fc99e Initial load duke parents: diff changeset	34 // Catch-all file for utility classes
a61af66fc99e Initial load duke parents: diff changeset	35
a61af66fc99e Initial load duke parents: diff changeset	36 // A weighted average maintains a running, weighted average
a61af66fc99e Initial load duke parents: diff changeset	37 // of some float value (templates would be handy here if we
a61af66fc99e Initial load duke parents: diff changeset	38 // need different types).
a61af66fc99e Initial load duke parents: diff changeset	39 //
a61af66fc99e Initial load duke parents: diff changeset	40 // The average is adaptive in that we smooth it for the
a61af66fc99e Initial load duke parents: diff changeset	41 // initial samples; we don't use the weight until we have
a61af66fc99e Initial load duke parents: diff changeset	42 // enough samples for it to be meaningful.
a61af66fc99e Initial load duke parents: diff changeset	43 //
a61af66fc99e Initial load duke parents: diff changeset	44 // This serves as our best estimate of a future unknown.
a61af66fc99e Initial load duke parents: diff changeset	45 //
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6060 diff changeset	46 class AdaptiveWeightedAverage : public CHeapObj<mtGC> {
0 a61af66fc99e Initial load duke parents: diff changeset	47 private:
a61af66fc99e Initial load duke parents: diff changeset	48 float _average; // The last computed average
a61af66fc99e Initial load duke parents: diff changeset	49 unsigned _sample_count; // How often we've sampled this average
a61af66fc99e Initial load duke parents: diff changeset	50 unsigned _weight; // The weight used to smooth the averages
a61af66fc99e Initial load duke parents: diff changeset	51 // A higher weight favors the most
a61af66fc99e Initial load duke parents: diff changeset	52 // recent data.
6060 78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	53 bool _is_old; // Has enough historical data
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	54
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	55 const static unsigned OLD_THRESHOLD = 100;
0 a61af66fc99e Initial load duke parents: diff changeset	56
a61af66fc99e Initial load duke parents: diff changeset	57 protected:
a61af66fc99e Initial load duke parents: diff changeset	58 float _last_sample; // The last value sampled.
a61af66fc99e Initial load duke parents: diff changeset	59
6060 78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	60 void increment_count() {
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	61 _sample_count++;
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	62 if (!_is_old && _sample_count > OLD_THRESHOLD) {
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	63 _is_old = true;
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	64 }
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	65 }
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	66
0 a61af66fc99e Initial load duke parents: diff changeset	67 void set_average(float avg) { _average = avg; }
a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 // Helper function, computes an adaptive weighted average
a61af66fc99e Initial load duke parents: diff changeset	70 // given a sample and the last average
a61af66fc99e Initial load duke parents: diff changeset	71 float compute_adaptive_average(float new_sample, float average);
a61af66fc99e Initial load duke parents: diff changeset	72
a61af66fc99e Initial load duke parents: diff changeset	73 public:
a61af66fc99e Initial load duke parents: diff changeset	74 // Input weight must be between 0 and 100
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	75 AdaptiveWeightedAverage(unsigned weight, float avg = 0.0) :
6060 78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	76 _average(avg), _sample_count(0), _weight(weight), _last_sample(0.0),
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	77 _is_old(false) {
0 a61af66fc99e Initial load duke parents: diff changeset	78 }
a61af66fc99e Initial load duke parents: diff changeset	79
268 d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	80 void clear() {
d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	81 _average = 0;
d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	82 _sample_count = 0;
d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	83 _last_sample = 0;
6060 78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	84 _is_old = false;
268 d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	85 }
d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	86
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	87 // Useful for modifying static structures after startup.
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	88 void modify(size_t avg, unsigned wt, bool force = false) {
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	89 assert(force, "Are you sure you want to call this?");
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	90 _average = (float)avg;
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	91 _weight = wt;
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	92 }
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	93
0 a61af66fc99e Initial load duke parents: diff changeset	94 // Accessors
a61af66fc99e Initial load duke parents: diff changeset	95 float average() const { return _average; }
a61af66fc99e Initial load duke parents: diff changeset	96 unsigned weight() const { return _weight; }
a61af66fc99e Initial load duke parents: diff changeset	97 unsigned count() const { return _sample_count; }
6060 78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	98 float last_sample() const { return _last_sample; }
78a1b285cda8 7158457: division by zero in adaptiveweightedaverage mikael parents: 1972 diff changeset	99 bool is_old() const { return _is_old; }
0 a61af66fc99e Initial load duke parents: diff changeset	100
a61af66fc99e Initial load duke parents: diff changeset	101 // Update data with a new sample.
a61af66fc99e Initial load duke parents: diff changeset	102 void sample(float new_sample);
a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 static inline float exp_avg(float avg, float sample,
a61af66fc99e Initial load duke parents: diff changeset	105 unsigned int weight) {
a61af66fc99e Initial load duke parents: diff changeset	106 assert(0 <= weight && weight <= 100, "weight must be a percent");
a61af66fc99e Initial load duke parents: diff changeset	107 return (100.0F - weight) * avg / 100.0F + weight * sample / 100.0F;
a61af66fc99e Initial load duke parents: diff changeset	108 }
a61af66fc99e Initial load duke parents: diff changeset	109 static inline size_t exp_avg(size_t avg, size_t sample,
a61af66fc99e Initial load duke parents: diff changeset	110 unsigned int weight) {
a61af66fc99e Initial load duke parents: diff changeset	111 // Convert to float and back to avoid integer overflow.
a61af66fc99e Initial load duke parents: diff changeset	112 return (size_t)exp_avg((float)avg, (float)sample, weight);
a61af66fc99e Initial load duke parents: diff changeset	113 }
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	114
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	115 // Printing
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	116 void print_on(outputStream* st) const;
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	117 void print() const;
0 a61af66fc99e Initial load duke parents: diff changeset	118 };
a61af66fc99e Initial load duke parents: diff changeset	119
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 // A weighted average that includes a deviation from the average,
a61af66fc99e Initial load duke parents: diff changeset	122 // some multiple of which is added to the average.
a61af66fc99e Initial load duke parents: diff changeset	123 //
a61af66fc99e Initial load duke parents: diff changeset	124 // This serves as our best estimate of an upper bound on a future
a61af66fc99e Initial load duke parents: diff changeset	125 // unknown.
a61af66fc99e Initial load duke parents: diff changeset	126 class AdaptivePaddedAverage : public AdaptiveWeightedAverage {
a61af66fc99e Initial load duke parents: diff changeset	127 private:
a61af66fc99e Initial load duke parents: diff changeset	128 float _padded_avg; // The last computed padded average
a61af66fc99e Initial load duke parents: diff changeset	129 float _deviation; // Running deviation from the average
a61af66fc99e Initial load duke parents: diff changeset	130 unsigned _padding; // A multiple which, added to the average,
a61af66fc99e Initial load duke parents: diff changeset	131 // gives us an upper bound guess.
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 protected:
a61af66fc99e Initial load duke parents: diff changeset	134 void set_padded_average(float avg) { _padded_avg = avg; }
a61af66fc99e Initial load duke parents: diff changeset	135 void set_deviation(float dev) { _deviation = dev; }
a61af66fc99e Initial load duke parents: diff changeset	136
a61af66fc99e Initial load duke parents: diff changeset	137 public:
a61af66fc99e Initial load duke parents: diff changeset	138 AdaptivePaddedAverage() :
a61af66fc99e Initial load duke parents: diff changeset	139 AdaptiveWeightedAverage(0),
a61af66fc99e Initial load duke parents: diff changeset	140 _padded_avg(0.0), _deviation(0.0), _padding(0) {}
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 AdaptivePaddedAverage(unsigned weight, unsigned padding) :
a61af66fc99e Initial load duke parents: diff changeset	143 AdaptiveWeightedAverage(weight),
a61af66fc99e Initial load duke parents: diff changeset	144 _padded_avg(0.0), _deviation(0.0), _padding(padding) {}
a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146 // Placement support
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 6842 diff changeset	147 void* operator new(size_t ignored, void* p) throw() { return p; }
0 a61af66fc99e Initial load duke parents: diff changeset	148 // Allocator
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 6842 diff changeset	149 void* operator new(size_t size) throw() { return CHeapObj<mtGC>::operator new(size); }
0 a61af66fc99e Initial load duke parents: diff changeset	150
a61af66fc99e Initial load duke parents: diff changeset	151 // Accessor
a61af66fc99e Initial load duke parents: diff changeset	152 float padded_average() const { return _padded_avg; }
a61af66fc99e Initial load duke parents: diff changeset	153 float deviation() const { return _deviation; }
a61af66fc99e Initial load duke parents: diff changeset	154 unsigned padding() const { return _padding; }
a61af66fc99e Initial load duke parents: diff changeset	155
268 d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	156 void clear() {
d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	157 AdaptiveWeightedAverage::clear();
d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	158 _padded_avg = 0;
d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	159 _deviation = 0;
d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	160 }
d6340ab4105b 6723228: NUMA allocator: assert(lgrp_id != -1, "No lgrp_id set") iveresov parents: 0 diff changeset	161
0 a61af66fc99e Initial load duke parents: diff changeset	162 // Override
a61af66fc99e Initial load duke parents: diff changeset	163 void sample(float new_sample);
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	164
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	165 // Printing
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	166 void print_on(outputStream* st) const;
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	167 void print() const;
0 a61af66fc99e Initial load duke parents: diff changeset	168 };
a61af66fc99e Initial load duke parents: diff changeset	169
a61af66fc99e Initial load duke parents: diff changeset	170 // A weighted average that includes a deviation from the average,
a61af66fc99e Initial load duke parents: diff changeset	171 // some multiple of which is added to the average.
a61af66fc99e Initial load duke parents: diff changeset	172 //
a61af66fc99e Initial load duke parents: diff changeset	173 // This serves as our best estimate of an upper bound on a future
a61af66fc99e Initial load duke parents: diff changeset	174 // unknown.
a61af66fc99e Initial load duke parents: diff changeset	175 // A special sort of padded average: it doesn't update deviations
a61af66fc99e Initial load duke parents: diff changeset	176 // if the sample is zero. The average is allowed to change. We're
a61af66fc99e Initial load duke parents: diff changeset	177 // preventing the zero samples from drastically changing our padded
a61af66fc99e Initial load duke parents: diff changeset	178 // average.
a61af66fc99e Initial load duke parents: diff changeset	179 class AdaptivePaddedNoZeroDevAverage : public AdaptivePaddedAverage {
a61af66fc99e Initial load duke parents: diff changeset	180 public:
a61af66fc99e Initial load duke parents: diff changeset	181 AdaptivePaddedNoZeroDevAverage(unsigned weight, unsigned padding) :
a61af66fc99e Initial load duke parents: diff changeset	182 AdaptivePaddedAverage(weight, padding) {}
a61af66fc99e Initial load duke parents: diff changeset	183 // Override
a61af66fc99e Initial load duke parents: diff changeset	184 void sample(float new_sample);
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	185
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	186 // Printing
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	187 void print_on(outputStream* st) const;
e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	188 void print() const;
0 a61af66fc99e Initial load duke parents: diff changeset	189 };
1145 e018e6884bd8 6631166: CMS: better heuristics when combatting fragmentation ysr parents: 337 diff changeset	190
0 a61af66fc99e Initial load duke parents: diff changeset	191 // Use a least squares fit to a set of data to generate a linear
a61af66fc99e Initial load duke parents: diff changeset	192 // equation.
a61af66fc99e Initial load duke parents: diff changeset	193 // y = intercept + slope * x
a61af66fc99e Initial load duke parents: diff changeset	194
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6060 diff changeset	195 class LinearLeastSquareFit : public CHeapObj<mtGC> {
0 a61af66fc99e Initial load duke parents: diff changeset	196 double _sum_x; // sum of all independent data points x
a61af66fc99e Initial load duke parents: diff changeset	197 double _sum_x_squared; // sum of all independent data points x**2
a61af66fc99e Initial load duke parents: diff changeset	198 double _sum_y; // sum of all dependent data points y
a61af66fc99e Initial load duke parents: diff changeset	199 double _sum_xy; // sum of all x * y.
a61af66fc99e Initial load duke parents: diff changeset	200 double _intercept; // constant term
a61af66fc99e Initial load duke parents: diff changeset	201 double _slope; // slope
a61af66fc99e Initial load duke parents: diff changeset	202 // The weighted averages are not currently used but perhaps should
a61af66fc99e Initial load duke parents: diff changeset	203 // be used to get decaying averages.
a61af66fc99e Initial load duke parents: diff changeset	204 AdaptiveWeightedAverage _mean_x; // weighted mean of independent variable
a61af66fc99e Initial load duke parents: diff changeset	205 AdaptiveWeightedAverage _mean_y; // weighted mean of dependent variable
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 public:
a61af66fc99e Initial load duke parents: diff changeset	208 LinearLeastSquareFit(unsigned weight);
a61af66fc99e Initial load duke parents: diff changeset	209 void update(double x, double y);
a61af66fc99e Initial load duke parents: diff changeset	210 double y(double x);
a61af66fc99e Initial load duke parents: diff changeset	211 double slope() { return _slope; }
a61af66fc99e Initial load duke parents: diff changeset	212 // Methods to decide if a change in the dependent variable will
a61af66fc99e Initial load duke parents: diff changeset	213 // achive a desired goal. Note that these methods are not
a61af66fc99e Initial load duke parents: diff changeset	214 // complementary and both are needed.
a61af66fc99e Initial load duke parents: diff changeset	215 bool decrement_will_decrease();
a61af66fc99e Initial load duke parents: diff changeset	216 bool increment_will_decrease();
a61af66fc99e Initial load duke parents: diff changeset	217 };
a61af66fc99e Initial load duke parents: diff changeset	218
a61af66fc99e Initial load duke parents: diff changeset	219 class GCPauseTimer : StackObj {
a61af66fc99e Initial load duke parents: diff changeset	220 elapsedTimer* _timer;
a61af66fc99e Initial load duke parents: diff changeset	221 public:
a61af66fc99e Initial load duke parents: diff changeset	222 GCPauseTimer(elapsedTimer* timer) {
a61af66fc99e Initial load duke parents: diff changeset	223 _timer = timer;
a61af66fc99e Initial load duke parents: diff changeset	224 _timer->stop();
a61af66fc99e Initial load duke parents: diff changeset	225 }
a61af66fc99e Initial load duke parents: diff changeset	226 ~GCPauseTimer() {
a61af66fc99e Initial load duke parents: diff changeset	227 _timer->start();
a61af66fc99e Initial load duke parents: diff changeset	228 }
a61af66fc99e Initial load duke parents: diff changeset	229 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	230
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	231 #endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_GCUTIL_HPP

Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/shared/gcUtil.hpp @ 12146:9758d9f36299