src/hotspot/share/gc/shared/collectedHeap.hpp
author shade
Thu, 07 Dec 2017 13:05:31 +0100
branchepsilon-gc-branch
changeset 55974 06122633fead
parent 55939 c5c3e1a5c3f0
parent 48168 cb5d2d4453d0
child 56276 ee5e58456be5
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
     2
 * Copyright (c) 2001, 2017, 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: 30581
diff changeset
    25
#ifndef SHARE_VM_GC_SHARED_COLLECTEDHEAP_HPP
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30581
diff changeset
    26
#define SHARE_VM_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"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    30
#include "memory/allocation.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    31
#include "runtime/handles.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    32
#include "runtime/perfData.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    33
#include "runtime/safepoint.hpp"
46560
388aa8d67c80 8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents: 46384
diff changeset
    34
#include "utilities/debug.hpp"
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    35
#include "utilities/events.hpp"
46560
388aa8d67c80 8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents: 46384
diff changeset
    36
#include "utilities/formatBuffer.hpp"
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
    37
#include "utilities/growableArray.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
    38
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// A "CollectedHeap" is an implementation of a java heap for HotSpot.  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// is an abstract class: there may be many different kinds of heaps.  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// class defines the functions that a heap must implement, and contains
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// infrastructure common to all heaps.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    44
class AdaptiveSizePolicy;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
class BarrierSet;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    46
class CollectorPolicy;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    47
class GCHeapSummary;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    48
class GCTimer;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    49
class GCTracer;
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
    50
class GCMemoryManager;
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
    51
class MemoryPool;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    52
class MetaspaceSummary;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    53
class Thread;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
class ThreadClosure;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
    55
class VirtualSpaceSummary;
46702
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
    56
class WorkGang;
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
    57
