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

annotate src/share/vm/utilities/workgroup.hpp @ 6197:d2a62e0f25eb

6995781: Native Memory Tracking (Phase 1) 7151532: DCmd for hotspot native memory tracking Summary: Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd Reviewed-by: acorn, coleenp, fparain

author	zgu
date	Thu, 28 Jun 2012 17:03:16 -0400
parents	441e946dc1af
children	b9a9ed0f8eeb

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

Mercurial > hg > graal-compiler

annotate src/share/vm/utilities/workgroup.hpp @ 6197:d2a62e0f25eb