Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/shared/vmGCOperations.hpp @ 452:00b023ae2d78
6722113: CMS: Incorrect overflow handling during precleaning of Reference lists
Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery.
Reviewed-by: apetrusenko, jcoomes
| author | ysr |
|---|---|
| date | Thu, 20 Nov 2008 12:27:41 -0800 |
| parents | d1605aabd0a1 |
| children | c6c601a0f2d6 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 196 | 2 * Copyright 2005-2008 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 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 | |
| 89 if (full) { | |
| 90 _full_gc_count_before = full_gc_count_before; | |
| 91 } | |
| 92 } | |
| 93 ~VM_GC_Operation() {} | |
| 94 | |
| 95 // Acquire the reference synchronization lock | |
| 96 virtual bool doit_prologue(); | |
| 97 // Do notifyAll (if needed) and release held lock | |
| 98 virtual void doit_epilogue(); | |
| 99 | |
| 100 virtual bool allow_nested_vm_operations() const { return true; } | |
| 101 bool prologue_succeeded() const { return _prologue_succeeded; } | |
| 102 | |
| 103 void set_gc_locked() { _gc_locked = true; } | |
| 104 bool gc_locked() const { return _gc_locked; } | |
| 105 | |
| 106 static void notify_gc_begin(bool full = false); | |
| 107 static void notify_gc_end(); | |
| 108 }; | |
| 109 | |
| 110 | |
| 111 class VM_GC_HeapInspection: public VM_GC_Operation { | |
| 112 private: | |
| 113 outputStream* _out; | |
| 114 bool _full_gc; | |
| 115 public: | |
| 116 VM_GC_HeapInspection(outputStream* out, bool request_full_gc) : | |
| 117 VM_GC_Operation(0 /* total collections, dummy, ignored */, | |
| 118 0 /* total full collections, dummy, ignored */, | |
| 119 request_full_gc) { | |
| 120 _out = out; | |
| 121 _full_gc = request_full_gc; | |
| 122 } | |
| 123 | |
| 124 ~VM_GC_HeapInspection() {} | |
| 125 virtual VMOp_Type type() const { return VMOp_GC_HeapInspection; } | |
| 126 virtual bool skip_operation() const; | |
| 127 virtual bool doit_prologue(); | |
| 128 virtual void doit(); | |
| 129 }; | |
| 130 | |
| 131 | |
| 132 class VM_GenCollectForAllocation: public VM_GC_Operation { | |
| 133 private: | |
| 134 HeapWord* _res; | |
| 135 size_t _size; // size of object to be allocated. | |
| 136 bool _tlab; // alloc is of a tlab. | |
| 137 public: | |
| 138 VM_GenCollectForAllocation(size_t size, | |
| 139 bool tlab, | |
| 140 unsigned int gc_count_before) | |
| 141 : VM_GC_Operation(gc_count_before), | |
| 142 _size(size), | |
| 143 _tlab(tlab) { | |
| 144 _res = NULL; | |
| 145 } | |
| 146 ~VM_GenCollectForAllocation() {} | |
| 147 virtual VMOp_Type type() const { return VMOp_GenCollectForAllocation; } | |
| 148 virtual void doit(); | |
| 149 HeapWord* result() const { return _res; } | |
| 150 }; | |
| 151 | |
| 152 | |
| 153 // VM operation to invoke a collection of the heap as a | |
| 154 // GenCollectedHeap heap. | |
| 155 class VM_GenCollectFull: public VM_GC_Operation { | |
| 156 private: | |
| 157 int _max_level; | |
| 158 public: | |
| 159 VM_GenCollectFull(unsigned int gc_count_before, | |
| 160 unsigned int full_gc_count_before, | |
| 161 GCCause::Cause gc_cause, | |
| 162 int max_level) | |
| 163 : VM_GC_Operation(gc_count_before, full_gc_count_before, true /* full */), | |
| 164 _max_level(max_level) | |
| 165 { _gc_cause = gc_cause; } | |
| 166 ~VM_GenCollectFull() {} | |
| 167 virtual VMOp_Type type() const { return VMOp_GenCollectFull; } | |
| 168 virtual void doit(); | |
| 169 }; | |
|
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
|
170 |
|
c0492d52d55b
6539517: CR 6186200 should be extended to perm gen allocation to prevent spurious OOM's from perm gen
apetrusenko
parents:
0
diff
changeset
|
171 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
|
172 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
|
173 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
|
174 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
|
175 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
|
176 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
|
177 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
|
178 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
|
179 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
|
180 : 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
|
181 _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
|
182 _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
|
183 _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
|
184 } |
|
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 ~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
|
186 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
|
187 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
|
188 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
|
189 }; |