Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/shared/vmGCOperations.hpp @ 1716:be3f9c242c9d
6948538: CMS: BOT walkers can fall into object allocation and initialization cracks
Summary: GC workers now recognize an intermediate transient state of blocks which are allocated but have not yet completed initialization. blk_start() calls do not attempt to determine the size of a block in the transient state, rather waiting for the block to become initialized so that it is safe to query its size. Audited and ensured the order of initialization of object fields (klass, free bit and size) to respect block state transition protocol. Also included some new assertion checking code enabled in debug mode.
Reviewed-by: chrisphi, johnc, poonam
| author | ysr |
|---|---|
| date | Mon, 16 Aug 2010 15:58:42 -0700 |
| parents | 4e5661ba9d98 |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1387
diff
changeset
|
2 * Copyright (c) 2005, 2010, 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 | |
| 25 // The following class hierarchy represents | |
| 26 // a set of operations (VM_Operation) related to GC. | |
| 27 // | |
| 28 // VM_Operation | |
| 29 // VM_GC_Operation | |
| 30 // VM_GC_HeapInspection | |
| 31 // VM_GenCollectForAllocation | |
| 32 // VM_GenCollectFull | |
| 33 // VM_GenCollectFullConcurrent | |
| 34 // VM_ParallelGCFailedAllocation | |
| 35 // VM_ParallelGCFailedPermanentAllocation | |
| 36 // VM_ParallelGCSystemGC | |
| 37 // VM_GC_Operation | |
| 38 // - implements methods common to all classes in the hierarchy: | |
| 39 // prevents multiple gc requests and manages lock on heap; | |
| 40 // | |
| 41 // VM_GC_HeapInspection | |
| 42 // - prints class histogram on SIGBREAK if PrintClassHistogram | |
| 43 // is specified; and also the attach "inspectheap" operation | |
| 44 // | |
| 45 // VM_GenCollectForAllocation | |
|
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
|
46 // VM_GenCollectForPermanentAllocation |
| 0 | 47 // VM_ParallelGCFailedAllocation |
| 48 // VM_ParallelGCFailedPermanentAllocation | |
| 49 // - this operation is invoked when allocation is failed; | |
| 50 // operation performs garbage collection and tries to | |
| 51 // allocate afterwards; | |
| 52 // | |
| 53 // VM_GenCollectFull | |
| 54 // VM_GenCollectFullConcurrent | |
| 55 // VM_ParallelGCSystemGC | |
| 56 // - these operations preform full collection of heaps of | |
| 57 // different kind | |
| 58 // | |
| 59 | |
| 60 class VM_GC_Operation: public VM_Operation { | |
| 61 protected: | |
| 62 BasicLock _pending_list_basic_lock; // for refs pending list notification (PLL) | |
| 63 unsigned int _gc_count_before; // gc count before acquiring PLL | |
| 64 unsigned int _full_gc_count_before; // full gc count before acquiring PLL | |
| 65 bool _full; // whether a "full" collection | |
| 66 bool _prologue_succeeded; // whether doit_prologue succeeded | |
| 67 GCCause::Cause _gc_cause; // the putative cause for this gc op | |
| 68 bool _gc_locked; // will be set if gc was locked | |
| 69 | |
| 70 virtual bool skip_operation() const; | |
| 71 | |
| 72 // java.lang.ref.Reference support | |
| 73 void acquire_pending_list_lock(); | |
| 74 void release_and_notify_pending_list_lock(); | |
| 75 | |
| 76 public: | |
| 77 VM_GC_Operation(unsigned int gc_count_before, | |
| 78 unsigned int full_gc_count_before = 0, | |
| 79 bool full = false) { | |
| 80 _full = full; | |
| 81 _prologue_succeeded = false; | |
| 82 _gc_count_before = gc_count_before; | |
| 83 | |
| 84 // A subclass constructor will likely overwrite the following | |
| 85 _gc_cause = GCCause::_no_cause_specified; | |
| 86 | |
| 87 _gc_locked = false; | |
| 88 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1552
diff
changeset
|
89 _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
|
90 // 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
|
91 // 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
|
92 // 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
|
93 // 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
|
94 // 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
|
95 // _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
|
96 // 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
|
97 // collection. |
| 0 | 98 } |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
99 ~VM_GC_Operation() { |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
100 CollectedHeap* ch = Universe::heap(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
615
diff
changeset
|
101 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
|
102 } |
| 0 | 103 |
| 104 // Acquire the reference synchronization lock | |
| 105 virtual bool doit_prologue(); | |
| 106 // Do notifyAll (if needed) and release held lock | |
| 107 virtual void doit_epilogue(); | |
| 108 | |
| 109 virtual bool allow_nested_vm_operations() const { return true; } | |
| 110 bool prologue_succeeded() const { return _prologue_succeeded; } | |
| 111 | |
| 112 void set_gc_locked() { _gc_locked = true; } | |
| 113 bool gc_locked() const { return _gc_locked; } | |
| 114 | |
| 115 static void notify_gc_begin(bool full = false); | |
| 116 static void notify_gc_end(); | |
| 117 }; | |
| 118 | |
| 119 | |
| 120 class VM_GC_HeapInspection: public VM_GC_Operation { | |
| 121 private: | |
| 122 outputStream* _out; | |
| 123 bool _full_gc; | |
|
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
196
diff
changeset
|
124 bool _need_prologue; |
| 0 | 125 public: |
|
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
196
diff
changeset
|
126 VM_GC_HeapInspection(outputStream* out, bool request_full_gc, |
|
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
196
diff
changeset
|
127 bool need_prologue) : |
| 0 | 128 VM_GC_Operation(0 /* total collections, dummy, ignored */, |
| 129 0 /* total full collections, dummy, ignored */, | |
| 130 request_full_gc) { | |
| 131 _out = out; | |
| 132 _full_gc = request_full_gc; | |
|
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
196
diff
changeset
|
133 _need_prologue = need_prologue; |
| 0 | 134 } |
| 135 | |
| 136 ~VM_GC_HeapInspection() {} | |
| 137 virtual VMOp_Type type() const { return VMOp_GC_HeapInspection; } | |
| 138 virtual bool skip_operation() const; | |
| 139 virtual bool doit_prologue(); | |
| 140 virtual void doit(); | |
| 141 }; | |
| 142 | |
| 143 | |
| 144 class VM_GenCollectForAllocation: public VM_GC_Operation { | |
| 145 private: | |
| 146 HeapWord* _res; | |
| 147 size_t _size; // size of object to be allocated. | |
| 148 bool _tlab; // alloc is of a tlab. | |
| 149 public: | |
| 150 VM_GenCollectForAllocation(size_t size, | |
| 151 bool tlab, | |
| 152 unsigned int gc_count_before) | |
| 153 : VM_GC_Operation(gc_count_before), | |
| 154 _size(size), | |
| 155 _tlab(tlab) { | |
| 156 _res = NULL; | |
| 157 } | |
| 158 ~VM_GenCollectForAllocation() {} | |
| 159 virtual VMOp_Type type() const { return VMOp_GenCollectForAllocation; } | |
| 160 virtual void doit(); | |
| 161 HeapWord* result() const { return _res; } | |
| 162 }; | |
| 163 | |
| 164 | |
| 165 // VM operation to invoke a collection of the heap as a | |
| 166 // GenCollectedHeap heap. | |
| 167 class VM_GenCollectFull: public VM_GC_Operation { | |
| 168 private: | |
| 169 int _max_level; | |
| 170 public: | |
| 171 VM_GenCollectFull(unsigned int gc_count_before, | |
| 172 unsigned int full_gc_count_before, | |
| 173 GCCause::Cause gc_cause, | |
| 174 int max_level) | |
| 175 : VM_GC_Operation(gc_count_before, full_gc_count_before, true /* full */), | |
| 176 _max_level(max_level) | |
| 177 { _gc_cause = gc_cause; } | |
| 178 ~VM_GenCollectFull() {} | |
| 179 virtual VMOp_Type type() const { return VMOp_GenCollectFull; } | |
| 180 virtual void doit(); | |
| 181 }; | |
|
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
|
182 |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
183 class VM_GenCollectForPermanentAllocation: public VM_GC_Operation { |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
184 private: |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
185 HeapWord* _res; |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
186 size_t _size; // size of object to be allocated |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
187 public: |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
188 VM_GenCollectForPermanentAllocation(size_t size, |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
189 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
|
190 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
|
191 GCCause::Cause gc_cause) |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
192 : VM_GC_Operation(gc_count_before, full_gc_count_before, true), |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
193 _size(size) { |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
194 _res = NULL; |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
195 _gc_cause = gc_cause; |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
196 } |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
197 ~VM_GenCollectForPermanentAllocation() {} |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
198 virtual VMOp_Type type() const { return VMOp_GenCollectForPermanentAllocation; } |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
199 virtual void doit(); |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
200 HeapWord* result() const { return _res; } |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
201 }; |