src/hotspot/share/gc/shared/collectorPolicy.hpp
author stefank
Thu, 22 Feb 2018 18:34:18 +0100
changeset 49043 092dc3d38bdc
parent 49021 975f5e109be2
child 49044 b01b69c220be
permissions -rw-r--r--
8198373: Remove CollectorPolicy::is/as functions Reviewed-by: sjohanss, pliden
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
49021
975f5e109be2 8198265: Make CollectorPolicy::satisfy_failed_metadata_allocation() virtual
pliden
parents: 47216
diff changeset
     2
 * Copyright (c) 2001, 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: 5343
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5343
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: 5343
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: 29794
diff changeset
    25
#ifndef SHARE_VM_GC_SHARED_COLLECTORPOLICY_HPP
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29794
diff changeset
    26
#define SHARE_VM_GC_SHARED_COLLECTORPOLICY_HPP
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29794
diff changeset
    28
#include "gc/shared/barrierSet.hpp"
33212
906b3d079b13 8139434: Unify GenRemSet and CardTableRS
david
parents: 32603
diff changeset
    29
#include "gc/shared/cardTableRS.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29794
diff changeset
    30
#include "gc/shared/generationSpec.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    31
#include "memory/allocation.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 13728
diff changeset
    32
#include "utilities/macros.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// This class (or more correctly, subtypes of this class)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// are used to define global garbage collector attributes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// This includes initialization of generations and any other
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// shared resources they may need.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// In general, all flag adjustment and validation should be
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// done in initialize_flags(), which is called prior to
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// initialize_size_info().
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// This class is not fully developed yet. As more collector(s)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// are added, it is expected that we will come across further
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
// behavior that requires global attention. The correct place
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
// to deal with those issues is this class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
// Forward declarations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
class GenCollectorPolicy;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 186
diff changeset
    50
class AdaptiveSizePolicy;
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 13728
diff changeset
    51
#if INCLUDE_ALL_GCS
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
class ConcurrentMarkSweepPolicy;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 186
diff changeset
    53
class G1CollectorPolicy;
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 13728
diff changeset
    54
#endif // INCLUDE_ALL_GCS
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 186
diff changeset
    55
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
class GCPolicyCounters;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
class MarkSweepPolicy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 9997
diff changeset
    59
class CollectorPolicy : public CHeapObj<mtGC> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
 protected:
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    61
  virtual void initialize_alignments() = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  virtual void initialize_flags();
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 186
diff changeset
    63
  virtual void initialize_size_info();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    65
  DEBUG_ONLY(virtual void assert_flags();)
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    66
  DEBUG_ONLY(virtual void assert_size_info();)
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    67
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  size_t _initial_heap_byte_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  size_t _max_heap_byte_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  size_t _min_heap_byte_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    72
  size_t _space_alignment;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    73
  size_t _heap_alignment;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    74
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    75
  // Set to true when policy wants soft refs cleared.
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    76
  // Reset to false by gc after it clears all soft refs.
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    77
  bool _should_clear_all_soft_refs;
21560
b3ae3ba25ebb 8026853: Prepare GC code for collector policy regression fix
jwilhelm
parents: 21558
diff changeset
    78
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    79
  // Set to true by the GC if the just-completed gc cleared all
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    80
  // softrefs.  This is set to true whenever a gc clears all softrefs, and
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    81
  // set to false each time gc returns to the mutator.  For example, in the
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    82
  // ParallelScavengeHeap case the latter would be done toward the end of
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    83
  // mem_allocate() where it returns op.result()
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    84
  bool _all_soft_refs_clear;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
    85
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    86
  CollectorPolicy();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
 public:
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    89
  virtual void initialize_all() {
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    90
    initialize_alignments();
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    91
    initialize_flags();
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    92
    initialize_size_info();
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    93
  }
