truffle: src/share/vm/utilities/workgroup.hpp annotate

annotate src/share/vm/utilities/workgroup.hpp @ 6972:bd7a7ce2e264

6830717: replay of compilations would help with debugging Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method. Reviewed-by: kvn, twisti, sspitsyn Contributed-by: yumin.qi@oracle.com

author	minqi
date	Mon, 12 Nov 2012 14:03:53 -0800
parents	b9a9ed0f8eeb
children	f34d701e952e

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6842 b9a9ed0f8eeb 7197424: update copyright year to match last edit in jdk8 hotspot repository mikael parents: 6197 diff changeset	2 * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
0 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 > truffle

annotate src/share/vm/utilities/workgroup.hpp @ 6972:bd7a7ce2e264