src/hotspot/share/gc/shared/collectedHeap.hpp
author chegar
Thu, 17 Oct 2019 20:54:25 +0100
branchdatagramsocketimpl-branch
changeset 58679 9c3209ff7550
parent 58678 9cf78a70fa4f
parent 58229 722a19a45994
permissions -rw-r--r--
datagramsocketimpl-branch: merge with default
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
53244
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 52925
diff changeset
     2
 * Copyright (c) 2001, 2019, 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
53244
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 52925
diff changeset
    25
#ifndef SHARE_GC_SHARED_COLLECTEDHEAP_HPP
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 52925
diff changeset
    26
#define SHARE_GC_SHARED_COLLECTEDHEAP_HPP
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    27
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30581
diff changeset
    28
#include "gc/shared/gcCause.hpp"
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30581
diff changeset
    29
#include "gc/shared/gcWhen.hpp"
54781
f3f07c76d3d1 8223619: Move VerifyOption out of Universe
stefank
parents: 54678
diff changeset
    30
#include "gc/shared/verifyOption.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    31
#include "memory/allocation.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    32
#include "runtime/handles.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    33
#include "runtime/perfData.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    34
#include "runtime/safepoint.hpp"
51625
c265860d5d45 8207200: Committed > max memory usage when getting MemoryUsage
tschatzl
parents: 50882
diff changeset
    35
#include "services/memoryUsage.hpp"
46560
388aa8d67c80 8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents: 46384
diff changeset
    36
#include "utilities/debug.hpp"
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    37
#include "utilities/events.hpp"
46560
388aa8d67c80 8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents: 46384
diff changeset
    38
#include "utilities/formatBuffer.hpp"
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
    39
#include "utilities/growableArray.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    40
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// A "CollectedHeap" is an implementation of a java heap for HotSpot.  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// is an abstract class: there may be many different kinds of heaps.  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// class defines the functions that a heap must implement, and contains
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// infrastructure common to all heaps.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    46
class AdaptiveSizePolicy;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
class BarrierSet;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    48
class GCHeapSummary;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    49
class GCTimer;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    50
class GCTracer;
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
    51
class GCMemoryManager;
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
    52
class MemoryPool;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    53
class MetaspaceSummary;
58015
dd84de796f2c 8224815: Remove non-GC uses of CollectedHeap::is_in_reserved()
eosterlund
parents: 57903
diff changeset
    54
class ReservedHeapSpace;
49047
8f004146e407 8198515: Extract SoftReferencePolicy code out of CollectorPolicy
stefank
parents: 49045
diff changeset
    55
class SoftRefPolicy;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    56
class Thread;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
class ThreadClosure;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    58
class VirtualSpaceSummary;
46702
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
    59
class WorkGang;
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
    60
class nmethod;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    62
class GCMessage : public FormatBuffer<1024> {
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    63
 public:
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    64
  bool is_before;
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    65
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    66
 public:
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    67
  GCMessage() {}
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    68
};
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    69
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    70
class CollectedHeap;
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    71
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    72
class GCHeapLog : public EventLogBase<GCMessage> {
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    73
 private:
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    74
  void log_heap(CollectedHeap* heap, bool before);
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    75
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    76
 public:
55217
bb3359bcf534 8224600: Provide VM.events command
stuefe
parents: 54807
diff changeset
    77
  GCHeapLog() : EventLogBase<GCMessage>("GC Heap History", "gc") {}
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    78
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    79
  void log_heap_before(CollectedHeap* heap) {
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    80
    log_heap(heap, true);
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    81
  }
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    82
  void log_heap_after(CollectedHeap* heap) {
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    83
    log_heap(heap, false);
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    84
  }
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    85
};
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    86
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
// CollectedHeap
30154
39cd4e2ccf1c 8076452: Remove SharedHeap
brutisso
parents: 30152
diff changeset
    89
//   GenCollectedHeap
47819
ee36a8e36561 8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents: 47636
diff changeset
    90
//     SerialHeap
ee36a8e36561 8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents: 47636
diff changeset
    91
//     CMSHeap
30154
39cd4e2ccf1c 8076452: Remove SharedHeap
brutisso
parents: 30152
diff changeset
    92
//   G1CollectedHeap
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
//   ParallelScavengeHeap
52925
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 52462
diff changeset
    94
//   ShenandoahHeap
50525
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 50523
diff changeset
    95
