src/hotspot/share/gc/shared/workgroup.hpp
author stefank
Thu, 22 Feb 2018 18:36:32 +0100
changeset 49048 4e8c86b75428
parent 49030 1817d118ff66
child 49392 2956d0ece7a9
permissions -rw-r--r--
8198525: Move _size_policy out of GenCollectorPolicy into GenCollectedHeap Reviewed-by: pliden, sjohanss
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
49030
1817d118ff66 8198267: Allow GCId::current_raw() calls from non-NamedThreads
pliden
parents: 48123
diff changeset
     2
 * Copyright (c) 2002, 2018, 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: 2105
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2105
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: 2105
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
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30585
diff changeset
    25
#ifndef SHARE_VM_GC_SHARED_WORKGROUP_HPP
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30585
diff changeset
    26
#define SHARE_VM_GC_SHARED_WORKGROUP_HPP
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    27
32361
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    28
#include "memory/allocation.hpp"
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    29
#include "runtime/globals.hpp"
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    30
#include "runtime/thread.hpp"
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
    31
#include "gc/shared/gcId.hpp"
36201
8d947f31586e 8150367: Add back information about the number of GC workers
brutisso
parents: 35465
diff changeset
    32
#include "logging/log.hpp"
32361
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    33
#include "utilities/debug.hpp"
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    34
#include "utilities/globalDefinitions.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    35
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    36
// Task class hierarchy:
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    37
//   AbstractGangTask
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    38
//
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    39
// Gang/Group class hierarchy:
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    40
//   AbstractWorkGang
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    41
//     WorkGang
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
    42
//     YieldingFlexibleWorkGang (defined in another file)
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    43
//
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    44
// Worker class hierarchy:
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
    45
//   AbstractGangWorker (subclass of WorkerThread)
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
    46
//     GangWorker
8688
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    47
//     YieldingFlexibleGangWorker   (defined in another file)
493d12ccc6db 6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents: 7397
diff changeset
    48
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// Forward declarations of classes defined here
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
    51
class AbstractGangWorker;
32361
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    52
class Semaphore;
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    53
class WorkGang;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// An abstract task to be worked on by a gang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// You subclass this to supply your own work() method
2013
49e915da0905 6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents: 1374
diff changeset
    57
