annotate src/share/vm/utilities/workgroup.hpp @ 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 92da084fefc9
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
2 * Copyright (c) 2002, 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: 579
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 579
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: 579
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 #ifndef SHARE_VM_UTILITIES_WORKGROUP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
26 #define SHARE_VM_UTILITIES_WORKGROUP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
27
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
28 #include "utilities/taskqueue.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
29 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
30 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
31 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
32 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
33 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
34 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
35 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
36 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
37 #endif
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
38
0
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // Forward declarations of classes defined here
a61af66fc99e Initial load
duke
parents:
diff changeset
40
a61af66fc99e Initial load
duke
parents:
diff changeset
41 class WorkGang;
a61af66fc99e Initial load
duke
parents:
diff changeset
42 class GangWorker;
a61af66fc99e Initial load
duke
parents:
diff changeset
43 class YieldingFlexibleGangWorker;
a61af66fc99e Initial load
duke
parents:
diff changeset
44 class YieldingFlexibleGangTask;
a61af66fc99e Initial load
duke
parents:
diff changeset
45 class WorkData;
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
46 class AbstractWorkGang;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
47
a61af66fc99e Initial load
duke
parents:
diff changeset
48 // An abstract task to be worked on by a gang.
a61af66fc99e Initial load
duke
parents:
diff changeset
49 // You subclass this to supply your own work() method
549
fe3d7c11b4b7 6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents: 342
diff changeset
50 class AbstractGangTask VALUE_OBJ_CLASS_SPEC {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
51 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
52 // The abstract work method.
a61af66fc99e Initial load
duke
parents:
diff changeset
53 // The argument tells you which member of the gang you are.
a61af66fc99e Initial load
duke
parents:
diff changeset
54 virtual void work(int i) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
55
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
56 // This method configures the task for proper termination.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
57 // Some tasks do not have any requirements on termination
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
58 // and may inherit this method that does nothing. Some
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
59 // tasks do some coordination on termination and override
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
60 // this method to implement that coordination.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
61 virtual void set_for_termination(int active_workers) {};
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
62
0
a61af66fc99e Initial load
duke
parents:
diff changeset
63 // Debugging accessor for the name.
a61af66fc99e Initial load
duke
parents:
diff changeset
64 const char* name() const PRODUCT_RETURN_(return NULL;);
a61af66fc99e Initial load
duke
parents:
diff changeset
65 int counter() { return _counter; }
a61af66fc99e Initial load
duke
parents:
diff changeset
66 void set_counter(int value) { _counter = value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
67 int *address_of_counter() { return &_counter; }
a61af66fc99e Initial load
duke
parents:
diff changeset
68
a61af66fc99e Initial load
duke
parents:
diff changeset
69 // RTTI
a61af66fc99e Initial load
duke
parents:
diff changeset
70 NOT_PRODUCT(virtual bool is_YieldingFlexibleGang_task() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
71 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
72 })
a61af66fc99e Initial load
duke
parents:
diff changeset
73
a61af66fc99e Initial load
duke
parents:
diff changeset
74 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
75 NOT_PRODUCT(const char* _name;)
a61af66fc99e Initial load
duke
parents:
diff changeset
76 // ??? Should a task have a priority associated with it?
a61af66fc99e Initial load
duke
parents:
diff changeset
77 // ??? Or can the run method adjust priority as needed?
a61af66fc99e Initial load
duke
parents:
diff changeset
78 int _counter;
a61af66fc99e Initial load
duke
parents:
diff changeset
79
a61af66fc99e Initial load
duke
parents:
diff changeset
80 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
81 // Constructor and desctructor: only construct subclasses.
a61af66fc99e Initial load
duke
parents:
diff changeset
82 AbstractGangTask(const char* name) {
a61af66fc99e Initial load
duke
parents:
diff changeset
83 NOT_PRODUCT(_name = name);
a61af66fc99e Initial load
duke
parents:
diff changeset
84 _counter = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
85 }
a61af66fc99e Initial load
duke
parents:
diff changeset
86 virtual ~AbstractGangTask() { }
a61af66fc99e Initial load
duke
parents:
diff changeset
87 };
a61af66fc99e Initial load
duke
parents:
diff changeset
88
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
89 class AbstractGangTaskWOopQueues : public AbstractGangTask {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
90 OopTaskQueueSet* _queues;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
91 ParallelTaskTerminator _terminator;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
92 public:
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
93 AbstractGangTaskWOopQueues(const char* name, OopTaskQueueSet* queues) :
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
94 AbstractGangTask(name), _queues(queues), _terminator(0, _queues) {}
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
95 ParallelTaskTerminator* terminator() { return &_terminator; }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
96 virtual void set_for_termination(int active_workers) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
97 terminator()->reset_for_reuse(active_workers);
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
98 }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
99 OopTaskQueueSet* queues() { return _queues; }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
100 };
0
a61af66fc99e Initial load
duke
parents:
diff changeset
101
a61af66fc99e Initial load
duke
parents:
diff changeset
102 // Class AbstractWorkGang:
a61af66fc99e Initial load
duke
parents:
diff changeset
103 // An abstract class representing a gang of workers.
a61af66fc99e Initial load
duke
parents:
diff changeset
104 // You subclass this to supply an implementation of run_task().
a61af66fc99e Initial load
duke
parents:
diff changeset
105 class AbstractWorkGang: public CHeapObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
106 // Here's the public interface to this class.
a61af66fc99e Initial load
duke
parents:
diff changeset
107 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
108 // Constructor and destructor.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
109 AbstractWorkGang(const char* name, bool are_GC_task_threads,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
110 bool are_ConcurrentGC_threads);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
111 ~AbstractWorkGang();
a61af66fc99e Initial load
duke
parents:
diff changeset
112 // Run a task, returns when the task is done (or terminated).
a61af66fc99e Initial load
duke
parents:
diff changeset
113 virtual void run_task(AbstractGangTask* task) = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // Stop and terminate all workers.
a61af66fc99e Initial load
duke
parents:
diff changeset
115 virtual void stop();
a61af66fc99e Initial load
duke
parents:
diff changeset
116 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
117 // Debugging.
a61af66fc99e Initial load
duke
parents:
diff changeset
118 const char* name() const;
a61af66fc99e Initial load
duke
parents:
diff changeset
119 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
120 // Initialize only instance data.
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
121 const bool _are_GC_task_threads;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
122 const bool _are_ConcurrentGC_threads;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
123 // Printing support.
a61af66fc99e Initial load
duke
parents:
diff changeset
124 const char* _name;
a61af66fc99e Initial load
duke
parents:
diff changeset
125 // The monitor which protects these data,
a61af66fc99e Initial load
duke
parents:
diff changeset
126 // and notifies of changes in it.
a61af66fc99e Initial load
duke
parents:
diff changeset
127 Monitor* _monitor;
a61af66fc99e Initial load
duke
parents:
diff changeset
128 // The count of the number of workers in the gang.
a61af66fc99e Initial load
duke
parents:
diff changeset
129 int _total_workers;
a61af66fc99e Initial load
duke
parents:
diff changeset
130 // Whether the workers should terminate.
a61af66fc99e Initial load
duke
parents:
diff changeset
131 bool _terminate;
a61af66fc99e Initial load
duke
parents:
diff changeset
132 // The array of worker threads for this gang.
a61af66fc99e Initial load
duke
parents:
diff changeset
133 // This is only needed for cleaning up.
a61af66fc99e Initial load
duke
parents:
diff changeset
134 GangWorker** _gang_workers;
a61af66fc99e Initial load
duke
parents:
diff changeset
135 // The task for this gang.
a61af66fc99e Initial load
duke
parents:
diff changeset
136 AbstractGangTask* _task;
a61af66fc99e Initial load
duke
parents:
diff changeset
137 // A sequence number for the current task.
a61af66fc99e Initial load
duke
parents:
diff changeset
138 int _sequence_number;
a61af66fc99e Initial load
duke
parents:
diff changeset
139 // The number of started workers.
a61af66fc99e Initial load
duke
parents:
diff changeset
140 int _started_workers;
a61af66fc99e Initial load
duke
parents:
diff changeset
141 // The number of finished workers.
a61af66fc99e Initial load
duke
parents:
diff changeset
142 int _finished_workers;
a61af66fc99e Initial load
duke
parents:
diff changeset
143 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
144 // Accessors for fields
a61af66fc99e Initial load
duke
parents:
diff changeset
145 Monitor* monitor() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
146 return _monitor;
a61af66fc99e Initial load
duke
parents:
diff changeset
147 }
a61af66fc99e Initial load
duke
parents:
diff changeset
148 int total_workers() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
149 return _total_workers;
a61af66fc99e Initial load
duke
parents:
diff changeset
150 }
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
151 virtual int active_workers() const {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
152 return _total_workers;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
153 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
154 bool terminate() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
155 return _terminate;
a61af66fc99e Initial load
duke
parents:
diff changeset
156 }
a61af66fc99e Initial load
duke
parents:
diff changeset
157 GangWorker** gang_workers() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
158 return _gang_workers;
a61af66fc99e Initial load
duke
parents:
diff changeset
159 }
a61af66fc99e Initial load
duke
parents:
diff changeset
160 AbstractGangTask* task() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
161 return _task;
a61af66fc99e Initial load
duke
parents:
diff changeset
162 }
a61af66fc99e Initial load
duke
parents:
diff changeset
163 int sequence_number() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
164 return _sequence_number;
a61af66fc99e Initial load
duke
parents:
diff changeset
165 }
a61af66fc99e Initial load
duke
parents:
diff changeset
166 int started_workers() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
167 return _started_workers;
a61af66fc99e Initial load
duke
parents:
diff changeset
168 }
a61af66fc99e Initial load
duke
parents:
diff changeset
169 int finished_workers() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
170 return _finished_workers;
a61af66fc99e Initial load
duke
parents:
diff changeset
171 }
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
172 bool are_GC_task_threads() const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
173 return _are_GC_task_threads;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
174 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
175 bool are_ConcurrentGC_threads() const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
176 return _are_ConcurrentGC_threads;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
177 }
a61af66fc99e Initial load
duke
parents:
diff changeset
178 // Predicates.
a61af66fc99e Initial load
duke
parents:
diff changeset
179 bool is_idle() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
180 return (task() == NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
181 }
a61af66fc99e Initial load
duke
parents:
diff changeset
182 // Return the Ith gang worker.
a61af66fc99e Initial load
duke
parents:
diff changeset
183 GangWorker* gang_worker(int i) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
184
a61af66fc99e Initial load
duke
parents:
diff changeset
185 void threads_do(ThreadClosure* tc) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
186
a61af66fc99e Initial load
duke
parents:
diff changeset
187 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
188 void print_worker_threads_on(outputStream *st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
189 void print_worker_threads() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
190 print_worker_threads_on(tty);
a61af66fc99e Initial load
duke
parents:
diff changeset
191 }
a61af66fc99e Initial load
duke
parents:
diff changeset
192
a61af66fc99e Initial load
duke
parents:
diff changeset
193 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
194 friend class GangWorker;
a61af66fc99e Initial load
duke
parents:
diff changeset
195 friend class YieldingFlexibleGangWorker;
a61af66fc99e Initial load
duke
parents:
diff changeset
196 // Note activation and deactivation of workers.
a61af66fc99e Initial load
duke
parents:
diff changeset
197 // These methods should only be called with the mutex held.
a61af66fc99e Initial load
duke
parents:
diff changeset
198 void internal_worker_poll(WorkData* data) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
199 void internal_note_start();
a61af66fc99e Initial load
duke
parents:
diff changeset
200 void internal_note_finish();
a61af66fc99e Initial load
duke
parents:
diff changeset
201 };
a61af66fc99e Initial load
duke
parents:
diff changeset
202
a61af66fc99e Initial load
duke
parents:
diff changeset
203 class WorkData: public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
204 // This would be a struct, but I want accessor methods.
a61af66fc99e Initial load
duke
parents:
diff changeset
205 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
206 bool _terminate;
a61af66fc99e Initial load
duke
parents:
diff changeset
207 AbstractGangTask* _task;
a61af66fc99e Initial load
duke
parents:
diff changeset
208 int _sequence_number;
a61af66fc99e Initial load
duke
parents:
diff changeset
209 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
210 // Constructor and destructor
a61af66fc99e Initial load
duke
parents:
diff changeset
211 WorkData() {
a61af66fc99e Initial load
duke
parents:
diff changeset
212 _terminate = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
213 _task = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
214 _sequence_number = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
215 }
a61af66fc99e Initial load
duke
parents:
diff changeset
216 ~WorkData() {
a61af66fc99e Initial load
duke
parents:
diff changeset
217 }
a61af66fc99e Initial load
duke
parents:
diff changeset
218 // Accessors and modifiers
a61af66fc99e Initial load
duke
parents:
diff changeset
219 bool terminate() const { return _terminate; }
a61af66fc99e Initial load
duke
parents:
diff changeset
220 void set_terminate(bool value) { _terminate = value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
221 AbstractGangTask* task() const { return _task; }
a61af66fc99e Initial load
duke
parents:
diff changeset
222 void set_task(AbstractGangTask* value) { _task = value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
223 int sequence_number() const { return _sequence_number; }
a61af66fc99e Initial load
duke
parents:
diff changeset
224 void set_sequence_number(int value) { _sequence_number = value; }
a61af66fc99e Initial load
duke
parents:
diff changeset
225
a61af66fc99e Initial load
duke
parents:
diff changeset
226 YieldingFlexibleGangTask* yf_task() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
227 return (YieldingFlexibleGangTask*)_task;
a61af66fc99e Initial load
duke
parents:
diff changeset
228 }
a61af66fc99e Initial load
duke
parents:
diff changeset
229 };
a61af66fc99e Initial load
duke
parents:
diff changeset
230
a61af66fc99e Initial load
duke
parents:
diff changeset
231 // Class WorkGang:
a61af66fc99e Initial load
duke
parents:
diff changeset
232 class WorkGang: public AbstractWorkGang {
a61af66fc99e Initial load
duke
parents:
diff changeset
233 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
234 // Constructor
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
235 WorkGang(const char* name, int workers,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
236 bool are_GC_task_threads, bool are_ConcurrentGC_threads);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
237 // Run a task, returns when the task is done (or terminated).
a61af66fc99e Initial load
duke
parents:
diff changeset
238 virtual void run_task(AbstractGangTask* task);
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
239 void run_task(AbstractGangTask* task, uint no_of_parallel_workers);
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
240 // Allocate a worker and return a pointer to it.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
241 virtual GangWorker* allocate_worker(int which);
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
242 // Initialize workers in the gang. Return true if initialization
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
243 // succeeded. The type of the worker can be overridden in a derived
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
244 // class with the appropriate implementation of allocate_worker().
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
245 bool initialize_workers();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
246 };
a61af66fc99e Initial load
duke
parents:
diff changeset
247
a61af66fc99e Initial load
duke
parents:
diff changeset
248 // Class GangWorker:
a61af66fc99e Initial load
duke
parents:
diff changeset
249 // Several instances of this class run in parallel as workers for a gang.
a61af66fc99e Initial load
duke
parents:
diff changeset
250 class GangWorker: public WorkerThread {
a61af66fc99e Initial load
duke
parents:
diff changeset
251 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
252 // Constructors and destructor.
a61af66fc99e Initial load
duke
parents:
diff changeset
253 GangWorker(AbstractWorkGang* gang, uint id);
a61af66fc99e Initial load
duke
parents:
diff changeset
254
a61af66fc99e Initial load
duke
parents:
diff changeset
255 // The only real method: run a task for the gang.
a61af66fc99e Initial load
duke
parents:
diff changeset
256 virtual void run();
a61af66fc99e Initial load
duke
parents:
diff changeset
257 // Predicate for Thread
a61af66fc99e Initial load
duke
parents:
diff changeset
258 virtual bool is_GC_task_thread() const;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
259 virtual bool is_ConcurrentGC_thread() const;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
260 // Printing
a61af66fc99e Initial load
duke
parents:
diff changeset
261 void print_on(outputStream* st) const;
a61af66fc99e Initial load
duke
parents:
diff changeset
262 virtual void print() const { print_on(tty); }
a61af66fc99e Initial load
duke
parents:
diff changeset
263 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
264 AbstractWorkGang* _gang;
a61af66fc99e Initial load
duke
parents:
diff changeset
265
a61af66fc99e Initial load
duke
parents:
diff changeset
266 virtual void initialize();
a61af66fc99e Initial load
duke
parents:
diff changeset
267 virtual void loop();
a61af66fc99e Initial load
duke
parents:
diff changeset
268
a61af66fc99e Initial load
duke
parents:
diff changeset
269 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
270 AbstractWorkGang* gang() const { return _gang; }
a61af66fc99e Initial load
duke
parents:
diff changeset
271 };
a61af66fc99e Initial load
duke
parents:
diff changeset
272
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
273 class FlexibleWorkGang: public WorkGang {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
274 protected:
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
275 int _active_workers;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
276 public:
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
277 // Constructor and destructor.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
278 FlexibleWorkGang(const char* name, int workers,
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
279 bool are_GC_task_threads,
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
280 bool are_ConcurrentGC_threads) :
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
281 WorkGang(name, workers, are_GC_task_threads, are_ConcurrentGC_threads) {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
282 _active_workers = ParallelGCThreads;
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
283 };
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
284 // Accessors for fields
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
285 virtual int active_workers() const { return _active_workers; }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
286 void set_active_workers(int v) { _active_workers = v; }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
287 };
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
288
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
289 // Work gangs in garbage collectors: 2009-06-10
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
290 //
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
291 // SharedHeap - work gang for stop-the-world parallel collection.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
292 // Used by
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
293 // ParNewGeneration
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
294 // CMSParRemarkTask
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
295 // CMSRefProcTaskExecutor
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
296 // G1CollectedHeap
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
297 // G1ParFinalCountTask
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
298 // ConcurrentMark
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
299 // CMSCollector
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
300
0
a61af66fc99e Initial load
duke
parents:
diff changeset
301 // A class that acts as a synchronisation barrier. Workers enter
a61af66fc99e Initial load
duke
parents:
diff changeset
302 // the barrier and must wait until all other workers have entered
a61af66fc99e Initial load
duke
parents:
diff changeset
303 // before any of them may leave.
a61af66fc99e Initial load
duke
parents:
diff changeset
304
a61af66fc99e Initial load
duke
parents:
diff changeset
305 class WorkGangBarrierSync : public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
306 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
307 Monitor _monitor;
a61af66fc99e Initial load
duke
parents:
diff changeset
308 int _n_workers;
a61af66fc99e Initial load
duke
parents:
diff changeset
309 int _n_completed;
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
310 bool _should_reset;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
311
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
312 Monitor* monitor() { return &_monitor; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
313 int n_workers() { return _n_workers; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
314 int n_completed() { return _n_completed; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
315 bool should_reset() { return _should_reset; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
316
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
317 void zero_completed() { _n_completed = 0; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
318 void inc_completed() { _n_completed++; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
319
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
320 void set_should_reset(bool v) { _should_reset = v; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
321
a61af66fc99e Initial load
duke
parents:
diff changeset
322 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
323 WorkGangBarrierSync();
a61af66fc99e Initial load
duke
parents:
diff changeset
324 WorkGangBarrierSync(int n_workers, const char* name);
a61af66fc99e Initial load
duke
parents:
diff changeset
325
a61af66fc99e Initial load
duke
parents:
diff changeset
326 // Set the number of workers that will use the barrier.
a61af66fc99e Initial load
duke
parents:
diff changeset
327 // Must be called before any of the workers start running.
a61af66fc99e Initial load
duke
parents:
diff changeset
328 void set_n_workers(int n_workers);
a61af66fc99e Initial load
duke
parents:
diff changeset
329
a61af66fc99e Initial load
duke
parents:
diff changeset
330 // Enter the barrier. A worker that enters the barrier will
a61af66fc99e Initial load
duke
parents:
diff changeset
331 // not be allowed to leave until all other threads have
a61af66fc99e Initial load
duke
parents:
diff changeset
332 // also entered the barrier.
a61af66fc99e Initial load
duke
parents:
diff changeset
333 void enter();
a61af66fc99e Initial load
duke
parents:
diff changeset
334 };
a61af66fc99e Initial load
duke
parents:
diff changeset
335
a61af66fc99e Initial load
duke
parents:
diff changeset
336 // A class to manage claiming of subtasks within a group of tasks. The
a61af66fc99e Initial load
duke
parents:
diff changeset
337 // subtasks will be identified by integer indices, usually elements of an
a61af66fc99e Initial load
duke
parents:
diff changeset
338 // enumeration type.
a61af66fc99e Initial load
duke
parents:
diff changeset
339
a61af66fc99e Initial load
duke
parents:
diff changeset
340 class SubTasksDone: public CHeapObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
341 jint* _tasks;
a61af66fc99e Initial load
duke
parents:
diff changeset
342 int _n_tasks;
a61af66fc99e Initial load
duke
parents:
diff changeset
343 int _n_threads;
a61af66fc99e Initial load
duke
parents:
diff changeset
344 jint _threads_completed;
a61af66fc99e Initial load
duke
parents:
diff changeset
345 #ifdef ASSERT
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
346 volatile jint _claimed;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
347 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
348
a61af66fc99e Initial load
duke
parents:
diff changeset
349 // Set all tasks to unclaimed.
a61af66fc99e Initial load
duke
parents:
diff changeset
350 void clear();
a61af66fc99e Initial load
duke
parents:
diff changeset
351
a61af66fc99e Initial load
duke
parents:
diff changeset
352 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
353 // Initializes "this" to a state in which there are "n" tasks to be
a61af66fc99e Initial load
duke
parents:
diff changeset
354 // processed, none of the which are originally claimed. The number of
a61af66fc99e Initial load
duke
parents:
diff changeset
355 // threads doing the tasks is initialized 1.
a61af66fc99e Initial load
duke
parents:
diff changeset
356 SubTasksDone(int n);
a61af66fc99e Initial load
duke
parents:
diff changeset
357
a61af66fc99e Initial load
duke
parents:
diff changeset
358 // True iff the object is in a valid state.
a61af66fc99e Initial load
duke
parents:
diff changeset
359 bool valid();
a61af66fc99e Initial load
duke
parents:
diff changeset
360
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
361 // Get/set the number of parallel threads doing the tasks to "t". Can only
0
a61af66fc99e Initial load
duke
parents:
diff changeset
362 // be called before tasks start or after they are complete.
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
363 int n_threads() { return _n_threads; }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
364 void set_n_threads(int t);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
365
a61af66fc99e Initial load
duke
parents:
diff changeset
366 // Returns "false" if the task "t" is unclaimed, and ensures that task is
a61af66fc99e Initial load
duke
parents:
diff changeset
367 // claimed. The task "t" is required to be within the range of "this".
a61af66fc99e Initial load
duke
parents:
diff changeset
368 bool is_task_claimed(int t);
a61af66fc99e Initial load
duke
parents:
diff changeset
369
a61af66fc99e Initial load
duke
parents:
diff changeset
370 // The calling thread asserts that it has attempted to claim all the
a61af66fc99e Initial load
duke
parents:
diff changeset
371 // tasks that it will try to claim. Every thread in the parallel task
a61af66fc99e Initial load
duke
parents:
diff changeset
372 // must execute this. (When the last thread does so, the task array is
a61af66fc99e Initial load
duke
parents:
diff changeset
373 // cleared.)
a61af66fc99e Initial load
duke
parents:
diff changeset
374 void all_tasks_completed();
a61af66fc99e Initial load
duke
parents:
diff changeset
375
a61af66fc99e Initial load
duke
parents:
diff changeset
376 // Destructor.
a61af66fc99e Initial load
duke
parents:
diff changeset
377 ~SubTasksDone();
a61af66fc99e Initial load
duke
parents:
diff changeset
378 };
a61af66fc99e Initial load
duke
parents:
diff changeset
379
a61af66fc99e Initial load
duke
parents:
diff changeset
380 // As above, but for sequential tasks, i.e. instead of claiming
a61af66fc99e Initial load
duke
parents:
diff changeset
381 // sub-tasks from a set (possibly an enumeration), claim sub-tasks
a61af66fc99e Initial load
duke
parents:
diff changeset
382 // in sequential order. This is ideal for claiming dynamically
a61af66fc99e Initial load
duke
parents:
diff changeset
383 // partitioned tasks (like striding in the parallel remembered
a61af66fc99e Initial load
duke
parents:
diff changeset
384 // set scanning). Note that unlike the above class this is
a61af66fc99e Initial load
duke
parents:
diff changeset
385 // a stack object - is there any reason for it not to be?
a61af66fc99e Initial load
duke
parents:
diff changeset
386
a61af66fc99e Initial load
duke
parents:
diff changeset
387 class SequentialSubTasksDone : public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
388 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
389 jint _n_tasks; // Total number of tasks available.
a61af66fc99e Initial load
duke
parents:
diff changeset
390 jint _n_claimed; // Number of tasks claimed.
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
391 // _n_threads is used to determine when a sub task is done.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
392 // See comments on SubTasksDone::_n_threads
0
a61af66fc99e Initial load
duke
parents:
diff changeset
393 jint _n_threads; // Total number of parallel threads.
a61af66fc99e Initial load
duke
parents:
diff changeset
394 jint _n_completed; // Number of completed threads.
a61af66fc99e Initial load
duke
parents:
diff changeset
395
a61af66fc99e Initial load
duke
parents:
diff changeset
396 void clear();
a61af66fc99e Initial load
duke
parents:
diff changeset
397
a61af66fc99e Initial load
duke
parents:
diff changeset
398 public:
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
399 SequentialSubTasksDone() {
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
400 clear();
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
401 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
402 ~SequentialSubTasksDone() {}
a61af66fc99e Initial load
duke
parents:
diff changeset
403
a61af66fc99e Initial load
duke
parents:
diff changeset
404 // True iff the object is in a valid state.
a61af66fc99e Initial load
duke
parents:
diff changeset
405 bool valid();
a61af66fc99e Initial load
duke
parents:
diff changeset
406
a61af66fc99e Initial load
duke
parents:
diff changeset
407 // number of tasks
a61af66fc99e Initial load
duke
parents:
diff changeset
408 jint n_tasks() const { return _n_tasks; }
a61af66fc99e Initial load
duke
parents:
diff changeset
409
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
410 // Get/set the number of parallel threads doing the tasks to t.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
411 // Should be called before the task starts but it is safe
a61af66fc99e Initial load
duke
parents:
diff changeset
412 // to call this once a task is running provided that all
a61af66fc99e Initial load
duke
parents:
diff changeset
413 // threads agree on the number of threads.
1833
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
414 int n_threads() { return _n_threads; }
8b10f48633dc 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 1552
diff changeset
415 void set_n_threads(int t) { _n_threads = t; }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
416
a61af66fc99e Initial load
duke
parents:
diff changeset
417 // Set the number of tasks to be claimed to t. As above,
a61af66fc99e Initial load
duke
parents:
diff changeset
418 // should be called before the tasks start but it is safe
a61af66fc99e Initial load
duke
parents:
diff changeset
419 // to call this once a task is running provided all threads
a61af66fc99e Initial load
duke
parents:
diff changeset
420 // agree on the number of tasks.
a61af66fc99e Initial load
duke
parents:
diff changeset
421 void set_n_tasks(int t) { _n_tasks = t; }
a61af66fc99e Initial load
duke
parents:
diff changeset
422
a61af66fc99e Initial load
duke
parents:
diff changeset
423 // Returns false if the next task in the sequence is unclaimed,
a61af66fc99e Initial load
duke
parents:
diff changeset
424 // and ensures that it is claimed. Will set t to be the index
a61af66fc99e Initial load
duke
parents:
diff changeset
425 // of the claimed task in the sequence. Will return true if
a61af66fc99e Initial load
duke
parents:
diff changeset
426 // the task cannot be claimed and there are none left to claim.
a61af66fc99e Initial load
duke
parents:
diff changeset
427 bool is_task_claimed(int& t);
a61af66fc99e Initial load
duke
parents:
diff changeset
428
a61af66fc99e Initial load
duke
parents:
diff changeset
429 // The calling thread asserts that it has attempted to claim
a61af66fc99e Initial load
duke
parents:
diff changeset
430 // all the tasks it possibly can in the sequence. Every thread
a61af66fc99e Initial load
duke
parents:
diff changeset
431 // claiming tasks must promise call this. Returns true if this
a61af66fc99e Initial load
duke
parents:
diff changeset
432 // is the last thread to complete so that the thread can perform
a61af66fc99e Initial load
duke
parents:
diff changeset
433 // cleanup if necessary.
a61af66fc99e Initial load
duke
parents:
diff changeset
434 bool all_tasks_completed();
a61af66fc99e Initial load
duke
parents:
diff changeset
435 };
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
436
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
437 // Represents a set of free small integer ids.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
438 class FreeIdSet {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
439 enum {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
440 end_of_list = -1,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
441 claimed = -2
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
442 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
443
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
444 int _sz;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
445 Monitor* _mon;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
446
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
447 int* _ids;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
448 int _hd;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
449 int _waiters;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
450 int _claimed;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
451
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
452 static bool _safepoint;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
453 typedef FreeIdSet* FreeIdSetPtr;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
454 static const int NSets = 10;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
455 static FreeIdSetPtr _sets[NSets];
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
456 static bool _stat_init;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
457 int _index;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
458
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
459 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
460 FreeIdSet(int sz, Monitor* mon);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
461 ~FreeIdSet();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
462
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
463 static void set_safepoint(bool b);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
464
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
465 // Attempt to claim the given id permanently. Returns "true" iff
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
466 // successful.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
467 bool claim_perm_id(int i);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
468
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
469 // Returns an unclaimed parallel id (waiting for one to be released if
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
470 // necessary). Returns "-1" if a GC wakes up a wait for an id.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
471 int claim_par_id();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
472
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
473 void release_par_id(int id);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
474 };
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
475
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1833
diff changeset
476 #endif // SHARE_VM_UTILITIES_WORKGROUP_HPP