Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/shared/vmGCOperations.hpp @ 10374:87c64c0438fb
6976350: G1: deal with fragmentation while copying objects during GC
Summary: Create G1ParGCAllocBufferContainer to contain two buffers instead of previously using one buffer, in order to hold the first priority buffer longer. Thus, when some large objects hits the value of free space left in the first priority buffer it has an alternative to fit in the second priority buffer while the first priority buffer is given more chances to try allocating smaller objects. Overall, it will improve heap space efficiency.
Reviewed-by: johnc, jmasa, brutisso
Contributed-by: tamao <tao.mao@oracle.com>
| author | tamao |
|---|---|
| date | Mon, 03 Jun 2013 14:37:13 -0700 |
| parents | 16fb9f942703 |
| children | f2110083203d |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 7956 | 2 * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_VMGCOPERATIONS_HPP |
| 26 #define SHARE_VM_GC_IMPLEMENTATION_SHARED_VMGCOPERATIONS_HPP | |
| 27 | |
| 28 #include "memory/heapInspection.hpp" | |
| 29 #include "runtime/handles.hpp" | |
| 30 #include "runtime/jniHandles.hpp" | |
| 31 #include "runtime/synchronizer.hpp" | |
| 32 #include "runtime/vm_operations.hpp" | |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
33 #include "prims/jvmtiExport.hpp" |
| 1972 | 34 |
| 0 | 35 // The following class hierarchy represents |
| 36 // a set of operations (VM_Operation) related to GC. | |
| 37 // | |
| 38 // VM_Operation | |
| 39 // VM_GC_Operation | |
| 40 // VM_GC_HeapInspection | |
| 41 // VM_GenCollectForAllocation | |
| 42 // VM_GenCollectFull | |
| 43 // VM_GenCollectFullConcurrent | |
| 44 // VM_ParallelGCFailedAllocation | |
| 45 // VM_ParallelGCSystemGC | |
| 46 // VM_GC_Operation | |
| 47 // - implements methods common to all classes in the hierarchy: | |
| 48 // prevents multiple gc requests and manages lock on heap; | |
| 49 // | |
| 50 // VM_GC_HeapInspection | |
| 51 // - prints class histogram on SIGBREAK if PrintClassHistogram | |
| 52 // is specified; and also the attach "inspectheap" operation | |
| 53 // | |
| 54 // VM_GenCollectForAllocation | |
| 55 // VM_ParallelGCFailedAllocation | |
| 56 // - this operation is invoked when allocation is failed; | |
| 57 // operation performs garbage collection and tries to | |
| 58 // allocate afterwards; | |
| 59 // | |
| 60 // VM_GenCollectFull | |
| 61 // VM_GenCollectFullConcurrent | |
| 62 // VM_ParallelGCSystemGC | |
| 63 // - these operations preform full collection of heaps of | |
| 64 // different kind | |
| 65 // | |
| 66 | |
| 67 class VM_GC_Operation: public VM_Operation { | |
| 68 protected: | |
| 69 BasicLock _pending_list_basic_lock; // for refs pending list notification (PLL) | |
| 70 unsigned int _gc_count_before; // gc count before acquiring PLL | |
| 71 unsigned int _full_gc_count_before; // full gc count before acquiring PLL | |
| 72 bool _full; // whether a "full" collection | |
| 73 bool _prologue_succeeded; // whether doit_prologue succeeded | |
| 74 GCCause::Cause _gc_cause; // the putative cause for this gc op | |
| 75 bool _gc_locked; // will be set if gc was locked | |
| 76 | |
| 77 virtual bool skip_operation() const; | |
| 78 | |
| 79 // java.lang.ref.Reference support | |
| 80 void acquire_pending_list_lock(); | |
| 81 void release_and_notify_pending_list_lock(); | |
| 82 | |
| 83 public: | |
| 84 VM_GC_Operation(unsigned int gc_count_before, | |
| 2225 | 85 GCCause::Cause _cause, |
| 0 | 86 unsigned int full_gc_count_before = 0, |
| 87 bool full = false) { | |
| 88 _full = full; | |
| 89 _prologue_succeeded = false; | |
| 90 _gc_count_before = gc_count_before; | |
| 91 | |
| 92 // A subclass constructor will likely overwrite the following | |
| 2225 | 93 _gc_cause = _cause; |
| 0 | 94 |
| 95 _gc_locked = false; | |
| 96 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
97 _full_gc_count_before = full_gc_count_before; |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
98 // In ParallelScavengeHeap::mem_allocate() collections can be |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
99 // executed within a loop and _all_soft_refs_clear can be set |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
100 // true after they have been cleared by a collection and another |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
101 // collection started so that _all_soft_refs_clear can be true |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
102 // when this collection is started. Don't assert that |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
103 // _all_soft_refs_clear have to be false here even though |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
104 // mutators have run. Soft refs will be cleared again in this |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
105 // collection. |
| 0 | 106 } |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
107 ~VM_GC_Operation() { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
108 CollectedHeap* ch = Universe::heap(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
109 ch->collector_policy()->set_all_soft_refs_clear(false); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
110 } |
| 0 | 111 |
| 112 // Acquire the reference synchronization lock | |
| 113 virtual bool doit_prologue(); | |
| 114 // Do notifyAll (if needed) and release held lock | |
| 115 virtual void doit_epilogue(); | |
| 116 | |
| 117 virtual bool allow_nested_vm_operations() const { return true; } | |
| 118 bool prologue_succeeded() const { return _prologue_succeeded; } | |
| 119 | |
| 120 void set_gc_locked() { _gc_locked = true; } | |
| 121 bool gc_locked() const { return _gc_locked; } | |
| 122 | |
| 123 static void notify_gc_begin(bool full = false); | |
| 124 static void notify_gc_end(); | |
| 125 }; | |
| 126 | |
| 127 | |
| 128 class VM_GC_HeapInspection: public VM_GC_Operation { | |
| 129 private: | |
| 130 outputStream* _out; | |
| 131 bool _full_gc; | |
|
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
196
diff
changeset
|
132 bool _need_prologue; |
| 7956 | 133 bool _csv_format; // "comma separated values" format for spreadsheet. |
| 134 bool _print_help; | |
| 135 bool _print_class_stats; | |
| 136 const char* _columns; | |
| 0 | 137 public: |
|
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
196
diff
changeset
|
138 VM_GC_HeapInspection(outputStream* out, bool request_full_gc, |
|
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
196
diff
changeset
|
139 bool need_prologue) : |
| 0 | 140 VM_GC_Operation(0 /* total collections, dummy, ignored */, |
| 2225 | 141 GCCause::_heap_inspection /* GC Cause */, |
| 0 | 142 0 /* total full collections, dummy, ignored */, |
| 143 request_full_gc) { | |
| 144 _out = out; | |
| 145 _full_gc = request_full_gc; | |
|
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
196
diff
changeset
|
146 _need_prologue = need_prologue; |
| 7956 | 147 _csv_format = false; |
| 148 _print_help = false; | |
| 149 _print_class_stats = false; | |
| 150 _columns = NULL; | |
| 0 | 151 } |
| 152 | |
| 153 ~VM_GC_HeapInspection() {} | |
| 154 virtual VMOp_Type type() const { return VMOp_GC_HeapInspection; } | |
| 155 virtual bool skip_operation() const; | |
| 156 virtual bool doit_prologue(); | |
| 157 virtual void doit(); | |
| 7956 | 158 void set_csv_format(bool value) {_csv_format = value;} |
| 159 void set_print_help(bool value) {_print_help = value;} | |
| 160 void set_print_class_stats(bool value) {_print_class_stats = value;} | |
| 161 void set_columns(const char* value) {_columns = value;} | |
| 0 | 162 }; |
| 163 | |
| 164 | |
| 165 class VM_GenCollectForAllocation: public VM_GC_Operation { | |
| 166 private: | |
| 167 HeapWord* _res; | |
| 168 size_t _size; // size of object to be allocated. | |
| 169 bool _tlab; // alloc is of a tlab. | |
| 170 public: | |
| 171 VM_GenCollectForAllocation(size_t size, | |
| 172 bool tlab, | |
| 173 unsigned int gc_count_before) | |
| 2225 | 174 : VM_GC_Operation(gc_count_before, GCCause::_allocation_failure), |
| 0 | 175 _size(size), |
| 176 _tlab(tlab) { | |
| 177 _res = NULL; | |
| 178 } | |
| 179 ~VM_GenCollectForAllocation() {} | |
| 180 virtual VMOp_Type type() const { return VMOp_GenCollectForAllocation; } | |
| 181 virtual void doit(); | |
| 182 HeapWord* result() const { return _res; } | |
| 183 }; | |
| 184 | |
| 185 | |
| 186 // VM operation to invoke a collection of the heap as a | |
| 187 // GenCollectedHeap heap. | |
| 188 class VM_GenCollectFull: public VM_GC_Operation { | |
| 189 private: | |
| 190 int _max_level; | |
| 191 public: | |
| 192 VM_GenCollectFull(unsigned int gc_count_before, | |
| 193 unsigned int full_gc_count_before, | |
| 194 GCCause::Cause gc_cause, | |
| 195 int max_level) | |
| 2225 | 196 : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true /* full */), |
| 197 _max_level(max_level) { } | |
| 0 | 198 ~VM_GenCollectFull() {} |
| 199 virtual VMOp_Type type() const { return VMOp_GenCollectFull; } | |
| 200 virtual void doit(); | |
| 201 }; | |
|
139
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
202 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
203 class VM_CollectForMetadataAllocation: public VM_GC_Operation { |
|
139
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
204 private: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
205 MetaWord* _result; |
| 6885 | 206 size_t _size; // size of object to be allocated |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
207 Metaspace::MetadataType _mdtype; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
208 ClassLoaderData* _loader_data; |
|
139
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
209 public: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
210 VM_CollectForMetadataAllocation(ClassLoaderData* loader_data, |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
211 size_t size, Metaspace::MetadataType mdtype, |
|
139
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
212 unsigned int gc_count_before, |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
213 unsigned int full_gc_count_before, |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
214 GCCause::Cause gc_cause) |
| 2225 | 215 : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true), |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
216 _loader_data(loader_data), _size(size), _mdtype(mdtype), _result(NULL) { |
|
139
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
217 } |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
218 ~VM_CollectForMetadataAllocation() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
219 MetaspaceGC::set_expand_after_GC(false); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
220 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
221 virtual VMOp_Type type() const { return VMOp_CollectForMetadataAllocation; } |
|
139
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
222 virtual void doit(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2225
diff
changeset
|
223 MetaWord* result() const { return _result; } |
|
139
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
224 }; |
| 1972 | 225 |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
226 class SvcGCMarker : public StackObj { |
|
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
227 private: |
|
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
228 JvmtiGCMarker _jgcm; |
|
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
229 public: |
|
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
230 typedef enum { MINOR, FULL, OTHER } reason_type; |
|
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
231 |
|
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
232 SvcGCMarker(reason_type reason ) { |
|
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
233 VM_GC_Operation::notify_gc_begin(reason == FULL); |
|
2039
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
1972
diff
changeset
|
234 } |
|
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
1972
diff
changeset
|
235 |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
236 ~SvcGCMarker() { |
|
2039
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
1972
diff
changeset
|
237 VM_GC_Operation::notify_gc_end(); |
|
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
1972
diff
changeset
|
238 } |
|
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
1972
diff
changeset
|
239 }; |
|
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
1972
diff
changeset
|
240 |
| 1972 | 241 #endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_VMGCOPERATIONS_HPP |