Mercurial > hg > graal-compiler
annotate src/share/vm/utilities/workgroup.hpp @ 8804:91bf0bdae37b
8008217: CDS: Class data sharing limits the malloc heap on Solaris
Summary: In 64bit VM move CDS archive address to 32G on all platforms using new flag SharedBaseAddress. In 32bit VM set CDS archive address to 3Gb on Linux and let other OSs pick the address.
Reviewed-by: kvn, dcubed, zgu, hseigel
author | coleenp |
---|---|
date | Wed, 20 Mar 2013 08:04:54 -0400 |
parents | 32164d89fe9c |
children | 6f817ce50129 |
rev | line source |
---|---|
0 | 1 /* |
6842
b9a9ed0f8eeb
7197424: update copyright year to match last edit in jdk8 hotspot repository
mikael
parents:
6197
diff
changeset
|
2 * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
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 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_UTILITIES_WORKGROUP_HPP |
26 #define SHARE_VM_UTILITIES_WORKGROUP_HPP | |
27 | |
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6842
diff
changeset
|
28 #include "runtime/thread.inline.hpp" |
1972 | 29 #include "utilities/taskqueue.hpp" |
30 | |
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
31 // Task class hierarchy: |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
32 // AbstractGangTask |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
33 // AbstractGangTaskWOopQueues |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
34 // |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
35 // Gang/Group class hierarchy: |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
36 // AbstractWorkGang |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
37 // WorkGang |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
38 // FlexibleWorkGang |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
39 // YieldingFlexibleWorkGang (defined in another file) |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
40 // |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
41 // Worker class hierarchy: |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
42 // GangWorker (subclass of WorkerThread) |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
43 // YieldingFlexibleGangWorker (defined in another file) |
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
1972
diff
changeset
|
44 |
0 | 45 // Forward declarations of classes defined here |
46 | |
47 class WorkGang; | |
48 class GangWorker; | |
49 class YieldingFlexibleGangWorker; | |
50 class YieldingFlexibleGangTask; | |
51 class WorkData; | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
52 class AbstractWorkGang; |
0 | 53 |
54 // An abstract task to be worked on by a gang. | |
55 // 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
|
56 class AbstractGangTask VALUE_OBJ_CLASS_SPEC { |
0 | 57 public: |
58 // The abstract work method. | |
59 // The argument tells you which member of the gang you are. | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
60 virtual void work(uint worker_id) = 0; |
0 | 61 |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
62 // This method configures the task for proper termination. |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
63 // Some tasks do not have any requirements on termination |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
64 // and may inherit this method that does nothing. Some |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
65 // tasks do some coordination on termination and override |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
66 // this method to implement that coordination. |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
67 virtual void set_for_termination(int active_workers) {}; |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
68 |
0 | 69 // Debugging accessor for the name. |
70 const char* name() const PRODUCT_RETURN_(return NULL;); | |
71 int counter() { return _counter; } | |
72 void set_counter(int value) { _counter = value; } | |
73 int *address_of_counter() { return &_counter; } | |
74 | |
75 // RTTI | |
76 NOT_PRODUCT(virtual bool is_YieldingFlexibleGang_task() const { | |
77 return false; | |
78 }) | |
79 | |
80 private: | |
81 NOT_PRODUCT(const char* _name;) | |
82 // ??? Should a task have a priority associated with it? | |
83 // ??? Or can the run method adjust priority as needed? | |
84 int _counter; | |
85 | |
86 protected: | |
87 // Constructor and desctructor: only construct subclasses. | |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
88 AbstractGangTask(const char* name) |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
89 { |
0 | 90 NOT_PRODUCT(_name = name); |
91 _counter = 0; | |
92 } | |
7434
32164d89fe9c
8004845: Catch incorrect usage of new and delete during compile time for value objects and stack objects
brutisso
parents:
7180
diff
changeset
|
93 ~AbstractGangTask() { } |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
94 |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
95 public: |
0 | 96 }; |
97 | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
98 class AbstractGangTaskWOopQueues : public AbstractGangTask { |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
99 OopTaskQueueSet* _queues; |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
100 ParallelTaskTerminator _terminator; |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
101 public: |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
102 AbstractGangTaskWOopQueues(const char* name, OopTaskQueueSet* queues) : |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
103 AbstractGangTask(name), _queues(queues), _terminator(0, _queues) {} |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
104 ParallelTaskTerminator* terminator() { return &_terminator; } |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
105 virtual void set_for_termination(int active_workers) { |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
106 terminator()->reset_for_reuse(active_workers); |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
107 } |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
108 OopTaskQueueSet* queues() { return _queues; } |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
109 }; |
0 | 110 |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
111 |
0 | 112 // Class AbstractWorkGang: |
113 // An abstract class representing a gang of workers. | |
114 // You subclass this to supply an implementation of run_task(). | |
6197 | 115 class AbstractWorkGang: public CHeapObj<mtInternal> { |
0 | 116 // Here's the public interface to this class. |
117 public: | |
118 // Constructor and destructor. | |
342 | 119 AbstractWorkGang(const char* name, bool are_GC_task_threads, |
120 bool are_ConcurrentGC_threads); | |
0 | 121 ~AbstractWorkGang(); |
122 // Run a task, returns when the task is done (or terminated). | |
123 virtual void run_task(AbstractGangTask* task) = 0; | |
124 // Stop and terminate all workers. | |
125 virtual void stop(); | |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
126 // Return true if more workers should be applied to the task. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
127 virtual bool needs_more_workers() const { return true; } |
0 | 128 public: |
129 // Debugging. | |
130 const char* name() const; | |
131 protected: | |
132 // Initialize only instance data. | |
342 | 133 const bool _are_GC_task_threads; |
134 const bool _are_ConcurrentGC_threads; | |
0 | 135 // Printing support. |
136 const char* _name; | |
137 // The monitor which protects these data, | |
138 // and notifies of changes in it. | |
139 Monitor* _monitor; | |
140 // The count of the number of workers in the gang. | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
141 uint _total_workers; |
0 | 142 // Whether the workers should terminate. |
143 bool _terminate; | |
144 // The array of worker threads for this gang. | |
145 // This is only needed for cleaning up. | |
146 GangWorker** _gang_workers; | |
147 // The task for this gang. | |
148 AbstractGangTask* _task; | |
149 // A sequence number for the current task. | |
150 int _sequence_number; | |
151 // The number of started workers. | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
152 uint _started_workers; |
0 | 153 // The number of finished workers. |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
154 uint _finished_workers; |
0 | 155 public: |
156 // Accessors for fields | |
157 Monitor* monitor() const { | |
158 return _monitor; | |
159 } | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
160 uint total_workers() const { |
0 | 161 return _total_workers; |
162 } | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
163 virtual uint active_workers() const { |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
164 return _total_workers; |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
165 } |
0 | 166 bool terminate() const { |
167 return _terminate; | |
168 } | |
169 GangWorker** gang_workers() const { | |
170 return _gang_workers; | |
171 } | |
172 AbstractGangTask* task() const { | |
173 return _task; | |
174 } | |
175 int sequence_number() const { | |
176 return _sequence_number; | |
177 } | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
178 uint started_workers() const { |
0 | 179 return _started_workers; |
180 } | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
181 uint finished_workers() const { |
0 | 182 return _finished_workers; |
183 } | |
342 | 184 bool are_GC_task_threads() const { |
185 return _are_GC_task_threads; | |
186 } | |
187 bool are_ConcurrentGC_threads() const { | |
188 return _are_ConcurrentGC_threads; | |
0 | 189 } |
190 // Predicates. | |
191 bool is_idle() const { | |
192 return (task() == NULL); | |
193 } | |
194 // Return the Ith gang worker. | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
195 GangWorker* gang_worker(uint i) const; |
0 | 196 |
197 void threads_do(ThreadClosure* tc) const; | |
198 | |
199 // Printing | |
200 void print_worker_threads_on(outputStream *st) const; | |
201 void print_worker_threads() const { | |
202 print_worker_threads_on(tty); | |
203 } | |
204 | |
205 protected: | |
206 friend class GangWorker; | |
207 friend class YieldingFlexibleGangWorker; | |
208 // Note activation and deactivation of workers. | |
209 // These methods should only be called with the mutex held. | |
210 void internal_worker_poll(WorkData* data) const; | |
211 void internal_note_start(); | |
212 void internal_note_finish(); | |
213 }; | |
214 | |
215 class WorkData: public StackObj { | |
216 // This would be a struct, but I want accessor methods. | |
217 private: | |
218 bool _terminate; | |
219 AbstractGangTask* _task; | |
220 int _sequence_number; | |
221 public: | |
222 // Constructor and destructor | |
223 WorkData() { | |
224 _terminate = false; | |
225 _task = NULL; | |
226 _sequence_number = 0; | |
227 } | |
228 ~WorkData() { | |
229 } | |
230 // Accessors and modifiers | |
231 bool terminate() const { return _terminate; } | |
232 void set_terminate(bool value) { _terminate = value; } | |
233 AbstractGangTask* task() const { return _task; } | |
234 void set_task(AbstractGangTask* value) { _task = value; } | |
235 int sequence_number() const { return _sequence_number; } | |
236 void set_sequence_number(int value) { _sequence_number = value; } | |
237 | |
238 YieldingFlexibleGangTask* yf_task() const { | |
239 return (YieldingFlexibleGangTask*)_task; | |
240 } | |
241 }; | |
242 | |
243 // Class WorkGang: | |
244 class WorkGang: public AbstractWorkGang { | |
245 public: | |
246 // Constructor | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
247 WorkGang(const char* name, uint workers, |
342 | 248 bool are_GC_task_threads, bool are_ConcurrentGC_threads); |
0 | 249 // Run a task, returns when the task is done (or terminated). |
250 virtual void run_task(AbstractGangTask* task); | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
251 void run_task(AbstractGangTask* task, uint no_of_parallel_workers); |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
252 // Allocate a worker and return a pointer to it. |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
253 virtual GangWorker* allocate_worker(uint which); |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
254 // Initialize workers in the gang. Return true if initialization |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
255 // 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
|
256 // class with the appropriate implementation of allocate_worker(). |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
257 bool initialize_workers(); |
0 | 258 }; |
259 | |
260 // Class GangWorker: | |
261 // Several instances of this class run in parallel as workers for a gang. | |
262 class GangWorker: public WorkerThread { | |
263 public: | |
264 // Constructors and destructor. | |
265 GangWorker(AbstractWorkGang* gang, uint id); | |
266 | |
267 // The only real method: run a task for the gang. | |
268 virtual void run(); | |
269 // Predicate for Thread | |
270 virtual bool is_GC_task_thread() const; | |
342 | 271 virtual bool is_ConcurrentGC_thread() const; |
0 | 272 // Printing |
273 void print_on(outputStream* st) const; | |
274 virtual void print() const { print_on(tty); } | |
275 protected: | |
276 AbstractWorkGang* _gang; | |
277 | |
278 virtual void initialize(); | |
279 virtual void loop(); | |
280 | |
281 public: | |
282 AbstractWorkGang* gang() const { return _gang; } | |
283 }; | |
284 | |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
285 // Dynamic number of worker threads |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
286 // |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
287 // This type of work gang is used to run different numbers of |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
288 // worker threads at different times. The |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
289 // number of workers run for a task is "_active_workers" |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
290 // instead of "_total_workers" in a WorkGang. The method |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
291 // "needs_more_workers()" returns true until "_active_workers" |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
292 // have been started and returns false afterwards. The |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
293 // implementation of "needs_more_workers()" in WorkGang always |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
294 // returns true so that all workers are started. The method |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
295 // "loop()" in GangWorker was modified to ask "needs_more_workers()" |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
296 // in its loop to decide if it should start working on a task. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
297 // A worker in "loop()" waits for notification on the WorkGang |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
298 // monitor and execution of each worker as it checks for work |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
299 // is serialized via the same monitor. The "needs_more_workers()" |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
300 // call is serialized and additionally the calculation for the |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
301 // "part" (effectively the worker id for executing the task) is |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
302 // serialized to give each worker a unique "part". Workers that |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
303 // are not needed for this tasks (i.e., "_active_workers" have |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
304 // been started before it, continue to wait for work. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
305 |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
306 class FlexibleWorkGang: public WorkGang { |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
307 // The currently active workers in this gang. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
308 // This is a number that is dynamically adjusted |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
309 // and checked in the run_task() method at each invocation. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
310 // As described above _active_workers determines the number |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
311 // of threads started on a task. It must also be used to |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
312 // determine completion. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
313 |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
314 protected: |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
315 uint _active_workers; |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
316 public: |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
317 // Constructor and destructor. |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
318 // Initialize active_workers to a minimum value. Setting it to |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
319 // the parameter "workers" will initialize it to a maximum |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
320 // value which is not desirable. |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
321 FlexibleWorkGang(const char* name, uint workers, |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
322 bool are_GC_task_threads, |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
323 bool are_ConcurrentGC_threads) : |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
324 WorkGang(name, workers, are_GC_task_threads, are_ConcurrentGC_threads), |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
325 _active_workers(UseDynamicNumberOfGCThreads ? 1U : ParallelGCThreads) {} |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
326 // Accessors for fields |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
327 virtual uint active_workers() const { return _active_workers; } |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
328 void set_active_workers(uint v) { |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
329 assert(v <= _total_workers, |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
330 "Trying to set more workers active than there are"); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
331 _active_workers = MIN2(v, _total_workers); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
332 assert(v != 0, "Trying to set active workers to 0"); |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
333 _active_workers = MAX2(1U, _active_workers); |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
334 assert(UseDynamicNumberOfGCThreads || _active_workers == _total_workers, |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
335 "Unless dynamic should use total workers"); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
336 } |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
337 virtual void run_task(AbstractGangTask* task); |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
338 virtual bool needs_more_workers() const { |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
339 return _started_workers < _active_workers; |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
340 } |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
341 }; |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
342 |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
343 // Work gangs in garbage collectors: 2009-06-10 |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
344 // |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
345 // SharedHeap - work gang for stop-the-world parallel collection. |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
346 // Used by |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
347 // ParNewGeneration |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
348 // CMSParRemarkTask |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
349 // CMSRefProcTaskExecutor |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
350 // G1CollectedHeap |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
351 // G1ParFinalCountTask |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
352 // ConcurrentMark |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
353 // CMSCollector |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
354 |
0 | 355 // A class that acts as a synchronisation barrier. Workers enter |
356 // the barrier and must wait until all other workers have entered | |
357 // before any of them may leave. | |
358 | |
359 class WorkGangBarrierSync : public StackObj { | |
360 protected: | |
361 Monitor _monitor; | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
362 uint _n_workers; |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
363 uint _n_completed; |
342 | 364 bool _should_reset; |
0 | 365 |
342 | 366 Monitor* monitor() { return &_monitor; } |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
367 uint n_workers() { return _n_workers; } |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
368 uint n_completed() { return _n_completed; } |
342 | 369 bool should_reset() { return _should_reset; } |
0 | 370 |
342 | 371 void zero_completed() { _n_completed = 0; } |
372 void inc_completed() { _n_completed++; } | |
373 | |
374 void set_should_reset(bool v) { _should_reset = v; } | |
0 | 375 |
376 public: | |
377 WorkGangBarrierSync(); | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
378 WorkGangBarrierSync(uint n_workers, const char* name); |
0 | 379 |
380 // Set the number of workers that will use the barrier. | |
381 // Must be called before any of the workers start running. | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
382 void set_n_workers(uint n_workers); |
0 | 383 |
384 // Enter the barrier. A worker that enters the barrier will | |
385 // not be allowed to leave until all other threads have | |
386 // also entered the barrier. | |
387 void enter(); | |
388 }; | |
389 | |
390 // A class to manage claiming of subtasks within a group of tasks. The | |
391 // subtasks will be identified by integer indices, usually elements of an | |
392 // enumeration type. | |
393 | |
6197 | 394 class SubTasksDone: public CHeapObj<mtInternal> { |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
395 uint* _tasks; |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
396 uint _n_tasks; |
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
397 // _n_threads is used to determine when a sub task is done. |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
398 // It does not control how many threads will execute the subtask |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
399 // but must be initialized to the number that do execute the task |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
400 // in order to correctly decide when the subtask is done (all the |
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
3960
diff
changeset
|
401 // threads working on the task have finished). |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
402 uint _n_threads; |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
403 uint _threads_completed; |
0 | 404 #ifdef ASSERT |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
405 volatile uint _claimed; |
0 | 406 #endif |
407 | |
408 // Set all tasks to unclaimed. | |
409 void clear(); | |
410 | |
411 public: | |
412 // Initializes "this" to a state in which there are "n" tasks to be | |
413 // processed, none of the which are originally claimed. The number of | |
414 // threads doing the tasks is initialized 1. | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
415 SubTasksDone(uint n); |
0 | 416 |
417 // True iff the object is in a valid state. | |
418 bool valid(); | |
419 | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
420 // Get/set the number of parallel threads doing the tasks to "t". Can only |
0 | 421 // be called before tasks start or after they are complete. |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
422 uint n_threads() { return _n_threads; } |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
423 void set_n_threads(uint t); |
0 | 424 |
425 // Returns "false" if the task "t" is unclaimed, and ensures that task is | |
426 // claimed. The task "t" is required to be within the range of "this". | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
427 bool is_task_claimed(uint t); |
0 | 428 |
429 // The calling thread asserts that it has attempted to claim all the | |
430 // tasks that it will try to claim. Every thread in the parallel task | |
431 // must execute this. (When the last thread does so, the task array is | |
432 // cleared.) | |
433 void all_tasks_completed(); | |
434 | |
435 // Destructor. | |
436 ~SubTasksDone(); | |
437 }; | |
438 | |
439 // As above, but for sequential tasks, i.e. instead of claiming | |
440 // sub-tasks from a set (possibly an enumeration), claim sub-tasks | |
441 // in sequential order. This is ideal for claiming dynamically | |
442 // partitioned tasks (like striding in the parallel remembered | |
443 // set scanning). Note that unlike the above class this is | |
444 // a stack object - is there any reason for it not to be? | |
445 | |
446 class SequentialSubTasksDone : public StackObj { | |
447 protected: | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
448 uint _n_tasks; // Total number of tasks available. |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
449 uint _n_claimed; // Number of tasks claimed. |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
450 // _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
|
451 // See comments on SubTasksDone::_n_threads |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
452 uint _n_threads; // Total number of parallel threads. |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
453 uint _n_completed; // Number of completed threads. |
0 | 454 |
455 void clear(); | |
456 | |
457 public: | |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
458 SequentialSubTasksDone() { |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
459 clear(); |
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
460 } |
0 | 461 ~SequentialSubTasksDone() {} |
462 | |
463 // True iff the object is in a valid state. | |
464 bool valid(); | |
465 | |
466 // number of tasks | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
467 uint n_tasks() const { return _n_tasks; } |
0 | 468 |
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1552
diff
changeset
|
469 // Get/set the number of parallel threads doing the tasks to t. |
0 | 470 // Should be called before the task starts but it is safe |
471 // to call this once a task is running provided that all | |
472 // threads agree on the number of threads. | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
473 uint n_threads() { return _n_threads; } |
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
474 void set_n_threads(uint t) { _n_threads = t; } |
0 | 475 |
476 // Set the number of tasks to be claimed to t. As above, | |
477 // should be called before the tasks start but it is safe | |
478 // to call this once a task is running provided all threads | |
479 // agree on the number of tasks. | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
480 void set_n_tasks(uint t) { _n_tasks = t; } |
0 | 481 |
482 // Returns false if the next task in the sequence is unclaimed, | |
483 // and ensures that it is claimed. Will set t to be the index | |
484 // of the claimed task in the sequence. Will return true if | |
485 // the task cannot be claimed and there are none left to claim. | |
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4095
diff
changeset
|
486 bool is_task_claimed(uint& t); |
0 | 487 |
488 // The calling thread asserts that it has attempted to claim | |
489 // all the tasks it possibly can in the sequence. Every thread | |
490 // claiming tasks must promise call this. Returns true if this | |
491 // is the last thread to complete so that the thread can perform | |
492 // cleanup if necessary. | |
493 bool all_tasks_completed(); | |
494 }; | |
342 | 495 |
496 // Represents a set of free small integer ids. | |
497 class FreeIdSet { | |
498 enum { | |
499 end_of_list = -1, | |
500 claimed = -2 | |
501 }; | |
502 | |
503 int _sz; | |
504 Monitor* _mon; | |
505 | |
506 int* _ids; | |
507 int _hd; | |
508 int _waiters; | |
509 int _claimed; | |
510 | |
511 static bool _safepoint; | |
512 typedef FreeIdSet* FreeIdSetPtr; | |
513 static const int NSets = 10; | |
514 static FreeIdSetPtr _sets[NSets]; | |
515 static bool _stat_init; | |
516 int _index; | |
517 | |
518 public: | |
519 FreeIdSet(int sz, Monitor* mon); | |
520 ~FreeIdSet(); | |
521 | |
522 static void set_safepoint(bool b); | |
523 | |
524 // Attempt to claim the given id permanently. Returns "true" iff | |
525 // successful. | |
526 bool claim_perm_id(int i); | |
527 | |
528 // Returns an unclaimed parallel id (waiting for one to be released if | |
529 // necessary). Returns "-1" if a GC wakes up a wait for an id. | |
530 int claim_par_id(); | |
531 | |
532 void release_par_id(int id); | |
533 }; | |
1972 | 534 |
535 #endif // SHARE_VM_UTILITIES_WORKGROUP_HPP |