19986
33d188c66ed9 8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents: 15497
diff changeset
    94
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 21567
diff changeset
    95
  // Return maximum heap alignment that may be imposed by the policy.
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    96
  static size_t compute_heap_alignment();
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    97
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    98
  size_t space_alignment()        { return _space_alignment; }
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
    99
  size_t heap_alignment()         { return _heap_alignment; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  size_t max_heap_byte_size()     { return _max_heap_byte_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  size_t min_heap_byte_size()     { return _min_heap_byte_size; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   105
  bool should_clear_all_soft_refs() { return _should_clear_all_soft_refs; }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   106
  void set_should_clear_all_soft_refs(bool v) { _should_clear_all_soft_refs = v; }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   107
  // Returns the current value of _should_clear_all_soft_refs.
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   108
  // _should_clear_all_soft_refs is set to false as a side effect.
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   109
  bool use_should_clear_all_soft_refs(bool v);
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   110
  bool all_soft_refs_clear() { return _all_soft_refs_clear; }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   111
  void set_all_soft_refs_clear(bool v) { _all_soft_refs_clear = v; }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   112
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   113
  // Called by the GC after Soft Refs have been cleared to indicate
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   114
  // that the request in _should_clear_all_soft_refs has been fulfilled.
46657
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   115
  virtual void cleared_all_soft_refs();
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   116
33212
906b3d079b13 8139434: Unify GenRemSet and CardTableRS
david
parents: 32603
diff changeset
   117
  virtual CardTableRS* create_rem_set(MemRegion reserved);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
49021
975f5e109be2 8198265: Make CollectorPolicy::satisfy_failed_metadata_allocation() virtual
pliden
parents: 47216
diff changeset
   119
  virtual MetaWord* satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
975f5e109be2 8198265: Make CollectorPolicy::satisfy_failed_metadata_allocation() virtual
pliden
parents: 47216
diff changeset
   120
                                                       size_t size,
975f5e109be2 8198265: Make CollectorPolicy::satisfy_failed_metadata_allocation() virtual
pliden
parents: 47216
diff changeset
   121
                                                       Metaspace::MetadataType mdtype);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   124
class ClearedAllSoftRefs : public StackObj {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   125
  bool _clear_all_soft_refs;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   126
  CollectorPolicy* _collector_policy;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   127
 public:
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   128
  ClearedAllSoftRefs(bool clear_all_soft_refs,
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   129
                     CollectorPolicy* collector_policy) :
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   130
    _clear_all_soft_refs(clear_all_soft_refs),
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   131
    _collector_policy(collector_policy) {}
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   132
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   133
  ~ClearedAllSoftRefs() {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   134
    if (_clear_all_soft_refs) {
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   135
      _collector_policy->cleared_all_soft_refs();
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   136
    }
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   137
  }
46828
19b0b4ceb75d 8177544: Restructure G1 Full GC code
sjohanss
parents: 46657
diff changeset
   138
19b0b4ceb75d 8177544: Restructure G1 Full GC code
sjohanss
parents: 46657
diff changeset
   139
  bool should_clear() { return _clear_all_soft_refs; }
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   140
};
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 1388
diff changeset
   141
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
class GenCollectorPolicy : public CollectorPolicy {
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   143
  friend class TestGenCollectorPolicy;
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   144
  friend class VMStructs;
46657
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   145
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   146
protected:
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   147
  size_t _min_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   148
  size_t _initial_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   149
  size_t _max_young_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   150
  size_t _min_old_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   151
  size_t _initial_old_size;
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   152
  size_t _max_old_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   154
  // _gen_alignment and _space_alignment will have the same value most of the
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   155
  // time. When using large pages they can differ.
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   156
  size_t _gen_alignment;
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   157
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   158
  GenerationSpec* _young_gen_spec;
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   159
  GenerationSpec* _old_gen_spec;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
38010
51fe205359f8 8154467: Cleanup initialization of GCPolicyCounters
mgerdin
parents: 35927
diff changeset
   161
  GCPolicyCounters* _gc_policy_counters;
51fe205359f8 8154467: Cleanup initialization of GCPolicyCounters
mgerdin
parents: 35927
diff changeset
   162
46657
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   163
  // The sizing of the heap is controlled by a sizing policy.
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   164
  AdaptiveSizePolicy* _size_policy;
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   165
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 21567
diff changeset
   166
  // Return true if an allocation should be attempted in the older generation
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 21567
diff changeset
   167
  // if it fails in the younger generation.  Return false, otherwise.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  virtual bool should_try_older_generation_allocation(size_t word_size) const;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  void initialize_flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  void initialize_size_info();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   173
  DEBUG_ONLY(void assert_flags();)
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   174
  DEBUG_ONLY(void assert_size_info();)
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   175
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  // Try to allocate space by expanding the heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
22551
9bf46d16dcc6 8025856: Fix typos in the GC code
jwilhelm
parents: 21567
diff changeset
   179
  // Compute max heap alignment.
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   180
  size_t compute_max_alignment();
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   181
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 22776
diff changeset
   182
  // Scale the base_size by NewRatio according to
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 22776
diff changeset
   183
  //     result = base_size / (NewRatio + 1)
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 22776
diff changeset
   184
  // and align by min_alignment()
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 22776
diff changeset
   185
  size_t scale_by_NewRatio_aligned(size_t base_size);
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   186
23851
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 22776
diff changeset
   187
  // Bound the value by the given maximum minus the min_alignment.
60303358c862 8029186: regression-hotspot nightly failure: assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize) failed
sjohanss
parents: 22776
diff changeset
   188
  size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
 public:
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   191
  GenCollectorPolicy();
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   192
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   193
  // Accessors
24941
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   194
  size_t min_young_size()     { return _min_young_size; }
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   195
  size_t initial_young_size() { return _initial_young_size; }
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   196
  size_t max_young_size()     { return _max_young_size; }
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   197
  size_t gen_alignment()      { return _gen_alignment; }
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   198
  size_t min_old_size()       { return _min_old_size; }
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   199
  size_t initial_old_size()   { return _initial_old_size; }
4ebbe176a7b1 8042298: Remove the names gen0 and gen1 from the GC code
jwilhelm
parents: 24353
diff changeset
   200
  size_t max_old_size()       { return _max_old_size; }
186
32e6c95f8d9b 6557851: CMS: ergonomics defaults are not set with FLAG_SET_ERGO
jmasa
parents: 1
diff changeset
   201
29794
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   202
  GenerationSpec* young_gen_spec() const {
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   203
    assert(_young_gen_spec != NULL, "_young_gen_spec should have been initialized");
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   204
    return _young_gen_spec;
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   205
  }
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   206
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   207
  GenerationSpec* old_gen_spec() const {
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   208
    assert(_old_gen_spec != NULL, "_old_gen_spec should have been initialized");
2dcbd946f9a8 8075635: Remove GenerationSpec array
jwilhelm
parents: 27687
diff changeset
   209
    return _old_gen_spec;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
38010
51fe205359f8 8154467: Cleanup initialization of GCPolicyCounters
mgerdin
parents: 35927
diff changeset
   212
  // Performance Counter support
51fe205359f8 8154467: Cleanup initialization of GCPolicyCounters
mgerdin
parents: 35927
diff changeset
   213
  GCPolicyCounters* counters()     { return _gc_policy_counters; }
51fe205359f8 8154467: Cleanup initialization of GCPolicyCounters
mgerdin
parents: 35927
diff changeset
   214
51fe205359f8 8154467: Cleanup initialization of GCPolicyCounters
mgerdin
parents: 35927
diff changeset
   215
  // Create the jstat counters for the GC policy.
51fe205359f8 8154467: Cleanup initialization of GCPolicyCounters
mgerdin
parents: 35927
diff changeset
   216
  virtual void initialize_gc_policy_counters() = 0;
51fe205359f8 8154467: Cleanup initialization of GCPolicyCounters
mgerdin
parents: 35927
diff changeset
   217
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   218
  virtual void initialize_generations() { };
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  virtual void initialize_all() {
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   221
    CollectorPolicy::initialize_all();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    initialize_generations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   225
  size_t young_gen_size_lower_bound();
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   226
32362
a487889ff52d 8133553: Running with -XX:+UseParallelGC -XX:OldSize=30k crashes jvm
david
parents: 31358
diff changeset
   227
  size_t old_gen_size_lower_bound();
a487889ff52d 8133553: Running with -XX:+UseParallelGC -XX:OldSize=30k crashes jvm
david
parents: 31358
diff changeset
   228
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  HeapWord* mem_allocate_work(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
                              bool is_tlab,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
                              bool* gc_overhead_limit_was_exceeded);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  HeapWord *satisfy_failed_allocation(size_t size, bool is_tlab);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  // Adaptive size policy
46657
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   236
  AdaptiveSizePolicy* size_policy() { return _size_policy; }
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   237
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  virtual void initialize_size_policy(size_t init_eden_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
                                      size_t init_promo_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
                                      size_t init_survivor_size);
46657
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   241
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   242
  virtual void cleared_all_soft_refs();
cc4ac8d1ef6b 8179268: Factor out AdaptiveSizePolicy from top-level interfaces CollectorPolicy and CollectedHeap
rkennke
parents: 39961
diff changeset
   243
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
24353
148147d21135 8027643: Merge GenCollectorPolicy and TwoGenerationCollectorPolicy
jwilhelm
parents: 23851
diff changeset
   246
class MarkSweepPolicy : public GenCollectorPolicy {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
 protected:
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   248
  void initialize_alignments();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  void initialize_generations();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
 public:
21561
c619b1cb4554 8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents: 21560
diff changeset
   252
  MarkSweepPolicy() {}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  void initialize_gc_policy_counters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
   256
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 29794
diff changeset
   257
#endif // SHARE_VM_GC_SHARED_COLLECTORPOLICY_HPP