hotspot/src/share/vm/utilities/yieldingWorkgroup.hpp
author dholmes
Wed, 11 Sep 2013 00:38:18 -0400
changeset 19974 0d2f09f4643c
parent 15482 470d0b0c09f1
permissions -rw-r--r--
8024256: Minimal VM build is broken with PCH disabled Reviewed-by: coleenp, twisti
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
19974
0d2f09f4643c 8024256: Minimal VM build is broken with PCH disabled
dholmes
parents: 15482
diff changeset
     2
 * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1374
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1374
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1374
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6763
diff changeset
    25
#ifndef SHARE_VM_UTILITIES_YIELDINGWORKGROUP_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6763
diff changeset
    26
#define SHARE_VM_UTILITIES_YIELDINGWORKGROUP_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6763
diff changeset
    27
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14841
diff changeset
    28
#include "utilities/macros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6763
diff changeset
    29
#include "utilities/workgroup.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// Forward declarations
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
class YieldingFlexibleWorkGang;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// Status of tasks
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
enum Status {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
    INACTIVE,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
    ACTIVE,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
    YIELDING,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
    YIELDED,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
    ABORTING,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
    ABORTED,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
    COMPLETING,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
    COMPLETED
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// Class YieldingFlexibleGangWorker:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
//   Several instances of this class run in parallel as workers for a gang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
class YieldingFlexibleGangWorker: public GangWorker {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  // Ctor
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  YieldingFlexibleGangWorker(AbstractWorkGang* gang, int id) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
    GangWorker(gang, id) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  YieldingFlexibleWorkGang* yf_gang() const
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
    { return (YieldingFlexibleWorkGang*)gang(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
protected: // Override from parent class
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  virtual void loop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    62
class FlexibleGangTask: public AbstractGangTask {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    63
  int _actual_size;                      // size of gang obtained
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    64
protected:
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    65
  int _requested_size;                   // size of gang requested
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    66
public:
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    67
 FlexibleGangTask(const char* name): AbstractGangTask(name),
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    68
    _requested_size(0) {}
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    69
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    70
  // The abstract work method.
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    71
  // The argument tells you which member of the gang you are.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
    72
  virtual void work(uint worker_id) = 0;
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    73
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    74
  int requested_size() const { return _requested_size; }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    75
  int actual_size()    const { return _actual_size; }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    76
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    77
  void set_requested_size(int sz) { _requested_size = sz; }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    78
  void set_actual_size(int sz)    { _actual_size    = sz; }
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    79
};
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    80
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
// An abstract task to be worked on by a flexible work gang,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
// and where the workers will periodically yield, usually
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
// in response to some condition that is signalled by means
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
// that are specific to the task at hand.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
// You subclass this to supply your own work() method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
// A second feature of this kind of work gang is that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
// it allows for the signalling of certain exceptional
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
// conditions that may be encountered during the performance
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
// of the task and that may require the task at hand to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
// `aborted' forthwith. Finally, these gangs are `flexible'
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
// in that they can operate at partial capacity with some
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
// gang workers waiting on the bench; in other words, the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
// size of the active worker pool can flex (up to an apriori
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
// maximum) in response to task requests at certain points.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
// The last part (the flexible part) has not yet been fully
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
// fleshed out and is a work in progress.
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    97
class YieldingFlexibleGangTask: public FlexibleGangTask {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  Status _status;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  YieldingFlexibleWorkGang* _gang;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  // Constructor and desctructor: only construct subclasses.
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   103
  YieldingFlexibleGangTask(const char* name): FlexibleGangTask(name),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
    _status(INACTIVE),
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   105
    _gang(NULL) { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
14841
d069f5506f71 8004845: Catch incorrect usage of new and delete during compile time for value objects and stack objects
brutisso
parents: 11396
diff changeset
   107
  ~YieldingFlexibleGangTask() { }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  friend class YieldingFlexibleWorkGang;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  friend class YieldingFlexibleGangWorker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  NOT_PRODUCT(virtual bool is_YieldingFlexibleGang_task() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  })
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  void set_status(Status s) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
    _status = s;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  YieldingFlexibleWorkGang* gang() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
    return _gang;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  void set_gang(YieldingFlexibleWorkGang* gang) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
    assert(_gang == NULL || gang == NULL, "Clobber without intermediate reset?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
    _gang = gang;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  // The abstract work method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  // The argument tells you which member of the gang you are.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   129
  virtual void work(uint worker_id) = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  // Subclasses should call the parent's yield() method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  // after having done any work specific to the subclass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  virtual void yield();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  // An abstract method supplied by
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // a concrete sub-class which is used by the coordinator
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  // to do any "central yielding" work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  virtual void coordinator_yield() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  // Subclasses should call the parent's abort() method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  // after having done any work specific to the sunbclass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  virtual void abort();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  Status status()  const { return _status; }
6763
711b8a44c4dd 6692906: CMS: parallel concurrent marking may be prone to hanging or stalling mutators for periods of time
ysr
parents: 6759
diff changeset
   145
  bool yielding()  const { return _status == YIELDING; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  bool yielded()   const { return _status == YIELDED; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  bool completed() const { return _status == COMPLETED; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  bool aborted()   const { return _status == ABORTED; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  bool active()    const { return _status == ACTIVE; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
// Class YieldingWorkGang: A subclass of WorkGang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
// In particular, a YieldingWorkGang is made up of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
// YieldingGangWorkers, and provides infrastructure
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
// supporting yielding to the "GangOverseer",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
// being the thread that orchestrates the WorkGang via run_task().
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   156
class YieldingFlexibleWorkGang: public FlexibleWorkGang {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // Here's the public interface to this class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  // Constructor and destructor.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   160
  YieldingFlexibleWorkGang(const char* name, uint workers,
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   161
                           bool are_GC_task_threads);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  YieldingFlexibleGangTask* yielding_task() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    assert(task() == NULL || task()->is_YieldingFlexibleGang_task(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
           "Incorrect cast");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    return (YieldingFlexibleGangTask*)task();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  }
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   168
  // Allocate a worker and return a pointer to it.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   169
  GangWorker* allocate_worker(uint which);
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   170
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  // Run a task; returns when the task is done, or the workers yield,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // or the task is aborted, or the work gang is terminated via stop().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // A task that has been yielded can be continued via this same interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  // by using the same task repeatedly as the argument to the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  // It is expected that the YieldingFlexibleGangTask carries the appropriate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  // continuation information used by workers to continue the task
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  // from its last yield point. Thus, a completed task will return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  // immediately with no actual work having been done by the workers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  void run_task(AbstractGangTask* task) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    guarantee(false, "Use start_task instead");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  void start_task(YieldingFlexibleGangTask* new_task);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  void continue_task(YieldingFlexibleGangTask* gang_task);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  // Abort a currently running task, if any; returns when all the workers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  // have stopped working on the current task and have returned to their
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // waiting stations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  void abort_task();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  // Yield: workers wait at their current working stations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  // until signalled to proceed by the overseer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  void yield();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  // Abort: workers are expected to return to their waiting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  // stations, whence they are ready for the next task dispatched
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  // by the overseer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  void abort();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
private:
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   200
  uint _yielded_workers;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  void wait_for_gang();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  // Accessors for fields
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   205
  uint yielded_workers() const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
    return _yielded_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  friend class YieldingFlexibleGangWorker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  void reset(); // NYI
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6763
diff changeset
   213
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6763
diff changeset
   214
#endif // SHARE_VM_UTILITIES_YIELDINGWORKGROUP_HPP