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

annotate src/share/vm/utilities/workgroup.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	487f09bf44e0
children

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

Mercurial > hg > truffle

annotate src/share/vm/utilities/workgroup.hpp @ 20543:e7d0505c8a30