Mercurial > hg > truffle

annotate src/share/vm/gc_implementation/shared/gcUtil.hpp @ 8733:9def4075da6d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate(). Reviewed-by: johnc, ysr Contributed-by: tamao <tao.mao@oracle.com>
author tamao
date Tue, 05 Mar 2013 15:36:56 -0800
parents b9a9ed0f8eeb
children 9758d9f36299
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
6842
b9a9ed0f8eeb 7197424: update copyright year to match last edit in jdk8 hotspot repository
mikael
parents: 6197
diff changeset
2 * Copyright (c) 2002, 2012, 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
a61af66fc99e Initial load
duke
parents:
diff changeset
147 void* operator new(size_t ignored, void* p) { return p; }
a61af66fc99e Initial load
duke
parents:
diff changeset
148 // Allocator
6197
d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 6060
diff changeset
149 void* operator new(size_t size) { 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