class nmethod;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    59
class GCMessage : public FormatBuffer<1024> {
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    60
 public:
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    61
  bool is_before;
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    62
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
  GCMessage() {}
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
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    67
class CollectedHeap;
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    68
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    69
class GCHeapLog : public EventLogBase<GCMessage> {
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    70
 private:
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    71
  void log_heap(CollectedHeap* heap, bool before);
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    72
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    73
 public:
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    74
  GCHeapLog() : EventLogBase<GCMessage>("GC Heap History") {}
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    75
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    76
  void log_heap_before(CollectedHeap* heap) {
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    77
    log_heap(heap, true);
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_after(CollectedHeap* heap) {
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
    80
    log_heap(heap, false);
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    81
  }
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    82
};
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
    83
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
// CollectedHeap
30154
39cd4e2ccf1c 8076452: Remove SharedHeap
brutisso
parents: 30152
diff changeset
    86
//   GenCollectedHeap
47819
ee36a8e36561 8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents: 47636
diff changeset
    87
//     SerialHeap
ee36a8e36561 8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents: 47636
diff changeset
    88
//     CMSHeap
30154
39cd4e2ccf1c 8076452: Remove SharedHeap
brutisso
parents: 30152
diff changeset
    89
//   G1CollectedHeap
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
//   ParallelScavengeHeap
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
//
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12379
diff changeset
    92
class CollectedHeap : public CHeapObj<mtInternal> {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  friend class VMStructs;
35123
b0b89d83bcf5 8134994: use separate VMStructs databases for SA and JVMCI
twisti
parents: 33160
diff changeset
    94
  friend class JVMCIVMStructs;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  friend class IsGCActiveMark; // Block structured external access to _is_gc_active
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
26829
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25905
diff changeset
    97
 private:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  static int       _fire_out_of_memory_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
11636
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
   102
  GCHeapLog* _gc_heap_log;
3c07b54482a5 7141200: log some interesting information in ring buffers for crashes
never
parents: 11396
diff changeset
   103
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31346
diff changeset
   104
  // Used in support of ReduceInitialCardMarks; only consulted if COMPILER2
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 31346
diff changeset
   105
  // or INCLUDE_JVMCI is being used
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   106
  bool _defer_initial_card_mark;
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   107
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
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
  BarrierSet* _barrier_set;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
  bool _is_gc_active;
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   113
31346
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 30871
diff changeset
   114
  // Used for filler objects (static, but initialized in ctor).
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 30871
diff changeset
   115
  static size_t _filler_array_max_size;
a70d45c06136 8042668: GC Support for shared heap ranges in CDS
jiangli
parents: 30871
diff changeset
   116
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  unsigned int _total_collections;          // ... started
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  unsigned int _total_full_collections;     // ... started
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  NOT_PRODUCT(volatile size_t _promotion_failure_alot_count;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  NOT_PRODUCT(volatile size_t _promotion_failure_alot_gc_number;)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  // Reason for current garbage collection.  Should be set to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  // a value reflecting no collection between collections.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  GCCause::Cause _gc_cause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  GCCause::Cause _gc_lastcause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  PerfStringVariable* _perf_gc_cause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  PerfStringVariable* _perf_gc_lastcause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  // Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  CollectedHeap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   132
  // Do common initializations that must follow instance construction,
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   133
  // for example, those needing virtual calls.
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   134
  // This code could perhaps be moved into initialize() but would
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   135
  // be slightly more awkward because we want the latter to be a
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   136
  // pure virtual.
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   137
  void pre_initialize();
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   138
9997
b75b7939f448 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents: 9995
diff changeset
   139
  // Create a new tlab. All TLAB allocations must go through this.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  virtual HeapWord* allocate_new_tlab(size_t size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  // Accumulate statistics on all tlabs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  virtual void accumulate_statistics_all_tlabs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // Reinitialize tlabs before resuming mutators.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  virtual void resize_all_tlabs();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // Allocate from the current thread's TLAB, with broken-out slow path.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   149
  inline static HeapWord* allocate_from_tlab(Klass* klass, Thread* thread, size_t size);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   150
  static HeapWord* allocate_from_tlab_slow(Klass* klass, Thread* thread, size_t size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // Allocate an uninitialized block of the given size, or returns NULL if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // this is impossible.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   154
  inline static HeapWord* common_mem_allocate_noinit(Klass* klass, size_t size, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  // Like allocate_init, but the block returned by a successful allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // is guaranteed initialized to zeros.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   158
  inline static HeapWord* common_mem_allocate_init(Klass* klass, size_t size, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  // Helper functions for (VM) allocation.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   161
  inline static void post_allocation_setup_common(Klass* klass, HeapWord* obj);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   162
  inline static void post_allocation_setup_no_klass_install(Klass* klass,
12236
51d6463cfd9d 7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents: 12229
diff changeset
   163
                                                            HeapWord* objPtr);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   165
  inline static void post_allocation_setup_obj(Klass* klass, HeapWord* obj, int size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   167
  inline static void post_allocation_setup_array(Klass* klass,
12236
51d6463cfd9d 7156764: Remove unused size parameter from some CollectedHeap methods
brutisso
parents: 12229
diff changeset
   168
                                                 HeapWord* obj, int length);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   170
  inline static void post_allocation_setup_class(Klass* klass, HeapWord* obj, int size);
39695
946f1321c075 8158946: btree009 fails with assert(s > 0) failed: Bad size calculated
drwhite
parents: 38011
diff changeset
   171
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  // Clears an allocated object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  inline static void init_obj(HeapWord* obj, size_t size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   175
  // Filler object utilities.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   176
  static inline size_t filler_array_hdr_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   177
  static inline size_t filler_array_min_size();
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   178
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   179
  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
   180
  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
   181
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   182
  // 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
   183
  // 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
   184
  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
   185
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   186
  // 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
   187
  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
   188
28940
c314cf1db3fa 8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents: 27623
diff changeset
   189
  virtual void trace_heap(GCWhen::Type when, const GCTracer* tracer);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   190
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  // Verification functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  virtual void check_for_bad_heap_word_value(HeapWord* addr, size_t size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    PRODUCT_RETURN;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  virtual void check_for_non_bad_heap_word_value(HeapWord* addr, size_t size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
    PRODUCT_RETURN;
2006
f2d2f0f20063 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark)
jmasa
parents: 1893
diff changeset
   196
  debug_only(static void check_for_valid_allocation_state();)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  enum Name {
47819
ee36a8e36561 8183542: Factor out serial GC specific code from GenCollectedHeap into its own subclass
rkennke
parents: 47636
diff changeset
   200
    SerialHeap,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
    ParallelScavengeHeap,
47622
817f2a7019e4 8179387: Factor out CMS specific code from GenCollectedHeap into its own subclass
rkennke
parents: 47216
diff changeset
   202
    G1CollectedHeap,
55767
8e22715afabc Initial import of Epsilon sources from jdk10/sandbox
shade
parents: 47636
diff changeset
   203
    CMSHeap,
55939
c5c3e1a5c3f0 Rename EpsilonCollectedHeap to EpsilonHeap.
shade
parents: 55934
diff changeset
   204
    EpsilonHeap,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
12229
c34a85c8f5aa 7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents: 11636
diff changeset
   207
  static inline size_t filler_array_max_size() {
c34a85c8f5aa 7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents: 11636
diff changeset
   208
    return _filler_array_max_size;
c34a85c8f5aa 7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents: 11636
diff changeset
   209
  }
c34a85c8f5aa 7103665: HeapWord*ParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97
brutisso
parents: 11636
diff changeset
   210
29808
9bbc65318fdd 8076294: Cleanup of CollectedHeap::kind()
pliden
parents: 29803
diff changeset
   211
  virtual Name kind() const = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   213
  virtual const char* name() const = 0;
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   214
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  /**
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
   * Returns JNI error code JNI_ENOMEM if memory could not be allocated,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
   * and JNI_OK on success.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
   */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  virtual jint initialize() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  // In many heaps, there will be a need to perform some initialization activities
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  // after the Universe is fully formed, but before general heap allocation is allowed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  // 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
   224
  virtual void post_initialize();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
24093
095cc0a63ed9 8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents: 22552
diff changeset
   226
  // Stop any onging concurrent work and prepare for exit.
095cc0a63ed9 8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents: 22552
diff changeset
   227
  virtual void stop() {}
095cc0a63ed9 8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents: 22552
diff changeset
   228
47636
52d46d7e3454 8188919: Generalize GC thread suspend/resume at safepoints
eosterlund
parents: 47624
diff changeset
   229
  // Stop and resume concurrent GC threads interfering with safepoint operations
52d46d7e3454 8188919: Generalize GC thread suspend/resume at safepoints
eosterlund
parents: 47624
diff changeset
   230
  virtual void safepoint_synchronize_begin() {}
52d46d7e3454 8188919: Generalize GC thread suspend/resume at safepoints
eosterlund
parents: 47624
diff changeset
   231
  virtual void safepoint_synchronize_end() {}
52d46d7e3454 8188919: Generalize GC thread suspend/resume at safepoints
eosterlund
parents: 47624
diff changeset
   232
26829
26315213bab8 8055091: CollectedHeap::_reserved usage should be cleaned up
mlarsson
parents: 25905
diff changeset
   233
  void initialize_reserved_region(HeapWord *start, HeapWord *end);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  MemRegion reserved_region() const { return _reserved; }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   235
  address base() const { return (address)reserved_region().start(); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  virtual size_t capacity() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  virtual size_t used() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  // Return "true" if the part of the heap that allocates Java
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  // objects has reached the maximal committed limit that it can
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  // reach, without a garbage collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  virtual bool is_maximal_no_gc() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  // Support for java.lang.Runtime.maxMemory():  return the maximum amount of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  // memory that the vm could make available for storing 'normal' java objects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  // 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
   248
  // 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
   249
  // (e.g., in the case of the young gen, one of the survivor
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  // spaces).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  virtual size_t max_capacity() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  // Returns "TRUE" if "p" points into the reserved area of the heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  bool is_in_reserved(const void* p) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    return _reserved.contains(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  bool is_in_reserved_or_null(const void* p) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
    return p == NULL || is_in_reserved(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
11247
d6faa02b3802 7121373: Clean up CollectedHeap::is_in
stefank
parents: 10997
diff changeset
   262
  // 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
   263
  // 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
   264
  // code.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  virtual bool is_in(const void* p) const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
30177
925cd0b4f0e7 8077403: Remove guarantee from GenCollectedHeap::is_in()
brutisso
parents: 30171
diff changeset
   267
  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
   268
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  // Let's define some terms: a "closed" subset of a heap is one that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  // 1) contains all currently-allocated objects, and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  // 2) is closed under reference: no object in the closed subset
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  //    references one outside the closed subset.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  // Membership in a heap's closed subset is useful for assertions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  // Clearly, the entire heap is a closed subset, so the default
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  // implementation is to use "is_in_reserved".  But this may not be too
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  // liberal to perform useful checking.  Also, the "is_in" predicate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  // defines a closed subset, but may be too expensive, since "is_in"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  // verifies that its argument points to an object head.  The
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  // "closed_subset" method allows a heap to define an intermediate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  // predicate, allowing more precise checking than "is_in_reserved" at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  // lower cost than "is_in."
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  // One important case is a heap composed of disjoint contiguous spaces,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  // such as the Garbage-First collector.  Such heaps have a convenient
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  // closed subset consisting of the allocated portions of those
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  // contiguous spaces.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  // Return "TRUE" iff the given pointer points into the heap's defined
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  // closed subset (which defaults to the entire heap).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  virtual bool is_in_closed_subset(const void* p) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    return is_in_reserved(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  bool is_in_closed_subset_or_null(const void* p) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    return p == NULL || is_in_closed_subset(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  void set_gc_cause(GCCause::Cause v) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
     if (UsePerfData) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
       _gc_lastcause = _gc_cause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
       _perf_gc_lastcause->set_value(GCCause::to_string(_gc_lastcause));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
       _perf_gc_cause->set_value(GCCause::to_string(v));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    _gc_cause = v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
  GCCause::Cause gc_cause() { return _gc_cause; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  // General obj/array allocation facilities.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   312
  inline static oop obj_allocate(Klass* klass, int size, TRAPS);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   313
  inline static oop array_allocate(Klass* klass, int size, int length, TRAPS);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   314
  inline static oop array_allocate_nozero(Klass* klass, int size, int length, TRAPS);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 42592
diff changeset
   315
  inline static oop class_allocate(Klass* klass, int size, TRAPS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  // Raw memory allocation facilities
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  // The obj and array allocate methods are covers for these methods.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   319
  // mem_allocate() should never be
9997
b75b7939f448 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap
tonyp
parents: 9995
diff changeset
   320
  // called to allocate TLABs, only individual objects.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  virtual HeapWord* mem_allocate(size_t size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
                                 bool* gc_overhead_limit_was_exceeded) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
1668
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   324
  // Utilities for turning raw memory into filler objects.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   325
  //
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   326
  // 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
   327
  // 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
   328
  // 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
   329
  // 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
   330
  // region and has slightly less overhead.
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   331
  static size_t min_fill_size() {
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   332
    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
   333
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   334
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   335
  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
   336
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   337
  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
   338
  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
   339
    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
   340
  }
4636
90e004691873 6902115: G1:assert(ignore_max_completed||thread->is_Java_thread()||SafepointSynchronize::is_at_safepoint())
johnc
parents: 4030
diff changeset
   341
  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
   342
    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
   343
  }
8ec481b8f514 6578152: fill_region_with_object has usability and safety issues
jcoomes
parents: 1388
diff changeset
   344
25905
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   345
  // 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
   346
  // an address is below "end".  Return NULL otherwise.
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   347
  inline static HeapWord* align_allocation_or_fail(HeapWord* addr,
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   348
                                                   HeapWord* end,
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   349
                                                   unsigned short alignment_in_bytes);
04a3d83cc752 8031323: Optionally align objects copied to survivor spaces
jmasa
parents: 24109
diff changeset
   350
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  // Some heaps may offer a contiguous region for shared non-blocking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  // allocation, via inlined code (by exporting the address of the top and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  // end fields defining the extent of the contiguous allocation region.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  // This function returns "true" iff the heap supports this kind of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  // allocation.  (Default is "no".)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  virtual bool supports_inline_contig_alloc() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  // These functions return the addresses of the fields that define the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
  // boundaries of the contiguous allocation area.  (These fields should be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  // physically near to one another.)
41283
2615c024f3eb 8033552: Fix missing missing volatile specifiers in CAS operations in GC code
eosterlund
parents: 41177
diff changeset
   363
  virtual HeapWord* volatile* top_addr() const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
    guarantee(false, "inline contiguous allocation not supported");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  virtual HeapWord** end_addr() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
    guarantee(false, "inline contiguous allocation not supported");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  // Some heaps may be in an unparseable state at certain times between
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  // collections. This may be necessary for efficient implementation of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  // certain allocation-related activities. Calling this function before
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  // attempting to parse a heap ensures that the heap is in a parsable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  // state (provided other concurrent activity does not introduce
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  // unparsability). It is normally expected, therefore, that this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  // method is invoked with the world stopped.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  // NOTE: if you override this method, make sure you call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  // super::ensure_parsability so that the non-generational
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  // part of the work gets done. See implementation of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  // CollectedHeap::ensure_parsability and, for instance,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  // that of GenCollectedHeap::ensure_parsability().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
  // The argument "retire_tlabs" controls whether existing TLABs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  // are merely filled or also retired, thus preventing further
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  // allocation from them and necessitating allocation of new TLABs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  virtual void ensure_parsability(bool retire_tlabs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  // Section on thread-local allocation buffers (TLABs)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  // If the heap supports thread-local allocation buffers, it should override
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  // the following methods:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  // Returns "true" iff the heap supports thread-local allocation buffers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  // The default is "no".
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   394
  virtual bool supports_tlab_allocation() const = 0;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   395
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  // The amount of space available for thread-local allocation buffers.
22552
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   397
  virtual size_t tlab_capacity(Thread *thr) const = 0;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   398
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   399
  // 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
   400
  virtual size_t tlab_used(Thread *thr) const = 0;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   401
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   402
  virtual size_t max_tlab_size() const;
a29022212180 8030177: G1: Enable TLAB resizing
brutisso
parents: 22203
diff changeset
   403
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
  // An estimate of the maximum allocation that could be performed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  // for thread-local allocation buffers without triggering any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  // collection or expansion activity.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  virtual size_t unsafe_max_tlab_alloc(Thread *thr) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
    guarantee(false, "thread-local allocation buffers not supported");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  }
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   411
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  // Can a compiler initialize a new object without store barriers?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  // This permission only extends from the creation of a new object
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   414
  // via a TLAB up to the first subsequent safepoint. If such permission
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   415
  // is granted for this heap type, the compiler promises to call
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   416
  // defer_store_barrier() below on any slow path allocation of
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   417
  // a new object for which such initializing store barriers will
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   418
  // have been elided.
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   419
  virtual bool can_elide_tlab_store_barriers() const = 0;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 360
diff changeset
   420
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
  // If a compiler is eliding store barriers for TLAB-allocated objects,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
  // there is probably a corresponding slow path which can produce
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
  // an object allocated anywhere.  The compiler's runtime support
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  // promises to call this function on such a slow-path-allocated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  // object before performing initializations that have elided
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   426
  // store barriers. Returns new_obj, or maybe a safer copy thereof.
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   427
  virtual oop new_store_pre_barrier(JavaThread* thread, oop new_obj);
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   428
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   429
  // Answers whether an initializing store to a new object currently
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   430
  // allocated at the given address doesn't need a store
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   431
  // barrier. Returns "true" if it doesn't need an initializing
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   432
  // store barrier; answers "false" if it does.
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   433
  virtual bool can_elide_initializing_store_barrier(oop new_obj) = 0;
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   434
4637
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   435
  // If a compiler is eliding store barriers for TLAB-allocated objects,
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   436
  // we will be informed of a slow-path allocation by a call
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   437
  // to new_store_pre_barrier() above. Such a call precedes the
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   438
  // initialization of the object itself, and no post-store-barriers will
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   439
  // be issued. Some heap types require that the barrier strictly follows
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   440
  // the initializing stores. (This is currently implemented by deferring the
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   441
  // barrier until the next slow-path allocation or gc-related safepoint.)
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   442
  // This interface answers whether a particular heap type needs the card
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   443
  // mark to be thus strictly sequenced after the stores.
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   444
  virtual bool card_mark_must_follow_store() const = 0;
af4d405aacc1 6896647: card marks can be deferred too long
ysr
parents: 4636
diff changeset
   445
4030
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   446
  // If the CollectedHeap was asked to defer a store barrier above,
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   447
  // this informs it to flush such a deferred store barrier to the
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   448
  // remembered set.
4c471254865e 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents: 3912
diff changeset
   449
  virtual void flush_deferred_store_barrier(JavaThread* thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  // Perform a collection of the heap; intended for use in implementing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  // "System.gc".  This probably implies as full a collection as the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  // "CollectedHeap" supports.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  virtual void collect(GCCause::Cause cause) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   456
  // Perform a full collection
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   457
  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
   458
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  // This interface assumes that it's being called by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  // vm thread. It collects the heap assuming that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  // heap lock is already held and that we are executing in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  // the context of the vm thread.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   463
  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
   464
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  // Returns the barrier set for this heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  BarrierSet* barrier_set() { return _barrier_set; }
30152
5fe1c8494b49 8076454: Clean up/move things out of SharedHeap
brutisso
parents: 29808
diff changeset
   467
  void set_barrier_set(BarrierSet* barrier_set);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  // Returns "true" iff there is a stop-world GC in progress.  (I assume
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  // that it should answer "false" for the concurrent part of a concurrent
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  // collector -- dld).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  bool is_gc_active() const { return _is_gc_active; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  // Total number of GC collections (started)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  unsigned int total_collections() const { return _total_collections; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  unsigned int total_full_collections() const { return _total_full_collections;}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  // Increment total number of GC collections (started)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  // Should be protected but used by PSMarkSweep - cleanup for 1.4.2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  void increment_total_collections(bool full = false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
    _total_collections++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    if (full) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
      increment_total_full_collections();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  void increment_total_full_collections() { _total_full_collections++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
5343
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4637
diff changeset
   489
  // Return the CollectorPolicy for the heap
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4637
diff changeset
   490
  virtual CollectorPolicy* collector_policy() const = 0;
95a5c4b89273 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents: 4637
diff changeset
   491
48168
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   492
  virtual GrowableArray<GCMemoryManager*> memory_managers() = 0;
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   493
  virtual GrowableArray<MemoryPool*> memory_pools() = 0;
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   494
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  // Iterate over all objects, calling "cl.do_object" on each.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  virtual void object_iterate(ObjectClosure* cl) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
1893
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1668
diff changeset
   498
  // Similar to object_iterate() except iterates only
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1668
diff changeset
   499
  // over live objects.
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1668
diff changeset
   500
  virtual void safe_object_iterate(ObjectClosure* cl) = 0;
c82e388e17c5 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents: 1668
diff changeset
   501
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  // NOTE! There is no requirement that a collector implement these
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  // functions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  // A CollectedHeap is divided into a dense sequence of "blocks"; that is,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  // each address in the (reserved) heap is a member of exactly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  // one block.  The defining characteristic of a block is that it is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  // possible to find its size, and thus to progress forward to the next
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  // block.  (Blocks may be of different sizes.)  Thus, blocks may
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  // represent Java objects, or they might be free blocks in a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  // free-list-based heap (or subheap), as long as the two kinds are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  // distinguishable and the size of each is determinable.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  // Returns the address of the start of the "block" that contains the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  // address "addr".  We say "blocks" instead of "object" since some heaps
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  // may not pack objects densely; a chunk may either be an object or a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  // non-object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  virtual HeapWord* block_start(const void* addr) const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  // Requires "addr" to be the start of a chunk, and returns its size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  // "addr + size" is required to be the start of a new chunk, or the end
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  // of the active area of the heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  virtual size_t block_size(const HeapWord* addr) const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  // Requires "addr" to be the start of a block, and returns "TRUE" iff
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  // the block is an object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  virtual bool block_is_obj(const HeapWord* addr) const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // Returns the longest time (in ms) that has elapsed since the last
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  // time that any part of the heap was examined by a garbage collection.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  virtual jlong millis_since_last_gc() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  // Perform any cleanup actions necessary before allowing a verification.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  virtual void prepare_for_verify() = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2006
diff changeset
   536
  // Generate any dumps preceding or following a full gc
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   537
 private:
35915
5808cd93abfc 8148755: -XX:+HeapDumpAfterFullGC creates heap dump both before and after Full GC
redestad
parents: 35135
diff changeset
   538
  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
   539
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   540
  virtual void initialize_serviceability() = 0;
cb5d2d4453d0 8191564: Refactor GC related servicability code into GC specific subclasses
rkennke
parents: 47819
diff changeset
   541
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   542
 public:
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   543
  void pre_full_gc_dump(GCTimer* timer);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   544
  void post_full_gc_dump(GCTimer* timer);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   545
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   546
  VirtualSpaceSummary create_heap_space_summary();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   547
  GCHeapSummary create_heap_summary();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   548
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   549
  MetaspaceSummary create_metaspace_summary();
2141
e9a644aaff87 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents: 2006
diff changeset
   550
10997
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   551
  // Print heap information on the given outputStream.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  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
   553
  // The default behavior is to call print_on() on tty.
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   554
  virtual void print() const {
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   555
    print_on(tty);
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   556
  }
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   557
  // Print more detailed heap information on the given
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   558
  // 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
   559
  // 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
   560
  // it needs.
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   561
  virtual void print_extended_on(outputStream* st) const {
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   562
    print_on(st);
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   563
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28940
diff changeset
   565
  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
   566
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  // Print all GC threads (other than the VM thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  // used by this heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  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
   570
  // 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
   571
  void print_gc_threads() {
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   572
    print_gc_threads_on(tty);
0be4b3be7197 7099849: G1: include heap region information in hs_err files
tonyp
parents: 10742
diff changeset
   573
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  // Iterator for all GC threads (other than VM thread)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  virtual void gc_threads_do(ThreadClosure* tc) const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  // Print any relevant tracing info that flags imply.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  // Default implementation does nothing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  virtual void print_tracing_info() const = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   581
  void print_heap_before_gc();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   582
  void print_heap_after_gc();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 16685
diff changeset
   583
47624
b055cb5170f5 8185141: Generalize scavengeable nmethod root handling
eosterlund
parents: 47622
diff changeset
   584
  // An object is scavengable if its location may move during a scavenge.
b055cb5170f5 8185141: Generalize scavengeable nmethod root handling
eosterlund
parents: 47622
diff changeset
   585
  // (A scavenge is a GC which is not a full GC.)
b055cb5170f5 8185141: Generalize scavengeable nmethod root handling
eosterlund
parents: 47622
diff changeset
   586
  virtual bool is_scavengable(oop obj) = 0;
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
   587
  // Registering and unregistering an nmethod (compiled code) with the heap.
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
   588
  // Override with specific mechanism for each specialized heap type.
47624
b055cb5170f5 8185141: Generalize scavengeable nmethod root handling
eosterlund
parents: 47622
diff changeset
   589
  virtual void register_nmethod(nmethod* nm) {}
b055cb5170f5 8185141: Generalize scavengeable nmethod root handling
eosterlund
parents: 47622
diff changeset
   590
  virtual void unregister_nmethod(nmethod* nm) {}
b055cb5170f5 8185141: Generalize scavengeable nmethod root handling
eosterlund
parents: 47622
diff changeset
   591
  virtual void verify_nmethod(nmethod* nmethod) {}
19339
d247781beec7 7145569: G1: optimize nmethods scanning
johnc
parents: 18025
diff changeset
   592
28940
c314cf1db3fa 8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents: 27623
diff changeset
   593
  void trace_heap_before_gc(const GCTracer* gc_tracer);
c314cf1db3fa 8066566: Refactor ParNewGeneration to contain ParNewTracer
mlarsson
parents: 27623
diff changeset
   594
  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
   595
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  // Heap verification
35061
be6025ebffea 8145092: Use Unified Logging for the GC logging
brutisso
parents: 33160
diff changeset
   597
  virtual void verify(VerifyOption option) = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
46384
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   599
  // Return true if concurrent phase control (via
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   600
  // request_concurrent_phase_control) is supported by this collector.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   601
  // The default implementation returns false.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   602
  virtual bool supports_concurrent_phase_control() const;
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   603
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   604
  // Return a NULL terminated array of concurrent phase names provided
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   605
  // by this collector.  Supports Whitebox testing.  These are the
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   606
  // names recognized by request_concurrent_phase(). The default
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   607
  // implementation returns an array of one NULL element.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   608
  virtual const char* const* concurrent_phases() const;
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   609
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   610
  // Request the collector enter the indicated concurrent phase, and
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   611
  // wait until it does so.  Supports WhiteBox testing.  Only one
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   612
  // 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
   613
  // 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
   614
  // requested phase has been reached, the collector will attempt to
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   615
  // 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
   616
  // [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
   617
  // For example, a full collection might cancel an in-progress
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   618
  // concurrent collection.]
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   619
  //
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   620
  // 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
   621
  // unknown phase.  The default implementation returns false.
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   622
  virtual bool request_concurrent_phase(const char* phase);
dacebddcdea0 8169517: WhiteBox should provide concurrent GC phase control
kbarrett
parents: 46329
diff changeset
   623
46702
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   624
  // Provides a thread pool to SafepointSynchronize to use
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   625
  // for parallel safepoint cleanup.
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   626
  // GCs that use a GC worker thread pool may want to share
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   627
  // it for use during safepoint cleanup. This is only possible
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   628
  // if the GC can pause and resume concurrent work (e.g. G1
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   629
  // concurrent marking) for an intermittent non-GC safepoint.
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   630
  // If this method returns NULL, SafepointSynchronize will
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   631
  // perform cleanup tasks serially in the VMThread.
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   632
  virtual WorkGang* get_safepoint_workers() { return NULL; }
13ae789b982e 8180932: Parallelize safepoint cleanup
rkennke
parents: 46657
diff changeset
   633
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  // Non product verification and debugging.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
  // Support for PromotionFailureALot.  Return true if it's time to cause a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  // promotion failure.  The no-argument version uses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  // this->_promotion_failure_alot_count as the counter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  inline bool promotion_should_fail(volatile size_t* count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  inline bool promotion_should_fail();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  // 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
   643
  // GC in which promotion failure occurred.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  inline void reset_promotion_should_fail(volatile size_t* count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  inline void reset_promotion_should_fail();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
#endif  // #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  static int fired_fake_oom() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    return (CIFireOOMAt > 1 && _fire_out_of_memory_count >= CIFireOOMAt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
#endif
6759
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   653
67b1a69ef5aa 6984287: Regularize how GC parallel workers are specified.
jmasa
parents: 5547
diff changeset
   654
 public:
26842
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26829
diff changeset
   655
  // Copy the current allocation context statistics for the specified contexts.
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26829
diff changeset
   656
  // For each context in contexts, set the corresponding entries in the totals
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26829
diff changeset
   657
  // and accuracy arrays to the current values held by the statistics.  Each
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26829
diff changeset
   658
  // array should be of length len.
27623
3f190bd7182f 8061234: ResourceContext.requestAccurateUpdate() is unreliable
sjohanss
parents: 26842
diff changeset
   659
  // Returns true if there are more stats available.
3f190bd7182f 8061234: ResourceContext.requestAccurateUpdate() is unreliable
sjohanss
parents: 26842
diff changeset
   660
  virtual bool copy_allocation_context_stats(const jint* contexts,
26842
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26829
diff changeset
   661
                                             jlong* totals,
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26829
diff changeset
   662
                                             jbyte* accuracy,
27623
3f190bd7182f 8061234: ResourceContext.requestAccurateUpdate() is unreliable
sjohanss
parents: 26842
diff changeset
   663
                                             jint len) {
3f190bd7182f 8061234: ResourceContext.requestAccurateUpdate() is unreliable
sjohanss
parents: 26842
diff changeset
   664
    return false;
3f190bd7182f 8061234: ResourceContext.requestAccurateUpdate() is unreliable
sjohanss
parents: 26842
diff changeset
   665
  }
26842
5081db39f634 8057824: methods to copy allocation context statistics
jcoomes
parents: 26829
diff changeset
   666
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
// Class to set and reset the GC cause for a CollectedHeap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
class GCCauseSetter : StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  CollectedHeap* _heap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  GCCause::Cause _previous_cause;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  GCCauseSetter(CollectedHeap* heap, GCCause::Cause cause) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    assert(SafepointSynchronize::is_at_safepoint(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
           "This method manipulates heap state without locking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    _heap = heap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
    _previous_cause = _heap->gc_cause();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
    _heap->set_gc_cause(cause);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  ~GCCauseSetter() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    assert(SafepointSynchronize::is_at_safepoint(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
          "This method manipulates heap state without locking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    _heap->set_gc_cause(_previous_cause);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
};
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6759
diff changeset
   689
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30581
diff changeset
   690
#endif // SHARE_VM_GC_SHARED_COLLECTEDHEAP_HPP