Mon, 03 Aug 2009 12:59:30 -0700
6865703: G1: Parallelize hot card cache cleanup
Summary: Have the GC worker threads clear the hot card cache in parallel by having each worker thread claim a chunk of the card cache and process the cards in that chunk. The size of the chunks that each thread will claim is determined at VM initialization from the size of the card cache and the number of worker threads.
Reviewed-by: jmasa, tonyp
1 /*
2 * Copyright 2001-2007 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
25 #include "incls/_precompiled.incl"
26 #include "incls/_g1MMUTracker.cpp.incl"
28 #define _DISABLE_MMU 0
30 // can't rely on comparing doubles with tolerating a small margin for error
31 #define SMALL_MARGIN 0.0000001
32 #define is_double_leq_0(_value) ( (_value) < SMALL_MARGIN )
33 #define is_double_leq(_val1, _val2) is_double_leq_0((_val1) - (_val2))
34 #define is_double_geq(_val1, _val2) is_double_leq_0((_val2) - (_val1))
36 /***** ALL TIMES ARE IN SECS!!!!!!! *****/
38 G1MMUTracker::G1MMUTracker(double time_slice, double max_gc_time) :
39 _time_slice(time_slice),
40 _max_gc_time(max_gc_time),
41 _conc_overhead_time_sec(0.0) { }
43 void
44 G1MMUTracker::update_conc_overhead(double conc_overhead) {
45 double conc_overhead_time_sec = _time_slice * conc_overhead;
46 if (conc_overhead_time_sec > 0.9 * _max_gc_time) {
47 // We are screwed, as we only seem to have <10% of the soft
48 // real-time goal available for pauses. Let's admit defeat and
49 // allow something more generous as a pause target.
50 conc_overhead_time_sec = 0.75 * _max_gc_time;
51 }
53 _conc_overhead_time_sec = conc_overhead_time_sec;
54 }
56 G1MMUTrackerQueue::G1MMUTrackerQueue(double time_slice, double max_gc_time) :
57 G1MMUTracker(time_slice, max_gc_time),
58 _head_index(0),
59 _tail_index(trim_index(_head_index+1)),
60 _no_entries(0) { }
62 void G1MMUTrackerQueue::remove_expired_entries(double current_time) {
63 double limit = current_time - _time_slice;
64 while (_no_entries > 0) {
65 if (is_double_geq(limit, _array[_tail_index].end_time())) {
66 _tail_index = trim_index(_tail_index + 1);
67 --_no_entries;
68 } else
69 return;
70 }
71 guarantee(_no_entries == 0, "should have no entries in the array");
72 }
74 double G1MMUTrackerQueue::calculate_gc_time(double current_time) {
75 double gc_time = 0.0;
76 double limit = current_time - _time_slice;
77 for (int i = 0; i < _no_entries; ++i) {
78 int index = trim_index(_tail_index + i);
79 G1MMUTrackerQueueElem *elem = &_array[index];
80 if (elem->end_time() > limit) {
81 if (elem->start_time() > limit)
82 gc_time += elem->duration();
83 else
84 gc_time += elem->end_time() - limit;
85 }
86 }
87 return gc_time;
88 }
90 void G1MMUTrackerQueue::add_pause(double start, double end, bool gc_thread) {
91 double longest_allowed = longest_pause_internal(start);
92 if (longest_allowed < 0.0)
93 longest_allowed = 0.0;
94 double duration = end - start;
96 remove_expired_entries(end);
97 if (_no_entries == QueueLength) {
98 // OK, right now when we fill up we bomb out
99 // there are a few ways of dealing with this "gracefully"
100 // increase the array size (:-)
101 // remove the oldest entry (this might allow more GC time for
102 // the time slice than what's allowed)
103 // concolidate the two entries with the minimum gap between them
104 // (this mighte allow less GC time than what's allowed)
105 guarantee(0, "array full, currently we can't recover");
106 }
107 _head_index = trim_index(_head_index + 1);
108 ++_no_entries;
109 _array[_head_index] = G1MMUTrackerQueueElem(start, end);
110 }
112 // basically the _internal call does not remove expired entries
113 // this is for trying things out in the future and a couple
114 // of other places (debugging)
116 double G1MMUTrackerQueue::longest_pause(double current_time) {
117 if (_DISABLE_MMU)
118 return _max_gc_time;
120 MutexLockerEx x(MMUTracker_lock, Mutex::_no_safepoint_check_flag);
121 remove_expired_entries(current_time);
123 return longest_pause_internal(current_time);
124 }
126 double G1MMUTrackerQueue::longest_pause_internal(double current_time) {
127 double target_time = _max_gc_time;
129 while( 1 ) {
130 double gc_time =
131 calculate_gc_time(current_time + target_time) + _conc_overhead_time_sec;
132 double diff = target_time + gc_time - _max_gc_time;
133 if (!is_double_leq_0(diff)) {
134 target_time -= diff;
135 if (is_double_leq_0(target_time)) {
136 target_time = -1.0;
137 break;
138 }
139 } else {
140 break;
141 }
142 }
144 return target_time;
145 }
147 // basically the _internal call does not remove expired entries
148 // this is for trying things out in the future and a couple
149 // of other places (debugging)
151 double G1MMUTrackerQueue::when_sec(double current_time, double pause_time) {
152 if (_DISABLE_MMU)
153 return 0.0;
155 MutexLockerEx x(MMUTracker_lock, Mutex::_no_safepoint_check_flag);
156 remove_expired_entries(current_time);
158 return when_internal(current_time, pause_time);
159 }
161 double G1MMUTrackerQueue::when_internal(double current_time,
162 double pause_time) {
163 // if the pause is over the maximum, just assume that it's the maximum
164 double adjusted_pause_time =
165 (pause_time > max_gc_time()) ? max_gc_time() : pause_time;
166 double earliest_end = current_time + adjusted_pause_time;
167 double limit = earliest_end - _time_slice;
168 double gc_time = calculate_gc_time(earliest_end);
169 double diff = gc_time + adjusted_pause_time - max_gc_time();
170 if (is_double_leq_0(diff))
171 return 0.0;
173 int index = _tail_index;
174 while ( 1 ) {
175 G1MMUTrackerQueueElem *elem = &_array[index];
176 if (elem->end_time() > limit) {
177 if (elem->start_time() > limit)
178 diff -= elem->duration();
179 else
180 diff -= elem->end_time() - limit;
181 if (is_double_leq_0(diff))
182 return elem->end_time() + diff + _time_slice - adjusted_pause_time - current_time;
183 }
184 index = trim_index(index+1);
185 guarantee(index != trim_index(_head_index + 1), "should not go past head");
186 }
187 }