hotspot/src/share/vm/memory/collectorPolicy.hpp
author duke
Sat, 01 Dec 2007 00:00:00 +0000
changeset 1 489c9b5090e2
child 186 32e6c95f8d9b
permissions -rw-r--r--
Initial load
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 2001-2006 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
// This class (or more correctly, subtypes of this class)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
// are used to define global garbage collector attributes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
// This includes initialization of generations and any other
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// shared resources they may need.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
// In general, all flag adjustment and validation should be
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// done in initialize_flags(), which is called prior to
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
// initialize_size_info().
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// This class is not fully developed yet. As more collector(s)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// are added, it is expected that we will come across further
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// behavior that requires global attention. The correct place
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// to deal with those issues is this class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// Forward declarations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
class GenCollectorPolicy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
class TwoGenerationCollectorPolicy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
#ifndef SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
class ConcurrentMarkSweepPolicy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
#endif // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
class AdaptiveSizePolicy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
class GCPolicyCounters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
class PermanentGenerationSpec;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
class MarkSweepPolicy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
class CollectorPolicy : public CHeapObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  PermanentGenerationSpec *_permanent_generation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  GCPolicyCounters* _gc_policy_counters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  // Requires that the concrete subclass sets the alignment constraints
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  // before calling.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  virtual void initialize_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  virtual void initialize_size_info() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  // Initialize "_permanent_generation" to a spec for the given kind of
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  // Perm Gen.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  void initialize_perm_generation(PermGen::Name pgnm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  size_t _initial_heap_byte_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  size_t _max_heap_byte_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  size_t _min_heap_byte_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  size_t _min_alignment;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  size_t _max_alignment;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  CollectorPolicy() :
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    _min_alignment(1),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
    _max_alignment(1),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    _initial_heap_byte_size(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    _max_heap_byte_size(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    _min_heap_byte_size(0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  {}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  void set_min_alignment(size_t align)         { _min_alignment = align; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  size_t min_alignment()                       { return _min_alignment; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  void set_max_alignment(size_t align)         { _max_alignment = align; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  size_t max_alignment()                       { return _max_alignment; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  size_t max_heap_byte_size()     { return _max_heap_byte_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  size_t min_heap_byte_size()     { return _min_heap_byte_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  enum Name {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
    CollectorPolicyKind,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
    TwoGenerationCollectorPolicyKind,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
    TrainPolicyKind,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
    ConcurrentMarkSweepPolicyKind,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    ASConcurrentMarkSweepPolicyKind
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  // Identification methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  virtual GenCollectorPolicy*           as_generation_policy()          { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  virtual TwoGenerationCollectorPolicy* as_two_generation_policy()        { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  virtual MarkSweepPolicy*              as_mark_sweep_policy()            { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
#ifndef SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  virtual ConcurrentMarkSweepPolicy*    as_concurrent_mark_sweep_policy() { return NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
#endif // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  // Note that these are not virtual.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  bool is_generation_policy()            { return as_generation_policy() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  bool is_two_generation_policy()        { return as_two_generation_policy() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  bool is_mark_sweep_policy()            { return as_mark_sweep_policy() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
#ifndef SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
  bool is_concurrent_mark_sweep_policy() { return as_concurrent_mark_sweep_policy() != NULL; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
#else  // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  bool is_concurrent_mark_sweep_policy() { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
#endif // SERIALGC
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  virtual PermanentGenerationSpec *permanent_generation() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    assert(_permanent_generation != NULL, "Sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    return _permanent_generation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  virtual BarrierSet::Name barrier_set_name() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  virtual GenRemSet::Name  rem_set_name() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  // Create the remembered set (to cover the given reserved region,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // allowing breaking up into at most "max_covered_regions").
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  virtual GenRemSet* create_rem_set(MemRegion reserved,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
                                    int max_covered_regions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  // This method controls how a collector satisfies a request
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  // for a block of memory.  "gc_time_limit_was_exceeded" will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  // be set to true if the adaptive size policy determine that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  // an excessive amount of time is being spent doing collections
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  // and caused a NULL to be returned.  If a NULL is not returned,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  // "gc_time_limit_was_exceeded" has an undefined meaning.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  virtual HeapWord* mem_allocate_work(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
                                      bool is_tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
                                      bool* gc_overhead_limit_was_exceeded) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  // This method controls how a collector handles one or more
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  // of its generations being fully allocated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  virtual HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  // Performace Counter support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  GCPolicyCounters* counters()     { return _gc_policy_counters; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  // Create the jstat counters for the GC policy.  By default, policy's
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  // don't have associated counters, and we complain if this is invoked.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  virtual void initialize_gc_policy_counters() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  virtual CollectorPolicy::Name kind() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
    return CollectorPolicy::CollectorPolicyKind;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // Returns true if a collector has eden space with soft end.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  virtual bool has_soft_ended_eden() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
class GenCollectorPolicy : public CollectorPolicy {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  size_t _min_gen0_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  size_t _initial_gen0_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  size_t _max_gen0_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  GenerationSpec **_generations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  // The sizing of the different generations in the heap are controlled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  // by a sizing policy.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  AdaptiveSizePolicy* _size_policy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  // Return true if an allocation should be attempted in the older
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // generation if it fails in the younger generation.  Return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  // false, otherwise.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  virtual bool should_try_older_generation_allocation(size_t word_size) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  void initialize_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  void initialize_size_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  // Try to allocate space by expanding the heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  // compute max heap alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  size_t compute_max_alignment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  virtual int number_of_generations() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  virtual GenerationSpec **generations()       {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    assert(_generations != NULL, "Sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    return _generations;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  virtual GenCollectorPolicy* as_generation_policy() { return this; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  virtual void initialize_generations() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  virtual void initialize_all() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
    initialize_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
    initialize_size_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    initialize_generations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  HeapWord* mem_allocate_work(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
                              bool is_tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
                              bool* gc_overhead_limit_was_exceeded);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  // The size that defines a "large array".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  virtual size_t large_typearray_limit();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  // Adaptive size policy
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  AdaptiveSizePolicy* size_policy() { return _size_policy; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  virtual void initialize_size_policy(size_t init_eden_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
                                      size_t init_promo_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
                                      size_t init_survivor_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
// All of hotspot's current collectors are subtypes of this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
// class. Currently, these collectors all use the same gen[0],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
// but have different gen[1] types. If we add another subtype
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
// of CollectorPolicy, this class should be broken out into
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
// its own file.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
class TwoGenerationCollectorPolicy : public GenCollectorPolicy {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  size_t _min_gen1_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  size_t _initial_gen1_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  size_t _max_gen1_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  void initialize_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  void initialize_size_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  void initialize_generations()                { ShouldNotReachHere(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // Inherited methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  int number_of_generations()                  { return 2; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  BarrierSet::Name barrier_set_name()          { return BarrierSet::CardTableModRef; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  GenRemSet::Name rem_set_name()               { return GenRemSet::CardTable; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  virtual CollectorPolicy::Name kind() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    return CollectorPolicy::TwoGenerationCollectorPolicyKind;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
class MarkSweepPolicy : public TwoGenerationCollectorPolicy {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  void initialize_generations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  MarkSweepPolicy();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  MarkSweepPolicy* as_mark_sweep_policy() { return this; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  void initialize_gc_policy_counters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
};