Mercurial > hg > graal-jvmci-8

annotate src/share/vm/utilities/taskqueue.cpp @ 845:df6caf649ff7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6700789: G1: Enable use of compressed oops with G1 heaps Summary: Modifications to G1 so as to allow the use of compressed oops. Reviewed-by: apetrusenko, coleenp, jmasa, kvn, never, phh, tonyp
author ysr
date Tue, 14 Jul 2009 15:40:39 -0700
parents 0fbdb4381b99
children 2a1472c30599
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
579
0fbdb4381b99 6814575: Update copyright year
xdono
parents: 546
diff changeset
2 * Copyright 2001-2009 Sun Microsystems, Inc. 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 *
a61af66fc99e Initial load
duke
parents:
diff changeset
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load
duke
parents:
diff changeset
20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load
duke
parents:
diff changeset
21 * have any questions.
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
a61af66fc99e Initial load
duke
parents:
diff changeset
25 # include "incls/_precompiled.incl"
a61af66fc99e Initial load
duke
parents:
diff changeset
26 # include "incls/_taskqueue.cpp.incl"
a61af66fc99e Initial load
duke
parents:
diff changeset
27
546
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
28 #ifdef TRACESPINNING
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
29 uint ParallelTaskTerminator::_total_yields = 0;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
30 uint ParallelTaskTerminator::_total_spins = 0;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
31 uint ParallelTaskTerminator::_total_peeks = 0;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
32 #endif
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
33
0
a61af66fc99e Initial load
duke
parents:
diff changeset
34 bool TaskQueueSuper::peek() {
a61af66fc99e Initial load
duke
parents:
diff changeset
35 return _bottom != _age.top();
a61af66fc99e Initial load
duke
parents:
diff changeset
36 }
a61af66fc99e Initial load
duke
parents:
diff changeset
37
a61af66fc99e Initial load
duke
parents:
diff changeset
38 int TaskQueueSetSuper::randomParkAndMiller(int *seed0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
39 const int a = 16807;
a61af66fc99e Initial load
duke
parents:
diff changeset
40 const int m = 2147483647;
a61af66fc99e Initial load
duke
parents:
diff changeset
41 const int q = 127773; /* m div a */
a61af66fc99e Initial load
duke
parents:
diff changeset
42 const int r = 2836; /* m mod a */
a61af66fc99e Initial load
duke
parents:
diff changeset
43 assert(sizeof(int) == 4, "I think this relies on that");
a61af66fc99e Initial load
duke
parents:
diff changeset
44 int seed = *seed0;
a61af66fc99e Initial load
duke
parents:
diff changeset
45 int hi = seed / q;
a61af66fc99e Initial load
duke
parents:
diff changeset
46 int lo = seed % q;
a61af66fc99e Initial load
duke
parents:
diff changeset
47 int test = a * lo - r * hi;
a61af66fc99e Initial load
duke
parents:
diff changeset
48 if (test > 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
49 seed = test;
a61af66fc99e Initial load
duke
parents:
diff changeset
50 else
a61af66fc99e Initial load
duke
parents:
diff changeset
51 seed = test + m;
a61af66fc99e Initial load
duke
parents:
diff changeset
52 *seed0 = seed;
a61af66fc99e Initial load
duke
parents:
diff changeset
53 return seed;
a61af66fc99e Initial load
duke
parents:
diff changeset
54 }
a61af66fc99e Initial load
duke
parents:
diff changeset
55
a61af66fc99e Initial load
duke
parents:
diff changeset
56 ParallelTaskTerminator::
a61af66fc99e Initial load
duke
parents:
diff changeset
57 ParallelTaskTerminator(int n_threads, TaskQueueSetSuper* queue_set) :
a61af66fc99e Initial load
duke
parents:
diff changeset
58 _n_threads(n_threads),
a61af66fc99e Initial load
duke
parents:
diff changeset
59 _queue_set(queue_set),
a61af66fc99e Initial load
duke
parents:
diff changeset
60 _offered_termination(0) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
61
a61af66fc99e Initial load
duke
parents:
diff changeset
62 bool ParallelTaskTerminator::peek_in_queue_set() {
a61af66fc99e Initial load
duke
parents:
diff changeset
63 return _queue_set->peek();
a61af66fc99e Initial load
duke
parents:
diff changeset
64 }
a61af66fc99e Initial load
duke
parents:
diff changeset
65
a61af66fc99e Initial load
duke
parents:
diff changeset
66 void ParallelTaskTerminator::yield() {
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 579
diff changeset
67 assert(_offered_termination <= _n_threads, "Invariant");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
68 os::yield();
a61af66fc99e Initial load
duke
parents:
diff changeset
69 }
a61af66fc99e Initial load
duke
parents:
diff changeset
70
a61af66fc99e Initial load
duke
parents:
diff changeset
71 void ParallelTaskTerminator::sleep(uint millis) {
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 579
diff changeset
72 assert(_offered_termination <= _n_threads, "Invariant");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
73 os::sleep(Thread::current(), millis, false);
a61af66fc99e Initial load
duke
parents:
diff changeset
74 }
a61af66fc99e Initial load
duke
parents:
diff changeset
75
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
76 bool
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
77 ParallelTaskTerminator::offer_termination(TerminatorTerminator* terminator) {
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 579
diff changeset
78 assert(_offered_termination < _n_threads, "Invariant");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
79 Atomic::inc(&_offered_termination);
a61af66fc99e Initial load
duke
parents:
diff changeset
80
541
23673011938d 6787254: Work queue capacity can be increased substantially on some platforms
ysr
parents: 470
diff changeset
81 uint yield_count = 0;
546
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
82 // 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
83 uint hard_spin_count = 0;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
84 // Number of iterations in the hard spin loop.
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
85 uint hard_spin_limit = WorkStealingHardSpins;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
86
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
87 // 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
88 // 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
89 // 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
90 // the count of hard spins exceeds WorkStealingSpinToYieldRatio.
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
91 // 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
92 if (WorkStealingSpinToYieldRatio > 0) {
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
93 hard_spin_limit = WorkStealingHardSpins >> WorkStealingSpinToYieldRatio;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
94 hard_spin_limit = MAX2(hard_spin_limit, 1U);
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
95 }
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
96 // Remember the initial spin limit.
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
97 uint hard_spin_start = hard_spin_limit;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
98
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
99 // 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
100 // more work.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
101 while (true) {
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 579
diff changeset
102 assert(_offered_termination <= _n_threads, "Invariant");
546
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
103 // Are all threads offering termination?
0
a61af66fc99e Initial load
duke
parents:
diff changeset
104 if (_offered_termination == _n_threads) {
a61af66fc99e Initial load
duke
parents:
diff changeset
105 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
106 } else {
546
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
107 // Look for more work.
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
108 // Periodically sleep() instead of yield() to give threads
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
109 // waiting on the cores the chance to grab this code
0
a61af66fc99e Initial load
duke
parents:
diff changeset
110 if (yield_count <= WorkStealingYieldsBeforeSleep) {
546
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
111 // 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
112 // to sleep, count this as a yield.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
113 yield_count++;
546
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
114
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
115 // Periodically call yield() instead spinning
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
116 // After WorkStealingSpinToYieldRatio spins, do a yield() call
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
117 // and reset the counts and starting limit.
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
118 if (hard_spin_count > WorkStealingSpinToYieldRatio) {
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
119 yield();
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
120 hard_spin_count = 0;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
121 hard_spin_limit = hard_spin_start;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
122 #ifdef TRACESPINNING
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
123 _total_yields++;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
124 #endif
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
125 } else {
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
126 // Hard spin this time
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
127 // 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
128 hard_spin_limit = MIN2(2*hard_spin_limit,
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
129 (uint) WorkStealingHardSpins);
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
130 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
131 SpinPause();
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
132 }
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
133 hard_spin_count++;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
134 #ifdef TRACESPINNING
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
135 _total_spins++;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
136 #endif
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
137 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
138 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
139 if (PrintGCDetails && Verbose) {
a61af66fc99e Initial load
duke
parents:
diff changeset
140 gclog_or_tty->print_cr("ParallelTaskTerminator::offer_termination() "
a61af66fc99e Initial load
duke
parents:
diff changeset
141 "thread %d sleeps after %d yields",
a61af66fc99e Initial load
duke
parents:
diff changeset
142 Thread::current(), yield_count);
a61af66fc99e Initial load
duke
parents:
diff changeset
143 }
a61af66fc99e Initial load
duke
parents:
diff changeset
144 yield_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
145 // A sleep will cause this processor to seek work on another processor's
a61af66fc99e Initial load
duke
parents:
diff changeset
146 // runqueue, if it has nothing else to run (as opposed to the yield
a61af66fc99e Initial load
duke
parents:
diff changeset
147 // which may only move the thread to the end of the this processor's
a61af66fc99e Initial load
duke
parents:
diff changeset
148 // runqueue).
a61af66fc99e Initial load
duke
parents:
diff changeset
149 sleep(WorkStealingSleepMillis);
a61af66fc99e Initial load
duke
parents:
diff changeset
150 }
a61af66fc99e Initial load
duke
parents:
diff changeset
151
546
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
152 #ifdef TRACESPINNING
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
153 _total_peeks++;
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
154 #endif
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
155 if (peek_in_queue_set() ||
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
156 (terminator != NULL && terminator->should_exit_termination())) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
157 Atomic::dec(&_offered_termination);
845
df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents: 579
diff changeset
158 assert(_offered_termination < _n_threads, "Invariant");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
159 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
160 }
a61af66fc99e Initial load
duke
parents:
diff changeset
161 }
a61af66fc99e Initial load
duke
parents:
diff changeset
162 }
a61af66fc99e Initial load
duke
parents:
diff changeset
163 }
a61af66fc99e Initial load
duke
parents:
diff changeset
164
546
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
165 #ifdef TRACESPINNING
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
166 void ParallelTaskTerminator::print_termination_counts() {
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
167 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
168 "Total spins: %lld Total peeks: %lld",
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
169 total_yields(),
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
170 total_spins(),
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
171 total_peeks());
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
172 }
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
173 #endif
05c6d52fa7a9 6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents: 541
diff changeset
174
0
a61af66fc99e Initial load
duke
parents:
diff changeset
175 void ParallelTaskTerminator::reset_for_reuse() {
a61af66fc99e Initial load
duke
parents:
diff changeset
176 if (_offered_termination != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
177 assert(_offered_termination == _n_threads,
a61af66fc99e Initial load
duke
parents:
diff changeset
178 "Terminator may still be in use");
a61af66fc99e Initial load
duke
parents:
diff changeset
179 _offered_termination = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
180 }
a61af66fc99e Initial load
duke
parents:
diff changeset
181 }
a61af66fc99e Initial load
duke
parents:
diff changeset
182
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
183 bool RegionTaskQueueWithOverflow::is_empty() {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
184 return (_region_queue.size() == 0) &&
0
a61af66fc99e Initial load
duke
parents:
diff changeset
185 (_overflow_stack->length() == 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
186 }
a61af66fc99e Initial load
duke
parents:
diff changeset
187
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
188 bool RegionTaskQueueWithOverflow::stealable_is_empty() {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
189 return _region_queue.size() == 0;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
190 }
a61af66fc99e Initial load
duke
parents:
diff changeset
191
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
192 bool RegionTaskQueueWithOverflow::overflow_is_empty() {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
193 return _overflow_stack->length() == 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
194 }
a61af66fc99e Initial load
duke
parents:
diff changeset
195
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
196 void RegionTaskQueueWithOverflow::initialize() {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
197 _region_queue.initialize();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
198 assert(_overflow_stack == 0, "Creating memory leak");
a61af66fc99e Initial load
duke
parents:
diff changeset
199 _overflow_stack =
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
200 new (ResourceObj::C_HEAP) GrowableArray<RegionTask>(10, true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
201 }
a61af66fc99e Initial load
duke
parents:
diff changeset
202
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
203 void RegionTaskQueueWithOverflow::save(RegionTask t) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
204 if (TraceRegionTasksQueuing && Verbose) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
205 gclog_or_tty->print_cr("CTQ: save " PTR_FORMAT, t);
a61af66fc99e Initial load
duke
parents:
diff changeset
206 }
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
207 if(!_region_queue.push(t)) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
208 _overflow_stack->push(t);
a61af66fc99e Initial load
duke
parents:
diff changeset
209 }
a61af66fc99e Initial load
duke
parents:
diff changeset
210 }
a61af66fc99e Initial load
duke
parents:
diff changeset
211
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
212 // Note that using this method will retrieve all regions
0
a61af66fc99e Initial load
duke
parents:
diff changeset
213 // that have been saved but that it will always check
a61af66fc99e Initial load
duke
parents:
diff changeset
214 // the overflow stack. It may be more efficient to
a61af66fc99e Initial load
duke
parents:
diff changeset
215 // check the stealable queue and the overflow stack
a61af66fc99e Initial load
duke
parents:
diff changeset
216 // separately.
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
217 bool RegionTaskQueueWithOverflow::retrieve(RegionTask& region_task) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
218 bool result = retrieve_from_overflow(region_task);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
219 if (!result) {
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
220 result = retrieve_from_stealable_queue(region_task);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
221 }
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
222 if (TraceRegionTasksQueuing && Verbose && result) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
223 gclog_or_tty->print_cr(" CTQ: retrieve " PTR_FORMAT, result);
a61af66fc99e Initial load
duke
parents:
diff changeset
224 }
a61af66fc99e Initial load
duke
parents:
diff changeset
225 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
226 }
a61af66fc99e Initial load
duke
parents:
diff changeset
227
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
228 bool RegionTaskQueueWithOverflow::retrieve_from_stealable_queue(
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
229 RegionTask& region_task) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
230 bool result = _region_queue.pop_local(region_task);
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
231 if (TraceRegionTasksQueuing && Verbose) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
232 gclog_or_tty->print_cr("CTQ: retrieve_stealable " PTR_FORMAT, region_task);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
233 }
a61af66fc99e Initial load
duke
parents:
diff changeset
234 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
235 }
a61af66fc99e Initial load
duke
parents:
diff changeset
236
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
237 bool
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
238 RegionTaskQueueWithOverflow::retrieve_from_overflow(RegionTask& region_task) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
239 bool result;
a61af66fc99e Initial load
duke
parents:
diff changeset
240 if (!_overflow_stack->is_empty()) {
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
241 region_task = _overflow_stack->pop();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
242 result = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
243 } else {
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
244 region_task = (RegionTask) NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
245 result = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
246 }
375
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
247 if (TraceRegionTasksQueuing && Verbose) {
81cd571500b0 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 342
diff changeset
248 gclog_or_tty->print_cr("CTQ: retrieve_stealable " PTR_FORMAT, region_task);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
249 }
a61af66fc99e Initial load
duke
parents:
diff changeset
250 return result;
a61af66fc99e Initial load
duke
parents:
diff changeset
251 }