hotspot/src/share/vm/gc_implementation/parallelScavenge/pcTasks.hpp
author jmasa
Fri, 01 Aug 2014 15:40:12 -0700
changeset 25905 04a3d83cc752
parent 22551 9bf46d16dcc6
permissions -rw-r--r--
8031323: Optionally align objects copied to survivor spaces Reviewed-by: brutisso, tschatzl
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
22234
da823d78ad65 8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents: 17844
diff changeset
     2
 * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3908
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3908
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: 3908
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    25
#ifndef SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PCTASKS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    26
#define SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PCTASKS_HPP
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    27
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    28
#include "gc_implementation/parallelScavenge/gcTaskManager.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    29
#include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    30
#include "gc_implementation/parallelScavenge/psTasks.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    31
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// Tasks for parallel compaction of the old generation
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// Tasks are created and enqueued on a task queue. The
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// tasks for parallel old collector for marking objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// are MarkFromRootsTask and ThreadRootsMarkingTask.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// MarkFromRootsTask's are created
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// with a root group (e.g., jni_handles) and when the do_it()
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// method of a MarkFromRootsTask is executed, it starts marking
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// form it's root group.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// ThreadRootsMarkingTask's are created for each Java thread.  When
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// the do_it() method of a ThreadRootsMarkingTask is executed, it
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// starts marking from the thread's roots.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
//
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 22234
diff changeset
    48
// The enqueueing of the MarkFromRootsTask and ThreadRootsMarkingTask
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// do little more than create the task and put it on a queue.  The
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// queue is a GCTaskQueue and threads steal tasks from this GCTaskQueue.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
// In addition to the MarkFromRootsTask and ThreadRootsMarkingTask
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
// tasks there are StealMarkingTask tasks.  The StealMarkingTask's
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
// steal a reference from the marking stack of another
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
// thread and transitively marks the object of the reference
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
// and internal references.  After successfully stealing a reference
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
// and marking it, the StealMarkingTask drains its marking stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
// stack before attempting another steal.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// ThreadRootsMarkingTask
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
// This task marks from the roots of a single thread. This task
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
// enables marking of thread roots in parallel.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
class ParallelTaskTerminator;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
class ThreadRootsMarkingTask : public GCTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  JavaThread* _java_thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  VMThread* _vm_thread;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  ThreadRootsMarkingTask(JavaThread* root) : _java_thread(root), _vm_thread(NULL) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  ThreadRootsMarkingTask(VMThread* root) : _java_thread(NULL), _vm_thread(root) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  char* name() { return (char *)"thread-roots-marking-task"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  virtual void do_it(GCTaskManager* manager, uint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
// MarkFromRootsTask
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
// This task marks from all the roots to all live
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
// objects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
class MarkFromRootsTask : public GCTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  enum RootType {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    universe              = 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
    jni_handles           = 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
    threads               = 3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    object_synchronizer   = 4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    flat_profiler         = 5,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    management            = 6,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
    jvmti                 = 7,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    system_dictionary     = 8,
17844
28ca9179db98 8015268: NPG: 2.5% regression in young GC times on CRM Sales Opty
stefank
parents: 10524
diff changeset
   101
    class_loader_data     = 9,
28ca9179db98 8015268: NPG: 2.5% regression in young GC times on CRM Sales Opty
stefank
parents: 10524
diff changeset
   102
    code_cache            = 10
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  RootType _root_type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  MarkFromRootsTask(RootType value) : _root_type(value) {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  char* name() { return (char *)"mark-from-roots-task"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  virtual void do_it(GCTaskManager* manager, uint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
// RefProcTaskProxy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
// This task is used as a proxy to parallel reference processing tasks .
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
class RefProcTaskProxy : public GCTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  ProcessTask & _rp_task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  uint          _work_id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  RefProcTaskProxy(ProcessTask & rp_task, uint work_id)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
    : _rp_task(rp_task),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
      _work_id(work_id)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  virtual char* name() { return (char *)"Process referents by policy in parallel"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  virtual void do_it(GCTaskManager* manager, uint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
// RefEnqueueTaskProxy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
// This task is used as a proxy to parallel reference processing tasks .
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
class RefEnqueueTaskProxy: public GCTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  EnqueueTask& _enq_task;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  uint         _work_id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  RefEnqueueTaskProxy(EnqueueTask& enq_task, uint work_id)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    : _enq_task(enq_task),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
      _work_id(work_id)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  virtual char* name() { return (char *)"Enqueue reference objects in parallel"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  virtual void do_it(GCTaskManager* manager, uint which)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    _enq_task.work(_work_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
// RefProcTaskExecutor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
// Task executor is an interface for the reference processor to run
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
// tasks using GCTaskManager.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
class RefProcTaskExecutor: public AbstractRefProcTaskExecutor {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  virtual void execute(ProcessTask& task);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  virtual void execute(EnqueueTask& task);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
// StealMarkingTask
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
// This task is used to distribute work to idle threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
class StealMarkingTask : public GCTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
   ParallelTaskTerminator* const _terminator;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  char* name() { return (char *)"steal-marking-task"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  StealMarkingTask(ParallelTaskTerminator* t);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  ParallelTaskTerminator* terminator() { return _terminator; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  virtual void do_it(GCTaskManager* manager, uint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
//
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   198
// StealRegionCompactionTask
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
// This task is used to distribute work to idle threads.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   203
class StealRegionCompactionTask : public GCTask {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
   ParallelTaskTerminator* const _terminator;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
 public:
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   207
  StealRegionCompactionTask(ParallelTaskTerminator* t);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   209
  char* name() { return (char *)"steal-region-task"; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  ParallelTaskTerminator* terminator() { return _terminator; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  virtual void do_it(GCTaskManager* manager, uint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
// UpdateDensePrefixTask
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
// This task is used to update the dense prefix
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
// of a space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
class UpdateDensePrefixTask : public GCTask {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
 private:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  PSParallelCompact::SpaceId _space_id;
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   225
  size_t _region_index_start;
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   226
  size_t _region_index_end;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  char* name() { return (char *)"update-dense_prefix-task"; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  UpdateDensePrefixTask(PSParallelCompact::SpaceId space_id,
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   232
                        size_t region_index_start,
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   233
                        size_t region_index_end);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  virtual void do_it(GCTaskManager* manager, uint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
// DrainStacksCompactionTask
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
//
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   241
// This task processes regions that have been added to the stacks of each
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
// compaction manager.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
// Trying to use one draining thread does not work because there are no
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
// guarantees about which task will be picked up by which thread.  For example,
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   246
// if thread A gets all the preloaded regions, thread A may not get a draining
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
// task (they may all be done by other threads).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
class DrainStacksCompactionTask : public GCTask {
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   251
 uint _stack_index;
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   252
 uint stack_index() { return _stack_index; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
 public:
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   254
  DrainStacksCompactionTask(uint stack_index) : GCTask(),
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   255
                                                _stack_index(stack_index) {};
1407
9006b01ba3fd 6725697: par compact - rename class ChunkData to RegionData
jcoomes
parents: 1
diff changeset
   256
  char* name() { return (char *)"drain-region-task"; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  virtual void do_it(GCTaskManager* manager, uint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
   259
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
   260
#endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PCTASKS_HPP