hotspot/src/share/vm/utilities/workgroup.hpp
author ysr
Thu, 05 Jun 2008 15:57:56 -0700
changeset 1374 4c24294029a9
parent 1 489c9b5090e2
child 2013 49e915da0905
permissions -rw-r--r--
6711316: Open source the Garbage-First garbage collector Summary: First mercurial integration of the code for the Garbage-First garbage collector. Reviewed-by: apetrusenko, iveresov, jmasa, sgoldman, tonyp, ysr
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
     2
 * Copyright 2002-2007 Sun Microsystems, Inc.  All Rights Reserved.
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
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
// Forward declarations of classes defined here
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
class WorkGang;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
class GangWorker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
class YieldingFlexibleGangWorker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
class YieldingFlexibleGangTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
class WorkData;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// An abstract task to be worked on by a gang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// You subclass this to supply your own work() method
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
class AbstractGangTask: public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
  // The abstract work method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
  // The argument tells you which member of the gang you are.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
  virtual void work(int i) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  // Debugging accessor for the name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  const char* name() const PRODUCT_RETURN_(return NULL;);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  int counter() { return _counter; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  void set_counter(int value) { _counter = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  int *address_of_counter() { return &_counter; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  // RTTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  NOT_PRODUCT(virtual bool is_YieldingFlexibleGang_task() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  })
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  NOT_PRODUCT(const char* _name;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  // ??? Should a task have a priority associated with it?
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  // ??? Or can the run method adjust priority as needed?
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  int _counter;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  // Constructor and desctructor: only construct subclasses.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  AbstractGangTask(const char* name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
    NOT_PRODUCT(_name = name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
    _counter = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  virtual ~AbstractGangTask() { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
// Class AbstractWorkGang:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
// An abstract class representing a gang of workers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
// You subclass this to supply an implementation of run_task().
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
class AbstractWorkGang: public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  // Here's the public interface to this class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  // Constructor and destructor.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
    75
  AbstractWorkGang(const char* name, bool are_GC_task_threads,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
    76
                   bool are_ConcurrentGC_threads);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  ~AbstractWorkGang();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  // Run a task, returns when the task is done (or terminated).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  virtual void run_task(AbstractGangTask* task) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  // Stop and terminate all workers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  virtual void stop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  // Debugging.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  const char* name() const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  // Initialize only instance data.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
    87
  const bool _are_GC_task_threads;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
    88
  const bool _are_ConcurrentGC_threads;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  // Printing support.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  const char* _name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  // The monitor which protects these data,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  // and notifies of changes in it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  Monitor*  _monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  // The count of the number of workers in the gang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  int _total_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  // Whether the workers should terminate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  bool _terminate;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  // The array of worker threads for this gang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  // This is only needed for cleaning up.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  GangWorker** _gang_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // The task for this gang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  AbstractGangTask* _task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // A sequence number for the current task.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  int _sequence_number;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  // The number of started workers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  int _started_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  // The number of finished workers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  int _finished_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  // Accessors for fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  Monitor* monitor() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    return _monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  int total_workers() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    return _total_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  bool terminate() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    return _terminate;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  GangWorker** gang_workers() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    return _gang_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  AbstractGangTask* task() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
    return _task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  int sequence_number() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    return _sequence_number;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  int started_workers() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
    return _started_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  int finished_workers() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    return _finished_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  }
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   135
  bool are_GC_task_threads() const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   136
    return _are_GC_task_threads;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   137
  }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   138
  bool are_ConcurrentGC_threads() const {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   139
    return _are_ConcurrentGC_threads;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  // Predicates.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  bool is_idle() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    return (task() == NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // Return the Ith gang worker.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  GangWorker* gang_worker(int i) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  void threads_do(ThreadClosure* tc) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  void print_worker_threads_on(outputStream *st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  void print_worker_threads() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
    print_worker_threads_on(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  friend class GangWorker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  friend class YieldingFlexibleGangWorker;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  // Note activation and deactivation of workers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  // These methods should only be called with the mutex held.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  void internal_worker_poll(WorkData* data) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  void internal_note_start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  void internal_note_finish();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
class WorkData: public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // This would be a struct, but I want accessor methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  bool              _terminate;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  AbstractGangTask* _task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  int               _sequence_number;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // Constructor and destructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  WorkData() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
    _terminate       = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
    _task            = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
    _sequence_number = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  ~WorkData() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  // Accessors and modifiers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  bool terminate()                       const { return _terminate;  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  void set_terminate(bool value)               { _terminate = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  AbstractGangTask* task()               const { return _task; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  void set_task(AbstractGangTask* value)       { _task = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  int sequence_number()                  const { return _sequence_number; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  void set_sequence_number(int value)          { _sequence_number = value; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  YieldingFlexibleGangTask* yf_task()    const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    return (YieldingFlexibleGangTask*)_task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
// Class WorkGang:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
class WorkGang: public AbstractWorkGang {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  // Constructor
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   198
  WorkGang(const char* name, int workers,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   199
           bool are_GC_task_threads, bool are_ConcurrentGC_threads);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  // Run a task, returns when the task is done (or terminated).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  virtual void run_task(AbstractGangTask* task);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
// Class GangWorker:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
//   Several instances of this class run in parallel as workers for a gang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
class GangWorker: public WorkerThread {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  // Constructors and destructor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  GangWorker(AbstractWorkGang* gang, uint id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  // The only real method: run a task for the gang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  virtual void run();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  // Predicate for Thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  virtual bool is_GC_task_thread() const;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   215
  virtual bool is_ConcurrentGC_thread() const;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  // Printing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  void print_on(outputStream* st) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  virtual void print() const { print_on(tty); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  AbstractWorkGang* _gang;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  virtual void initialize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  virtual void loop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  AbstractWorkGang* gang() const { return _gang; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
// A class that acts as a synchronisation barrier. Workers enter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
// the barrier and must wait until all other workers have entered
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
// before any of them may leave.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
class WorkGangBarrierSync : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  Monitor _monitor;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  int     _n_workers;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  int     _n_completed;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   238
  bool    _should_reset;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   240
  Monitor* monitor()        { return &_monitor; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   241
  int      n_workers()      { return _n_workers; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   242
  int      n_completed()    { return _n_completed; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   243
  bool     should_reset()   { return _should_reset; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   245
  void     zero_completed() { _n_completed = 0; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   246
  void     inc_completed()  { _n_completed++; }
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   247
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   248
  void     set_should_reset(bool v) { _should_reset = v; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  WorkGangBarrierSync();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  WorkGangBarrierSync(int n_workers, const char* name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  // Set the number of workers that will use the barrier.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // Must be called before any of the workers start running.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  void set_n_workers(int n_workers);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  // Enter the barrier. A worker that enters the barrier will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  // not be allowed to leave until all other threads have
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  // also entered the barrier.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  void enter();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
// A class to manage claiming of subtasks within a group of tasks.  The
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
// subtasks will be identified by integer indices, usually elements of an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
// enumeration type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
class SubTasksDone: public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  jint* _tasks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  int _n_tasks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  int _n_threads;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  jint _threads_completed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  jint _claimed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  // Set all tasks to unclaimed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  void clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  // Initializes "this" to a state in which there are "n" tasks to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  // processed, none of the which are originally claimed.  The number of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  // threads doing the tasks is initialized 1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  SubTasksDone(int n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  // True iff the object is in a valid state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  bool valid();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  // Set the number of parallel threads doing the tasks to "t".  Can only
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  // be called before tasks start or after they are complete.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  void set_par_threads(int t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  // Returns "false" if the task "t" is unclaimed, and ensures that task is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  // claimed.  The task "t" is required to be within the range of "this".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  bool is_task_claimed(int t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // The calling thread asserts that it has attempted to claim all the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  // tasks that it will try to claim.  Every thread in the parallel task
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  // must execute this.  (When the last thread does so, the task array is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  // cleared.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  void all_tasks_completed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  // Destructor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  ~SubTasksDone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
// As above, but for sequential tasks, i.e. instead of claiming
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
// sub-tasks from a set (possibly an enumeration), claim sub-tasks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
// in sequential order. This is ideal for claiming dynamically
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
// partitioned tasks (like striding in the parallel remembered
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
// set scanning). Note that unlike the above class this is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
// a stack object - is there any reason for it not to be?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
class SequentialSubTasksDone : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  jint _n_tasks;     // Total number of tasks available.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  jint _n_claimed;   // Number of tasks claimed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  jint _n_threads;   // Total number of parallel threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  jint _n_completed; // Number of completed threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  void clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  SequentialSubTasksDone() { clear(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  ~SequentialSubTasksDone() {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  // True iff the object is in a valid state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  bool valid();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  // number of tasks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  jint n_tasks() const { return _n_tasks; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  // Set the number of parallel threads doing the tasks to t.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  // Should be called before the task starts but it is safe
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  // to call this once a task is running provided that all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  // threads agree on the number of threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  void set_par_threads(int t) { _n_threads = t; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  // Set the number of tasks to be claimed to t. As above,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  // should be called before the tasks start but it is safe
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  // to call this once a task is running provided all threads
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // agree on the number of tasks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  void set_n_tasks(int t) { _n_tasks = t; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  // Returns false if the next task in the sequence is unclaimed,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  // and ensures that it is claimed. Will set t to be the index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  // of the claimed task in the sequence. Will return true if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // the task cannot be claimed and there are none left to claim.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  bool is_task_claimed(int& t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  // The calling thread asserts that it has attempted to claim
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  // all the tasks it possibly can in the sequence. Every thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  // claiming tasks must promise call this. Returns true if this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  // is the last thread to complete so that the thread can perform
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  // cleanup if necessary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  bool all_tasks_completed();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
};
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   358
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   359
// Represents a set of free small integer ids.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   360
class FreeIdSet {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   361
  enum {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   362
    end_of_list = -1,
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   363
    claimed = -2
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   364
  };
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   365
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   366
  int _sz;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   367
  Monitor* _mon;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   368
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   369
  int* _ids;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   370
  int _hd;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   371
  int _waiters;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   372
  int _claimed;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   373
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   374
  static bool _safepoint;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   375
  typedef FreeIdSet* FreeIdSetPtr;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   376
  static const int NSets = 10;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   377
  static FreeIdSetPtr _sets[NSets];
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   378
  static bool _stat_init;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   379
  int _index;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   380
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   381
public:
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   382
  FreeIdSet(int sz, Monitor* mon);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   383
  ~FreeIdSet();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   384
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   385
  static void set_safepoint(bool b);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   386
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   387
  // Attempt to claim the given id permanently.  Returns "true" iff
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   388
  // successful.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   389
  bool claim_perm_id(int i);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   390
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   391
  // Returns an unclaimed parallel id (waiting for one to be released if
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   392
  // necessary).  Returns "-1" if a GC wakes up a wait for an id.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   393
  int claim_par_id();
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   394
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   395
  void release_par_id(int id);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   396
};