class AbstractGangTask VALUE_OBJ_CLASS_SPEC {
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
    58
  const char* _name;
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
    59
  const uint _gc_id;
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
    60
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
    61
 public:
49030
1817d118ff66 8198267: Allow GCId::current_raw() calls from non-NamedThreads
pliden
parents: 48123
diff changeset
    62
  explicit AbstractGangTask(const char* name) :
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
    63
    _name(name),
49030
1817d118ff66 8198267: Allow GCId::current_raw() calls from non-NamedThreads
pliden
parents: 48123
diff changeset
    64
    _gc_id(GCId::current_or_undefined())
41178
e567be097315 8157952: Parallelize Memory Pretouch
tschatzl
parents: 40922
diff changeset
    65
  {}
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
    66
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  // The abstract work method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  // 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
    69
  virtual void work(uint worker_id) = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  // Debugging accessor for the name.
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
    72
  const char* name() const { return _name; }
33107
77bf0d2069a3 8134953: Make the GC ID available in a central place
brutisso
parents: 33105
diff changeset
    73
  const uint gc_id() const { return _gc_id; }
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
    74
};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
32361
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    76
struct WorkData {
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    77
  AbstractGangTask* _task;
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    78
  uint              _worker_id;
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    79
  WorkData(AbstractGangTask* task, uint worker_id) : _task(task), _worker_id(worker_id) {}
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    80
};
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    81
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    82
// Interface to handle the synchronization between the coordinator thread and the worker threads,
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    83
// when a task is dispatched out to the worker threads.
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    84
class GangTaskDispatcher : public CHeapObj<mtGC> {
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    85
 public:
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    86
  virtual ~GangTaskDispatcher() {}
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    87
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    88
  // Coordinator API.
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    89
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    90
  // Distributes the task out to num_workers workers.
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    91
  // Returns when the task has been completed by all workers.
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    92
  virtual void coordinator_execute_on_workers(AbstractGangTask* task, uint num_workers) = 0;
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    93
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    94
  // Worker API.
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    95
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    96
  // Waits for a task to become available to the worker.
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    97
  // Returns when the worker has been assigned a task.
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    98
  virtual WorkData worker_wait_for_task() = 0;
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
    99
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   100
  // Signal to the coordinator that the worker is done with the assigned task.
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   101
  virtual void     worker_done_with_task() = 0;
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   102
};
11174
fccee5238e70 6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents: 10565
diff changeset
   103
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   104
// The work gang is the collection of workers to execute tasks.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   105
// The number of workers run for a task is "_active_workers"
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   106
// while "_total_workers" is the number of available of workers.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   107
class AbstractWorkGang : public CHeapObj<mtInternal> {
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   108
 protected:
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   109
  // The array of worker threads for this gang.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   110
  AbstractGangWorker** _workers;
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   111
  // The count of the number of workers in the gang.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   112
  uint _total_workers;
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   113
  // The currently active workers in this gang.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   114
  uint _active_workers;
38216
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   115
  // The count of created workers in the gang.
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   116
  uint _created_workers;
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   117
  // Printing support.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   118
  const char* _name;
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   119
48123
f93055f440d8 8191864: Provide a public destructor for WorkGang
pliden
parents: 47216
diff changeset
   120
  ~AbstractWorkGang() {}
f93055f440d8 8191864: Provide a public destructor for WorkGang
pliden
parents: 47216
diff changeset
   121
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   122
 private:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // Initialize only instance data.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   124
  const bool _are_GC_task_threads;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   125
  const bool _are_ConcurrentGC_threads;
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   126
38216
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   127
  void set_thread(uint worker_id, AbstractGangWorker* worker) {
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   128
    _workers[worker_id] = worker;
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   129
  }
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   130
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   131
 public:
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   132
  AbstractWorkGang(const char* name, uint workers, bool are_GC_task_threads, bool are_ConcurrentGC_threads) :
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   133
      _name(name),
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   134
      _total_workers(workers),
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   135
      _active_workers(UseDynamicNumberOfGCThreads ? 1U : workers),
38216
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   136
      _created_workers(0),
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   137
      _are_GC_task_threads(are_GC_task_threads),
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   138
      _are_ConcurrentGC_threads(are_ConcurrentGC_threads)
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   139
  { }
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   140
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   141
  // Initialize workers in the gang.  Return true if initialization succeeded.
38216
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   142
  void initialize_workers();
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   143
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   144
  bool are_GC_task_threads()      const { return _are_GC_task_threads; }
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   145
  bool are_ConcurrentGC_threads() const { return _are_ConcurrentGC_threads; }
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   146
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   147
  uint total_workers() const { return _total_workers; }
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   148
38216
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   149
  uint created_workers() const {
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   150
    return _created_workers;
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   151
  }
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   152
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   153
  virtual uint active_workers() const {
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   154
    assert(_active_workers <= _total_workers,
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32361
diff changeset
   155
           "_active_workers: %u > _total_workers: %u", _active_workers, _total_workers);
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   156
    assert(UseDynamicNumberOfGCThreads || _active_workers == _total_workers,
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   157
           "Unless dynamic should use total workers");
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   158
    return _active_workers;
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   159
  }
38216
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   160
40096
246c62cd9180 8159073: : Error handling incomplete when creating GC threads lazily
jmasa
parents: 39704
diff changeset
   161
  uint update_active_workers(uint v) {
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   162
    assert(v <= _total_workers,
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   163
           "Trying to set more workers active than there are");
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   164
    _active_workers = MIN2(v, _total_workers);
38216
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   165
    add_workers(false /* exit_on_failure */);
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   166
    assert(v != 0, "Trying to set active workers to 0");
40922
d9f1eaf18f9a 8165292: The gc+task logging is repeated a lot, decreasing the usefulness of -Xlog:gc*=info
tschatzl
parents: 40096
diff changeset
   167
    log_trace(gc, task)("%s: using %d out of %d workers", name(), _active_workers, _total_workers);
40096
246c62cd9180 8159073: : Error handling incomplete when creating GC threads lazily
jmasa
parents: 39704
diff changeset
   168
    return _active_workers;
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   169
  }
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   170
38216
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   171
  // Add GC workers as needed.
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   172
  void add_workers(bool initializing);
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   173
39231
e6aa09b4f1b9 8157620: Guarantee in run_task(task, num_workers) fails
jmasa
parents: 38216
diff changeset
   174
  // Add GC workers as needed to reach the specified number of workers.
e6aa09b4f1b9 8157620: Guarantee in run_task(task, num_workers) fails
jmasa
parents: 38216
diff changeset
   175
  void add_workers(uint active_workers, bool initializing);
e6aa09b4f1b9 8157620: Guarantee in run_task(task, num_workers) fails
jmasa
parents: 38216
diff changeset
   176
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   177
  // Return the Ith worker.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   178
  AbstractGangWorker* worker(uint i) const;
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   179
39704
157f39705057 8157240: GC task trace logging is incomprehensible
jmasa
parents: 39231
diff changeset
   180
  // Base name (without worker id #) of threads.
157f39705057 8157240: GC task trace logging is incomprehensible
jmasa
parents: 39231
diff changeset
   181
  const char* group_name() { return name(); }
157f39705057 8157240: GC task trace logging is incomprehensible
jmasa
parents: 39231
diff changeset
   182
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   183
  void threads_do(ThreadClosure* tc) const;
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   184
38216
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   185
  // Create a GC worker and install it into the work gang.
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   186
  virtual AbstractGangWorker* install_worker(uint which);
250794c6f95f 6858051: Create GC worker threads dynamically
jmasa
parents: 38153
diff changeset
   187
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   188
  // Debugging.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   189
  const char* name() const { return _name; }
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   190
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   191
  // Printing
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   192
  void print_worker_threads_on(outputStream *st) const;
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   193
  void print_worker_threads() const {
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   194
    print_worker_threads_on(tty);
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   195
  }
32361
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   196
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   197
 protected:
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   198
  virtual AbstractGangWorker* allocate_worker(uint which) = 0;
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   199
};
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   200
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   201
// An class representing a gang of workers.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   202
class WorkGang: public AbstractWorkGang {
32361
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   203
  // To get access to the GangTaskDispatcher instance.
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   204
  friend class GangWorker;
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   205
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   206
  GangTaskDispatcher* const _dispatcher;
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   207
  GangTaskDispatcher* dispatcher() const {
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   208
    return _dispatcher;
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   209
  }
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   210
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   211
public:
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   212
  WorkGang(const char* name,
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   213
           uint workers,
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   214
           bool are_GC_task_threads,
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   215
           bool are_ConcurrentGC_threads);
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   216
48123
f93055f440d8 8191864: Provide a public destructor for WorkGang
pliden
parents: 47216
diff changeset
   217
  ~WorkGang();
f93055f440d8 8191864: Provide a public destructor for WorkGang
pliden
parents: 47216
diff changeset
   218
38153
4f13f0b690c3 8155232: Augment Workgang to run task with a given number of threads
tschatzl
parents: 37225
diff changeset
   219
  // Run a task using the current active number of workers, returns when the task is done.
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   220
  virtual void run_task(AbstractGangTask* task);
38153
4f13f0b690c3 8155232: Augment Workgang to run task with a given number of threads
tschatzl
parents: 37225
diff changeset
   221
  // Run a task with the given number of workers, returns
4f13f0b690c3 8155232: Augment Workgang to run task with a given number of threads
tschatzl
parents: 37225
diff changeset
   222
  // when the task is done. The number of workers must be at most the number of
39231
e6aa09b4f1b9 8157620: Guarantee in run_task(task, num_workers) fails
jmasa
parents: 38216
diff changeset
   223
  // active workers.  Additional workers may be created if an insufficient
e6aa09b4f1b9 8157620: Guarantee in run_task(task, num_workers) fails
jmasa
parents: 38216
diff changeset
   224
  // number currently exists.
38153
4f13f0b690c3 8155232: Augment Workgang to run task with a given number of threads
tschatzl
parents: 37225
diff changeset
   225
  void run_task(AbstractGangTask* task, uint num_workers);
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   226
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   227
protected:
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   228
  virtual AbstractGangWorker* allocate_worker(uint which);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   231
// Several instances of this class run in parallel as workers for a gang.
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   232
class AbstractGangWorker: public WorkerThread {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
public:
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   234
  AbstractGangWorker(AbstractWorkGang* gang, uint id);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  // The only real method: run a task for the gang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  virtual void run();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  // Predicate for Thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  virtual bool is_GC_task_thread() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   240
  virtual bool is_ConcurrentGC_thread() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  // Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  void print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  virtual void print() const { print_on(tty); }
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   244
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  AbstractWorkGang* _gang;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  virtual void initialize();
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   249
  virtual void loop() = 0;
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   250
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   251
  AbstractWorkGang* gang() const { return _gang; }
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   252
};
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   253
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   254
class GangWorker: public AbstractGangWorker {
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   255
public:
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   256
  GangWorker(WorkGang* gang, uint id) : AbstractGangWorker(gang, id) {}
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   257
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   258
protected:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  virtual void loop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   261
private:
32361
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   262
  WorkData wait_for_task();
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   263
  void run_task(WorkData work);
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   264
  void signal_task_done();
3de9a2e1e2d0 8087324: Use semaphores when starting and stopping GC task threads
stefank
parents: 32360
diff changeset
   265
32360
86790204fc23 8087323: Unify and split the work gang classes
stefank
parents: 31030
diff changeset
   266
  WorkGang* gang() const { return (WorkGang*)_gang; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
// A class that acts as a synchronisation barrier. Workers enter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
// the barrier and must wait until all other workers have entered
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
// before any of them may leave.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
class WorkGangBarrierSync : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  Monitor _monitor;
24468
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   276
  uint    _n_workers;
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   277
  uint    _n_completed;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   278
  bool    _should_reset;
24468
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   279
  bool    _aborted;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   281
  Monitor* monitor()        { return &_monitor; }
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   282
  uint     n_workers()      { return _n_workers; }
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   283
  uint     n_completed()    { return _n_completed; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   284
  bool     should_reset()   { return _should_reset; }
24468
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   285
  bool     aborted()        { return _aborted; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   287
  void     zero_completed() { _n_completed = 0; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   288
  void     inc_completed()  { _n_completed++; }
24468
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   289
  void     set_aborted()    { _aborted = true; }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   290
  void     set_should_reset(bool v) { _should_reset = v; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  WorkGangBarrierSync();
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   294
  WorkGangBarrierSync(uint n_workers, const char* name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  // Set the number of workers that will use the barrier.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // Must be called before any of the workers start running.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   298
  void set_n_workers(uint n_workers);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  // Enter the barrier. A worker that enters the barrier will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  // not be allowed to leave until all other threads have
24468
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   302
  // also entered the barrier or the barrier is aborted.
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   303
  // Returns false if the barrier was aborted.
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   304
  bool enter();
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   305
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   306
  // Aborts the barrier and wakes up any threads waiting for
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   307
  // the barrier to complete. The barrier will remain in the
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   308
  // aborted state until the next call to set_n_workers().
cb71997b6484 8040803: G1: Concurrent mark hangs when mark stack overflows
pliden
parents: 17376
diff changeset
   309
  void abort();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
// A class to manage claiming of subtasks within a group of tasks.  The
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
// subtasks will be identified by integer indices, usually elements of an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
// enumeration type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 11396
diff changeset
   316
class SubTasksDone: public CHeapObj<mtInternal> {
41279
5a7c83da4a2d 8165860: WorkGroup classes are missing volatile specifiers for lock-free code
eosterlund
parents: 41178
diff changeset
   317
  volatile uint* _tasks;
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   318
  uint _n_tasks;
41279
5a7c83da4a2d 8165860: WorkGroup classes are missing volatile specifiers for lock-free code
eosterlund
parents: 41178
diff changeset
   319
  volatile uint _threads_completed;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
#ifdef ASSERT
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   321
  volatile uint _claimed;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  // Set all tasks to unclaimed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  void clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  // Initializes "this" to a state in which there are "n" tasks to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // processed, none of the which are originally claimed.  The number of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  // threads doing the tasks is initialized 1.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   331
  SubTasksDone(uint n);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  // True iff the object is in a valid state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  bool valid();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  // Returns "false" if the task "t" is unclaimed, and ensures that task is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // claimed.  The task "t" is required to be within the range of "this".
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   338
  bool is_task_claimed(uint t);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  // The calling thread asserts that it has attempted to claim all the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  // tasks that it will try to claim.  Every thread in the parallel task
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // must execute this.  (When the last thread does so, the task array is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // cleared.)
30869
d5cbedffb50b 8080111: Remove SubTaskDone::_n_threads
stefank
parents: 30764
diff changeset
   344
  //
d5cbedffb50b 8080111: Remove SubTaskDone::_n_threads
stefank
parents: 30764
diff changeset
   345
  // n_threads - Number of threads executing the sub-tasks.
d5cbedffb50b 8080111: Remove SubTaskDone::_n_threads
stefank
parents: 30764
diff changeset
   346
  void all_tasks_completed(uint n_threads);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // Destructor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  ~SubTasksDone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
// As above, but for sequential tasks, i.e. instead of claiming
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
// sub-tasks from a set (possibly an enumeration), claim sub-tasks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
// in sequential order. This is ideal for claiming dynamically
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
// partitioned tasks (like striding in the parallel remembered
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
// set scanning). Note that unlike the above class this is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
// a stack object - is there any reason for it not to be?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
class SequentialSubTasksDone : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
protected:
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   361
  uint _n_tasks;     // Total number of tasks available.
41279
5a7c83da4a2d 8165860: WorkGroup classes are missing volatile specifiers for lock-free code
eosterlund
parents: 41178
diff changeset
   362
  volatile uint _n_claimed;   // Number of tasks claimed.
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   363
  // _n_threads is used to determine when a sub task is done.
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   364
  // See comments on SubTasksDone::_n_threads
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   365
  uint _n_threads;   // Total number of parallel threads.
41279
5a7c83da4a2d 8165860: WorkGroup classes are missing volatile specifiers for lock-free code
eosterlund
parents: 41178
diff changeset
   366
  volatile uint _n_completed; // Number of completed threads.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  void clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
public:
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   371
  SequentialSubTasksDone() {
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   372
    clear();
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   373
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  ~SequentialSubTasksDone() {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  // True iff the object is in a valid state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  bool valid();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  // number of tasks
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   380
  uint n_tasks() const { return _n_tasks; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   382
  // Get/set the number of parallel threads doing the tasks to t.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  // Should be called before the task starts but it is safe
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  // to call this once a task is running provided that all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  // threads agree on the number of threads.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   386
  uint n_threads() { return _n_threads; }
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   387
  void set_n_threads(uint t) { _n_threads = t; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  // Set the number of tasks to be claimed to t. As above,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  // should be called before the tasks start but it is safe
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  // to call this once a task is running provided all threads
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  // agree on the number of tasks.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   393
  void set_n_tasks(uint t) { _n_tasks = t; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  // Returns false if the next task in the sequence is unclaimed,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  // and ensures that it is claimed. Will set t to be the index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  // of the claimed task in the sequence. Will return true if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  // the task cannot be claimed and there are none left to claim.
11396
917d8673b5ef 7121618: Change type of number of GC workers to unsigned int.
jmasa
parents: 11174
diff changeset
   399
  bool is_task_claimed(uint& t);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  // The calling thread asserts that it has attempted to claim
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  // all the tasks it possibly can in the sequence. Every thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
  // claiming tasks must promise call this. Returns true if this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  // is the last thread to complete so that the thread can perform
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  // cleanup if necessary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  bool all_tasks_completed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
};
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   408
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30585
diff changeset
   409
#endif // SHARE_VM_GC_SHARED_WORKGROUP_HPP