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
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1638
b2a00dd3117c 6957084: simplify TaskQueue overflow handling
jcoomes
parents: 1552
diff changeset
2 * Copyright (c) 2001, 2010, 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: 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
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: 1833
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
26 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
27 #include "runtime/os.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
28 #include "utilities/debug.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
29 #include "utilities/stack.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
30 #include "utilities/taskqueue.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
31 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
32 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
33 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
34 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
35 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
36 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
37 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
38 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
39 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
47 #if TASKQUEUE_STATS
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
48 const char * const TaskQueueStats::_names[last_stat_id] = {
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
49 "qpush", "qpop", "qpop-s", "qattempt", "qsteal", "opush", "omax"
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
50 };
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
51
1709
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
52 TaskQueueStats & TaskQueueStats::operator +=(const TaskQueueStats & addend)
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
53 {
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
54 for (unsigned int i = 0; i < last_stat_id; ++i) {
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
55 _stats[i] += addend._stats[i];
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
56 }
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
57 return *this;
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
58 }
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
59
1665
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
60 void TaskQueueStats::print_header(unsigned int line, outputStream* const stream,
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
61 unsigned int width)
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
62 {
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
63 // Use a width w: 1 <= w <= max_width
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
64 const unsigned int max_width = 40;
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
65 const unsigned int w = MAX2(MIN2(width, max_width), 1U);
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
66
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
67 if (line == 0) { // spaces equal in width to the header
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
68 const unsigned int hdr_width = w * last_stat_id + last_stat_id - 1;
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
69 stream->print("%*s", hdr_width, " ");
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
70 } else if (line == 1) { // labels
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
71 stream->print("%*s", w, _names[0]);
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
72 for (unsigned int i = 1; i < last_stat_id; ++i) {
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
73 stream->print(" %*s", w, _names[i]);
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
74 }
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
75 } else if (line == 2) { // dashed lines
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
76 char dashes[max_width + 1];
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
77 memset(dashes, '-', w);
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
78 dashes[w] = '\0';
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
79 stream->print("%s", dashes);
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
80 for (unsigned int i = 1; i < last_stat_id; ++i) {
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
81 stream->print(" %s", dashes);
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
82 }
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
83 }
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
84 }
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
85
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
86 void TaskQueueStats::print(outputStream* stream, unsigned int width) const
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
87 {
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
88 #define FMT SIZE_FORMAT_W(*)
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
89 stream->print(FMT, width, _stats[0]);
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
90 for (unsigned int i = 1; i < last_stat_id; ++i) {
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
91 stream->print(" " FMT, width, _stats[i]);
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
92 }
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
93 #undef FMT
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
94 }
1709
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
95
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
96 #ifdef ASSERT
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
97 // Invariants which should hold after a TaskQueue has been emptied and is
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
98 // quiescent; they do not hold at arbitrary times.
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
99 void TaskQueueStats::verify() const
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
100 {
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
101 assert(get(push) == get(pop) + get(steal),
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
102 err_msg("push=" SIZE_FORMAT " pop=" SIZE_FORMAT " steal=" SIZE_FORMAT,
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
103 get(push), get(pop), get(steal)));
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
104 assert(get(pop_slow) <= get(pop),
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
105 err_msg("pop_slow=" SIZE_FORMAT " pop=" SIZE_FORMAT,
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
106 get(pop_slow), get(pop)));
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
107 assert(get(steal) <= get(steal_attempt),
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
108 err_msg("steal=" SIZE_FORMAT " steal_attempt=" SIZE_FORMAT,
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
109 get(steal), get(steal_attempt)));
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
110 assert(get(overflow) == 0 || get(push) != 0,
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
111 err_msg("overflow=" SIZE_FORMAT " push=" SIZE_FORMAT,
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
112 get(overflow), get(push)));
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
113 assert(get(overflow_max_len) == 0 || get(overflow) != 0,
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
114 err_msg("overflow_max_len=" SIZE_FORMAT " overflow=" SIZE_FORMAT,
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
115 get(overflow_max_len), get(overflow)));
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
116 }
5f429ee79634 6966222: G1: simplify TaskQueue overflow handling
jcoomes
parents: 1665
diff changeset
117 #endif // ASSERT
1665
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
118 #endif // TASKQUEUE_STATS
a93a9eda13f7 6962947: shared TaskQueue statistics
jcoomes
parents: 1638
diff changeset
119
0
a61af66fc99e Initial load
duke
parents:
diff changeset
120 int TaskQueueSetSuper::randomParkAndMiller(int *seed0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
121 const int a = 16807;
a61af66fc99e Initial load
duke
parents:
diff changeset
122 const int m = 2147483647;
a61af66fc99e Initial load
duke
parents:
diff changeset
123 const int q = 127773; /* m div a */
a61af66fc99e Initial load
duke
parents:
diff changeset
124 const int r = 2836; /* m mod a */
a61af66fc99e Initial load
duke
parents:
diff changeset
125 assert(sizeof(int) == 4, "I think this relies on that");
a61af66fc99e Initial load
duke
parents:
diff changeset
126 int seed = *seed0;
a61af66fc99e Initial load
duke
parents:
diff changeset
127 int hi = seed / q;
a61af66fc99e Initial load
duke
parents:
diff changeset
128 int lo = seed % q;
a61af66fc99e Initial load
duke
parents:
diff changeset
129 int test = a * lo - r * hi;
a61af66fc99e Initial load
duke
parents:
diff changeset
130 if (test > 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
131 seed = test;
a61af66fc99e Initial load
duke
parents:
diff changeset
132 else
a61af66fc99e Initial load
duke
parents:
diff changeset
133 seed = test + m;
a61af66fc99e Initial load
duke
parents:
diff changeset
134 *seed0 = seed;
a61af66fc99e Initial load
duke
parents:
diff changeset
135 return seed;
a61af66fc99e Initial load
duke
parents:
diff changeset
136 }
a61af66fc99e Initial load
duke
parents:
diff changeset
137
a61af66fc99e Initial load
duke
parents:
diff changeset
138 ParallelTaskTerminator::
a61af66fc99e Initial load
duke
parents:
diff changeset
139 ParallelTaskTerminator(int n_threads, TaskQueueSetSuper* queue_set) :
a61af66fc99e Initial load
duke
parents:
diff changeset
140 _n_threads(n_threads),
a61af66fc99e Initial load
duke
parents:
diff changeset
141 _queue_set(queue_set),
a61af66fc99e Initial load
duke
parents:
diff changeset
142 _offered_termination(0) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
143
a61af66fc99e Initial load
duke
parents:
diff changeset
144 bool ParallelTaskTerminator::peek_in_queue_set() {
a61af66fc99e Initial load
duke
parents:
diff changeset
145 return _queue_set->peek();
a61af66fc99e Initial load
duke
parents:
diff changeset
146 }
a61af66fc99e Initial load
duke
parents:
diff changeset
147
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
150 os::yield();
a61af66fc99e Initial load
duke
parents:
diff changeset
151 }
a61af66fc99e Initial load
duke
parents:
diff changeset
152
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
155 os::sleep(Thread::current(), millis, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
156 }
a61af66fc99e Initial load
duke
parents:
diff changeset
157
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
158 bool
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
162 Atomic::inc(&_offered_termination);
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
187 if (_offered_termination == _n_threads) {
a61af66fc99e Initial load
duke
parents:
diff changeset
188 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
221 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
222 if (PrintGCDetails && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
223 gclog_or_tty->print_cr("ParallelTaskTerminator::offer_termination() "
a61af66fc99e Initial load
duke
parents:
diff changeset
224 "thread %d sleeps after %d yields",
a61af66fc99e Initial load
duke
parents:
diff changeset
225 Thread::current(), yield_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
226 }
a61af66fc99e Initial load
duke
parents:
diff changeset
227 yield_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
228 // A sleep will cause this processor to seek work on another processor's
a61af66fc99e Initial load
duke
parents:
diff changeset
229 // runqueue, if it has nothing else to run (as opposed to the yield
a61af66fc99e Initial load
duke
parents:
diff changeset
230 // which may only move the thread to the end of the this processor's
a61af66fc99e Initial load
duke
parents:
diff changeset
231 // runqueue).
a61af66fc99e Initial load
duke
parents:
diff changeset
232 sleep(WorkStealingSleepMillis);
a61af66fc99e Initial load
duke
parents:
diff changeset
233 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
238 if (peek_in_queue_set() ||
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
239 (terminator != NULL && terminator->should_exit_termination())) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
242 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
243 }
a61af66fc99e Initial load
duke
parents:
diff changeset
244 }
a61af66fc99e Initial load
duke
parents:
diff changeset
245 }
a61af66fc99e Initial load
duke
parents:
diff changeset
246 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
258 void ParallelTaskTerminator::reset_for_reuse() {
a61af66fc99e Initial load
duke
parents:
diff changeset
259 if (_offered_termination != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
260 assert(_offered_termination == _n_threads,
a61af66fc99e Initial load
duke
parents:
diff changeset
261 "Terminator may still be in use");
a61af66fc99e Initial load
duke
parents:
diff changeset
262 _offered_termination = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
263 }
a61af66fc99e Initial load
duke
parents:
diff changeset
264 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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