//   ZCollectedHeap
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
//
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12379
diff changeset
    97
class CollectedHeap : public CHeapObj<mtInternal> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  friend class VMStructs;
35123
b0b89d83bcf5 8134994: use separate VMStructs databases for SA and JVMCI
twisti
parents: 33160
diff changeset
    99
  friend class JVMCIVMStructs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  friend class IsGCActiveMark; // Block structured external access to _is_gc_active
50882
80abf702eed8 8205683: Refactor heap allocation to separate concerns
eosterlund
parents: 50578
diff changeset
   101
  friend class MemAllocator;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
26829
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25905
diff changeset
   103
 private:
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
   104
  GCHeapLog* _gc_heap_log;
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
   105
58015
dd84de796f2c 8224815: Remove non-GC uses of CollectedHeap::is_in_reserved()
eosterlund
parents: 57903
diff changeset
   106
 protected:
dd84de796f2c 8224815: Remove non-GC uses of CollectedHeap::is_in_reserved()
eosterlund
parents: 57903
diff changeset
   107
  // Not used by all GCs
26829
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25905
diff changeset
   108
  MemRegion _reserved;
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25905
diff changeset
   109
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  bool _is_gc_active;
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   111
31346
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 30871
diff changeset
   112
  // Used for filler objects (static, but initialized in ctor).
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 30871
diff changeset
   113
  static size_t _filler_array_max_size;
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 30871
diff changeset
   114
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  unsigned int _total_collections;          // ... started
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  unsigned int _total_full_collections;     // ... started
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  NOT_PRODUCT(volatile size_t _promotion_failure_alot_count;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  NOT_PRODUCT(volatile size_t _promotion_failure_alot_gc_number;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  // Reason for current garbage collection.  Should be set to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  // a value reflecting no collection between collections.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  GCCause::Cause _gc_cause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  GCCause::Cause _gc_lastcause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  PerfStringVariable* _perf_gc_cause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  PerfStringVariable* _perf_gc_lastcause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  CollectedHeap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
9997
b75b7939f448 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents: 9995
diff changeset
   130
  // Create a new tlab. All TLAB allocations must go through this.
49945
9425445633cf 8191471: Elastic TLABs for G1
sjohanss
parents: 49851
diff changeset
   131
  // To allow more flexible TLAB allocations min_size specifies
9425445633cf 8191471: Elastic TLABs for G1
sjohanss
parents: 49851
diff changeset
   132
  // the minimum size needed, while requested_size is the requested
9425445633cf 8191471: Elastic TLABs for G1
sjohanss
parents: 49851
diff changeset
   133
  // size based on ergonomics. The actually allocated size will be
9425445633cf 8191471: Elastic TLABs for G1
sjohanss
parents: 49851
diff changeset
   134
  // returned in actual_size.
9425445633cf 8191471: Elastic TLABs for G1
sjohanss
parents: 49851
diff changeset
   135
  virtual HeapWord* allocate_new_tlab(size_t min_size,
9425445633cf 8191471: Elastic TLABs for G1
sjohanss
parents: 49851
diff changeset
   136
                                      size_t requested_size,
9425445633cf 8191471: Elastic TLABs for G1
sjohanss
parents: 49851
diff changeset
   137
                                      size_t* actual_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  // Reinitialize tlabs before resuming mutators.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  virtual void resize_all_tlabs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
50414
7efd1291e962 8202776: Modularize GC allocations in runtime
rkennke
parents: 50057
diff changeset
   142
  // Raw memory allocation facilities
7efd1291e962 8202776: Modularize GC allocations in runtime
rkennke
parents: 50057
diff changeset
   143
  // The obj and array allocate methods are covers for these methods.
7efd1291e962 8202776: Modularize GC allocations in runtime
rkennke
parents: 50057
diff changeset
   144
  // mem_allocate() should never be
7efd1291e962 8202776: Modularize GC allocations in runtime
rkennke
parents: 50057
diff changeset
   145
  // called to allocate TLABs, only individual objects.
7efd1291e962 8202776: Modularize GC allocations in runtime
rkennke
parents: 50057
diff changeset
   146
  virtual HeapWord* mem_allocate(size_t size,
7efd1291e962 8202776: Modularize GC allocations in runtime
rkennke
parents: 50057
diff changeset
   147
                                 bool* gc_overhead_limit_was_exceeded) = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   149
  // Filler object utilities.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   150
  static inline size_t filler_array_hdr_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   151
  static inline size_t filler_array_min_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   152
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   153
  DEBUG_ONLY(static void fill_args_check(HeapWord* start, size_t words);)
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   154
  DEBUG_ONLY(static void zap_filler_array(HeapWord* start, size_t words, bool zap = true);)
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   155
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   156
  // Fill with a single array; caller must ensure filler_array_min_size() <=
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   157
  // words <= filler_array_max_size().
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   158
  static inline void fill_with_array(HeapWord* start, size_t words, bool zap = true);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   159
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   160
  // Fill with a single object (either an int array or a java.lang.Object).
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   161
  static inline void fill_with_object_impl(HeapWord* start, size_t words, bool zap = true);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   162
28940
c314cf1db3fa 8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents: 27623
diff changeset
   163
  virtual void trace_heap(GCWhen::Type when, const GCTracer* tracer);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   164
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  // Verification functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  virtual void check_for_non_bad_heap_word_value(HeapWord* addr, size_t size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    PRODUCT_RETURN;
2006
f2d2f0f20063 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents: 1893
diff changeset
   168
  debug_only(static void check_for_valid_allocation_state();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  enum Name {
49629
b786280276dc 8199925: Break out GC selection logic from GCArguments to GCConfig
pliden
parents: 49628
diff changeset
   172
    None,
49628
88478047bc8f 8199918: Shorten names of CollectedHeap::Name members
pliden
parents: 49593
diff changeset
   173
    Serial,
88478047bc8f 8199918: Shorten names of CollectedHeap::Name members
pliden
parents: 49593
diff changeset
   174
    Parallel,
88478047bc8f 8199918: Shorten names of CollectedHeap::Name members
pliden
parents: 49593
diff changeset
   175
    CMS,
50523
7b7c75d87f9b 8204180: Implementation: JEP 318: Epsilon, A No-Op Garbage Collector
shade
parents: 50448
diff changeset
   176
    G1,
50525
767cdb97f103 8204210: Implementation: JEP 333: ZGC: A Scalable Low-Latency Garbage Collector (Experimental)
pliden
parents: 50523
diff changeset
   177
    Epsilon,
52925
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 52462
diff changeset
   178
    Z,
9c18c9d839d3 8214259: Implementation: JEP 189: Shenandoah: A Low-Pause-Time Garbage Collector (Experimental)
rkennke
parents: 52462
diff changeset
   179
    Shenandoah
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
12229
c34a85c8f5aa 7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents: 11636
diff changeset
   182
  static inline size_t filler_array_max_size() {
c34a85c8f5aa 7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents: 11636
diff changeset
   183
    return _filler_array_max_size;
c34a85c8f5aa 7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents: 11636
diff changeset
   184
  }
c34a85c8f5aa 7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents: 11636
diff changeset
   185
29808
9bbc65318fdd 8076294: Cleanup of CollectedHeap::kind()
pliden
parents: 29803
diff changeset
   186
  virtual Name kind() const = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   188
  virtual const char* name() const = 0;
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   189
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  /**
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
   * Returns JNI error code JNI_ENOMEM if memory could not be allocated,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
   * and JNI_OK on success.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
   */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  virtual jint initialize() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  // In many heaps, there will be a need to perform some initialization activities
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  // after the Universe is fully formed, but before general heap allocation is allowed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  // This is the correct place to place such initialization methods.
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   199
  virtual void post_initialize();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
24093
095cc0a63ed9 8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents: 22552
diff changeset
   201
  // Stop any onging concurrent work and prepare for exit.
095cc0a63ed9 8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents: 22552
diff changeset
   202
  virtual void stop() {}
095cc0a63ed9 8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents: 22552
diff changeset
   203
47636
52d46d7e3454 8188919: Generalize GC thread suspend/resume at safepoints
eosterlund
parents: 47624
diff changeset
   204
  // Stop and resume concurrent GC threads interfering with safepoint operations
52d46d7e3454 8188919: Generalize GC thread suspend/resume at safepoints
eosterlund
parents: 47624
diff changeset
   205
  virtual void safepoint_synchronize_begin() {}
52d46d7e3454 8188919: Generalize GC thread suspend/resume at safepoints
eosterlund
parents: 47624
diff changeset
   206
  virtual void safepoint_synchronize_end() {}
52d46d7e3454 8188919: Generalize GC thread suspend/resume at safepoints
eosterlund
parents: 47624
diff changeset
   207
58015
dd84de796f2c 8224815: Remove non-GC uses of CollectedHeap::is_in_reserved()
eosterlund
parents: 57903
diff changeset
   208
  void initialize_reserved_region(const ReservedHeapSpace& rs);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  virtual size_t capacity() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  virtual size_t used() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
54616
3ab77d8dc60a 8222462: Introduce CollectedHeap::unused()
pliden
parents: 54376
diff changeset
   213
  // Returns unused capacity.
3ab77d8dc60a 8222462: Introduce CollectedHeap::unused()
pliden
parents: 54376
diff changeset
   214
  virtual size_t unused() const;
3ab77d8dc60a 8222462: Introduce CollectedHeap::unused()
pliden
parents: 54376
diff changeset
   215
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  // Return "true" if the part of the heap that allocates Java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  // objects has reached the maximal committed limit that it can
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  // reach, without a garbage collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  virtual bool is_maximal_no_gc() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  // Support for java.lang.Runtime.maxMemory():  return the maximum amount of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  // memory that the vm could make available for storing 'normal' java objects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  // This is based on the reserved address space, but should not include space
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   224
  // that the vm uses internally for bookkeeping or temporary storage
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   225
  // (e.g., in the case of the young gen, one of the survivor
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  // spaces).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  virtual size_t max_capacity() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
11247
d6faa02b3802 7121373: Clean up CollectedHeap::is_in
stefank
parents: 10997
diff changeset
   229
  // Returns "TRUE" iff "p" points into the committed areas of the heap.
30177
925cd0b4f0e7 8077403: Remove guarantee from GenCollectedHeap::is_in()
brutisso
parents: 30171
diff changeset
   230
  // This method can be expensive so avoid using it in performance critical
925cd0b4f0e7 8077403: Remove guarantee from GenCollectedHeap::is_in()
brutisso
parents: 30171
diff changeset
   231
  // code.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
  virtual bool is_in(const void* p) const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
30177
925cd0b4f0e7 8077403: Remove guarantee from GenCollectedHeap::is_in()
brutisso
parents: 30171
diff changeset
   234
  DEBUG_ONLY(bool is_in_or_null(const void* p) const { return p == NULL || is_in(p); })
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   235
54376
2a2fab6fb3a5 8221732: Introduce CollectedHeap::hash_oop()
pliden
parents: 54375
diff changeset
   236
  virtual uint32_t hash_oop(oop obj) const;
2a2fab6fb3a5 8221732: Introduce CollectedHeap::hash_oop()
pliden
parents: 54375
diff changeset
   237
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  void set_gc_cause(GCCause::Cause v) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
     if (UsePerfData) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
       _gc_lastcause = _gc_cause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
       _perf_gc_lastcause->set_value(GCCause::to_string(_gc_lastcause));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
       _perf_gc_cause->set_value(GCCause::to_string(v));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    _gc_cause = v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  GCCause::Cause gc_cause() { return _gc_cause; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
57852
92f994585e25 8229127: Make some methods in the allocation path non-virtual
pliden
parents: 55425
diff changeset
   248
  oop obj_allocate(Klass* klass, int size, TRAPS);
50882
80abf702eed8 8205683: Refactor heap allocation to separate concerns
eosterlund
parents: 50578
diff changeset
   249
  virtual oop array_allocate(Klass* klass, int size, int length, bool do_zero, TRAPS);
57852
92f994585e25 8229127: Make some methods in the allocation path non-virtual
pliden
parents: 55425
diff changeset
   250
  oop class_allocate(Klass* klass, int size, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   252
  // Utilities for turning raw memory into filler objects.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   253
  //
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   254
  // min_fill_size() is the smallest region that can be filled.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   255
  // fill_with_objects() can fill arbitrary-sized regions of the heap using
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   256
  // multiple objects.  fill_with_object() is for regions known to be smaller
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   257
  // than the largest array of integers; it uses a single object to fill the
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   258
  // region and has slightly less overhead.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   259
  static size_t min_fill_size() {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   260
    return size_t(align_object_size(oopDesc::header_size()));
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   261
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   262
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   263
  static void fill_with_objects(HeapWord* start, size_t words, bool zap = true);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   264
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   265
  static void fill_with_object(HeapWord* start, size_t words, bool zap = true);
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   266
  static void fill_with_object(MemRegion region, bool zap = true) {
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   267
    fill_with_object(region.start(), region.word_size(), zap);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   268
  }
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   269
  static void fill_with_object(HeapWord* start, HeapWord* end, bool zap = true) {
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   270
    fill_with_object(start, pointer_delta(end, start), zap);
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   271
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   272
50537
d12828b7cd64 8204685: Abstraction for TLAB dummy object
rkennke
parents: 50525
diff changeset
   273
  virtual void fill_with_dummy_object(HeapWord* start, HeapWord* end, bool zap);
52124
c64384f414bc 8211955: GC abstraction for LAB reserve
rkennke
parents: 52071
diff changeset
   274
  virtual size_t min_dummy_object_size() const;
c64384f414bc 8211955: GC abstraction for LAB reserve
rkennke
parents: 52071
diff changeset
   275
  size_t tlab_alloc_reserve() const;
50537
d12828b7cd64 8204685: Abstraction for TLAB dummy object
rkennke
parents: 50525
diff changeset
   276
25905
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   277
  // Return the address "addr" aligned by "alignment_in_bytes" if such
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   278
  // an address is below "end".  Return NULL otherwise.
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   279
  inline static HeapWord* align_allocation_or_fail(HeapWord* addr,
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   280
                                                   HeapWord* end,
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   281
                                                   unsigned short alignment_in_bytes);
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   282
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  // Some heaps may offer a contiguous region for shared non-blocking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  // allocation, via inlined code (by exporting the address of the top and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  // end fields defining the extent of the contiguous allocation region.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  // This function returns "true" iff the heap supports this kind of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  // allocation.  (Default is "no".)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  virtual bool supports_inline_contig_alloc() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  // These functions return the addresses of the fields that define the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  // boundaries of the contiguous allocation area.  (These fields should be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  // physically near to one another.)
41283
2615c024f3eb 8033552: Fix missing missing volatile specifiers in CAS operations in GC code
eosterlund
parents: 41177
diff changeset
   295
  virtual HeapWord* volatile* top_addr() const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    guarantee(false, "inline contiguous allocation not supported");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  virtual HeapWord** end_addr() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    guarantee(false, "inline contiguous allocation not supported");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  // Some heaps may be in an unparseable state at certain times between
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  // collections. This may be necessary for efficient implementation of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  // certain allocation-related activities. Calling this function before
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  // attempting to parse a heap ensures that the heap is in a parsable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  // state (provided other concurrent activity does not introduce
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  // unparsability). It is normally expected, therefore, that this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  // method is invoked with the world stopped.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  // NOTE: if you override this method, make sure you call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  // super::ensure_parsability so that the non-generational
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  // part of the work gets done. See implementation of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  // CollectedHeap::ensure_parsability and, for instance,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  // that of GenCollectedHeap::ensure_parsability().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  // The argument "retire_tlabs" controls whether existing TLABs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  // are merely filled or also retired, thus preventing further
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  // allocation from them and necessitating allocation of new TLABs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  virtual void ensure_parsability(bool retire_tlabs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  // Section on thread-local allocation buffers (TLABs)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  // If the heap supports thread-local allocation buffers, it should override
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  // the following methods:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  // Returns "true" iff the heap supports thread-local allocation buffers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  // The default is "no".
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   326
  virtual bool supports_tlab_allocation() const = 0;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   327
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  // The amount of space available for thread-local allocation buffers.
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   329
  virtual size_t tlab_capacity(Thread *thr) const = 0;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   330
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   331
  // The amount of used space for thread-local allocation buffers for the given thread.
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   332
  virtual size_t tlab_used(Thread *thr) const = 0;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   333
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   334
  virtual size_t max_tlab_size() const;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   335
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  // An estimate of the maximum allocation that could be performed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  // for thread-local allocation buffers without triggering any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  // collection or expansion activity.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  virtual size_t unsafe_max_tlab_alloc(Thread *thr) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    guarantee(false, "thread-local allocation buffers not supported");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  }
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   343
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // Perform a collection of the heap; intended for use in implementing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  // "System.gc".  This probably implies as full a collection as the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  // "CollectedHeap" supports.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  virtual void collect(GCCause::Cause cause) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   349
  // Perform a full collection
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   350
  virtual void do_full_collection(bool clear_all_soft_refs) = 0;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   351
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  // This interface assumes that it's being called by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  // vm thread. It collects the heap assuming that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  // heap lock is already held and that we are executing in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  // the context of the vm thread.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   356
  virtual void collect_as_vm_thread(GCCause::Cause cause);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   357
49045
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 49019
diff changeset
   358
  virtual MetaWord* satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 49019
diff changeset
   359
                                                       size_t size,
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 49019
diff changeset
   360
                                                       Metaspace::MetadataType mdtype);
9b556b613a07 8198509: Move satisfy_failed_metadata_allocation out from CollectorPolicy
stefank
parents: 49019
diff changeset
   361
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  // Returns "true" iff there is a stop-world GC in progress.  (I assume
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  // that it should answer "false" for the concurrent part of a concurrent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  // collector -- dld).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  bool is_gc_active() const { return _is_gc_active; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  // Total number of GC collections (started)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  unsigned int total_collections() const { return _total_collections; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  unsigned int total_full_collections() const { return _total_full_collections;}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  // Increment total number of GC collections (started)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  // Should be protected but used by PSMarkSweep - cleanup for 1.4.2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  void increment_total_collections(bool full = false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    _total_collections++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
    if (full) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
      increment_total_full_collections();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  void increment_total_full_collections() { _total_full_collections++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
49047
8f004146e407 8198515: Extract SoftReferencePolicy code out of CollectorPolicy
stefank
parents: 49045
diff changeset
   382
  // Return the SoftRefPolicy for the heap;
8f004146e407 8198515: Extract SoftReferencePolicy code out of CollectorPolicy
stefank
parents: 49045
diff changeset
   383
  virtual SoftRefPolicy* soft_ref_policy() = 0;
8f004146e407 8198515: Extract SoftReferencePolicy code out of CollectorPolicy
stefank
parents: 49045
diff changeset
   384
51625
c265860d5d45 8207200: Committed > max memory usage when getting MemoryUsage
tschatzl
parents: 50882
diff changeset
   385
  virtual MemoryUsage memory_usage();
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   386
  virtual GrowableArray<GCMemoryManager*> memory_managers() = 0;
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   387
  virtual GrowableArray<MemoryPool*> memory_pools() = 0;
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   388
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  // Iterate over all objects, calling "cl.do_object" on each.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  virtual void object_iterate(ObjectClosure* cl) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
1893
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1668
diff changeset
   392
  // Similar to object_iterate() except iterates only
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1668
diff changeset
   393
  // over live objects.
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1668
diff changeset
   394
  virtual void safe_object_iterate(ObjectClosure* cl) = 0;
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1668
diff changeset
   395
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  // Returns the longest time (in ms) that has elapsed since the last
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  // time that any part of the heap was examined by a garbage collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  virtual jlong millis_since_last_gc() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  // Perform any cleanup actions necessary before allowing a verification.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  virtual void prepare_for_verify() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2006
diff changeset
   403
  // Generate any dumps preceding or following a full gc
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   404
 private:
35915
5808cd93abfc 8148755: -XX:+HeapDumpAfterFullGC creates heap dump both before and after Full GC
redestad
parents: 35135
diff changeset
   405
  void full_gc_dump(GCTimer* timer, bool before);
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   406
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   407
  virtual void initialize_serviceability() = 0;
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   408
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   409
 public:
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   410
  void pre_full_gc_dump(GCTimer* timer);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   411
  void post_full_gc_dump(GCTimer* timer);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   412
49014
407a8495d4b3 8198271: Make CollectedHeap::create_heap_space_summary() virtual
pliden
parents: 48961
diff changeset
   413
  virtual VirtualSpaceSummary create_heap_space_summary();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   414
  GCHeapSummary create_heap_summary();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   415
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   416
  MetaspaceSummary create_metaspace_summary();
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2006
diff changeset
   417
10997
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   418
  // Print heap information on the given outputStream.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  virtual void print_on(outputStream* st) const = 0;
10997
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   420
  // The default behavior is to call print_on() on tty.
54807
33fe50b6d707 8223626: move print() functions to cpp files
coleenp
parents: 54781
diff changeset
   421
  virtual void print() const;
33fe50b6d707 8223626: move print() functions to cpp files
coleenp
parents: 54781
diff changeset
   422
10997
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   423
  // Print more detailed heap information on the given
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   424
  // outputStream. The default behavior is to call print_on(). It is
10997
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   425
  // up to each subclass to override it and add any additional output
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   426
  // it needs.
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   427
  virtual void print_extended_on(outputStream* st) const {
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   428
    print_on(st);
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   429
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   431
  virtual void print_on_error(outputStream* st) const;
16685
41c34debcde0 8011872: Include Bit Map addresses in the hs_err files
stefank
parents: 14579
diff changeset
   432
57903
5e2576c303a2 8229278: Improve hs_err location printing to assume less about GC internals
eosterlund
parents: 57852
diff changeset
   433
  // Used to print information about locations in the hs_err file.
5e2576c303a2 8229278: Improve hs_err location printing to assume less about GC internals
eosterlund
parents: 57852
diff changeset
   434
  virtual bool print_location(outputStream* st, void* addr) const = 0;
5e2576c303a2 8229278: Improve hs_err location printing to assume less about GC internals
eosterlund
parents: 57852
diff changeset
   435
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  // Print all GC threads (other than the VM thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  // used by this heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  virtual void print_gc_threads_on(outputStream* st) const = 0;
10997
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   439
  // The default behavior is to call print_gc_threads_on() on tty.
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   440
  void print_gc_threads() {
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   441
    print_gc_threads_on(tty);
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   442
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  // Iterator for all GC threads (other than VM thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  virtual void gc_threads_do(ThreadClosure* tc) const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  // Print any relevant tracing info that flags imply.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // Default implementation does nothing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  virtual void print_tracing_info() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   450
  void print_heap_before_gc();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   451
  void print_heap_after_gc();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   452
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
   453
  // Registering and unregistering an nmethod (compiled code) with the heap.
54361
879051d3772a 8220610: Make CollectedHeap nmethod functions pure virtual
stefank
parents: 54122
diff changeset
   454
  virtual void register_nmethod(nmethod* nm) = 0;
879051d3772a 8220610: Make CollectedHeap nmethod functions pure virtual
stefank
parents: 54122
diff changeset
   455
  virtual void unregister_nmethod(nmethod* nm) = 0;
879051d3772a 8220610: Make CollectedHeap nmethod functions pure virtual
stefank
parents: 54122
diff changeset
   456
  // Callback for when nmethod is about to be deleted.
879051d3772a 8220610: Make CollectedHeap nmethod functions pure virtual
stefank
parents: 54122
diff changeset
   457
  virtual void flush_nmethod(nmethod* nm) = 0;
879051d3772a 8220610: Make CollectedHeap nmethod functions pure virtual
stefank
parents: 54122
diff changeset
   458
  virtual void verify_nmethod(nmethod* nm) = 0;
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
   459
28940
c314cf1db3fa 8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents: 27623
diff changeset
   460
  void trace_heap_before_gc(const GCTracer* gc_tracer);
c314cf1db3fa 8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents: 27623
diff changeset
   461
  void trace_heap_after_gc(const GCTracer* gc_tracer);
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
   462
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  // Heap verification
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   464
  virtual void verify(VerifyOption option) = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
46384
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   466
  // Return true if concurrent phase control (via
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   467
  // request_concurrent_phase_control) is supported by this collector.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   468
  // The default implementation returns false.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   469
  virtual bool supports_concurrent_phase_control() const;
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   470
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   471
  // Request the collector enter the indicated concurrent phase, and
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   472
  // wait until it does so.  Supports WhiteBox testing.  Only one
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   473
  // request may be active at a time.  Phases are designated by name;
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   474
  // the set of names and their meaning is GC-specific.  Once the
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   475
  // requested phase has been reached, the collector will attempt to
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   476
  // avoid transitioning to a new phase until a new request is made.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   477
  // [Note: A collector might not be able to remain in a given phase.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   478
  // For example, a full collection might cancel an in-progress
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   479
  // concurrent collection.]
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   480
  //
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   481
  // Returns true when the phase is reached.  Returns false for an
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   482
  // unknown phase.  The default implementation returns false.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   483
  virtual bool request_concurrent_phase(const char* phase);
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   484
46702
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   485
  // Provides a thread pool to SafepointSynchronize to use
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   486
  // for parallel safepoint cleanup.
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   487
  // GCs that use a GC worker thread pool may want to share
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   488
  // it for use during safepoint cleanup. This is only possible
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   489
  // if the GC can pause and resume concurrent work (e.g. G1
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   490
  // concurrent marking) for an intermittent non-GC safepoint.
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   491
  // If this method returns NULL, SafepointSynchronize will
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   492
  // perform cleanup tasks serially in the VMThread.
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   493
  virtual WorkGang* get_safepoint_workers() { return NULL; }
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   494
49669
3569b528972e 8200429: Adjust object pinning interface on CollectedHeap
pliden
parents: 49629
diff changeset
   495
  // Support for object pinning. This is used by JNI Get*Critical()
3569b528972e 8200429: Adjust object pinning interface on CollectedHeap
pliden
parents: 49629
diff changeset
   496
  // and Release*Critical() family of functions. If supported, the GC
3569b528972e 8200429: Adjust object pinning interface on CollectedHeap
pliden
parents: 49629
diff changeset
   497
  // must guarantee that pinned objects never move.
3569b528972e 8200429: Adjust object pinning interface on CollectedHeap
pliden
parents: 49629
diff changeset
   498
  virtual bool supports_object_pinning() const;
3569b528972e 8200429: Adjust object pinning interface on CollectedHeap
pliden
parents: 49629
diff changeset
   499
  virtual oop pin_object(JavaThread* thread, oop obj);
3569b528972e 8200429: Adjust object pinning interface on CollectedHeap
pliden
parents: 49629
diff changeset
   500
  virtual void unpin_object(JavaThread* thread, oop obj);
49466
6ce398fe53fd 8199620: Support for JNI object pinning
rkennke
parents: 49054
diff changeset
   501
50057
f945444fabc3 8202647: Add deduplicate_string function to CollectedHeap
stefank
parents: 49945
diff changeset
   502
  // Deduplicate the string, iff the GC supports string deduplication.
f945444fabc3 8202647: Add deduplicate_string function to CollectedHeap
stefank
parents: 49945
diff changeset
   503
  virtual void deduplicate_string(oop str);
f945444fabc3 8202647: Add deduplicate_string function to CollectedHeap
stefank
parents: 49945
diff changeset
   504
49851
9082914ccaf2 8202081: Introduce CollectedHeap::is_oop()
stefank
parents: 49754
diff changeset
   505
  virtual bool is_oop(oop object) const;
9082914ccaf2 8202081: Introduce CollectedHeap::is_oop()
stefank
parents: 49754
diff changeset
   506
52071
c4a39588a075 8211270: GC abstraction to get real object and headers size
rkennke
parents: 51801
diff changeset
   507
  virtual size_t obj_size(oop obj) const;
c4a39588a075 8211270: GC abstraction to get real object and headers size
rkennke
parents: 51801
diff changeset
   508
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  // Non product verification and debugging.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  // Support for PromotionFailureALot.  Return true if it's time to cause a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  // promotion failure.  The no-argument version uses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  // this->_promotion_failure_alot_count as the counter.
49593
4dd58ecc9912 8200105: Remove cyclic dependency between oop.inline.hpp and collectedHeap.inline.hpp
stefank
parents: 49466
diff changeset
   514
  bool promotion_should_fail(volatile size_t* count);
4dd58ecc9912 8200105: Remove cyclic dependency between oop.inline.hpp and collectedHeap.inline.hpp
stefank
parents: 49466
diff changeset
   515
  bool promotion_should_fail();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  // Reset the PromotionFailureALot counters.  Should be called at the end of a
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   518
  // GC in which promotion failure occurred.
49593
4dd58ecc9912 8200105: Remove cyclic dependency between oop.inline.hpp and collectedHeap.inline.hpp
stefank
parents: 49466
diff changeset
   519
  void reset_promotion_should_fail(volatile size_t* count);
4dd58ecc9912 8200105: Remove cyclic dependency between oop.inline.hpp and collectedHeap.inline.hpp
stefank
parents: 49466
diff changeset
   520
  void reset_promotion_should_fail();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
#endif  // #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
// Class to set and reset the GC cause for a CollectedHeap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
class GCCauseSetter : StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  CollectedHeap* _heap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  GCCause::Cause _previous_cause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  GCCauseSetter(CollectedHeap* heap, GCCause::Cause cause) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
    _heap = heap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    _previous_cause = _heap->gc_cause();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
    _heap->set_gc_cause(cause);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  ~GCCauseSetter() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    _heap->set_gc_cause(_previous_cause);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
   540
53244
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 52925
diff changeset
   541
#endif // SHARE_GC_SHARED_COLLECTEDHEAP_HPP