truffle: src/share/vm/gc_interface/collectedHeap.hpp annotate

annotate src/share/vm/gc_interface/collectedHeap.hpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	096c224171c4
children	d8041d695d19

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1387 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	25 #ifndef SHARE_VM_GC_INTERFACE_COLLECTEDHEAP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	26 #define SHARE_VM_GC_INTERFACE_COLLECTEDHEAP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	28 #include "gc_interface/gcCause.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	29 #include "gc_implementation/shared/gcWhen.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	30 #include "memory/allocation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	31 #include "memory/barrierSet.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	32 #include "runtime/handles.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	33 #include "runtime/perfData.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	34 #include "runtime/safepoint.hpp"
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	35 #include "utilities/events.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	36
0 a61af66fc99e Initial load duke parents: diff changeset	37 // A "CollectedHeap" is an implementation of a java heap for HotSpot. This
a61af66fc99e Initial load duke parents: diff changeset	38 // is an abstract class: there may be many different kinds of heaps. This
a61af66fc99e Initial load duke parents: diff changeset	39 // class defines the functions that a heap must implement, and contains
a61af66fc99e Initial load duke parents: diff changeset	40 // infrastructure common to all heaps.
a61af66fc99e Initial load duke parents: diff changeset	41
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	42 class AdaptiveSizePolicy;
0 a61af66fc99e Initial load duke parents: diff changeset	43 class BarrierSet;
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	44 class CollectorPolicy;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	45 class GCHeapSummary;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	46 class GCTimer;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	47 class GCTracer;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	48 class MetaspaceSummary;
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	49 class Thread;
0 a61af66fc99e Initial load duke parents: diff changeset	50 class ThreadClosure;
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	51 class VirtualSpaceSummary;
12080 5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 10405 diff changeset	52 class nmethod;
0 a61af66fc99e Initial load duke parents: diff changeset	53
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	54 class GCMessage : public FormatBuffer<1024> {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	55 public:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	56 bool is_before;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	57
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	58 public:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	59 GCMessage() {}
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	60 };
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	61
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	62 class GCHeapLog : public EventLogBase<GCMessage> {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	63 private:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	64 void log_heap(bool before);
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	65
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	66 public:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	67 GCHeapLog() : EventLogBase<GCMessage>("GC Heap History") {}
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	68
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	69 void log_heap_before() {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	70 log_heap(true);
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	71 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	72 void log_heap_after() {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	73 log_heap(false);
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	74 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	75 };
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	76
0 a61af66fc99e Initial load duke parents: diff changeset	77 //
a61af66fc99e Initial load duke parents: diff changeset	78 // CollectedHeap
a61af66fc99e Initial load duke parents: diff changeset	79 // SharedHeap
a61af66fc99e Initial load duke parents: diff changeset	80 // GenCollectedHeap
a61af66fc99e Initial load duke parents: diff changeset	81 // G1CollectedHeap
a61af66fc99e Initial load duke parents: diff changeset	82 // ParallelScavengeHeap
a61af66fc99e Initial load duke parents: diff changeset	83 //
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6008 diff changeset	84 class CollectedHeap : public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	85 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	86 friend class IsGCActiveMark; // Block structured external access to _is_gc_active
a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	89 static int _fire_out_of_memory_count;
a61af66fc99e Initial load duke parents: diff changeset	90 #endif
a61af66fc99e Initial load duke parents: diff changeset	91
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	92 // Used for filler objects (static, but initialized in ctor).
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	93 static size_t _filler_array_max_size;
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	94
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	95 GCHeapLog* _gc_heap_log;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	96
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	97 // Used in support of ReduceInitialCardMarks; only consulted if COMPILER2 is being used
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	98 bool _defer_initial_card_mark;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	99
0 a61af66fc99e Initial load duke parents: diff changeset	100 protected:
a61af66fc99e Initial load duke parents: diff changeset	101 MemRegion _reserved;
a61af66fc99e Initial load duke parents: diff changeset	102 BarrierSet* _barrier_set;
a61af66fc99e Initial load duke parents: diff changeset	103 bool _is_gc_active;
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4708 diff changeset	104 uint _n_par_threads;
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	105
0 a61af66fc99e Initial load duke parents: diff changeset	106 unsigned int _total_collections; // ... started
a61af66fc99e Initial load duke parents: diff changeset	107 unsigned int _total_full_collections; // ... started
a61af66fc99e Initial load duke parents: diff changeset	108 NOT_PRODUCT(volatile size_t _promotion_failure_alot_count;)
a61af66fc99e Initial load duke parents: diff changeset	109 NOT_PRODUCT(volatile size_t _promotion_failure_alot_gc_number;)
a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 // Reason for current garbage collection. Should be set to
a61af66fc99e Initial load duke parents: diff changeset	112 // a value reflecting no collection between collections.
a61af66fc99e Initial load duke parents: diff changeset	113 GCCause::Cause _gc_cause;
a61af66fc99e Initial load duke parents: diff changeset	114 GCCause::Cause _gc_lastcause;
a61af66fc99e Initial load duke parents: diff changeset	115 PerfStringVariable* _perf_gc_cause;
a61af66fc99e Initial load duke parents: diff changeset	116 PerfStringVariable* _perf_gc_lastcause;
a61af66fc99e Initial load duke parents: diff changeset	117
a61af66fc99e Initial load duke parents: diff changeset	118 // Constructor
a61af66fc99e Initial load duke parents: diff changeset	119 CollectedHeap();
a61af66fc99e Initial load duke parents: diff changeset	120
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	121 // Do common initializations that must follow instance construction,
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	122 // for example, those needing virtual calls.
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	123 // This code could perhaps be moved into initialize() but would
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	124 // be slightly more awkward because we want the latter to be a
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	125 // pure virtual.
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	126 void pre_initialize();
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	127
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	128 // Create a new tlab. All TLAB allocations must go through this.
0 a61af66fc99e Initial load duke parents: diff changeset	129 virtual HeapWord* allocate_new_tlab(size_t size);
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131 // Accumulate statistics on all tlabs.
a61af66fc99e Initial load duke parents: diff changeset	132 virtual void accumulate_statistics_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	133
a61af66fc99e Initial load duke parents: diff changeset	134 // Reinitialize tlabs before resuming mutators.
a61af66fc99e Initial load duke parents: diff changeset	135 virtual void resize_all_tlabs();
a61af66fc99e Initial load duke parents: diff changeset	136
a61af66fc99e Initial load duke parents: diff changeset	137 // Allocate from the current thread's TLAB, with broken-out slow path.
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	138 inline static HeapWord* allocate_from_tlab(KlassHandle klass, Thread* thread, size_t size);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	139 static HeapWord* allocate_from_tlab_slow(KlassHandle klass, Thread* thread, size_t size);
0 a61af66fc99e Initial load duke parents: diff changeset	140
a61af66fc99e Initial load duke parents: diff changeset	141 // Allocate an uninitialized block of the given size, or returns NULL if
a61af66fc99e Initial load duke parents: diff changeset	142 // this is impossible.
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	143 inline static HeapWord* common_mem_allocate_noinit(KlassHandle klass, size_t size, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145 // Like allocate_init, but the block returned by a successful allocation
a61af66fc99e Initial load duke parents: diff changeset	146 // is guaranteed initialized to zeros.
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	147 inline static HeapWord* common_mem_allocate_init(KlassHandle klass, size_t size, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 // Helper functions for (VM) allocation.
5972 9a9bb0010c91 7156764: Remove unused size parameter from some CollectedHeap methods brutisso parents: 5965 diff changeset	150 inline static void post_allocation_setup_common(KlassHandle klass, HeapWord* obj);
0 a61af66fc99e Initial load duke parents: diff changeset	151 inline static void post_allocation_setup_no_klass_install(KlassHandle klass,
5972 9a9bb0010c91 7156764: Remove unused size parameter from some CollectedHeap methods brutisso parents: 5965 diff changeset	152 HeapWord* objPtr);
0 a61af66fc99e Initial load duke parents: diff changeset	153
5972 9a9bb0010c91 7156764: Remove unused size parameter from some CollectedHeap methods brutisso parents: 5965 diff changeset	154 inline static void post_allocation_setup_obj(KlassHandle klass, HeapWord* obj);
0 a61af66fc99e Initial load duke parents: diff changeset	155
a61af66fc99e Initial load duke parents: diff changeset	156 inline static void post_allocation_setup_array(KlassHandle klass,
5972 9a9bb0010c91 7156764: Remove unused size parameter from some CollectedHeap methods brutisso parents: 5965 diff changeset	157 HeapWord* obj, int length);
0 a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 // Clears an allocated object.
a61af66fc99e Initial load duke parents: diff changeset	160 inline static void init_obj(HeapWord* obj, size_t size);
a61af66fc99e Initial load duke parents: diff changeset	161
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	162 // Filler object utilities.
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	163 static inline size_t filler_array_hdr_size();
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	164 static inline size_t filler_array_min_size();
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	165
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	166 DEBUG_ONLY(static void fill_args_check(HeapWord* start, size_t words);)
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1027 diff changeset	167 DEBUG_ONLY(static void zap_filler_array(HeapWord* start, size_t words, bool zap = true);)
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	168
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	169 // Fill with a single array; caller must ensure filler_array_min_size() <=
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	170 // words <= filler_array_max_size().
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1027 diff changeset	171 static inline void fill_with_array(HeapWord* start, size_t words, bool zap = true);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	172
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	173 // Fill with a single object (either an int array or a java.lang.Object).
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1027 diff changeset	174 static inline void fill_with_object_impl(HeapWord* start, size_t words, bool zap = true);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	175
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	176 virtual void trace_heap(GCWhen::Type when, GCTracer* tracer);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	177
0 a61af66fc99e Initial load duke parents: diff changeset	178 // Verification functions
a61af66fc99e Initial load duke parents: diff changeset	179 virtual void check_for_bad_heap_word_value(HeapWord* addr, size_t size)
a61af66fc99e Initial load duke parents: diff changeset	180 PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	181 virtual void check_for_non_bad_heap_word_value(HeapWord* addr, size_t size)
a61af66fc99e Initial load duke parents: diff changeset	182 PRODUCT_RETURN;
542 9a25e0c45327 6792421: assert(_bitMap->isMarked(addr+size-1),inconsistent Printezis mark) jmasa parents: 517 diff changeset	183 debug_only(static void check_for_valid_allocation_state();)
0 a61af66fc99e Initial load duke parents: diff changeset	184
a61af66fc99e Initial load duke parents: diff changeset	185 public:
a61af66fc99e Initial load duke parents: diff changeset	186 enum Name {
a61af66fc99e Initial load duke parents: diff changeset	187 Abstract,
a61af66fc99e Initial load duke parents: diff changeset	188 SharedHeap,
a61af66fc99e Initial load duke parents: diff changeset	189 GenCollectedHeap,
a61af66fc99e Initial load duke parents: diff changeset	190 ParallelScavengeHeap,
a61af66fc99e Initial load duke parents: diff changeset	191 G1CollectedHeap
a61af66fc99e Initial load duke parents: diff changeset	192 };
a61af66fc99e Initial load duke parents: diff changeset	193
5965 cc74fa5a91a9 7103665: HeapWordParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97 brutisso* parents: 4872 diff changeset	194 static inline size_t filler_array_max_size() {
cc74fa5a91a9 7103665: HeapWordParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97 brutisso* parents: 4872 diff changeset	195 return _filler_array_max_size;
cc74fa5a91a9 7103665: HeapWordParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97 brutisso* parents: 4872 diff changeset	196 }
cc74fa5a91a9 7103665: HeapWordParallelScavengeHeap::failed_mem_allocate(unsigned long,bool)+0x97 brutisso* parents: 4872 diff changeset	197
0 a61af66fc99e Initial load duke parents: diff changeset	198 virtual CollectedHeap::Name kind() const { return CollectedHeap::Abstract; }
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 /**
a61af66fc99e Initial load duke parents: diff changeset	201 * Returns JNI error code JNI_ENOMEM if memory could not be allocated,
a61af66fc99e Initial load duke parents: diff changeset	202 * and JNI_OK on success.
a61af66fc99e Initial load duke parents: diff changeset	203 */
a61af66fc99e Initial load duke parents: diff changeset	204 virtual jint initialize() = 0;
a61af66fc99e Initial load duke parents: diff changeset	205
a61af66fc99e Initial load duke parents: diff changeset	206 // In many heaps, there will be a need to perform some initialization activities
a61af66fc99e Initial load duke parents: diff changeset	207 // after the Universe is fully formed, but before general heap allocation is allowed.
a61af66fc99e Initial load duke parents: diff changeset	208 // This is the correct place to place such initialization methods.
a61af66fc99e Initial load duke parents: diff changeset	209 virtual void post_initialize() = 0;
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 MemRegion reserved_region() const { return _reserved; }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	212 address base() const { return (address)reserved_region().start(); }
0 a61af66fc99e Initial load duke parents: diff changeset	213
a61af66fc99e Initial load duke parents: diff changeset	214 virtual size_t capacity() const = 0;
a61af66fc99e Initial load duke parents: diff changeset	215 virtual size_t used() const = 0;
a61af66fc99e Initial load duke parents: diff changeset	216
a61af66fc99e Initial load duke parents: diff changeset	217 // Return "true" if the part of the heap that allocates Java
a61af66fc99e Initial load duke parents: diff changeset	218 // objects has reached the maximal committed limit that it can
a61af66fc99e Initial load duke parents: diff changeset	219 // reach, without a garbage collection.
a61af66fc99e Initial load duke parents: diff changeset	220 virtual bool is_maximal_no_gc() const = 0;
a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 // Support for java.lang.Runtime.maxMemory(): return the maximum amount of
a61af66fc99e Initial load duke parents: diff changeset	223 // memory that the vm could make available for storing 'normal' java objects.
a61af66fc99e Initial load duke parents: diff changeset	224 // This is based on the reserved address space, but should not include space
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	225 // that the vm uses internally for bookkeeping or temporary storage
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	226 // (e.g., in the case of the young gen, one of the survivor
0 a61af66fc99e Initial load duke parents: diff changeset	227 // spaces).
a61af66fc99e Initial load duke parents: diff changeset	228 virtual size_t max_capacity() const = 0;
a61af66fc99e Initial load duke parents: diff changeset	229
a61af66fc99e Initial load duke parents: diff changeset	230 // Returns "TRUE" if "p" points into the reserved area of the heap.
a61af66fc99e Initial load duke parents: diff changeset	231 bool is_in_reserved(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	232 return _reserved.contains(p);
a61af66fc99e Initial load duke parents: diff changeset	233 }
a61af66fc99e Initial load duke parents: diff changeset	234
a61af66fc99e Initial load duke parents: diff changeset	235 bool is_in_reserved_or_null(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	236 return p == NULL \|\| is_in_reserved(p);
a61af66fc99e Initial load duke parents: diff changeset	237 }
a61af66fc99e Initial load duke parents: diff changeset	238
4708 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4073 diff changeset	239 // Returns "TRUE" iff "p" points into the committed areas of the heap.
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4073 diff changeset	240 // Since this method can be expensive in general, we restrict its
0 a61af66fc99e Initial load duke parents: diff changeset	241 // use to assertion checking only.
a61af66fc99e Initial load duke parents: diff changeset	242 virtual bool is_in(const void* p) const = 0;
a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 bool is_in_or_null(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	245 return p == NULL \|\| is_in(p);
a61af66fc99e Initial load duke parents: diff changeset	246 }
a61af66fc99e Initial load duke parents: diff changeset	247
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	248 bool is_in_place(Metadata** p) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	249 return !Universe::heap()->is_in(p);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	250 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	251 bool is_in_place(oop* p) { return Universe::heap()->is_in(p); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	252 bool is_in_place(narrowOop* p) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	253 oop o = oopDesc::load_decode_heap_oop_not_null(p);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	254 return Universe::heap()->is_in((const void*)o);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	255 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	256
0 a61af66fc99e Initial load duke parents: diff changeset	257 // Let's define some terms: a "closed" subset of a heap is one that
a61af66fc99e Initial load duke parents: diff changeset	258 //
a61af66fc99e Initial load duke parents: diff changeset	259 // 1) contains all currently-allocated objects, and
a61af66fc99e Initial load duke parents: diff changeset	260 //
a61af66fc99e Initial load duke parents: diff changeset	261 // 2) is closed under reference: no object in the closed subset
a61af66fc99e Initial load duke parents: diff changeset	262 // references one outside the closed subset.
a61af66fc99e Initial load duke parents: diff changeset	263 //
a61af66fc99e Initial load duke parents: diff changeset	264 // Membership in a heap's closed subset is useful for assertions.
a61af66fc99e Initial load duke parents: diff changeset	265 // Clearly, the entire heap is a closed subset, so the default
a61af66fc99e Initial load duke parents: diff changeset	266 // implementation is to use "is_in_reserved". But this may not be too
a61af66fc99e Initial load duke parents: diff changeset	267 // liberal to perform useful checking. Also, the "is_in" predicate
a61af66fc99e Initial load duke parents: diff changeset	268 // defines a closed subset, but may be too expensive, since "is_in"
a61af66fc99e Initial load duke parents: diff changeset	269 // verifies that its argument points to an object head. The
a61af66fc99e Initial load duke parents: diff changeset	270 // "closed_subset" method allows a heap to define an intermediate
a61af66fc99e Initial load duke parents: diff changeset	271 // predicate, allowing more precise checking than "is_in_reserved" at
a61af66fc99e Initial load duke parents: diff changeset	272 // lower cost than "is_in."
a61af66fc99e Initial load duke parents: diff changeset	273
a61af66fc99e Initial load duke parents: diff changeset	274 // One important case is a heap composed of disjoint contiguous spaces,
a61af66fc99e Initial load duke parents: diff changeset	275 // such as the Garbage-First collector. Such heaps have a convenient
a61af66fc99e Initial load duke parents: diff changeset	276 // closed subset consisting of the allocated portions of those
a61af66fc99e Initial load duke parents: diff changeset	277 // contiguous spaces.
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 // Return "TRUE" iff the given pointer points into the heap's defined
a61af66fc99e Initial load duke parents: diff changeset	280 // closed subset (which defaults to the entire heap).
a61af66fc99e Initial load duke parents: diff changeset	281 virtual bool is_in_closed_subset(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	282 return is_in_reserved(p);
a61af66fc99e Initial load duke parents: diff changeset	283 }
a61af66fc99e Initial load duke parents: diff changeset	284
a61af66fc99e Initial load duke parents: diff changeset	285 bool is_in_closed_subset_or_null(const void* p) const {
a61af66fc99e Initial load duke parents: diff changeset	286 return p == NULL \|\| is_in_closed_subset(p);
a61af66fc99e Initial load duke parents: diff changeset	287 }
a61af66fc99e Initial load duke parents: diff changeset	288
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	289 #ifdef ASSERT
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	290 // Returns true if "p" is in the part of the
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	291 // heap being collected.
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	292 virtual bool is_in_partial_collection(const void *p) = 0;
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	293 #endif
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	294
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	295 // An object is scavengable if its location may move during a scavenge.
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	296 // (A scavenge is a GC which is not a full GC.)
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 1972 diff changeset	297 virtual bool is_scavengable(const void *p) = 0;
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 845 diff changeset	298
0 a61af66fc99e Initial load duke parents: diff changeset	299 void set_gc_cause(GCCause::Cause v) {
a61af66fc99e Initial load duke parents: diff changeset	300 if (UsePerfData) {
a61af66fc99e Initial load duke parents: diff changeset	301 _gc_lastcause = _gc_cause;
a61af66fc99e Initial load duke parents: diff changeset	302 _perf_gc_lastcause->set_value(GCCause::to_string(_gc_lastcause));
a61af66fc99e Initial load duke parents: diff changeset	303 _perf_gc_cause->set_value(GCCause::to_string(v));
a61af66fc99e Initial load duke parents: diff changeset	304 }
a61af66fc99e Initial load duke parents: diff changeset	305 _gc_cause = v;
a61af66fc99e Initial load duke parents: diff changeset	306 }
a61af66fc99e Initial load duke parents: diff changeset	307 GCCause::Cause gc_cause() { return _gc_cause; }
a61af66fc99e Initial load duke parents: diff changeset	308
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	309 // Number of threads currently working on GC tasks.
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4708 diff changeset	310 uint n_par_threads() { return _n_par_threads; }
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	311
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	312 // May be overridden to set additional parallelism.
4728 441e946dc1af 7121618: Change type of number of GC workers to unsigned int. jmasa parents: 4708 diff changeset	313 virtual void set_par_threads(uint t) { _n_par_threads = t; };
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	314
4009 e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3961 diff changeset	315 // Allocate and initialize instances of Class
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3961 diff changeset	316 static oop Class_obj_allocate(KlassHandle klass, int size, KlassHandle real_klass, TRAPS);
e5928e7dab26 7098528: crash with java -XX:+ExtendedDTraceProbes never parents: 3961 diff changeset	317
0 a61af66fc99e Initial load duke parents: diff changeset	318 // General obj/array allocation facilities.
a61af66fc99e Initial load duke parents: diff changeset	319 inline static oop obj_allocate(KlassHandle klass, int size, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	320 inline static oop array_allocate(KlassHandle klass, int size, int length, TRAPS);
3961 a92cdbac8b9e 7081933: Use zeroing elimination optimization for large array kvn parents: 3774 diff changeset	321 inline static oop array_allocate_nozero(KlassHandle klass, int size, int length, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	322
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	323 inline static void post_allocation_install_obj_klass(KlassHandle klass,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	324 oop obj);
0 a61af66fc99e Initial load duke parents: diff changeset	325
a61af66fc99e Initial load duke parents: diff changeset	326 // Raw memory allocation facilities
a61af66fc99e Initial load duke parents: diff changeset	327 // The obj and array allocate methods are covers for these methods.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	328 // mem_allocate() should never be
3774 c9ca3f51cf41 6994322: Remove the is_tlab and is_noref / is_large_noref parameters from the CollectedHeap tonyp parents: 3772 diff changeset	329 // called to allocate TLABs, only individual objects.
0 a61af66fc99e Initial load duke parents: diff changeset	330 virtual HeapWord* mem_allocate(size_t size,
a61af66fc99e Initial load duke parents: diff changeset	331 bool* gc_overhead_limit_was_exceeded) = 0;
a61af66fc99e Initial load duke parents: diff changeset	332
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	333 // Utilities for turning raw memory into filler objects.
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	334 //
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	335 // min_fill_size() is the smallest region that can be filled.
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	336 // fill_with_objects() can fill arbitrary-sized regions of the heap using
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	337 // multiple objects. fill_with_object() is for regions known to be smaller
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	338 // than the largest array of integers; it uses a single object to fill the
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	339 // region and has slightly less overhead.
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	340 static size_t min_fill_size() {
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	341 return size_t(align_object_size(oopDesc::header_size()));
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	342 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	343
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1027 diff changeset	344 static void fill_with_objects(HeapWord* start, size_t words, bool zap = true);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	345
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1027 diff changeset	346 static void fill_with_object(HeapWord* start, size_t words, bool zap = true);
2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1027 diff changeset	347 static void fill_with_object(MemRegion region, bool zap = true) {
2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1027 diff changeset	348 fill_with_object(region.start(), region.word_size(), zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	349 }
1165 2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1027 diff changeset	350 static void fill_with_object(HeapWord* start, HeapWord* end, bool zap = true) {
2dd52dea6d28 6902115: G1:assert(ignore_max_completed\|\|thread->is_Java_thread()\|\|SafepointSynchronize::is_at_safepoint()) johnc parents: 1027 diff changeset	351 fill_with_object(start, pointer_delta(end, start), zap);
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	352 }
7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 356 diff changeset	353
0 a61af66fc99e Initial load duke parents: diff changeset	354 // Some heaps may offer a contiguous region for shared non-blocking
a61af66fc99e Initial load duke parents: diff changeset	355 // allocation, via inlined code (by exporting the address of the top and
a61af66fc99e Initial load duke parents: diff changeset	356 // end fields defining the extent of the contiguous allocation region.)
a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358 // This function returns "true" iff the heap supports this kind of
a61af66fc99e Initial load duke parents: diff changeset	359 // allocation. (Default is "no".)
a61af66fc99e Initial load duke parents: diff changeset	360 virtual bool supports_inline_contig_alloc() const {
a61af66fc99e Initial load duke parents: diff changeset	361 return false;
a61af66fc99e Initial load duke parents: diff changeset	362 }
a61af66fc99e Initial load duke parents: diff changeset	363 // These functions return the addresses of the fields that define the
a61af66fc99e Initial load duke parents: diff changeset	364 // boundaries of the contiguous allocation area. (These fields should be
a61af66fc99e Initial load duke parents: diff changeset	365 // physically near to one another.)
a61af66fc99e Initial load duke parents: diff changeset	366 virtual HeapWord** top_addr() const {
a61af66fc99e Initial load duke parents: diff changeset	367 guarantee(false, "inline contiguous allocation not supported");
a61af66fc99e Initial load duke parents: diff changeset	368 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	369 }
a61af66fc99e Initial load duke parents: diff changeset	370 virtual HeapWord** end_addr() const {
a61af66fc99e Initial load duke parents: diff changeset	371 guarantee(false, "inline contiguous allocation not supported");
a61af66fc99e Initial load duke parents: diff changeset	372 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	373 }
a61af66fc99e Initial load duke parents: diff changeset	374
a61af66fc99e Initial load duke parents: diff changeset	375 // Some heaps may be in an unparseable state at certain times between
a61af66fc99e Initial load duke parents: diff changeset	376 // collections. This may be necessary for efficient implementation of
a61af66fc99e Initial load duke parents: diff changeset	377 // certain allocation-related activities. Calling this function before
a61af66fc99e Initial load duke parents: diff changeset	378 // attempting to parse a heap ensures that the heap is in a parsable
a61af66fc99e Initial load duke parents: diff changeset	379 // state (provided other concurrent activity does not introduce
a61af66fc99e Initial load duke parents: diff changeset	380 // unparsability). It is normally expected, therefore, that this
a61af66fc99e Initial load duke parents: diff changeset	381 // method is invoked with the world stopped.
a61af66fc99e Initial load duke parents: diff changeset	382 // NOTE: if you override this method, make sure you call
a61af66fc99e Initial load duke parents: diff changeset	383 // super::ensure_parsability so that the non-generational
a61af66fc99e Initial load duke parents: diff changeset	384 // part of the work gets done. See implementation of
a61af66fc99e Initial load duke parents: diff changeset	385 // CollectedHeap::ensure_parsability and, for instance,
a61af66fc99e Initial load duke parents: diff changeset	386 // that of GenCollectedHeap::ensure_parsability().
a61af66fc99e Initial load duke parents: diff changeset	387 // The argument "retire_tlabs" controls whether existing TLABs
a61af66fc99e Initial load duke parents: diff changeset	388 // are merely filled or also retired, thus preventing further
a61af66fc99e Initial load duke parents: diff changeset	389 // allocation from them and necessitating allocation of new TLABs.
a61af66fc99e Initial load duke parents: diff changeset	390 virtual void ensure_parsability(bool retire_tlabs);
a61af66fc99e Initial load duke parents: diff changeset	391
a61af66fc99e Initial load duke parents: diff changeset	392 // Return an estimate of the maximum allocation that could be performed
a61af66fc99e Initial load duke parents: diff changeset	393 // without triggering any collection or expansion activity. In a
a61af66fc99e Initial load duke parents: diff changeset	394 // generational collector, for example, this is probably the largest
a61af66fc99e Initial load duke parents: diff changeset	395 // allocation that could be supported (without expansion) in the youngest
a61af66fc99e Initial load duke parents: diff changeset	396 // generation. It is "unsafe" because no locks are taken; the result
a61af66fc99e Initial load duke parents: diff changeset	397 // should be treated as an approximation, not a guarantee, for use in
a61af66fc99e Initial load duke parents: diff changeset	398 // heuristic resizing decisions.
a61af66fc99e Initial load duke parents: diff changeset	399 virtual size_t unsafe_max_alloc() = 0;
a61af66fc99e Initial load duke parents: diff changeset	400
a61af66fc99e Initial load duke parents: diff changeset	401 // Section on thread-local allocation buffers (TLABs)
a61af66fc99e Initial load duke parents: diff changeset	402 // If the heap supports thread-local allocation buffers, it should override
a61af66fc99e Initial load duke parents: diff changeset	403 // the following methods:
a61af66fc99e Initial load duke parents: diff changeset	404 // Returns "true" iff the heap supports thread-local allocation buffers.
a61af66fc99e Initial load duke parents: diff changeset	405 // The default is "no".
a61af66fc99e Initial load duke parents: diff changeset	406 virtual bool supports_tlab_allocation() const {
a61af66fc99e Initial load duke parents: diff changeset	407 return false;
a61af66fc99e Initial load duke parents: diff changeset	408 }
a61af66fc99e Initial load duke parents: diff changeset	409 // The amount of space available for thread-local allocation buffers.
a61af66fc99e Initial load duke parents: diff changeset	410 virtual size_t tlab_capacity(Thread *thr) const {
a61af66fc99e Initial load duke parents: diff changeset	411 guarantee(false, "thread-local allocation buffers not supported");
a61af66fc99e Initial load duke parents: diff changeset	412 return 0;
a61af66fc99e Initial load duke parents: diff changeset	413 }
a61af66fc99e Initial load duke parents: diff changeset	414 // An estimate of the maximum allocation that could be performed
a61af66fc99e Initial load duke parents: diff changeset	415 // for thread-local allocation buffers without triggering any
a61af66fc99e Initial load duke parents: diff changeset	416 // collection or expansion activity.
a61af66fc99e Initial load duke parents: diff changeset	417 virtual size_t unsafe_max_tlab_alloc(Thread *thr) const {
a61af66fc99e Initial load duke parents: diff changeset	418 guarantee(false, "thread-local allocation buffers not supported");
a61af66fc99e Initial load duke parents: diff changeset	419 return 0;
a61af66fc99e Initial load duke parents: diff changeset	420 }
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	421
0 a61af66fc99e Initial load duke parents: diff changeset	422 // Can a compiler initialize a new object without store barriers?
a61af66fc99e Initial load duke parents: diff changeset	423 // This permission only extends from the creation of a new object
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	424 // via a TLAB up to the first subsequent safepoint. If such permission
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	425 // is granted for this heap type, the compiler promises to call
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	426 // defer_store_barrier() below on any slow path allocation of
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	427 // a new object for which such initializing store barriers will
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	428 // have been elided.
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	429 virtual bool can_elide_tlab_store_barriers() const = 0;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	430
0 a61af66fc99e Initial load duke parents: diff changeset	431 // If a compiler is eliding store barriers for TLAB-allocated objects,
a61af66fc99e Initial load duke parents: diff changeset	432 // there is probably a corresponding slow path which can produce
a61af66fc99e Initial load duke parents: diff changeset	433 // an object allocated anywhere. The compiler's runtime support
a61af66fc99e Initial load duke parents: diff changeset	434 // promises to call this function on such a slow-path-allocated
a61af66fc99e Initial load duke parents: diff changeset	435 // object before performing initializations that have elided
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	436 // store barriers. Returns new_obj, or maybe a safer copy thereof.
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	437 virtual oop new_store_pre_barrier(JavaThread* thread, oop new_obj);
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	438
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	439 // Answers whether an initializing store to a new object currently
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	440 // allocated at the given address doesn't need a store
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	441 // barrier. Returns "true" if it doesn't need an initializing
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	442 // store barrier; answers "false" if it does.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	443 virtual bool can_elide_initializing_store_barrier(oop new_obj) = 0;
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	444
1166 7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	445 // If a compiler is eliding store barriers for TLAB-allocated objects,
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	446 // we will be informed of a slow-path allocation by a call
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	447 // to new_store_pre_barrier() above. Such a call precedes the
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	448 // initialization of the object itself, and no post-store-barriers will
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	449 // be issued. Some heap types require that the barrier strictly follows
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	450 // the initializing stores. (This is currently implemented by deferring the
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	451 // barrier until the next slow-path allocation or gc-related safepoint.)
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	452 // This interface answers whether a particular heap type needs the card
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	453 // mark to be thus strictly sequenced after the stores.
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	454 virtual bool card_mark_must_follow_store() const = 0;
7b0e9cba0307 6896647: card marks can be deferred too long ysr parents: 1165 diff changeset	455
1027 39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	456 // If the CollectedHeap was asked to defer a store barrier above,
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	457 // this informs it to flush such a deferred store barrier to the
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	458 // remembered set.
39b01ab7035a 6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning ysr parents: 993 diff changeset	459 virtual void flush_deferred_store_barrier(JavaThread* thread);
0 a61af66fc99e Initial load duke parents: diff changeset	460
a61af66fc99e Initial load duke parents: diff changeset	461 // Does this heap support heap inspection (+PrintClassHistogram?)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	462 virtual bool supports_heap_inspection() const = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	463
a61af66fc99e Initial load duke parents: diff changeset	464 // Perform a collection of the heap; intended for use in implementing
a61af66fc99e Initial load duke parents: diff changeset	465 // "System.gc". This probably implies as full a collection as the
a61af66fc99e Initial load duke parents: diff changeset	466 // "CollectedHeap" supports.
a61af66fc99e Initial load duke parents: diff changeset	467 virtual void collect(GCCause::Cause cause) = 0;
a61af66fc99e Initial load duke parents: diff changeset	468
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	469 // Perform a full collection
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	470 virtual void do_full_collection(bool clear_all_soft_refs) = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	471
0 a61af66fc99e Initial load duke parents: diff changeset	472 // This interface assumes that it's being called by the
a61af66fc99e Initial load duke parents: diff changeset	473 // vm thread. It collects the heap assuming that the
a61af66fc99e Initial load duke parents: diff changeset	474 // heap lock is already held and that we are executing in
a61af66fc99e Initial load duke parents: diff changeset	475 // the context of the vm thread.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	476 virtual void collect_as_vm_thread(GCCause::Cause cause);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	477
0 a61af66fc99e Initial load duke parents: diff changeset	478 // Returns the barrier set for this heap
a61af66fc99e Initial load duke parents: diff changeset	479 BarrierSet* barrier_set() { return _barrier_set; }
a61af66fc99e Initial load duke parents: diff changeset	480
a61af66fc99e Initial load duke parents: diff changeset	481 // Returns "true" iff there is a stop-world GC in progress. (I assume
a61af66fc99e Initial load duke parents: diff changeset	482 // that it should answer "false" for the concurrent part of a concurrent
a61af66fc99e Initial load duke parents: diff changeset	483 // collector -- dld).
a61af66fc99e Initial load duke parents: diff changeset	484 bool is_gc_active() const { return _is_gc_active; }
a61af66fc99e Initial load duke parents: diff changeset	485
a61af66fc99e Initial load duke parents: diff changeset	486 // Total number of GC collections (started)
a61af66fc99e Initial load duke parents: diff changeset	487 unsigned int total_collections() const { return _total_collections; }
a61af66fc99e Initial load duke parents: diff changeset	488 unsigned int total_full_collections() const { return _total_full_collections;}
a61af66fc99e Initial load duke parents: diff changeset	489
a61af66fc99e Initial load duke parents: diff changeset	490 // Increment total number of GC collections (started)
a61af66fc99e Initial load duke parents: diff changeset	491 // Should be protected but used by PSMarkSweep - cleanup for 1.4.2
a61af66fc99e Initial load duke parents: diff changeset	492 void increment_total_collections(bool full = false) {
a61af66fc99e Initial load duke parents: diff changeset	493 _total_collections++;
a61af66fc99e Initial load duke parents: diff changeset	494 if (full) {
a61af66fc99e Initial load duke parents: diff changeset	495 increment_total_full_collections();
a61af66fc99e Initial load duke parents: diff changeset	496 }
a61af66fc99e Initial load duke parents: diff changeset	497 }
a61af66fc99e Initial load duke parents: diff changeset	498
a61af66fc99e Initial load duke parents: diff changeset	499 void increment_total_full_collections() { _total_full_collections++; }
a61af66fc99e Initial load duke parents: diff changeset	500
a61af66fc99e Initial load duke parents: diff changeset	501 // Return the AdaptiveSizePolicy for the heap.
a61af66fc99e Initial load duke parents: diff changeset	502 virtual AdaptiveSizePolicy* size_policy() = 0;
a61af66fc99e Initial load duke parents: diff changeset	503
1387 0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	504 // Return the CollectorPolicy for the heap
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	505 virtual CollectorPolicy* collector_policy() const = 0;
0bfd3fb24150 6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit. jmasa parents: 1166 diff changeset	506
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	507 void oop_iterate_no_header(OopClosure* cl);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	508
0 a61af66fc99e Initial load duke parents: diff changeset	509 // Iterate over all the ref-containing fields of all objects, calling
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	510 // "cl.do_oop" on each.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	511 virtual void oop_iterate(ExtendedOopClosure* cl) = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	512
a61af66fc99e Initial load duke parents: diff changeset	513 // Iterate over all objects, calling "cl.do_object" on each.
a61af66fc99e Initial load duke parents: diff changeset	514 virtual void object_iterate(ObjectClosure* cl) = 0;
a61af66fc99e Initial load duke parents: diff changeset	515
517 e9be0e04635a 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off jmasa parents: 481 diff changeset	516 // Similar to object_iterate() except iterates only
e9be0e04635a 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off jmasa parents: 481 diff changeset	517 // over live objects.
e9be0e04635a 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off jmasa parents: 481 diff changeset	518 virtual void safe_object_iterate(ObjectClosure* cl) = 0;
e9be0e04635a 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off jmasa parents: 481 diff changeset	519
0 a61af66fc99e Initial load duke parents: diff changeset	520 // NOTE! There is no requirement that a collector implement these
a61af66fc99e Initial load duke parents: diff changeset	521 // functions.
a61af66fc99e Initial load duke parents: diff changeset	522 //
a61af66fc99e Initial load duke parents: diff changeset	523 // A CollectedHeap is divided into a dense sequence of "blocks"; that is,
a61af66fc99e Initial load duke parents: diff changeset	524 // each address in the (reserved) heap is a member of exactly
a61af66fc99e Initial load duke parents: diff changeset	525 // one block. The defining characteristic of a block is that it is
a61af66fc99e Initial load duke parents: diff changeset	526 // possible to find its size, and thus to progress forward to the next
a61af66fc99e Initial load duke parents: diff changeset	527 // block. (Blocks may be of different sizes.) Thus, blocks may
a61af66fc99e Initial load duke parents: diff changeset	528 // represent Java objects, or they might be free blocks in a
a61af66fc99e Initial load duke parents: diff changeset	529 // free-list-based heap (or subheap), as long as the two kinds are
a61af66fc99e Initial load duke parents: diff changeset	530 // distinguishable and the size of each is determinable.
a61af66fc99e Initial load duke parents: diff changeset	531
a61af66fc99e Initial load duke parents: diff changeset	532 // Returns the address of the start of the "block" that contains the
a61af66fc99e Initial load duke parents: diff changeset	533 // address "addr". We say "blocks" instead of "object" since some heaps
a61af66fc99e Initial load duke parents: diff changeset	534 // may not pack objects densely; a chunk may either be an object or a
a61af66fc99e Initial load duke parents: diff changeset	535 // non-object.
a61af66fc99e Initial load duke parents: diff changeset	536 virtual HeapWord* block_start(const void* addr) const = 0;
a61af66fc99e Initial load duke parents: diff changeset	537
a61af66fc99e Initial load duke parents: diff changeset	538 // Requires "addr" to be the start of a chunk, and returns its size.
a61af66fc99e Initial load duke parents: diff changeset	539 // "addr + size" is required to be the start of a new chunk, or the end
a61af66fc99e Initial load duke parents: diff changeset	540 // of the active area of the heap.
a61af66fc99e Initial load duke parents: diff changeset	541 virtual size_t block_size(const HeapWord* addr) const = 0;
a61af66fc99e Initial load duke parents: diff changeset	542
a61af66fc99e Initial load duke parents: diff changeset	543 // Requires "addr" to be the start of a block, and returns "TRUE" iff
a61af66fc99e Initial load duke parents: diff changeset	544 // the block is an object.
a61af66fc99e Initial load duke parents: diff changeset	545 virtual bool block_is_obj(const HeapWord* addr) const = 0;
a61af66fc99e Initial load duke parents: diff changeset	546
a61af66fc99e Initial load duke parents: diff changeset	547 // Returns the longest time (in ms) that has elapsed since the last
a61af66fc99e Initial load duke parents: diff changeset	548 // time that any part of the heap was examined by a garbage collection.
a61af66fc99e Initial load duke parents: diff changeset	549 virtual jlong millis_since_last_gc() = 0;
a61af66fc99e Initial load duke parents: diff changeset	550
a61af66fc99e Initial load duke parents: diff changeset	551 // Perform any cleanup actions necessary before allowing a verification.
a61af66fc99e Initial load duke parents: diff changeset	552 virtual void prepare_for_verify() = 0;
a61af66fc99e Initial load duke parents: diff changeset	553
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 542 diff changeset	554 // Generate any dumps preceding or following a full gc
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	555 void pre_full_gc_dump(GCTimer* timer);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	556 void post_full_gc_dump(GCTimer* timer);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	557
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	558 VirtualSpaceSummary create_heap_space_summary();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	559 GCHeapSummary create_heap_summary();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	560
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	561 MetaspaceSummary create_metaspace_summary();
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 542 diff changeset	562
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	563 // Print heap information on the given outputStream.
0 a61af66fc99e Initial load duke parents: diff changeset	564 virtual void print_on(outputStream* st) const = 0;
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	565 // The default behavior is to call print_on() on tty.
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	566 virtual void print() const {
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	567 print_on(tty);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	568 }
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	569 // Print more detailed heap information on the given
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	570 // outputStream. The default behavior is to call print_on(). It is
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	571 // up to each subclass to override it and add any additional output
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	572 // it needs.
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	573 virtual void print_extended_on(outputStream* st) const {
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	574 print_on(st);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	575 }
0 a61af66fc99e Initial load duke parents: diff changeset	576
9076 7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7176 diff changeset	577 virtual void print_on_error(outputStream* st) const {
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7176 diff changeset	578 st->print_cr("Heap:");
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7176 diff changeset	579 print_extended_on(st);
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7176 diff changeset	580 st->cr();
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7176 diff changeset	581
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7176 diff changeset	582 _barrier_set->print_on(st);
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7176 diff changeset	583 }
7b835924c31c 8011872: Include Bit Map addresses in the hs_err files stefank parents: 7176 diff changeset	584
0 a61af66fc99e Initial load duke parents: diff changeset	585 // Print all GC threads (other than the VM thread)
a61af66fc99e Initial load duke parents: diff changeset	586 // used by this heap.
a61af66fc99e Initial load duke parents: diff changeset	587 virtual void print_gc_threads_on(outputStream* st) const = 0;
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	588 // The default behavior is to call print_gc_threads_on() on tty.
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	589 void print_gc_threads() {
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	590 print_gc_threads_on(tty);
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 4009 diff changeset	591 }
0 a61af66fc99e Initial load duke parents: diff changeset	592 // Iterator for all GC threads (other than VM thread)
a61af66fc99e Initial load duke parents: diff changeset	593 virtual void gc_threads_do(ThreadClosure* tc) const = 0;
a61af66fc99e Initial load duke parents: diff changeset	594
a61af66fc99e Initial load duke parents: diff changeset	595 // Print any relevant tracing info that flags imply.
a61af66fc99e Initial load duke parents: diff changeset	596 // Default implementation does nothing.
a61af66fc99e Initial load duke parents: diff changeset	597 virtual void print_tracing_info() const = 0;
a61af66fc99e Initial load duke parents: diff changeset	598
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	599 void print_heap_before_gc();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	600 void print_heap_after_gc();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	601
12080 5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 10405 diff changeset	602 // Registering and unregistering an nmethod (compiled code) with the heap.
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 10405 diff changeset	603 // Override with specific mechanism for each specialized heap type.
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 10405 diff changeset	604 virtual void register_nmethod(nmethod* nm);
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 10405 diff changeset	605 virtual void unregister_nmethod(nmethod* nm);
5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 10405 diff changeset	606
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	607 void trace_heap_before_gc(GCTracer* gc_tracer);
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	608 void trace_heap_after_gc(GCTracer* gc_tracer);
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4728 diff changeset	609
0 a61af66fc99e Initial load duke parents: diff changeset	610 // Heap verification
6008 b632e80fc9dc 4988100: oop_verify_old_oop appears to be dead brutisso parents: 5972 diff changeset	611 virtual void verify(bool silent, VerifyOption option) = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	612
a61af66fc99e Initial load duke parents: diff changeset	613 // Non product verification and debugging.
a61af66fc99e Initial load duke parents: diff changeset	614 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	615 // Support for PromotionFailureALot. Return true if it's time to cause a
a61af66fc99e Initial load duke parents: diff changeset	616 // promotion failure. The no-argument version uses
a61af66fc99e Initial load duke parents: diff changeset	617 // this->_promotion_failure_alot_count as the counter.
a61af66fc99e Initial load duke parents: diff changeset	618 inline bool promotion_should_fail(volatile size_t* count);
a61af66fc99e Initial load duke parents: diff changeset	619 inline bool promotion_should_fail();
a61af66fc99e Initial load duke parents: diff changeset	620
a61af66fc99e Initial load duke parents: diff changeset	621 // Reset the PromotionFailureALot counters. Should be called at the end of a
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 9076 diff changeset	622 // GC in which promotion failure occurred.
0 a61af66fc99e Initial load duke parents: diff changeset	623 inline void reset_promotion_should_fail(volatile size_t* count);
a61af66fc99e Initial load duke parents: diff changeset	624 inline void reset_promotion_should_fail();
a61af66fc99e Initial load duke parents: diff changeset	625 #endif // #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	626
a61af66fc99e Initial load duke parents: diff changeset	627 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	628 static int fired_fake_oom() {
a61af66fc99e Initial load duke parents: diff changeset	629 return (CIFireOOMAt > 1 && _fire_out_of_memory_count >= CIFireOOMAt);
a61af66fc99e Initial load duke parents: diff changeset	630 }
a61af66fc99e Initial load duke parents: diff changeset	631 #endif
1833 8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	632
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	633 public:
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	634 // This is a convenience method that is used in cases where
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	635 // the actual number of GC worker threads is not pertinent but
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	636 // only whether there more than 0. Use of this method helps
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	637 // reduce the occurrence of ParallelGCThreads to uses where the
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	638 // actual number may be germane.
8b10f48633dc 6984287: Regularize how GC parallel workers are specified. jmasa parents: 1552 diff changeset	639 static bool use_parallel_gc_threads() { return ParallelGCThreads > 0; }
4708 3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4073 diff changeset	640
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4073 diff changeset	641 /////////////// Unit tests ///////////////
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4073 diff changeset	642
3c648b9ad052 7121373: Clean up CollectedHeap::is_in stefank parents: 4073 diff changeset	643 NOT_PRODUCT(static void test_is_in();)
0 a61af66fc99e Initial load duke parents: diff changeset	644 };
a61af66fc99e Initial load duke parents: diff changeset	645
a61af66fc99e Initial load duke parents: diff changeset	646 // Class to set and reset the GC cause for a CollectedHeap.
a61af66fc99e Initial load duke parents: diff changeset	647
a61af66fc99e Initial load duke parents: diff changeset	648 class GCCauseSetter : StackObj {
a61af66fc99e Initial load duke parents: diff changeset	649 CollectedHeap* _heap;
a61af66fc99e Initial load duke parents: diff changeset	650 GCCause::Cause _previous_cause;
a61af66fc99e Initial load duke parents: diff changeset	651 public:
a61af66fc99e Initial load duke parents: diff changeset	652 GCCauseSetter(CollectedHeap* heap, GCCause::Cause cause) {
a61af66fc99e Initial load duke parents: diff changeset	653 assert(SafepointSynchronize::is_at_safepoint(),
a61af66fc99e Initial load duke parents: diff changeset	654 "This method manipulates heap state without locking");
a61af66fc99e Initial load duke parents: diff changeset	655 _heap = heap;
a61af66fc99e Initial load duke parents: diff changeset	656 _previous_cause = _heap->gc_cause();
a61af66fc99e Initial load duke parents: diff changeset	657 _heap->set_gc_cause(cause);
a61af66fc99e Initial load duke parents: diff changeset	658 }
a61af66fc99e Initial load duke parents: diff changeset	659
a61af66fc99e Initial load duke parents: diff changeset	660 ~GCCauseSetter() {
a61af66fc99e Initial load duke parents: diff changeset	661 assert(SafepointSynchronize::is_at_safepoint(),
a61af66fc99e Initial load duke parents: diff changeset	662 "This method manipulates heap state without locking");
a61af66fc99e Initial load duke parents: diff changeset	663 _heap->set_gc_cause(_previous_cause);
a61af66fc99e Initial load duke parents: diff changeset	664 }
a61af66fc99e Initial load duke parents: diff changeset	665 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	666
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1833 diff changeset	667 #endif // SHARE_VM_GC_INTERFACE_COLLECTEDHEAP_HPP

Mercurial > hg > truffle

annotate src/share/vm/gc_interface/collectedHeap.hpp @ 13212:eb03a7335eb0