graal-compiler: src/share/vm/utilities/workgroup.hpp annotate

annotate src/share/vm/utilities/workgroup.hpp @ 10130:6f817ce50129

8010992: Remove calls to global ::operator new[] and new Summary: disable use of global operator new and new[] which could cause unexpected exception and escape from NMT tracking. Reviewed-by: coleenp, dholmes, zgu Contributed-by: yumin.qi@oracle.com

author	minqi
date	Fri, 19 Apr 2013 11:08:52 -0700
parents	32164d89fe9c
children	5a9fa2ba85f0

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10130 6f817ce50129 8010992: Remove calls to global ::operator new[] and new minqi parents: 7434 diff changeset	2 * Copyright (c) 2002, 2013, 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
7180 f34d701e952e 8003935: Simplify the needed includes for using Thread::current() stefank parents: 6842 diff changeset	28 #include "runtime/thread.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	29 #include "utilities/taskqueue.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	45 // Forward declarations of classes defined here
a61af66fc99e Initial load duke parents: diff changeset	46
a61af66fc99e Initial load duke parents: diff changeset	47 class WorkGang;
a61af66fc99e Initial load duke parents: diff changeset	48 class GangWorker;
a61af66fc99e Initial load duke parents: diff changeset	49 class YieldingFlexibleGangWorker;
a61af66fc99e Initial load duke parents: diff changeset	50 class YieldingFlexibleGangTask;
a61af66fc99e Initial load duke parents: diff changeset	51 class WorkData;
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	52 class AbstractWorkGang;
0 a61af66fc99e Initial load duke parents: diff changeset	53
a61af66fc99e Initial load duke parents: diff changeset	54 // An abstract task to be worked on by a gang.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	57 public:
a61af66fc99e Initial load duke parents: diff changeset	58 // The abstract work method.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	69 // Debugging accessor for the name.
a61af66fc99e Initial load duke parents: diff changeset	70 const char* name() const PRODUCT_RETURN_(return NULL;);
a61af66fc99e Initial load duke parents: diff changeset	71 int counter() { return _counter; }
a61af66fc99e Initial load duke parents: diff changeset	72 void set_counter(int value) { _counter = value; }
a61af66fc99e Initial load duke parents: diff changeset	73 int *address_of_counter() { return &_counter; }
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75 // RTTI
a61af66fc99e Initial load duke parents: diff changeset	76 NOT_PRODUCT(virtual bool is_YieldingFlexibleGang_task() const {
a61af66fc99e Initial load duke parents: diff changeset	77 return false;
a61af66fc99e Initial load duke parents: diff changeset	78 })
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 private:
a61af66fc99e Initial load duke parents: diff changeset	81 NOT_PRODUCT(const char* _name;)
a61af66fc99e Initial load duke parents: diff changeset	82 // ??? Should a task have a priority associated with it?
a61af66fc99e Initial load duke parents: diff changeset	83 // ??? Or can the run method adjust priority as needed?
a61af66fc99e Initial load duke parents: diff changeset	84 int _counter;
a61af66fc99e Initial load duke parents: diff changeset	85
a61af66fc99e Initial load duke parents: diff changeset	86 protected:
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	90 NOT_PRODUCT(_name = name);
a61af66fc99e Initial load duke parents: diff changeset	91 _counter = 0;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	96 };
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	110
4095 bca17e38de00 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads jmasa parents: 3960 diff changeset	111
0 a61af66fc99e Initial load duke parents: diff changeset	112 // Class AbstractWorkGang:
a61af66fc99e Initial load duke parents: diff changeset	113 // An abstract class representing a gang of workers.
a61af66fc99e Initial load duke parents: diff changeset	114 // You subclass this to supply an implementation of run_task().
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4728 diff changeset	115 class AbstractWorkGang: public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	116 // Here's the public interface to this class.
a61af66fc99e Initial load duke parents: diff changeset	117 public:
a61af66fc99e Initial load duke parents: diff changeset	118 // Constructor and destructor.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	119 AbstractWorkGang(const char* name, bool are_GC_task_threads,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	120 bool are_ConcurrentGC_threads);
0 a61af66fc99e Initial load duke parents: diff changeset	121 ~AbstractWorkGang();
a61af66fc99e Initial load duke parents: diff changeset	122 // Run a task, returns when the task is done (or terminated).
a61af66fc99e Initial load duke parents: diff changeset	123 virtual void run_task(AbstractGangTask* task) = 0;
a61af66fc99e Initial load duke parents: diff changeset	124 // Stop and terminate all workers.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	128 public:
a61af66fc99e Initial load duke parents: diff changeset	129 // Debugging.
a61af66fc99e Initial load duke parents: diff changeset	130 const char* name() const;
a61af66fc99e Initial load duke parents: diff changeset	131 protected:
a61af66fc99e Initial load duke parents: diff changeset	132 // Initialize only instance data.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	133 const bool _are_GC_task_threads;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	134 const bool _are_ConcurrentGC_threads;
0 a61af66fc99e Initial load duke parents: diff changeset	135 // Printing support.
a61af66fc99e Initial load duke parents: diff changeset	136 const char* _name;
a61af66fc99e Initial load duke parents: diff changeset	137 // The monitor which protects these data,
a61af66fc99e Initial load duke parents: diff changeset	138 // and notifies of changes in it.
a61af66fc99e Initial load duke parents: diff changeset	139 Monitor* _monitor;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	142 // Whether the workers should terminate.
a61af66fc99e Initial load duke parents: diff changeset	143 bool _terminate;
a61af66fc99e Initial load duke parents: diff changeset	144 // The array of worker threads for this gang.
a61af66fc99e Initial load duke parents: diff changeset	145 // This is only needed for cleaning up.
a61af66fc99e Initial load duke parents: diff changeset	146 GangWorker** _gang_workers;
a61af66fc99e Initial load duke parents: diff changeset	147 // The task for this gang.
a61af66fc99e Initial load duke parents: diff changeset	148 AbstractGangTask* _task;
a61af66fc99e Initial load duke parents: diff changeset	149 // A sequence number for the current task.
a61af66fc99e Initial load duke parents: diff changeset	150 int _sequence_number;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	155 public:
a61af66fc99e Initial load duke parents: diff changeset	156 // Accessors for fields
a61af66fc99e Initial load duke parents: diff changeset	157 Monitor* monitor() const {
a61af66fc99e Initial load duke parents: diff changeset	158 return _monitor;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	161 return _total_workers;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	166 bool terminate() const {
a61af66fc99e Initial load duke parents: diff changeset	167 return _terminate;
a61af66fc99e Initial load duke parents: diff changeset	168 }
a61af66fc99e Initial load duke parents: diff changeset	169 GangWorker** gang_workers() const {
a61af66fc99e Initial load duke parents: diff changeset	170 return _gang_workers;
a61af66fc99e Initial load duke parents: diff changeset	171 }
a61af66fc99e Initial load duke parents: diff changeset	172 AbstractGangTask* task() const {
a61af66fc99e Initial load duke parents: diff changeset	173 return _task;
a61af66fc99e Initial load duke parents: diff changeset	174 }
a61af66fc99e Initial load duke parents: diff changeset	175 int sequence_number() const {
a61af66fc99e Initial load duke parents: diff changeset	176 return _sequence_number;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	179 return _started_workers;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	182 return _finished_workers;
a61af66fc99e Initial load duke parents: diff changeset	183 }
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	184 bool are_GC_task_threads() const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	185 return _are_GC_task_threads;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	186 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	187 bool are_ConcurrentGC_threads() const {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	188 return _are_ConcurrentGC_threads;
0 a61af66fc99e Initial load duke parents: diff changeset	189 }
a61af66fc99e Initial load duke parents: diff changeset	190 // Predicates.
a61af66fc99e Initial load duke parents: diff changeset	191 bool is_idle() const {
a61af66fc99e Initial load duke parents: diff changeset	192 return (task() == NULL);
a61af66fc99e Initial load duke parents: diff changeset	193 }
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	196
a61af66fc99e Initial load duke parents: diff changeset	197 void threads_do(ThreadClosure* tc) const;
a61af66fc99e Initial load duke parents: diff changeset	198
a61af66fc99e Initial load duke parents: diff changeset	199 // Printing
a61af66fc99e Initial load duke parents: diff changeset	200 void print_worker_threads_on(outputStream *st) const;
a61af66fc99e Initial load duke parents: diff changeset	201 void print_worker_threads() const {
a61af66fc99e Initial load duke parents: diff changeset	202 print_worker_threads_on(tty);
a61af66fc99e Initial load duke parents: diff changeset	203 }
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 protected:
a61af66fc99e Initial load duke parents: diff changeset	206 friend class GangWorker;
a61af66fc99e Initial load duke parents: diff changeset	207 friend class YieldingFlexibleGangWorker;
a61af66fc99e Initial load duke parents: diff changeset	208 // Note activation and deactivation of workers.
a61af66fc99e Initial load duke parents: diff changeset	209 // These methods should only be called with the mutex held.
a61af66fc99e Initial load duke parents: diff changeset	210 void internal_worker_poll(WorkData* data) const;
a61af66fc99e Initial load duke parents: diff changeset	211 void internal_note_start();
a61af66fc99e Initial load duke parents: diff changeset	212 void internal_note_finish();
a61af66fc99e Initial load duke parents: diff changeset	213 };
a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215 class WorkData: public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	216 // This would be a struct, but I want accessor methods.
a61af66fc99e Initial load duke parents: diff changeset	217 private:
a61af66fc99e Initial load duke parents: diff changeset	218 bool _terminate;
a61af66fc99e Initial load duke parents: diff changeset	219 AbstractGangTask* _task;
a61af66fc99e Initial load duke parents: diff changeset	220 int _sequence_number;
a61af66fc99e Initial load duke parents: diff changeset	221 public:
a61af66fc99e Initial load duke parents: diff changeset	222 // Constructor and destructor
a61af66fc99e Initial load duke parents: diff changeset	223 WorkData() {
a61af66fc99e Initial load duke parents: diff changeset	224 _terminate = false;
a61af66fc99e Initial load duke parents: diff changeset	225 _task = NULL;
a61af66fc99e Initial load duke parents: diff changeset	226 _sequence_number = 0;
a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	228 ~WorkData() {
a61af66fc99e Initial load duke parents: diff changeset	229 }
a61af66fc99e Initial load duke parents: diff changeset	230 // Accessors and modifiers
a61af66fc99e Initial load duke parents: diff changeset	231 bool terminate() const { return _terminate; }
a61af66fc99e Initial load duke parents: diff changeset	232 void set_terminate(bool value) { _terminate = value; }
a61af66fc99e Initial load duke parents: diff changeset	233 AbstractGangTask* task() const { return _task; }
a61af66fc99e Initial load duke parents: diff changeset	234 void set_task(AbstractGangTask* value) { _task = value; }
a61af66fc99e Initial load duke parents: diff changeset	235 int sequence_number() const { return _sequence_number; }
a61af66fc99e Initial load duke parents: diff changeset	236 void set_sequence_number(int value) { _sequence_number = value; }
a61af66fc99e Initial load duke parents: diff changeset	237
a61af66fc99e Initial load duke parents: diff changeset	238 YieldingFlexibleGangTask* yf_task() const {
a61af66fc99e Initial load duke parents: diff changeset	239 return (YieldingFlexibleGangTask*)_task;
a61af66fc99e Initial load duke parents: diff changeset	240 }
a61af66fc99e Initial load duke parents: diff changeset	241 };
a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243 // Class WorkGang:
a61af66fc99e Initial load duke parents: diff changeset	244 class WorkGang: public AbstractWorkGang {
a61af66fc99e Initial load duke parents: diff changeset	245 public:
a61af66fc99e Initial load duke parents: diff changeset	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 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	248 bool are_GC_task_threads, bool are_ConcurrentGC_threads);
0 a61af66fc99e Initial load duke parents: diff changeset	249 // Run a task, returns when the task is done (or terminated).
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	258 };
a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 // Class GangWorker:
a61af66fc99e Initial load duke parents: diff changeset	261 // Several instances of this class run in parallel as workers for a gang.
a61af66fc99e Initial load duke parents: diff changeset	262 class GangWorker: public WorkerThread {
a61af66fc99e Initial load duke parents: diff changeset	263 public:
a61af66fc99e Initial load duke parents: diff changeset	264 // Constructors and destructor.
a61af66fc99e Initial load duke parents: diff changeset	265 GangWorker(AbstractWorkGang* gang, uint id);
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 // The only real method: run a task for the gang.
a61af66fc99e Initial load duke parents: diff changeset	268 virtual void run();
a61af66fc99e Initial load duke parents: diff changeset	269 // Predicate for Thread
a61af66fc99e Initial load duke parents: diff changeset	270 virtual bool is_GC_task_thread() const;
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	271 virtual bool is_ConcurrentGC_thread() const;
0 a61af66fc99e Initial load duke parents: diff changeset	272 // Printing
a61af66fc99e Initial load duke parents: diff changeset	273 void print_on(outputStream* st) const;
a61af66fc99e Initial load duke parents: diff changeset	274 virtual void print() const { print_on(tty); }
a61af66fc99e Initial load duke parents: diff changeset	275 protected:
a61af66fc99e Initial load duke parents: diff changeset	276 AbstractWorkGang* _gang;
a61af66fc99e Initial load duke parents: diff changeset	277
a61af66fc99e Initial load duke parents: diff changeset	278 virtual void initialize();
a61af66fc99e Initial load duke parents: diff changeset	279 virtual void loop();
a61af66fc99e Initial load duke parents: diff changeset	280
a61af66fc99e Initial load duke parents: diff changeset	281 public:
a61af66fc99e Initial load duke parents: diff changeset	282 AbstractWorkGang* gang() const { return _gang; }
a61af66fc99e Initial load duke parents: diff changeset	283 };
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	355 // A class that acts as a synchronisation barrier. Workers enter
a61af66fc99e Initial load duke parents: diff changeset	356 // the barrier and must wait until all other workers have entered
a61af66fc99e Initial load duke parents: diff changeset	357 // before any of them may leave.
a61af66fc99e Initial load duke parents: diff changeset	358
a61af66fc99e Initial load duke parents: diff changeset	359 class WorkGangBarrierSync : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	360 protected:
a61af66fc99e Initial load duke parents: diff changeset	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 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	364 bool _should_reset;
0 a61af66fc99e Initial load duke parents: diff changeset	365
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	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 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	369 bool should_reset() { return _should_reset; }
0 a61af66fc99e Initial load duke parents: diff changeset	370
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	371 void zero_completed() { _n_completed = 0; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	372 void inc_completed() { _n_completed++; }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	373
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	374 void set_should_reset(bool v) { _should_reset = v; }
0 a61af66fc99e Initial load duke parents: diff changeset	375
a61af66fc99e Initial load duke parents: diff changeset	376 public:
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	379
a61af66fc99e Initial load duke parents: diff changeset	380 // Set the number of workers that will use the barrier.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	383
a61af66fc99e Initial load duke parents: diff changeset	384 // Enter the barrier. A worker that enters the barrier will
a61af66fc99e Initial load duke parents: diff changeset	385 // not be allowed to leave until all other threads have
a61af66fc99e Initial load duke parents: diff changeset	386 // also entered the barrier.
a61af66fc99e Initial load duke parents: diff changeset	387 void enter();
a61af66fc99e Initial load duke parents: diff changeset	388 };
a61af66fc99e Initial load duke parents: diff changeset	389
a61af66fc99e Initial load duke parents: diff changeset	390 // A class to manage claiming of subtasks within a group of tasks. The
a61af66fc99e Initial load duke parents: diff changeset	391 // subtasks will be identified by integer indices, usually elements of an
a61af66fc99e Initial load duke parents: diff changeset	392 // enumeration type.
a61af66fc99e Initial load duke parents: diff changeset	393
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 4728 diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	406 #endif
a61af66fc99e Initial load duke parents: diff changeset	407
a61af66fc99e Initial load duke parents: diff changeset	408 // Set all tasks to unclaimed.
a61af66fc99e Initial load duke parents: diff changeset	409 void clear();
a61af66fc99e Initial load duke parents: diff changeset	410
a61af66fc99e Initial load duke parents: diff changeset	411 public:
a61af66fc99e Initial load duke parents: diff changeset	412 // Initializes "this" to a state in which there are "n" tasks to be
a61af66fc99e Initial load duke parents: diff changeset	413 // processed, none of the which are originally claimed. The number of
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	416
a61af66fc99e Initial load duke parents: diff changeset	417 // True iff the object is in a valid state.
a61af66fc99e Initial load duke parents: diff changeset	418 bool valid();
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	424
a61af66fc99e Initial load duke parents: diff changeset	425 // Returns "false" if the task "t" is unclaimed, and ensures that task is
a61af66fc99e Initial load duke parents: diff changeset	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 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 all the
a61af66fc99e Initial load duke parents: diff changeset	430 // tasks that it will try to claim. Every thread in the parallel task
a61af66fc99e Initial load duke parents: diff changeset	431 // must execute this. (When the last thread does so, the task array is
a61af66fc99e Initial load duke parents: diff changeset	432 // cleared.)
a61af66fc99e Initial load duke parents: diff changeset	433 void all_tasks_completed();
a61af66fc99e Initial load duke parents: diff changeset	434
a61af66fc99e Initial load duke parents: diff changeset	435 // Destructor.
a61af66fc99e Initial load duke parents: diff changeset	436 ~SubTasksDone();
a61af66fc99e Initial load duke parents: diff changeset	437 };
a61af66fc99e Initial load duke parents: diff changeset	438
a61af66fc99e Initial load duke parents: diff changeset	439 // As above, but for sequential tasks, i.e. instead of claiming
a61af66fc99e Initial load duke parents: diff changeset	440 // sub-tasks from a set (possibly an enumeration), claim sub-tasks
a61af66fc99e Initial load duke parents: diff changeset	441 // in sequential order. This is ideal for claiming dynamically
a61af66fc99e Initial load duke parents: diff changeset	442 // partitioned tasks (like striding in the parallel remembered
a61af66fc99e Initial load duke parents: diff changeset	443 // set scanning). Note that unlike the above class this is
a61af66fc99e Initial load duke parents: diff changeset	444 // a stack object - is there any reason for it not to be?
a61af66fc99e Initial load duke parents: diff changeset	445
a61af66fc99e Initial load duke parents: diff changeset	446 class SequentialSubTasksDone : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	454
a61af66fc99e Initial load duke parents: diff changeset	455 void clear();
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	461 ~SequentialSubTasksDone() {}
a61af66fc99e Initial load duke parents: diff changeset	462
a61af66fc99e Initial load duke parents: diff changeset	463 // True iff the object is in a valid state.
a61af66fc99e Initial load duke parents: diff changeset	464 bool valid();
a61af66fc99e Initial load duke parents: diff changeset	465
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	470 // Should be called before the task starts but it is safe
a61af66fc99e Initial load duke parents: diff changeset	471 // to call this once a task is running provided that all
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	475
a61af66fc99e Initial load duke parents: diff changeset	476 // Set the number of tasks to be claimed to t. As above,
a61af66fc99e Initial load duke parents: diff changeset	477 // should be called before the tasks start but it is safe
a61af66fc99e Initial load duke parents: diff changeset	478 // to call this once a task is running provided all threads
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	481
a61af66fc99e Initial load duke parents: diff changeset	482 // Returns false if the next task in the sequence is unclaimed,
a61af66fc99e Initial load duke parents: diff changeset	483 // and ensures that it is claimed. Will set t to be the index
a61af66fc99e Initial load duke parents: diff changeset	484 // of the claimed task in the sequence. Will return true if
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488 // The calling thread asserts that it has attempted to claim
a61af66fc99e Initial load duke parents: diff changeset	489 // all the tasks it possibly can in the sequence. Every thread
a61af66fc99e Initial load duke parents: diff changeset	490 // claiming tasks must promise call this. Returns true if this
a61af66fc99e Initial load duke parents: diff changeset	491 // is the last thread to complete so that the thread can perform
a61af66fc99e Initial load duke parents: diff changeset	492 // cleanup if necessary.
a61af66fc99e Initial load duke parents: diff changeset	493 bool all_tasks_completed();
a61af66fc99e Initial load duke parents: diff changeset	494 };
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	495
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	496 // Represents a set of free small integer ids.
10130 6f817ce50129 8010992: Remove calls to global ::operator new[] and new minqi parents: 7434 diff changeset	497 class FreeIdSet : public CHeapObj<mtInternal> {
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	498 enum {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	499 end_of_list = -1,
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	500 claimed = -2
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	501 };
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	502
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	503 int _sz;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	504 Monitor* _mon;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	505
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	506 int* _ids;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	507 int _hd;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	508 int _waiters;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	509 int _claimed;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	510
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	511 static bool _safepoint;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	512 typedef FreeIdSet* FreeIdSetPtr;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	513 static const int NSets = 10;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	514 static FreeIdSetPtr _sets[NSets];
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	515 static bool _stat_init;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	516 int _index;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	517
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	518 public:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	519 FreeIdSet(int sz, Monitor* mon);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	520 ~FreeIdSet();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	521
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	522 static void set_safepoint(bool b);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	523
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	524 // Attempt to claim the given id permanently. Returns "true" iff
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	525 // successful.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	526 bool claim_perm_id(int i);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	527
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	528 // 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	529 // 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	530 int claim_par_id();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	531
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	532 void release_par_id(int id);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 0 diff changeset	533 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	534
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	535 #endif // SHARE_VM_UTILITIES_WORKGROUP_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/utilities/workgroup.hpp @ 10130:6f817ce50129