Mercurial > hg > truffle
annotate src/share/vm/utilities/taskqueue.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
author | ysr |
---|---|
date | Tue, 07 Dec 2010 21:55:53 -0800 |
parents | f95d63e2154a |
children | f08d439fab8c |
rev | line source |
---|---|
0 | 1 /* |
1638 | 2 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1311
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1311
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:
1311
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "oops/oop.inline.hpp" | |
27 #include "runtime/os.hpp" | |
28 #include "utilities/debug.hpp" | |
29 #include "utilities/stack.inline.hpp" | |
30 #include "utilities/taskqueue.hpp" | |
31 #ifdef TARGET_OS_FAMILY_linux | |
32 # include "thread_linux.inline.hpp" | |
33 #endif | |
34 #ifdef TARGET_OS_FAMILY_solaris | |
35 # include "thread_solaris.inline.hpp" | |
36 #endif | |
37 #ifdef TARGET_OS_FAMILY_windows | |
38 # include "thread_windows.inline.hpp" | |
39 #endif | |
0 | 40 |
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
41 #ifdef TRACESPINNING |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
42 uint ParallelTaskTerminator::_total_yields = 0; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
43 uint ParallelTaskTerminator::_total_spins = 0; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
44 uint ParallelTaskTerminator::_total_peeks = 0; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
45 #endif |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
46 |
1665 | 47 #if TASKQUEUE_STATS |
48 const char * const TaskQueueStats::_names[last_stat_id] = { | |
49 "qpush", "qpop", "qpop-s", "qattempt", "qsteal", "opush", "omax" | |
50 }; | |
51 | |
1709 | 52 TaskQueueStats & TaskQueueStats::operator +=(const TaskQueueStats & addend) |
53 { | |
54 for (unsigned int i = 0; i < last_stat_id; ++i) { | |
55 _stats[i] += addend._stats[i]; | |
56 } | |
57 return *this; | |
58 } | |
59 | |
1665 | 60 void TaskQueueStats::print_header(unsigned int line, outputStream* const stream, |
61 unsigned int width) | |
62 { | |
63 // Use a width w: 1 <= w <= max_width | |
64 const unsigned int max_width = 40; | |
65 const unsigned int w = MAX2(MIN2(width, max_width), 1U); | |
66 | |
67 if (line == 0) { // spaces equal in width to the header | |
68 const unsigned int hdr_width = w * last_stat_id + last_stat_id - 1; | |
69 stream->print("%*s", hdr_width, " "); | |
70 } else if (line == 1) { // labels | |
71 stream->print("%*s", w, _names[0]); | |
72 for (unsigned int i = 1; i < last_stat_id; ++i) { | |
73 stream->print(" %*s", w, _names[i]); | |
74 } | |
75 } else if (line == 2) { // dashed lines | |
76 char dashes[max_width + 1]; | |
77 memset(dashes, '-', w); | |
78 dashes[w] = '\0'; | |
79 stream->print("%s", dashes); | |
80 for (unsigned int i = 1; i < last_stat_id; ++i) { | |
81 stream->print(" %s", dashes); | |
82 } | |
83 } | |
84 } | |
85 | |
86 void TaskQueueStats::print(outputStream* stream, unsigned int width) const | |
87 { | |
88 #define FMT SIZE_FORMAT_W(*) | |
89 stream->print(FMT, width, _stats[0]); | |
90 for (unsigned int i = 1; i < last_stat_id; ++i) { | |
91 stream->print(" " FMT, width, _stats[i]); | |
92 } | |
93 #undef FMT | |
94 } | |
1709 | 95 |
96 #ifdef ASSERT | |
97 // Invariants which should hold after a TaskQueue has been emptied and is | |
98 // quiescent; they do not hold at arbitrary times. | |
99 void TaskQueueStats::verify() const | |
100 { | |
101 assert(get(push) == get(pop) + get(steal), | |
102 err_msg("push=" SIZE_FORMAT " pop=" SIZE_FORMAT " steal=" SIZE_FORMAT, | |
103 get(push), get(pop), get(steal))); | |
104 assert(get(pop_slow) <= get(pop), | |
105 err_msg("pop_slow=" SIZE_FORMAT " pop=" SIZE_FORMAT, | |
106 get(pop_slow), get(pop))); | |
107 assert(get(steal) <= get(steal_attempt), | |
108 err_msg("steal=" SIZE_FORMAT " steal_attempt=" SIZE_FORMAT, | |
109 get(steal), get(steal_attempt))); | |
110 assert(get(overflow) == 0 || get(push) != 0, | |
111 err_msg("overflow=" SIZE_FORMAT " push=" SIZE_FORMAT, | |
112 get(overflow), get(push))); | |
113 assert(get(overflow_max_len) == 0 || get(overflow) != 0, | |
114 err_msg("overflow_max_len=" SIZE_FORMAT " overflow=" SIZE_FORMAT, | |
115 get(overflow_max_len), get(overflow))); | |
116 } | |
117 #endif // ASSERT | |
1665 | 118 #endif // TASKQUEUE_STATS |
119 | |
0 | 120 int TaskQueueSetSuper::randomParkAndMiller(int *seed0) { |
121 const int a = 16807; | |
122 const int m = 2147483647; | |
123 const int q = 127773; /* m div a */ | |
124 const int r = 2836; /* m mod a */ | |
125 assert(sizeof(int) == 4, "I think this relies on that"); | |
126 int seed = *seed0; | |
127 int hi = seed / q; | |
128 int lo = seed % q; | |
129 int test = a * lo - r * hi; | |
130 if (test > 0) | |
131 seed = test; | |
132 else | |
133 seed = test + m; | |
134 *seed0 = seed; | |
135 return seed; | |
136 } | |
137 | |
138 ParallelTaskTerminator:: | |
139 ParallelTaskTerminator(int n_threads, TaskQueueSetSuper* queue_set) : | |
140 _n_threads(n_threads), | |
141 _queue_set(queue_set), | |
142 _offered_termination(0) {} | |
143 | |
144 bool ParallelTaskTerminator::peek_in_queue_set() { | |
145 return _queue_set->peek(); | |
146 } | |
147 | |
148 void ParallelTaskTerminator::yield() { | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
149 assert(_offered_termination <= _n_threads, "Invariant"); |
0 | 150 os::yield(); |
151 } | |
152 | |
153 void ParallelTaskTerminator::sleep(uint millis) { | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
154 assert(_offered_termination <= _n_threads, "Invariant"); |
0 | 155 os::sleep(Thread::current(), millis, false); |
156 } | |
157 | |
342 | 158 bool |
159 ParallelTaskTerminator::offer_termination(TerminatorTerminator* terminator) { | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1709
diff
changeset
|
160 assert(_n_threads > 0, "Initialization is incorrect"); |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
161 assert(_offered_termination < _n_threads, "Invariant"); |
0 | 162 Atomic::inc(&_offered_termination); |
163 | |
541
23673011938d
6787254: Work queue capacity can be increased substantially on some platforms
ysr
parents:
470
diff
changeset
|
164 uint yield_count = 0; |
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
165 // Number of hard spin loops done since last yield |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
166 uint hard_spin_count = 0; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
167 // Number of iterations in the hard spin loop. |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
168 uint hard_spin_limit = WorkStealingHardSpins; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
169 |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
170 // If WorkStealingSpinToYieldRatio is 0, no hard spinning is done. |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
171 // If it is greater than 0, then start with a small number |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
172 // of spins and increase number with each turn at spinning until |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
173 // the count of hard spins exceeds WorkStealingSpinToYieldRatio. |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
174 // Then do a yield() call and start spinning afresh. |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
175 if (WorkStealingSpinToYieldRatio > 0) { |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
176 hard_spin_limit = WorkStealingHardSpins >> WorkStealingSpinToYieldRatio; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
177 hard_spin_limit = MAX2(hard_spin_limit, 1U); |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
178 } |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
179 // Remember the initial spin limit. |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
180 uint hard_spin_start = hard_spin_limit; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
181 |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
182 // Loop waiting for all threads to offer termination or |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
183 // more work. |
0 | 184 while (true) { |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
185 assert(_offered_termination <= _n_threads, "Invariant"); |
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
186 // Are all threads offering termination? |
0 | 187 if (_offered_termination == _n_threads) { |
188 return true; | |
189 } else { | |
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
190 // Look for more work. |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
191 // Periodically sleep() instead of yield() to give threads |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
192 // waiting on the cores the chance to grab this code |
0 | 193 if (yield_count <= WorkStealingYieldsBeforeSleep) { |
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
194 // Do a yield or hardspin. For purposes of deciding whether |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
195 // to sleep, count this as a yield. |
0 | 196 yield_count++; |
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
197 |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
198 // Periodically call yield() instead spinning |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
199 // After WorkStealingSpinToYieldRatio spins, do a yield() call |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
200 // and reset the counts and starting limit. |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
201 if (hard_spin_count > WorkStealingSpinToYieldRatio) { |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
202 yield(); |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
203 hard_spin_count = 0; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
204 hard_spin_limit = hard_spin_start; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
205 #ifdef TRACESPINNING |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
206 _total_yields++; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
207 #endif |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
208 } else { |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
209 // Hard spin this time |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
210 // Increase the hard spinning period but only up to a limit. |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
211 hard_spin_limit = MIN2(2*hard_spin_limit, |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
212 (uint) WorkStealingHardSpins); |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
213 for (uint j = 0; j < hard_spin_limit; j++) { |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
214 SpinPause(); |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
215 } |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
216 hard_spin_count++; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
217 #ifdef TRACESPINNING |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
218 _total_spins++; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
219 #endif |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
220 } |
0 | 221 } else { |
222 if (PrintGCDetails && Verbose) { | |
223 gclog_or_tty->print_cr("ParallelTaskTerminator::offer_termination() " | |
224 "thread %d sleeps after %d yields", | |
225 Thread::current(), yield_count); | |
226 } | |
227 yield_count = 0; | |
228 // A sleep will cause this processor to seek work on another processor's | |
229 // runqueue, if it has nothing else to run (as opposed to the yield | |
230 // which may only move the thread to the end of the this processor's | |
231 // runqueue). | |
232 sleep(WorkStealingSleepMillis); | |
233 } | |
234 | |
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
235 #ifdef TRACESPINNING |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
236 _total_peeks++; |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
237 #endif |
342 | 238 if (peek_in_queue_set() || |
239 (terminator != NULL && terminator->should_exit_termination())) { | |
0 | 240 Atomic::dec(&_offered_termination); |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
241 assert(_offered_termination < _n_threads, "Invariant"); |
0 | 242 return false; |
243 } | |
244 } | |
245 } | |
246 } | |
247 | |
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
248 #ifdef TRACESPINNING |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
249 void ParallelTaskTerminator::print_termination_counts() { |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
250 gclog_or_tty->print_cr("ParallelTaskTerminator Total yields: %lld " |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
251 "Total spins: %lld Total peeks: %lld", |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
252 total_yields(), |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
253 total_spins(), |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
254 total_peeks()); |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
255 } |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
256 #endif |
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
541
diff
changeset
|
257 |
0 | 258 void ParallelTaskTerminator::reset_for_reuse() { |
259 if (_offered_termination != 0) { | |
260 assert(_offered_termination == _n_threads, | |
261 "Terminator may still be in use"); | |
262 _offered_termination = 0; | |
263 } | |
264 } | |
265 | |
1311
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
845
diff
changeset
|
266 #ifdef ASSERT |
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
845
diff
changeset
|
267 bool ObjArrayTask::is_valid() const { |
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
845
diff
changeset
|
268 return _obj != NULL && _obj->is_objArray() && _index > 0 && |
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
845
diff
changeset
|
269 _index < objArrayOop(_obj)->length(); |
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
845
diff
changeset
|
270 } |
2a1472c30599
4396719: Mark Sweep stack overflow on deeply nested Object arrays
jcoomes
parents:
845
diff
changeset
|
271 #endif // ASSERT |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1709
diff
changeset
|
272 |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1709
diff
changeset
|
273 void ParallelTaskTerminator::reset_for_reuse(int n_threads) { |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1709
diff
changeset
|
274 reset_for_reuse(); |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1709
diff
changeset
|
275 _n_threads = n_threads; |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1709
diff
changeset
|
276 } |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1709
diff
changeset
|
277 |