Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 20295:3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
Summary: Refactor preparation for compaction during Full GC so that it lazily initializes the first compaction point. This also avoids problems later when the first region may not be committed. Also reviewed by K. Barrett.
Reviewed-by: brutisso
| author | tschatzl |
|---|---|
| date | Mon, 21 Jul 2014 10:00:31 +0200 |
| parents | e0954897238a |
| children | a3953c777565 |
| rev | line source |
|---|---|
| 342 | 1 /* |
|
17651
7a860525e91e
8033106: Wrong predicate for checking whether the correct amount of symbol table entries have been processed in G1
tschatzl
parents:
17648
diff
changeset
|
2 * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. |
| 342 | 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:
1547
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1547
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:
1547
diff
changeset
|
21 * questions. |
| 342 | 22 * |
| 23 */ | |
| 24 | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
25 #if !defined(__clang_major__) && defined(__GNUC__) |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
26 #define ATTRIBUTE_PRINTF(x,y) // FIXME, formats are a mess. |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
27 #endif |
|
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
28 |
| 1972 | 29 #include "precompiled.hpp" |
| 12080 | 30 #include "code/codeCache.hpp" |
| 1972 | 31 #include "code/icBuffer.hpp" |
| 32 #include "gc_implementation/g1/bufferingOopClosure.hpp" | |
| 33 #include "gc_implementation/g1/concurrentG1Refine.hpp" | |
| 34 #include "gc_implementation/g1/concurrentG1RefineThread.hpp" | |
| 35 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp" | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
36 #include "gc_implementation/g1/g1AllocRegion.inline.hpp" |
| 1972 | 37 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" |
| 38 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
39 #include "gc_implementation/g1/g1ErgoVerbose.hpp" |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
40 #include "gc_implementation/g1/g1EvacFailure.hpp" |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
41 #include "gc_implementation/g1/g1GCPhaseTimes.hpp" |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
42 #include "gc_implementation/g1/g1Log.hpp" |
| 1972 | 43 #include "gc_implementation/g1/g1MarkSweep.hpp" |
| 44 #include "gc_implementation/g1/g1OopClosures.inline.hpp" | |
|
20223
b0c374311c4e
8035400: Move G1ParScanThreadState into its own files
tschatzl
parents:
20217
diff
changeset
|
45 #include "gc_implementation/g1/g1ParScanThreadState.inline.hpp" |
| 1972 | 46 #include "gc_implementation/g1/g1RemSet.inline.hpp" |
| 17764 | 47 #include "gc_implementation/g1/g1StringDedup.hpp" |
| 10405 | 48 #include "gc_implementation/g1/g1YCTypes.hpp" |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
49 #include "gc_implementation/g1/heapRegion.inline.hpp" |
| 1972 | 50 #include "gc_implementation/g1/heapRegionRemSet.hpp" |
| 51 #include "gc_implementation/g1/heapRegionSeq.inline.hpp" | |
| 52 #include "gc_implementation/g1/vm_operations_g1.hpp" | |
| 10405 | 53 #include "gc_implementation/shared/gcHeapSummary.hpp" |
| 54 #include "gc_implementation/shared/gcTimer.hpp" | |
| 55 #include "gc_implementation/shared/gcTrace.hpp" | |
| 56 #include "gc_implementation/shared/gcTraceTime.hpp" | |
| 1972 | 57 #include "gc_implementation/shared/isGCActiveMark.hpp" |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
58 #include "memory/allocation.hpp" |
| 1972 | 59 #include "memory/gcLocker.inline.hpp" |
| 60 #include "memory/generationSpec.hpp" | |
|
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
17634
diff
changeset
|
61 #include "memory/iterator.hpp" |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
62 #include "memory/referenceProcessor.hpp" |
| 1972 | 63 #include "oops/oop.inline.hpp" |
| 64 #include "oops/oop.pcgc.inline.hpp" | |
|
20197
ce8f6bb717c9
8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents:
20192
diff
changeset
|
65 #include "runtime/orderAccess.inline.hpp" |
| 1972 | 66 #include "runtime/vmThread.hpp" |
| 342 | 67 |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
68 size_t G1CollectedHeap::_humongous_object_threshold_in_words = 0; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
69 |
| 342 | 70 // turn it on so that the contents of the young list (scan-only / |
| 71 // to-be-collected) are printed at "strategic" points before / during | |
| 72 // / after the collection --- this is useful for debugging | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
73 #define YOUNG_LIST_VERBOSE 0 |
| 342 | 74 // CURRENT STATUS |
| 75 // This file is under construction. Search for "FIXME". | |
| 76 | |
| 77 // INVARIANTS/NOTES | |
| 78 // | |
| 79 // All allocation activity covered by the G1CollectedHeap interface is | |
| 1973 | 80 // serialized by acquiring the HeapLock. This happens in mem_allocate |
| 81 // and allocate_new_tlab, which are the "entry" points to the | |
| 82 // allocation code from the rest of the JVM. (Note that this does not | |
| 83 // apply to TLAB allocation, which is not part of this interface: it | |
| 84 // is done by clients of this interface.) | |
| 342 | 85 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
86 // Notes on implementation of parallelism in different tasks. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
87 // |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
88 // G1ParVerifyTask uses heap_region_par_iterate_chunked() for parallelism. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
89 // The number of GC workers is passed to heap_region_par_iterate_chunked(). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
90 // It does use run_task() which sets _n_workers in the task. |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
91 // G1ParTask executes g1_process_roots() -> |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
92 // SharedHeap::process_roots() which calls eventually to |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
93 // CardTableModRefBS::par_non_clean_card_iterate_work() which uses |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
94 // SequentialSubTasksDone. SharedHeap::process_roots() also |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
95 // directly uses SubTasksDone (_process_strong_tasks field in SharedHeap). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
96 // |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
97 |
| 342 | 98 // Local to this file. |
| 99 | |
| 100 class RefineCardTableEntryClosure: public CardTableEntryClosure { | |
| 101 bool _concurrent; | |
| 102 public: | |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
103 RefineCardTableEntryClosure() : _concurrent(true) { } |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
104 |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17833
diff
changeset
|
105 bool do_card_ptr(jbyte* card_ptr, uint worker_i) { |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
106 bool oops_into_cset = G1CollectedHeap::heap()->g1_rem_set()->refine_card(card_ptr, worker_i, false); |
| 1705 | 107 // This path is executed by the concurrent refine or mutator threads, |
| 108 // concurrently, and so we do not care if card_ptr contains references | |
| 109 // that point into the collection set. | |
| 110 assert(!oops_into_cset, "should be"); | |
| 111 | |
| 20192 | 112 if (_concurrent && SuspendibleThreadSet::should_yield()) { |
| 342 | 113 // Caller will actually yield. |
| 114 return false; | |
| 115 } | |
| 116 // Otherwise, we finished successfully; return true. | |
| 117 return true; | |
| 118 } | |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
119 |
| 342 | 120 void set_concurrent(bool b) { _concurrent = b; } |
| 121 }; | |
| 122 | |
| 123 | |
| 124 class ClearLoggedCardTableEntryClosure: public CardTableEntryClosure { | |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
125 size_t _num_processed; |
| 342 | 126 CardTableModRefBS* _ctbs; |
| 127 int _histo[256]; | |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
128 |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
129 public: |
| 342 | 130 ClearLoggedCardTableEntryClosure() : |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
131 _num_processed(0), _ctbs(G1CollectedHeap::heap()->g1_barrier_set()) |
| 342 | 132 { |
| 133 for (int i = 0; i < 256; i++) _histo[i] = 0; | |
| 134 } | |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
135 |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17833
diff
changeset
|
136 bool do_card_ptr(jbyte* card_ptr, uint worker_i) { |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
137 unsigned char* ujb = (unsigned char*)card_ptr; |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
138 int ind = (int)(*ujb); |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
139 _histo[ind]++; |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
140 |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
141 *card_ptr = (jbyte)CardTableModRefBS::clean_card_val(); |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
142 _num_processed++; |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
143 |
| 342 | 144 return true; |
| 145 } | |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
146 |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
147 size_t num_processed() { return _num_processed; } |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
148 |
| 342 | 149 void print_histo() { |
| 150 gclog_or_tty->print_cr("Card table value histogram:"); | |
| 151 for (int i = 0; i < 256; i++) { | |
| 152 if (_histo[i] != 0) { | |
| 153 gclog_or_tty->print_cr(" %d: %d", i, _histo[i]); | |
| 154 } | |
| 155 } | |
| 156 } | |
| 157 }; | |
| 158 | |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
159 class RedirtyLoggedCardTableEntryClosure : public CardTableEntryClosure { |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
160 private: |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
161 size_t _num_processed; |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
162 |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
163 public: |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
164 RedirtyLoggedCardTableEntryClosure() : CardTableEntryClosure(), _num_processed(0) { } |
| 12343 | 165 |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17833
diff
changeset
|
166 bool do_card_ptr(jbyte* card_ptr, uint worker_i) { |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
167 *card_ptr = CardTableModRefBS::dirty_card_val(); |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
168 _num_processed++; |
| 342 | 169 return true; |
| 170 } | |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
171 |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
172 size_t num_processed() const { return _num_processed; } |
| 342 | 173 }; |
| 174 | |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
175 YoungList::YoungList(G1CollectedHeap* g1h) : |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
176 _g1h(g1h), _head(NULL), _length(0), _last_sampled_rs_lengths(0), |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
177 _survivor_head(NULL), _survivor_tail(NULL), _survivor_length(0) { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
178 guarantee(check_list_empty(false), "just making sure..."); |
| 342 | 179 } |
| 180 | |
| 181 void YoungList::push_region(HeapRegion *hr) { | |
| 182 assert(!hr->is_young(), "should not already be young"); | |
| 183 assert(hr->get_next_young_region() == NULL, "cause it should!"); | |
| 184 | |
| 185 hr->set_next_young_region(_head); | |
| 186 _head = hr; | |
| 187 | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
188 _g1h->g1_policy()->set_region_eden(hr, (int) _length); |
| 342 | 189 ++_length; |
| 190 } | |
| 191 | |
| 192 void YoungList::add_survivor_region(HeapRegion* hr) { | |
| 545 | 193 assert(hr->is_survivor(), "should be flagged as survivor region"); |
| 342 | 194 assert(hr->get_next_young_region() == NULL, "cause it should!"); |
| 195 | |
| 196 hr->set_next_young_region(_survivor_head); | |
| 197 if (_survivor_head == NULL) { | |
| 545 | 198 _survivor_tail = hr; |
| 342 | 199 } |
| 200 _survivor_head = hr; | |
| 201 ++_survivor_length; | |
| 202 } | |
| 203 | |
| 204 void YoungList::empty_list(HeapRegion* list) { | |
| 205 while (list != NULL) { | |
| 206 HeapRegion* next = list->get_next_young_region(); | |
| 207 list->set_next_young_region(NULL); | |
| 208 list->uninstall_surv_rate_group(); | |
| 209 list->set_not_young(); | |
| 210 list = next; | |
| 211 } | |
| 212 } | |
| 213 | |
| 214 void YoungList::empty_list() { | |
| 215 assert(check_list_well_formed(), "young list should be well formed"); | |
| 216 | |
| 217 empty_list(_head); | |
| 218 _head = NULL; | |
| 219 _length = 0; | |
| 220 | |
| 221 empty_list(_survivor_head); | |
| 222 _survivor_head = NULL; | |
| 545 | 223 _survivor_tail = NULL; |
| 342 | 224 _survivor_length = 0; |
| 225 | |
| 226 _last_sampled_rs_lengths = 0; | |
| 227 | |
| 228 assert(check_list_empty(false), "just making sure..."); | |
| 229 } | |
| 230 | |
| 231 bool YoungList::check_list_well_formed() { | |
| 232 bool ret = true; | |
| 233 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
234 uint length = 0; |
| 342 | 235 HeapRegion* curr = _head; |
| 236 HeapRegion* last = NULL; | |
| 237 while (curr != NULL) { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
238 if (!curr->is_young()) { |
| 342 | 239 gclog_or_tty->print_cr("### YOUNG REGION "PTR_FORMAT"-"PTR_FORMAT" " |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
240 "incorrectly tagged (y: %d, surv: %d)", |
| 342 | 241 curr->bottom(), curr->end(), |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
242 curr->is_young(), curr->is_survivor()); |
| 342 | 243 ret = false; |
| 244 } | |
| 245 ++length; | |
| 246 last = curr; | |
| 247 curr = curr->get_next_young_region(); | |
| 248 } | |
| 249 ret = ret && (length == _length); | |
| 250 | |
| 251 if (!ret) { | |
| 252 gclog_or_tty->print_cr("### YOUNG LIST seems not well formed!"); | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
253 gclog_or_tty->print_cr("### list has %u entries, _length is %u", |
| 342 | 254 length, _length); |
| 255 } | |
| 256 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
257 return ret; |
| 342 | 258 } |
| 259 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
260 bool YoungList::check_list_empty(bool check_sample) { |
| 342 | 261 bool ret = true; |
| 262 | |
| 263 if (_length != 0) { | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
264 gclog_or_tty->print_cr("### YOUNG LIST should have 0 length, not %u", |
| 342 | 265 _length); |
| 266 ret = false; | |
| 267 } | |
| 268 if (check_sample && _last_sampled_rs_lengths != 0) { | |
| 269 gclog_or_tty->print_cr("### YOUNG LIST has non-zero last sampled RS lengths"); | |
| 270 ret = false; | |
| 271 } | |
| 272 if (_head != NULL) { | |
| 273 gclog_or_tty->print_cr("### YOUNG LIST does not have a NULL head"); | |
| 274 ret = false; | |
| 275 } | |
| 276 if (!ret) { | |
| 277 gclog_or_tty->print_cr("### YOUNG LIST does not seem empty"); | |
| 278 } | |
| 279 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
280 return ret; |
| 342 | 281 } |
| 282 | |
| 283 void | |
| 284 YoungList::rs_length_sampling_init() { | |
| 285 _sampled_rs_lengths = 0; | |
| 286 _curr = _head; | |
| 287 } | |
| 288 | |
| 289 bool | |
| 290 YoungList::rs_length_sampling_more() { | |
| 291 return _curr != NULL; | |
| 292 } | |
| 293 | |
| 294 void | |
| 295 YoungList::rs_length_sampling_next() { | |
| 296 assert( _curr != NULL, "invariant" ); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
297 size_t rs_length = _curr->rem_set()->occupied(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
298 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
299 _sampled_rs_lengths += rs_length; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
300 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
301 // The current region may not yet have been added to the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
302 // incremental collection set (it gets added when it is |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
303 // retired as the current allocation region). |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
304 if (_curr->in_collection_set()) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
305 // Update the collection set policy information for this region |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
306 _g1h->g1_policy()->update_incremental_cset_info(_curr, rs_length); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
307 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
308 |
| 342 | 309 _curr = _curr->get_next_young_region(); |
| 310 if (_curr == NULL) { | |
| 311 _last_sampled_rs_lengths = _sampled_rs_lengths; | |
| 312 // gclog_or_tty->print_cr("last sampled RS lengths = %d", _last_sampled_rs_lengths); | |
| 313 } | |
| 314 } | |
| 315 | |
| 316 void | |
| 317 YoungList::reset_auxilary_lists() { | |
| 318 guarantee( is_empty(), "young list should be empty" ); | |
| 319 assert(check_list_well_formed(), "young list should be well formed"); | |
| 320 | |
| 321 // Add survivor regions to SurvRateGroup. | |
| 322 _g1h->g1_policy()->note_start_adding_survivor_regions(); | |
| 545 | 323 _g1h->g1_policy()->finished_recalculating_age_indexes(true /* is_survivors */); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
324 |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
325 int young_index_in_cset = 0; |
| 342 | 326 for (HeapRegion* curr = _survivor_head; |
| 327 curr != NULL; | |
| 328 curr = curr->get_next_young_region()) { | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
329 _g1h->g1_policy()->set_region_survivor(curr, young_index_in_cset); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
330 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
331 // The region is a non-empty survivor so let's add it to |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
332 // the incremental collection set for the next evacuation |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
333 // pause. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
334 _g1h->g1_policy()->add_region_to_incremental_cset_rhs(curr); |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
335 young_index_in_cset += 1; |
|
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
336 } |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
337 assert((uint) young_index_in_cset == _survivor_length, "post-condition"); |
| 342 | 338 _g1h->g1_policy()->note_stop_adding_survivor_regions(); |
| 339 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
340 _head = _survivor_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
341 _length = _survivor_length; |
| 342 | 342 if (_survivor_head != NULL) { |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
343 assert(_survivor_tail != NULL, "cause it shouldn't be"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
344 assert(_survivor_length > 0, "invariant"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
345 _survivor_tail->set_next_young_region(NULL); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
346 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
347 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
348 // Don't clear the survivor list handles until the start of |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
349 // the next evacuation pause - we need it in order to re-tag |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
350 // the survivor regions from this evacuation pause as 'young' |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
351 // at the start of the next. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
352 |
| 545 | 353 _g1h->g1_policy()->finished_recalculating_age_indexes(false /* is_survivors */); |
| 342 | 354 |
| 355 assert(check_list_well_formed(), "young list should be well formed"); | |
| 356 } | |
| 357 | |
| 358 void YoungList::print() { | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
359 HeapRegion* lists[] = {_head, _survivor_head}; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
360 const char* names[] = {"YOUNG", "SURVIVOR"}; |
| 342 | 361 |
| 362 for (unsigned int list = 0; list < ARRAY_SIZE(lists); ++list) { | |
| 363 gclog_or_tty->print_cr("%s LIST CONTENTS", names[list]); | |
| 364 HeapRegion *curr = lists[list]; | |
| 365 if (curr == NULL) | |
| 366 gclog_or_tty->print_cr(" empty"); | |
| 367 while (curr != NULL) { | |
|
6027
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
368 gclog_or_tty->print_cr(" "HR_FORMAT", P: "PTR_FORMAT "N: "PTR_FORMAT", age: %4d", |
|
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
369 HR_FORMAT_PARAMS(curr), |
| 342 | 370 curr->prev_top_at_mark_start(), |
| 371 curr->next_top_at_mark_start(), | |
|
6027
8a2e5a6a19a4
7143490: G1: Remove HeapRegion::_top_at_conc_mark_count
johnc
parents:
6011
diff
changeset
|
372 curr->age_in_surv_rate_group_cond()); |
| 342 | 373 curr = curr->get_next_young_region(); |
| 374 } | |
| 375 } | |
| 376 | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
377 gclog_or_tty->cr(); |
| 342 | 378 } |
| 379 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
380 void G1CollectedHeap::push_dirty_cards_region(HeapRegion* hr) |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
381 { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
382 // Claim the right to put the region on the dirty cards region list |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
383 // by installing a self pointer. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
384 HeapRegion* next = hr->get_next_dirty_cards_region(); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
385 if (next == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
386 HeapRegion* res = (HeapRegion*) |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
387 Atomic::cmpxchg_ptr(hr, hr->next_dirty_cards_region_addr(), |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
388 NULL); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
389 if (res == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
390 HeapRegion* head; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
391 do { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
392 // Put the region to the dirty cards region list. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
393 head = _dirty_cards_region_list; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
394 next = (HeapRegion*) |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
395 Atomic::cmpxchg_ptr(hr, &_dirty_cards_region_list, head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
396 if (next == head) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
397 assert(hr->get_next_dirty_cards_region() == hr, |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
398 "hr->get_next_dirty_cards_region() != hr"); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
399 if (next == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
400 // The last region in the list points to itself. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
401 hr->set_next_dirty_cards_region(hr); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
402 } else { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
403 hr->set_next_dirty_cards_region(next); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
404 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
405 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
406 } while (next != head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
407 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
408 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
409 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
410 |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
411 HeapRegion* G1CollectedHeap::pop_dirty_cards_region() |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
412 { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
413 HeapRegion* head; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
414 HeapRegion* hr; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
415 do { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
416 head = _dirty_cards_region_list; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
417 if (head == NULL) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
418 return NULL; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
419 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
420 HeapRegion* new_head = head->get_next_dirty_cards_region(); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
421 if (head == new_head) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
422 // The last region. |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
423 new_head = NULL; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
424 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
425 hr = (HeapRegion*)Atomic::cmpxchg_ptr(new_head, &_dirty_cards_region_list, |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
426 head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
427 } while (hr != head); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
428 assert(hr != NULL, "invariant"); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
429 hr->set_next_dirty_cards_region(NULL); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
430 return hr; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
431 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
432 |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
433 #ifdef ASSERT |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
434 // A region is added to the collection set as it is retired |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
435 // so an address p can point to a region which will be in the |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
436 // collection set but has not yet been retired. This method |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
437 // therefore is only accurate during a GC pause after all |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
438 // regions have been retired. It is used for debugging |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
439 // to check if an nmethod has references to objects that can |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
440 // be move during a partial collection. Though it can be |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
441 // inaccurate, it is sufficient for G1 because the conservative |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
442 // implementation of is_scavengable() for G1 will indicate that |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
443 // all nmethods must be scanned during a partial collection. |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
444 bool G1CollectedHeap::is_in_partial_collection(const void* p) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
445 HeapRegion* hr = heap_region_containing(p); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
446 return hr != NULL && hr->in_collection_set(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
447 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
448 #endif |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
449 |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
450 // Returns true if the reference points to an object that |
| 10405 | 451 // can move in an incremental collection. |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
452 bool G1CollectedHeap::is_scavengable(const void* p) { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
453 G1CollectedHeap* g1h = G1CollectedHeap::heap(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
454 G1CollectorPolicy* g1p = g1h->g1_policy(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
455 HeapRegion* hr = heap_region_containing(p); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
456 if (hr == NULL) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
457 // null |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
458 assert(p == NULL, err_msg("Not NULL " PTR_FORMAT ,p)); |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
459 return false; |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
460 } else { |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
461 return !hr->isHumongous(); |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
462 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
463 } |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
3356
diff
changeset
|
464 |
| 342 | 465 void G1CollectedHeap::check_ct_logs_at_safepoint() { |
| 466 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 12343 | 467 CardTableModRefBS* ct_bs = g1_barrier_set(); |
| 342 | 468 |
| 469 // Count the dirty cards at the start. | |
| 470 CountNonCleanMemRegionClosure count1(this); | |
| 471 ct_bs->mod_card_iterate(&count1); | |
| 472 int orig_count = count1.n(); | |
| 473 | |
| 474 // First clear the logged cards. | |
| 475 ClearLoggedCardTableEntryClosure clear; | |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
476 dcqs.apply_closure_to_all_completed_buffers(&clear); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
477 dcqs.iterate_closure_all_threads(&clear, false); |
| 342 | 478 clear.print_histo(); |
| 479 | |
| 480 // Now ensure that there's no dirty cards. | |
| 481 CountNonCleanMemRegionClosure count2(this); | |
| 482 ct_bs->mod_card_iterate(&count2); | |
| 483 if (count2.n() != 0) { | |
| 484 gclog_or_tty->print_cr("Card table has %d entries; %d originally", | |
| 485 count2.n(), orig_count); | |
| 486 } | |
| 487 guarantee(count2.n() == 0, "Card table should be clean."); | |
| 488 | |
| 489 RedirtyLoggedCardTableEntryClosure redirty; | |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
490 dcqs.apply_closure_to_all_completed_buffers(&redirty); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
491 dcqs.iterate_closure_all_threads(&redirty, false); |
| 342 | 492 gclog_or_tty->print_cr("Log entries = %d, dirty cards = %d.", |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
493 clear.num_processed(), orig_count); |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
494 guarantee(redirty.num_processed() == clear.num_processed(), |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
495 err_msg("Redirtied "SIZE_FORMAT" cards, bug cleared "SIZE_FORMAT, |
|
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
496 redirty.num_processed(), clear.num_processed())); |
| 342 | 497 |
| 498 CountNonCleanMemRegionClosure count3(this); | |
| 499 ct_bs->mod_card_iterate(&count3); | |
| 500 if (count3.n() != orig_count) { | |
| 501 gclog_or_tty->print_cr("Should have restored them all: orig = %d, final = %d.", | |
| 502 orig_count, count3.n()); | |
| 503 guarantee(count3.n() >= orig_count, "Should have restored them all."); | |
| 504 } | |
| 505 } | |
| 506 | |
| 507 // Private class members. | |
| 508 | |
| 509 G1CollectedHeap* G1CollectedHeap::_g1h; | |
| 510 | |
| 511 // Private methods. | |
| 512 | |
| 2152 | 513 HeapRegion* |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
514 G1CollectedHeap::new_region_try_secondary_free_list(bool is_old) { |
| 2152 | 515 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); |
| 516 while (!_secondary_free_list.is_empty() || free_regions_coming()) { | |
| 517 if (!_secondary_free_list.is_empty()) { | |
| 518 if (G1ConcRegionFreeingVerbose) { | |
| 519 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
520 "secondary_free_list has %u entries", |
| 2152 | 521 _secondary_free_list.length()); |
| 522 } | |
| 523 // It looks as if there are free regions available on the | |
| 524 // secondary_free_list. Let's move them to the free_list and try | |
| 525 // again to allocate from it. | |
| 526 append_secondary_free_list(); | |
| 527 | |
| 528 assert(!_free_list.is_empty(), "if the secondary_free_list was not " | |
| 529 "empty we should have moved at least one entry to the free_list"); | |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
530 HeapRegion* res = _free_list.remove_region(is_old); |
| 2152 | 531 if (G1ConcRegionFreeingVerbose) { |
| 532 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 533 "allocated "HR_FORMAT" from secondary_free_list", | |
| 534 HR_FORMAT_PARAMS(res)); | |
| 535 } | |
| 536 return res; | |
| 537 } | |
| 538 | |
| 10405 | 539 // Wait here until we get notified either when (a) there are no |
| 2152 | 540 // more free regions coming or (b) some regions have been moved on |
| 541 // the secondary_free_list. | |
| 542 SecondaryFreeList_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 543 } | |
| 544 | |
| 545 if (G1ConcRegionFreeingVerbose) { | |
| 546 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 547 "could not allocate from secondary_free_list"); | |
| 548 } | |
| 549 return NULL; | |
| 550 } | |
| 551 | |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
552 HeapRegion* G1CollectedHeap::new_region(size_t word_size, bool is_old, bool do_expand) { |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
553 assert(!isHumongous(word_size) || word_size <= HeapRegion::GrainWords, |
| 2152 | 554 "the only time we use this to allocate a humongous region is " |
| 555 "when we are allocating a single humongous region"); | |
| 556 | |
| 557 HeapRegion* res; | |
| 558 if (G1StressConcRegionFreeing) { | |
| 559 if (!_secondary_free_list.is_empty()) { | |
| 560 if (G1ConcRegionFreeingVerbose) { | |
| 561 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 562 "forced to look at the secondary_free_list"); | |
| 563 } | |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
564 res = new_region_try_secondary_free_list(is_old); |
| 2152 | 565 if (res != NULL) { |
| 566 return res; | |
| 567 } | |
| 568 } | |
| 569 } | |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
570 |
|
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
571 res = _free_list.remove_region(is_old); |
|
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
572 |
| 2152 | 573 if (res == NULL) { |
| 574 if (G1ConcRegionFreeingVerbose) { | |
| 575 gclog_or_tty->print_cr("G1ConcRegionFreeing [region alloc] : " | |
| 576 "res == NULL, trying the secondary_free_list"); | |
| 577 } | |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
578 res = new_region_try_secondary_free_list(is_old); |
| 2152 | 579 } |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
580 if (res == NULL && do_expand && _expand_heap_after_alloc_failure) { |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
581 // Currently, only attempts to allocate GC alloc regions set |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
582 // do_expand to true. So, we should only reach here during a |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
583 // safepoint. If this assumption changes we might have to |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
584 // reconsider the use of _expand_heap_after_alloc_failure. |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
585 assert(SafepointSynchronize::is_at_safepoint(), "invariant"); |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
586 |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
587 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
588 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
589 ergo_format_reason("region allocation request failed") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
590 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
591 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
592 if (expand(word_size * HeapWordSize)) { |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
593 // Given that expand() succeeded in expanding the heap, and we |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
594 // always expand the heap by an amount aligned to the heap |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
595 // region size, the free list should in theory not be empty. |
|
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
596 // In either case remove_region() will check for NULL. |
|
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
597 res = _free_list.remove_region(is_old); |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
598 } else { |
|
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
599 _expand_heap_after_alloc_failure = false; |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
600 } |
| 342 | 601 } |
| 602 return res; | |
| 603 } | |
| 604 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
605 uint G1CollectedHeap::humongous_obj_allocate_find_first(uint num_regions, |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
606 size_t word_size) { |
| 2361 | 607 assert(isHumongous(word_size), "word_size should be humongous"); |
| 608 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); | |
| 609 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
610 uint first = G1_NULL_HRS_INDEX; |
| 2152 | 611 if (num_regions == 1) { |
| 612 // Only one region to allocate, no need to go through the slower | |
| 10405 | 613 // path. The caller will attempt the expansion if this fails, so |
| 2152 | 614 // let's not try to expand here too. |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
615 HeapRegion* hr = new_region(word_size, true /* is_old */, false /* do_expand */); |
| 2152 | 616 if (hr != NULL) { |
| 617 first = hr->hrs_index(); | |
| 618 } else { | |
| 3766 | 619 first = G1_NULL_HRS_INDEX; |
| 2152 | 620 } |
| 621 } else { | |
| 622 // We can't allocate humongous regions while cleanupComplete() is | |
| 623 // running, since some of the regions we find to be empty might not | |
| 624 // yet be added to the free list and it is not straightforward to | |
| 625 // know which list they are on so that we can remove them. Note | |
| 626 // that we only need to do this if we need to allocate more than | |
| 627 // one region to satisfy the current humongous allocation | |
| 628 // request. If we are only allocating one region we use the common | |
| 629 // region allocation code (see above). | |
| 630 wait_while_free_regions_coming(); | |
| 2361 | 631 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 632 |
| 633 if (free_regions() >= num_regions) { | |
| 3766 | 634 first = _hrs.find_contiguous(num_regions); |
| 635 if (first != G1_NULL_HRS_INDEX) { | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
636 for (uint i = first; i < first + num_regions; ++i) { |
| 3766 | 637 HeapRegion* hr = region_at(i); |
| 2152 | 638 assert(hr->is_empty(), "sanity"); |
| 2361 | 639 assert(is_on_master_free_list(hr), "sanity"); |
| 2152 | 640 hr->set_pending_removal(true); |
| 641 } | |
| 642 _free_list.remove_all_pending(num_regions); | |
| 643 } | |
| 644 } | |
| 645 } | |
| 646 return first; | |
| 647 } | |
| 648 | |
| 2361 | 649 HeapWord* |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
650 G1CollectedHeap::humongous_obj_allocate_initialize_regions(uint first, |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
651 uint num_regions, |
| 2361 | 652 size_t word_size) { |
| 3766 | 653 assert(first != G1_NULL_HRS_INDEX, "pre-condition"); |
| 2361 | 654 assert(isHumongous(word_size), "word_size should be humongous"); |
| 655 assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition"); | |
| 656 | |
| 657 // Index of last region in the series + 1. | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
658 uint last = first + num_regions; |
| 2361 | 659 |
| 660 // We need to initialize the region(s) we just discovered. This is | |
| 661 // a bit tricky given that it can happen concurrently with | |
| 662 // refinement threads refining cards on these regions and | |
| 663 // potentially wanting to refine the BOT as they are scanning | |
| 664 // those cards (this can happen shortly after a cleanup; see CR | |
| 665 // 6991377). So we have to set up the region(s) carefully and in | |
| 666 // a specific order. | |
| 667 | |
| 668 // The word size sum of all the regions we will allocate. | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
669 size_t word_size_sum = (size_t) num_regions * HeapRegion::GrainWords; |
| 2361 | 670 assert(word_size <= word_size_sum, "sanity"); |
| 671 | |
| 672 // This will be the "starts humongous" region. | |
| 3766 | 673 HeapRegion* first_hr = region_at(first); |
| 2361 | 674 // The header of the new object will be placed at the bottom of |
| 675 // the first region. | |
| 676 HeapWord* new_obj = first_hr->bottom(); | |
| 677 // This will be the new end of the first region in the series that | |
| 10405 | 678 // should also match the end of the last region in the series. |
| 2361 | 679 HeapWord* new_end = new_obj + word_size_sum; |
| 680 // This will be the new top of the first region that will reflect | |
| 681 // this allocation. | |
| 682 HeapWord* new_top = new_obj + word_size; | |
| 683 | |
| 684 // First, we need to zero the header of the space that we will be | |
| 685 // allocating. When we update top further down, some refinement | |
| 686 // threads might try to scan the region. By zeroing the header we | |
| 687 // ensure that any thread that will try to scan the region will | |
| 688 // come across the zero klass word and bail out. | |
| 689 // | |
| 690 // NOTE: It would not have been correct to have used | |
| 691 // CollectedHeap::fill_with_object() and make the space look like | |
| 692 // an int array. The thread that is doing the allocation will | |
| 693 // later update the object header to a potentially different array | |
| 694 // type and, for a very short period of time, the klass and length | |
| 695 // fields will be inconsistent. This could cause a refinement | |
| 696 // thread to calculate the object size incorrectly. | |
| 697 Copy::fill_to_words(new_obj, oopDesc::header_size(), 0); | |
| 698 | |
| 699 // We will set up the first region as "starts humongous". This | |
| 700 // will also update the BOT covering all the regions to reflect | |
| 701 // that there is a single object that starts at the bottom of the | |
| 702 // first region. | |
| 703 first_hr->set_startsHumongous(new_top, new_end); | |
| 704 | |
| 705 // Then, if there are any, we will set up the "continues | |
| 706 // humongous" regions. | |
| 707 HeapRegion* hr = NULL; | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
708 for (uint i = first + 1; i < last; ++i) { |
| 3766 | 709 hr = region_at(i); |
| 2361 | 710 hr->set_continuesHumongous(first_hr); |
| 711 } | |
| 712 // If we have "continues humongous" regions (hr != NULL), then the | |
| 713 // end of the last one should match new_end. | |
| 714 assert(hr == NULL || hr->end() == new_end, "sanity"); | |
| 715 | |
| 716 // Up to this point no concurrent thread would have been able to | |
| 717 // do any scanning on any region in this series. All the top | |
| 718 // fields still point to bottom, so the intersection between | |
| 719 // [bottom,top] and [card_start,card_end] will be empty. Before we | |
| 720 // update the top fields, we'll do a storestore to make sure that | |
| 721 // no thread sees the update to top before the zeroing of the | |
| 722 // object header and the BOT initialization. | |
| 723 OrderAccess::storestore(); | |
| 724 | |
| 725 // Now that the BOT and the object header have been initialized, | |
| 726 // we can update top of the "starts humongous" region. | |
| 727 assert(first_hr->bottom() < new_top && new_top <= first_hr->end(), | |
| 728 "new_top should be in this region"); | |
| 729 first_hr->set_top(new_top); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
730 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
731 HeapWord* bottom = first_hr->bottom(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
732 HeapWord* end = first_hr->orig_end(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
733 if ((first + 1) == last) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
734 // the series has a single humongous region |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
735 _hr_printer.alloc(G1HRPrinter::SingleHumongous, first_hr, new_top); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
736 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
737 // the series has more than one humongous regions |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
738 _hr_printer.alloc(G1HRPrinter::StartsHumongous, first_hr, end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
739 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
740 } |
| 2361 | 741 |
| 742 // Now, we will update the top fields of the "continues humongous" | |
| 743 // regions. The reason we need to do this is that, otherwise, | |
| 744 // these regions would look empty and this will confuse parts of | |
| 745 // G1. For example, the code that looks for a consecutive number | |
| 746 // of empty regions will consider them empty and try to | |
| 747 // re-allocate them. We can extend is_empty() to also include | |
| 748 // !continuesHumongous(), but it is easier to just update the top | |
| 749 // fields here. The way we set top for all regions (i.e., top == | |
| 750 // end for all regions but the last one, top == new_top for the | |
| 751 // last one) is actually used when we will free up the humongous | |
| 752 // region in free_humongous_region(). | |
| 753 hr = NULL; | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
754 for (uint i = first + 1; i < last; ++i) { |
| 3766 | 755 hr = region_at(i); |
| 2361 | 756 if ((i + 1) == last) { |
| 757 // last continues humongous region | |
| 758 assert(hr->bottom() < new_top && new_top <= hr->end(), | |
| 759 "new_top should fall on this region"); | |
| 760 hr->set_top(new_top); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
761 _hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, new_top); |
| 2361 | 762 } else { |
| 763 // not last one | |
| 764 assert(new_top > hr->end(), "new_top should be above this region"); | |
| 765 hr->set_top(hr->end()); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
766 _hr_printer.alloc(G1HRPrinter::ContinuesHumongous, hr, hr->end()); |
| 2361 | 767 } |
| 768 } | |
| 769 // If we have continues humongous regions (hr != NULL), then the | |
| 770 // end of the last one should match new_end and its top should | |
| 771 // match new_top. | |
| 772 assert(hr == NULL || | |
| 773 (hr->end() == new_end && hr->top() == new_top), "sanity"); | |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
774 check_bitmaps("Humongous Region Allocation", first_hr); |
| 2361 | 775 |
| 776 assert(first_hr->used() == word_size * HeapWordSize, "invariant"); | |
| 777 _summary_bytes_used += first_hr->used(); | |
| 778 _humongous_set.add(first_hr); | |
| 779 | |
| 780 return new_obj; | |
| 781 } | |
| 782 | |
| 342 | 783 // If could fit into free regions w/o expansion, try. |
| 784 // Otherwise, if can expand, do so. | |
| 785 // Otherwise, if using ex regions might help, try with ex given back. | |
| 1973 | 786 HeapWord* G1CollectedHeap::humongous_obj_allocate(size_t word_size) { |
| 2152 | 787 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); |
| 788 | |
| 789 verify_region_sets_optional(); | |
| 342 | 790 |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
791 size_t word_size_rounded = round_to(word_size, HeapRegion::GrainWords); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
792 uint num_regions = (uint) (word_size_rounded / HeapRegion::GrainWords); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
793 uint x_num = expansion_regions(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
794 uint fs = _hrs.free_suffix(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
795 uint first = humongous_obj_allocate_find_first(num_regions, word_size); |
| 3766 | 796 if (first == G1_NULL_HRS_INDEX) { |
| 2152 | 797 // The only thing we can do now is attempt expansion. |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
798 if (fs + x_num >= num_regions) { |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
799 // If the number of regions we're trying to allocate for this |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
800 // object is at most the number of regions in the free suffix, |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
801 // then the call to humongous_obj_allocate_find_first() above |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
802 // should have succeeded and we wouldn't be here. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
803 // |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
804 // We should only be trying to expand when the free suffix is |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
805 // not sufficient for the object _and_ we have some expansion |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
806 // room available. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
807 assert(num_regions > fs, "earlier allocation should have succeeded"); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
808 |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
809 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
810 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
811 ergo_format_reason("humongous allocation request failed") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
812 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
813 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
814 if (expand((num_regions - fs) * HeapRegion::GrainBytes)) { |
| 3766 | 815 // Even though the heap was expanded, it might not have |
| 816 // reached the desired size. So, we cannot assume that the | |
| 817 // allocation will succeed. | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
818 first = humongous_obj_allocate_find_first(num_regions, word_size); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
819 } |
| 2152 | 820 } |
| 821 } | |
| 822 | |
| 2361 | 823 HeapWord* result = NULL; |
| 3766 | 824 if (first != G1_NULL_HRS_INDEX) { |
| 2361 | 825 result = |
| 826 humongous_obj_allocate_initialize_regions(first, num_regions, word_size); | |
| 827 assert(result != NULL, "it should always return a valid result"); | |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
828 |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
829 // A successful humongous object allocation changes the used space |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
830 // information of the old generation so we need to recalculate the |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
831 // sizes and update the jstat counters here. |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
832 g1mm()->update_sizes(); |
| 2152 | 833 } |
| 834 | |
| 835 verify_region_sets_optional(); | |
| 2361 | 836 |
| 837 return result; | |
| 342 | 838 } |
| 839 | |
| 1973 | 840 HeapWord* G1CollectedHeap::allocate_new_tlab(size_t word_size) { |
| 841 assert_heap_not_locked_and_not_at_safepoint(); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
842 assert(!isHumongous(word_size), "we do not allow humongous TLABs"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
843 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
844 unsigned int dummy_gc_count_before; |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
845 int dummy_gclocker_retry_count = 0; |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
846 return attempt_allocation(word_size, &dummy_gc_count_before, &dummy_gclocker_retry_count); |
| 342 | 847 } |
| 848 | |
| 849 HeapWord* | |
| 850 G1CollectedHeap::mem_allocate(size_t word_size, | |
| 1973 | 851 bool* gc_overhead_limit_was_exceeded) { |
| 852 assert_heap_not_locked_and_not_at_safepoint(); | |
| 342 | 853 |
| 10405 | 854 // Loop until the allocation is satisfied, or unsatisfied after GC. |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
855 for (int try_count = 1, gclocker_retry_count = 0; /* we'll return */; try_count += 1) { |
| 1973 | 856 unsigned int gc_count_before; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
857 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
858 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
859 if (!isHumongous(word_size)) { |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
860 result = attempt_allocation(word_size, &gc_count_before, &gclocker_retry_count); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
861 } else { |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
862 result = attempt_allocation_humongous(word_size, &gc_count_before, &gclocker_retry_count); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
863 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
864 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
865 return result; |
| 342 | 866 } |
| 867 | |
| 868 // Create the garbage collection operation... | |
| 1973 | 869 VM_G1CollectForAllocation op(gc_count_before, word_size); |
| 342 | 870 // ...and get the VM thread to execute it. |
| 871 VMThread::execute(&op); | |
| 1973 | 872 |
| 873 if (op.prologue_succeeded() && op.pause_succeeded()) { | |
| 874 // If the operation was successful we'll return the result even | |
| 875 // if it is NULL. If the allocation attempt failed immediately | |
| 876 // after a Full GC, it's unlikely we'll be able to allocate now. | |
| 877 HeapWord* result = op.result(); | |
| 878 if (result != NULL && !isHumongous(word_size)) { | |
| 879 // Allocations that take place on VM operations do not do any | |
| 880 // card dirtying and we have to do it here. We only have to do | |
| 881 // this for non-humongous allocations, though. | |
| 882 dirty_young_block(result, word_size); | |
| 883 } | |
| 342 | 884 return result; |
| 1973 | 885 } else { |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
886 if (gclocker_retry_count > GCLockerRetryAllocationCount) { |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
887 return NULL; |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
888 } |
| 1973 | 889 assert(op.result() == NULL, |
| 890 "the result should be NULL if the VM op did not succeed"); | |
| 342 | 891 } |
| 892 | |
| 893 // Give a warning if we seem to be looping forever. | |
| 894 if ((QueuedAllocationWarningCount > 0) && | |
| 895 (try_count % QueuedAllocationWarningCount == 0)) { | |
| 1973 | 896 warning("G1CollectedHeap::mem_allocate retries %d times", try_count); |
| 342 | 897 } |
| 898 } | |
| 1973 | 899 |
| 900 ShouldNotReachHere(); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
901 return NULL; |
| 342 | 902 } |
| 903 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
904 HeapWord* G1CollectedHeap::attempt_allocation_slow(size_t word_size, |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
905 unsigned int *gc_count_before_ret, |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
906 int* gclocker_retry_count_ret) { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
907 // Make sure you read the note in attempt_allocation_humongous(). |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
908 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
909 assert_heap_not_locked_and_not_at_safepoint(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
910 assert(!isHumongous(word_size), "attempt_allocation_slow() should not " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
911 "be called for humongous allocation requests"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
912 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
913 // We should only get here after the first-level allocation attempt |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
914 // (attempt_allocation()) failed to allocate. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
915 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
916 // We will loop until a) we manage to successfully perform the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
917 // allocation or b) we successfully schedule a collection which |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
918 // fails to perform the allocation. b) is the only case when we'll |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
919 // return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
920 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
921 for (int try_count = 1; /* we'll return */; try_count += 1) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
922 bool should_try_gc; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
923 unsigned int gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
924 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
925 { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
926 MutexLockerEx x(Heap_lock); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
927 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
928 result = _mutator_alloc_region.attempt_allocation_locked(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
929 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
930 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
931 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
932 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
933 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
934 // If we reach here, attempt_allocation_locked() above failed to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
935 // allocate a new region. So the mutator alloc region should be NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
936 assert(_mutator_alloc_region.get() == NULL, "only way to get here"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
937 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
938 if (GC_locker::is_active_and_needs_gc()) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
939 if (g1_policy()->can_expand_young_list()) { |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
940 // No need for an ergo verbose message here, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
941 // can_expand_young_list() does this when it returns true. |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
942 result = _mutator_alloc_region.attempt_allocation_force(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
943 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
944 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
945 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
946 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
947 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
948 should_try_gc = false; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
949 } else { |
|
6106
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
950 // The GCLocker may not be active but the GCLocker initiated |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
951 // GC may not yet have been performed (GCLocker::needs_gc() |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
952 // returns true). In this case we do not try this GC and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
953 // wait until the GCLocker initiated GC is performed, and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
954 // then retry the allocation. |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
955 if (GC_locker::needs_gc()) { |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
956 should_try_gc = false; |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
957 } else { |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
958 // Read the GC count while still holding the Heap_lock. |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
959 gc_count_before = total_collections(); |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
960 should_try_gc = true; |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
961 } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
962 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
963 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
964 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
965 if (should_try_gc) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
966 bool succeeded; |
|
12113
f7d3b4387a16
8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents:
12082
diff
changeset
|
967 result = do_collection_pause(word_size, gc_count_before, &succeeded, |
|
f7d3b4387a16
8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents:
12082
diff
changeset
|
968 GCCause::_g1_inc_collection_pause); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
969 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
970 assert(succeeded, "only way to get back a non-NULL result"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
971 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
972 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
973 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
974 if (succeeded) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
975 // If we get here we successfully scheduled a collection which |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
976 // failed to allocate. No point in trying to allocate |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
977 // further. We'll just return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
978 MutexLockerEx x(Heap_lock); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
979 *gc_count_before_ret = total_collections(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
980 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
981 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
982 } else { |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
983 if (*gclocker_retry_count_ret > GCLockerRetryAllocationCount) { |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
984 MutexLockerEx x(Heap_lock); |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
985 *gc_count_before_ret = total_collections(); |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
986 return NULL; |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
987 } |
|
6106
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
988 // The GCLocker is either active or the GCLocker initiated |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
989 // GC has not yet been performed. Stall until it is and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
990 // then retry the allocation. |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
991 GC_locker::stall_until_clear(); |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
992 (*gclocker_retry_count_ret) += 1; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
993 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
994 |
| 10405 | 995 // We can reach here if we were unsuccessful in scheduling a |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
996 // collection (because another thread beat us to it) or if we were |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
997 // stalled due to the GC locker. In either can we should retry the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
998 // allocation attempt in case another thread successfully |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
999 // performed a collection and reclaimed enough space. We do the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1000 // first attempt (without holding the Heap_lock) here and the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1001 // follow-on attempt will be at the start of the next loop |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1002 // iteration (after taking the Heap_lock). |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1003 result = _mutator_alloc_region.attempt_allocation(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1004 false /* bot_updates */); |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
1005 if (result != NULL) { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1006 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1007 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1008 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1009 // Give a warning if we seem to be looping forever. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1010 if ((QueuedAllocationWarningCount > 0) && |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1011 (try_count % QueuedAllocationWarningCount == 0)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1012 warning("G1CollectedHeap::attempt_allocation_slow() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1013 "retries %d times", try_count); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1014 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1015 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1016 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1017 ShouldNotReachHere(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1018 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1019 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1020 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1021 HeapWord* G1CollectedHeap::attempt_allocation_humongous(size_t word_size, |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
1022 unsigned int * gc_count_before_ret, |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
1023 int* gclocker_retry_count_ret) { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1024 // The structure of this method has a lot of similarities to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1025 // attempt_allocation_slow(). The reason these two were not merged |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1026 // into a single one is that such a method would require several "if |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1027 // allocation is not humongous do this, otherwise do that" |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1028 // conditional paths which would obscure its flow. In fact, an early |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1029 // version of this code did use a unified method which was harder to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1030 // follow and, as a result, it had subtle bugs that were hard to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1031 // track down. So keeping these two methods separate allows each to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1032 // be more readable. It will be good to keep these two in sync as |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1033 // much as possible. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1034 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1035 assert_heap_not_locked_and_not_at_safepoint(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1036 assert(isHumongous(word_size), "attempt_allocation_humongous() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1037 "should only be called for humongous allocations"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1038 |
|
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1039 // Humongous objects can exhaust the heap quickly, so we should check if we |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1040 // need to start a marking cycle at each humongous object allocation. We do |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1041 // the check before we do the actual allocation. The reason for doing it |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1042 // before the allocation is that we avoid having to keep track of the newly |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1043 // allocated memory while we do a GC. |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
1044 if (g1_policy()->need_to_start_conc_mark("concurrent humongous allocation", |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
1045 word_size)) { |
|
4834
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1046 collect(GCCause::_g1_humongous_allocation); |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1047 } |
|
6a78aa6ac1ff
7132311: G1: assert((s == klass->oop_size(this)) || (Universe::heap()->is_gc_active() && ((is_typeArray()...
brutisso
parents:
4833
diff
changeset
|
1048 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1049 // We will loop until a) we manage to successfully perform the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1050 // allocation or b) we successfully schedule a collection which |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1051 // fails to perform the allocation. b) is the only case when we'll |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1052 // return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1053 HeapWord* result = NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1054 for (int try_count = 1; /* we'll return */; try_count += 1) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1055 bool should_try_gc; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1056 unsigned int gc_count_before; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1057 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1058 { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1059 MutexLockerEx x(Heap_lock); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1060 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1061 // Given that humongous objects are not allocated in young |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1062 // regions, we'll first try to do the allocation without doing a |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1063 // collection hoping that there's enough space in the heap. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1064 result = humongous_obj_allocate(word_size); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1065 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1066 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1067 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1068 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1069 if (GC_locker::is_active_and_needs_gc()) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1070 should_try_gc = false; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1071 } else { |
|
6106
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1072 // The GCLocker may not be active but the GCLocker initiated |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1073 // GC may not yet have been performed (GCLocker::needs_gc() |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1074 // returns true). In this case we do not try this GC and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1075 // wait until the GCLocker initiated GC is performed, and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1076 // then retry the allocation. |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1077 if (GC_locker::needs_gc()) { |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1078 should_try_gc = false; |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1079 } else { |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1080 // Read the GC count while still holding the Heap_lock. |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1081 gc_count_before = total_collections(); |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1082 should_try_gc = true; |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1083 } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1084 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1085 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1086 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1087 if (should_try_gc) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1088 // If we failed to allocate the humongous object, we should try to |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1089 // do a collection pause (if we're allowed) in case it reclaims |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1090 // enough space for the allocation to succeed after the pause. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1091 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1092 bool succeeded; |
|
12113
f7d3b4387a16
8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents:
12082
diff
changeset
|
1093 result = do_collection_pause(word_size, gc_count_before, &succeeded, |
|
f7d3b4387a16
8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents:
12082
diff
changeset
|
1094 GCCause::_g1_humongous_allocation); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1095 if (result != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1096 assert(succeeded, "only way to get back a non-NULL result"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1097 return result; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1098 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1099 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1100 if (succeeded) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1101 // If we get here we successfully scheduled a collection which |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1102 // failed to allocate. No point in trying to allocate |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1103 // further. We'll just return NULL. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1104 MutexLockerEx x(Heap_lock); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
1105 *gc_count_before_ret = total_collections(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1106 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1107 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1108 } else { |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
1109 if (*gclocker_retry_count_ret > GCLockerRetryAllocationCount) { |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
1110 MutexLockerEx x(Heap_lock); |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
1111 *gc_count_before_ret = total_collections(); |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
1112 return NULL; |
|
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
1113 } |
|
6106
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1114 // The GCLocker is either active or the GCLocker initiated |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1115 // GC has not yet been performed. Stall until it is and |
|
1d478c993020
7143858: G1: Back to back young GCs with the second GC having a minimally sized eden
johnc
parents:
6064
diff
changeset
|
1116 // then retry the allocation. |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1117 GC_locker::stall_until_clear(); |
|
8853
2e093b564241
7014552: gc/lock/jni/jnilockXXX works too slow on 1-processor machine
mgerdin
parents:
8038
diff
changeset
|
1118 (*gclocker_retry_count_ret) += 1; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1119 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1120 |
| 10405 | 1121 // We can reach here if we were unsuccessful in scheduling a |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1122 // collection (because another thread beat us to it) or if we were |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1123 // stalled due to the GC locker. In either can we should retry the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1124 // allocation attempt in case another thread successfully |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1125 // performed a collection and reclaimed enough space. Give a |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1126 // warning if we seem to be looping forever. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1127 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1128 if ((QueuedAllocationWarningCount > 0) && |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1129 (try_count % QueuedAllocationWarningCount == 0)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1130 warning("G1CollectedHeap::attempt_allocation_humongous() " |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1131 "retries %d times", try_count); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1132 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1133 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1134 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1135 ShouldNotReachHere(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1136 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1137 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1138 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1139 HeapWord* G1CollectedHeap::attempt_allocation_at_safepoint(size_t word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1140 bool expect_null_mutator_alloc_region) { |
| 2152 | 1141 assert_at_safepoint(true /* should_be_vm_thread */); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1142 assert(_mutator_alloc_region.get() == NULL || |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1143 !expect_null_mutator_alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1144 "the current alloc region was unexpectedly found to be non-NULL"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1145 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1146 if (!isHumongous(word_size)) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1147 return _mutator_alloc_region.attempt_allocation_locked(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1148 false /* bot_updates */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1149 } else { |
|
4829
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1150 HeapWord* result = humongous_obj_allocate(word_size); |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1151 if (result != NULL && g1_policy()->need_to_start_conc_mark("STW humongous allocation")) { |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1152 g1_policy()->set_initiate_conc_mark_if_possible(); |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1153 } |
|
9509c20bba28
6976060: G1: humongous object allocations should initiate marking cycles when necessary
brutisso
parents:
4787
diff
changeset
|
1154 return result; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1155 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1156 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1157 ShouldNotReachHere(); |
| 342 | 1158 } |
| 1159 | |
| 1160 class PostMCRemSetClearClosure: public HeapRegionClosure { | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1161 G1CollectedHeap* _g1h; |
| 342 | 1162 ModRefBarrierSet* _mr_bs; |
| 1163 public: | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1164 PostMCRemSetClearClosure(G1CollectedHeap* g1h, ModRefBarrierSet* mr_bs) : |
| 12080 | 1165 _g1h(g1h), _mr_bs(mr_bs) {} |
| 1166 | |
| 342 | 1167 bool doHeapRegion(HeapRegion* r) { |
| 12080 | 1168 HeapRegionRemSet* hrrs = r->rem_set(); |
| 1169 | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1170 if (r->continuesHumongous()) { |
| 12080 | 1171 // We'll assert that the strong code root list and RSet is empty |
| 1172 assert(hrrs->strong_code_roots_list_length() == 0, "sanity"); | |
| 1173 assert(hrrs->occupied() == 0, "RSet should be empty"); | |
| 342 | 1174 return false; |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1175 } |
| 12080 | 1176 |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1177 _g1h->reset_gc_time_stamps(r); |
| 12080 | 1178 hrrs->clear(); |
| 342 | 1179 // You might think here that we could clear just the cards |
| 1180 // corresponding to the used region. But no: if we leave a dirty card | |
| 1181 // in a region we might allocate into, then it would prevent that card | |
| 1182 // from being enqueued, and cause it to be missed. | |
| 1183 // Re: the performance cost: we shouldn't be doing full GC anyway! | |
| 1184 _mr_bs->clear(MemRegion(r->bottom(), r->end())); | |
| 12080 | 1185 |
| 342 | 1186 return false; |
| 1187 } | |
| 1188 }; | |
| 1189 | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1190 void G1CollectedHeap::clear_rsets_post_compaction() { |
| 12343 | 1191 PostMCRemSetClearClosure rs_clear(this, g1_barrier_set()); |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1192 heap_region_iterate(&rs_clear); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1193 } |
| 342 | 1194 |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1195 class RebuildRSOutOfRegionClosure: public HeapRegionClosure { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1196 G1CollectedHeap* _g1h; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1197 UpdateRSOopClosure _cl; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1198 int _worker_i; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1199 public: |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1200 RebuildRSOutOfRegionClosure(G1CollectedHeap* g1, int worker_i = 0) : |
| 1861 | 1201 _cl(g1->g1_rem_set(), worker_i), |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1202 _worker_i(worker_i), |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1203 _g1h(g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1204 { } |
|
1960
878b57474103
6978187: G1: assert(ParallelGCThreads> 1 || n_yielded() == _hrrs->occupied()) strikes again
johnc
parents:
1883
diff
changeset
|
1205 |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1206 bool doHeapRegion(HeapRegion* r) { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1207 if (!r->continuesHumongous()) { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1208 _cl.set_from(r); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1209 r->oop_iterate(&_cl); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1210 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1211 return false; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1212 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1213 }; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1214 |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1215 class ParRebuildRSTask: public AbstractGangTask { |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1216 G1CollectedHeap* _g1; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1217 public: |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1218 ParRebuildRSTask(G1CollectedHeap* g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1219 : AbstractGangTask("ParRebuildRSTask"), |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1220 _g1(g1) |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1221 { } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1222 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1223 void work(uint worker_id) { |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1224 RebuildRSOutOfRegionClosure rebuild_rs(_g1, worker_id); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
1225 _g1->heap_region_par_iterate_chunked(&rebuild_rs, worker_id, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
1226 _g1->workers()->active_workers(), |
|
626
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1227 HeapRegion::RebuildRSClaimValue); |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1228 } |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1229 }; |
|
87fa6e083d82
6760309: G1: update remembered sets during Full GCs
apetrusenko
parents:
620
diff
changeset
|
1230 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1231 class PostCompactionPrinterClosure: public HeapRegionClosure { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1232 private: |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1233 G1HRPrinter* _hr_printer; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1234 public: |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1235 bool doHeapRegion(HeapRegion* hr) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1236 assert(!hr->is_young(), "not expecting to find young regions"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1237 // We only generate output for non-empty regions. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1238 if (!hr->is_empty()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1239 if (!hr->isHumongous()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1240 _hr_printer->post_compaction(hr, G1HRPrinter::Old); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1241 } else if (hr->startsHumongous()) { |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1242 if (hr->region_num() == 1) { |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1243 // single humongous region |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1244 _hr_printer->post_compaction(hr, G1HRPrinter::SingleHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1245 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1246 _hr_printer->post_compaction(hr, G1HRPrinter::StartsHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1247 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1248 } else { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1249 assert(hr->continuesHumongous(), "only way to get here"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1250 _hr_printer->post_compaction(hr, G1HRPrinter::ContinuesHumongous); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1251 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1252 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1253 return false; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1254 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1255 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1256 PostCompactionPrinterClosure(G1HRPrinter* hr_printer) |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1257 : _hr_printer(hr_printer) { } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1258 }; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1259 |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1260 void G1CollectedHeap::print_hrs_post_compaction() { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1261 PostCompactionPrinterClosure cl(hr_printer()); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1262 heap_region_iterate(&cl); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1263 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
1264 |
| 1973 | 1265 bool G1CollectedHeap::do_collection(bool explicit_gc, |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
1266 bool clear_all_soft_refs, |
| 342 | 1267 size_t word_size) { |
| 2152 | 1268 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1269 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1270 if (GC_locker::check_active_before_gc()) { |
| 1973 | 1271 return false; |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1272 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
1273 |
| 10405 | 1274 STWGCTimer* gc_timer = G1MarkSweep::gc_timer(); |
|
13400
86e6d691f2e1
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
13062
diff
changeset
|
1275 gc_timer->register_gc_start(); |
| 10405 | 1276 |
| 1277 SerialOldTracer* gc_tracer = G1MarkSweep::gc_tracer(); | |
| 1278 gc_tracer->report_gc_start(gc_cause(), gc_timer->gc_start()); | |
| 1279 | |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
1280 SvcGCMarker sgcm(SvcGCMarker::FULL); |
| 342 | 1281 ResourceMark rm; |
| 1282 | |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4787
diff
changeset
|
1283 print_heap_before_gc(); |
| 10405 | 1284 trace_heap_before_gc(gc_tracer); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
1285 |
|
17866
270d7cb38f40
8038934: Remove prefix allocated_ from methods and variables in Metaspace
ehelin
parents:
17844
diff
changeset
|
1286 size_t metadata_prev_used = MetaspaceAux::used_bytes(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
1287 |
| 2152 | 1288 verify_region_sets_optional(); |
| 342 | 1289 |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1290 const bool do_clear_all_soft_refs = clear_all_soft_refs || |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1291 collector_policy()->should_clear_all_soft_refs(); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1292 |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1293 ClearedAllSoftRefs casr(do_clear_all_soft_refs, collector_policy()); |
|
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1294 |
| 342 | 1295 { |
| 1296 IsGCActiveMark x; | |
| 1297 | |
| 1298 // Timing | |
| 6030 | 1299 assert(gc_cause() != GCCause::_java_lang_system_gc || explicit_gc, "invariant"); |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1300 gclog_or_tty->date_stamp(G1Log::fine() && PrintGCDateStamps); |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1301 TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); |
| 6030 | 1302 |
| 342 | 1303 { |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17992
diff
changeset
|
1304 GCTraceTime t(GCCauseString("Full GC", gc_cause()), G1Log::fine(), true, NULL, gc_tracer->gc_id()); |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1305 TraceCollectorStats tcs(g1mm()->full_collection_counters()); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1306 TraceMemoryManagerStats tms(true /* fullGC */, gc_cause()); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1307 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1308 double start = os::elapsedTime(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1309 g1_policy()->record_full_collection_start(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1310 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1311 // Note: When we have a more flexible GC logging framework that |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1312 // allows us to add optional attributes to a GC log record we |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1313 // could consider timing and reporting how long we wait in the |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1314 // following two methods. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1315 wait_while_free_regions_coming(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1316 // If we start the compaction before the CM threads finish |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1317 // scanning the root regions we might trip them over as we'll |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1318 // be moving objects / updating references. So let's wait until |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1319 // they are done. By telling them to abort, they should complete |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1320 // early. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1321 _cm->root_regions()->abort(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1322 _cm->root_regions()->wait_until_scan_finished(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1323 append_secondary_free_list_if_not_empty_with_lock(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1324 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1325 gc_prologue(true); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1326 increment_total_collections(true /* full gc */); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1327 increment_old_marking_cycles_started(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1328 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1329 assert(used() == recalculate_used(), "Should be equal"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1330 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1331 verify_before_gc(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1332 |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1333 check_bitmaps("Full GC Start"); |
| 10405 | 1334 pre_full_gc_dump(gc_timer); |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1335 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1336 COMPILER2_PRESENT(DerivedPointerTable::clear()); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1337 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1338 // Disable discovery and empty the discovered lists |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1339 // for the CM ref processor. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1340 ref_processor_cm()->disable_discovery(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1341 ref_processor_cm()->abandon_partial_discovery(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1342 ref_processor_cm()->verify_no_references_recorded(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1343 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1344 // Abandon current iterations of concurrent marking and concurrent |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1345 // refinement, if any are in progress. We have to do this before |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1346 // wait_until_scan_finished() below. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1347 concurrent_mark()->abort(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1348 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1349 // Make sure we'll choose a new allocation region afterwards. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1350 release_mutator_alloc_region(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1351 abandon_gc_alloc_regions(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1352 g1_rem_set()->cleanupHRRS(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1353 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1354 // We should call this after we retire any currently active alloc |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1355 // regions so that all the ALLOC / RETIRE events are generated |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1356 // before the start GC event. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1357 _hr_printer.start_gc(true /* full */, (size_t) total_collections()); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1358 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1359 // We may have added regions to the current incremental collection |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1360 // set between the last GC or pause and now. We need to clear the |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1361 // incremental collection set and then start rebuilding it afresh |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1362 // after this full GC. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1363 abandon_collection_set(g1_policy()->inc_cset_head()); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1364 g1_policy()->clear_incremental_cset(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1365 g1_policy()->stop_incremental_cset_building(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1366 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1367 tear_down_region_sets(false /* free_list_only */); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1368 g1_policy()->set_gcs_are_young(true); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1369 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1370 // See the comments in g1CollectedHeap.hpp and |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1371 // G1CollectedHeap::ref_processing_init() about |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1372 // how reference processing currently works in G1. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1373 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1374 // Temporarily make discovery by the STW ref processor single threaded (non-MT). |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1375 ReferenceProcessorMTDiscoveryMutator stw_rp_disc_ser(ref_processor_stw(), false); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1376 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1377 // Temporarily clear the STW ref processor's _is_alive_non_header field. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1378 ReferenceProcessorIsAliveMutator stw_rp_is_alive_null(ref_processor_stw(), NULL); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1379 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1380 ref_processor_stw()->enable_discovery(true /*verify_disabled*/, true /*verify_no_refs*/); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1381 ref_processor_stw()->setup_policy(do_clear_all_soft_refs); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1382 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1383 // Do collection work |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1384 { |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1385 HandleMark hm; // Discard invalid handles created during gc |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1386 G1MarkSweep::invoke_at_safepoint(ref_processor_stw(), do_clear_all_soft_refs); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1387 } |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1388 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1389 assert(free_regions() == 0, "we should not have added any free regions"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1390 rebuild_region_sets(false /* free_list_only */); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1391 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1392 // Enqueue any discovered reference objects that have |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1393 // not been removed from the discovered lists. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1394 ref_processor_stw()->enqueue_discovered_references(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1395 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1396 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1397 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1398 MemoryService::track_memory_usage(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1399 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1400 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1401 ref_processor_stw()->verify_no_references_recorded(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1402 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1403 // Delete metaspaces for unloaded class loaders and clean up loader_data graph |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1404 ClassLoaderDataGraph::purge(); |
| 12080 | 1405 MetaspaceAux::verify_metrics(); |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1406 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1407 // Note: since we've just done a full GC, concurrent |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1408 // marking is no longer active. Therefore we need not |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1409 // re-enable reference discovery for the CM ref processor. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1410 // That will be done at the start of the next marking cycle. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1411 assert(!ref_processor_cm()->discovery_enabled(), "Postcondition"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1412 ref_processor_cm()->verify_no_references_recorded(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1413 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1414 reset_gc_time_stamp(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1415 // Since everything potentially moved, we will clear all remembered |
| 10405 | 1416 // sets, and clear all cards. Later we will rebuild remembered |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1417 // sets. We will also reset the GC time stamps of the regions. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1418 clear_rsets_post_compaction(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1419 check_gc_time_stamps(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1420 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1421 // Resize the heap if necessary. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1422 resize_if_necessary_after_full_collection(explicit_gc ? 0 : word_size); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1423 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1424 if (_hr_printer.is_active()) { |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1425 // We should do this after we potentially resize the heap so |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1426 // that all the COMMIT / UNCOMMIT events are generated before |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1427 // the end GC event. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1428 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1429 print_hrs_post_compaction(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1430 _hr_printer.end_gc(true /* full */, (size_t) total_collections()); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1431 } |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1432 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
1433 G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
1434 if (hot_card_cache->use_cache()) { |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
1435 hot_card_cache->reset_card_counts(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
1436 hot_card_cache->reset_hot_cache(); |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1437 } |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1438 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1439 // Rebuild remembered sets of all regions. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1440 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1441 uint n_workers = |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1442 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(), |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1443 workers()->active_workers(), |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1444 Threads::number_of_non_daemon_threads()); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1445 assert(UseDynamicNumberOfGCThreads || |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1446 n_workers == workers()->total_workers(), |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1447 "If not dynamic should be using all the workers"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1448 workers()->set_active_workers(n_workers); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1449 // Set parallel threads in the heap (_n_par_threads) only |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1450 // before a parallel phase and always reset it to 0 after |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1451 // the phase so that the number of parallel threads does |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1452 // no get carried forward to a serial phase where there |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1453 // may be code that is "possibly_parallel". |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1454 set_par_threads(n_workers); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1455 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1456 ParRebuildRSTask rebuild_rs_task(this); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1457 assert(check_heap_region_claim_values( |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1458 HeapRegion::InitialClaimValue), "sanity check"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1459 assert(UseDynamicNumberOfGCThreads || |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1460 workers()->active_workers() == workers()->total_workers(), |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1461 "Unless dynamic should use total workers"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1462 // Use the most recent number of active workers |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1463 assert(workers()->active_workers() > 0, |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1464 "Active workers not properly set"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1465 set_par_threads(workers()->active_workers()); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1466 workers()->run_task(&rebuild_rs_task); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1467 set_par_threads(0); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1468 assert(check_heap_region_claim_values( |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1469 HeapRegion::RebuildRSClaimValue), "sanity check"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1470 reset_heap_region_claim_values(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1471 } else { |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1472 RebuildRSOutOfRegionClosure rebuild_rs(this); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1473 heap_region_iterate(&rebuild_rs); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1474 } |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1475 |
| 12080 | 1476 // Rebuild the strong code root lists for each region |
| 1477 rebuild_strong_code_roots(); | |
| 1478 | |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1479 if (true) { // FIXME |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1480 MetaspaceGC::compute_new_size(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1481 } |
| 342 | 1482 |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1483 #ifdef TRACESPINNING |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1484 ParallelTaskTerminator::print_termination_counts(); |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1485 #endif |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
1486 |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1487 // Discard all rset updates |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1488 JavaThread::dirty_card_queue_set().abandon_logs(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1489 assert(!G1DeferredRSUpdate |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1490 || (G1DeferredRSUpdate && |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1491 (dirty_card_queue_set().completed_buffers_num() == 0)), "Should not be any"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1492 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1493 _young_list->reset_sampled_info(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1494 // At this point there should be no regions in the |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1495 // entire heap tagged as young. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1496 assert(check_young_list_empty(true /* check_heap */), |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1497 "young list should be empty at this point"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1498 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1499 // Update the number of full collections that have been completed. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1500 increment_old_marking_cycles_completed(false /* concurrent */); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1501 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1502 _hrs.verify_optional(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1503 verify_region_sets_optional(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1504 |
|
10373
3a4805ad0005
8015244: G1: Verification after a full GC is incorrectly placed.
johnc
parents:
10372
diff
changeset
|
1505 verify_after_gc(); |
|
3a4805ad0005
8015244: G1: Verification after a full GC is incorrectly placed.
johnc
parents:
10372
diff
changeset
|
1506 |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1507 // Clear the previous marking bitmap, if needed for bitmap verification. |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1508 // Note we cannot do this when we clear the next marking bitmap in |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1509 // ConcurrentMark::abort() above since VerifyDuringGC verifies the |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1510 // objects marked during a full GC against the previous bitmap. |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1511 // But we need to clear it before calling check_bitmaps below since |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1512 // the full GC has compacted objects and updated TAMS but not updated |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1513 // the prev bitmap. |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1514 if (G1VerifyBitmaps) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1515 ((CMBitMap*) concurrent_mark()->prevMarkBitMap())->clearAll(); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1516 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1517 check_bitmaps("Full GC End"); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
1518 |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1519 // Start a new incremental collection set for the next pause |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1520 assert(g1_policy()->collection_set() == NULL, "must be"); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1521 g1_policy()->start_incremental_cset_building(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1522 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1523 clear_cset_fast_test(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1524 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1525 init_mutator_alloc_region(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1526 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1527 double end = os::elapsedTime(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1528 g1_policy()->record_full_collection_end(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1529 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1530 if (G1Log::fine()) { |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1531 g1_policy()->print_heap_transition(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1532 } |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1533 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1534 // We must call G1MonitoringSupport::update_sizes() in the same scoping level |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1535 // as an active TraceMemoryManagerStats object (i.e. before the destructor for the |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1536 // TraceMemoryManagerStats is called) so that the G1 memory pools are updated |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1537 // before any GC notifications are raised. |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1538 g1mm()->update_sizes(); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1539 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1540 gc_epilogue(true); |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1541 } |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1542 |
|
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1543 if (G1Log::finer()) { |
|
10291
48391ab0687e
8010738: G1: Output for full GCs with +PrintGCDetails should contain perm gen size/meta data change info
johnc
parents:
10246
diff
changeset
|
1544 g1_policy()->print_detailed_heap_transition(true /* full */); |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1545 } |
|
6121
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1546 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
1547 print_heap_after_gc(); |
| 10405 | 1548 trace_heap_after_gc(gc_tracer); |
| 1549 | |
| 1550 post_full_gc_dump(gc_timer); | |
| 1551 | |
|
13400
86e6d691f2e1
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
13062
diff
changeset
|
1552 gc_timer->register_gc_end(); |
| 10405 | 1553 gc_tracer->report_gc_end(gc_timer->gc_end(), gc_timer->time_partitions()); |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
1554 } |
| 1973 | 1555 |
| 1556 return true; | |
| 342 | 1557 } |
| 1558 | |
| 1559 void G1CollectedHeap::do_full_collection(bool clear_all_soft_refs) { | |
| 1973 | 1560 // do_collection() will return whether it succeeded in performing |
| 1561 // the GC. Currently, there is no facility on the | |
| 1562 // do_full_collection() API to notify the caller than the collection | |
| 1563 // did not succeed (e.g., because it was locked out by the GC | |
| 1564 // locker). So, right now, we'll ignore the return value. | |
| 1565 bool dummy = do_collection(true, /* explicit_gc */ | |
| 1566 clear_all_soft_refs, | |
| 1567 0 /* word_size */); | |
| 342 | 1568 } |
| 1569 | |
| 1570 // This code is mostly copied from TenuredGeneration. | |
| 1571 void | |
| 1572 G1CollectedHeap:: | |
| 1573 resize_if_necessary_after_full_collection(size_t word_size) { | |
| 1574 // Include the current allocation, if any, and bytes that will be | |
| 1575 // pre-allocated to support collections, as "used". | |
| 1576 const size_t used_after_gc = used(); | |
| 1577 const size_t capacity_after_gc = capacity(); | |
| 1578 const size_t free_after_gc = capacity_after_gc - used_after_gc; | |
| 1579 | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1580 // This is enforced in arguments.cpp. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1581 assert(MinHeapFreeRatio <= MaxHeapFreeRatio, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1582 "otherwise the code below doesn't make sense"); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1583 |
| 342 | 1584 // We don't have floating point command-line arguments |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1585 const double minimum_free_percentage = (double) MinHeapFreeRatio / 100.0; |
| 342 | 1586 const double maximum_used_percentage = 1.0 - minimum_free_percentage; |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1587 const double maximum_free_percentage = (double) MaxHeapFreeRatio / 100.0; |
| 342 | 1588 const double minimum_used_percentage = 1.0 - maximum_free_percentage; |
| 1589 | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1590 const size_t min_heap_size = collector_policy()->min_heap_byte_size(); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1591 const size_t max_heap_size = collector_policy()->max_heap_byte_size(); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1592 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1593 // We have to be careful here as these two calculations can overflow |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1594 // 32-bit size_t's. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1595 double used_after_gc_d = (double) used_after_gc; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1596 double minimum_desired_capacity_d = used_after_gc_d / maximum_used_percentage; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1597 double maximum_desired_capacity_d = used_after_gc_d / minimum_used_percentage; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1598 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1599 // Let's make sure that they are both under the max heap size, which |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1600 // by default will make them fit into a size_t. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1601 double desired_capacity_upper_bound = (double) max_heap_size; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1602 minimum_desired_capacity_d = MIN2(minimum_desired_capacity_d, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1603 desired_capacity_upper_bound); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1604 maximum_desired_capacity_d = MIN2(maximum_desired_capacity_d, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1605 desired_capacity_upper_bound); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1606 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1607 // We can now safely turn them into size_t's. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1608 size_t minimum_desired_capacity = (size_t) minimum_desired_capacity_d; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1609 size_t maximum_desired_capacity = (size_t) maximum_desired_capacity_d; |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1610 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1611 // This assert only makes sense here, before we adjust them |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1612 // with respect to the min and max heap size. |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1613 assert(minimum_desired_capacity <= maximum_desired_capacity, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1614 err_msg("minimum_desired_capacity = "SIZE_FORMAT", " |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1615 "maximum_desired_capacity = "SIZE_FORMAT, |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1616 minimum_desired_capacity, maximum_desired_capacity)); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1617 |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1618 // Should not be greater than the heap max size. No need to adjust |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1619 // it with respect to the heap min size as it's a lower bound (i.e., |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1620 // we'll try to make the capacity larger than it, not smaller). |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1621 minimum_desired_capacity = MIN2(minimum_desired_capacity, max_heap_size); |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1622 // Should not be less than the heap min size. No need to adjust it |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1623 // with respect to the heap max size as it's an upper bound (i.e., |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1624 // we'll try to make the capacity smaller than it, not greater). |
|
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1625 maximum_desired_capacity = MAX2(maximum_desired_capacity, min_heap_size); |
| 342 | 1626 |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1627 if (capacity_after_gc < minimum_desired_capacity) { |
| 342 | 1628 // Don't expand unless it's significant |
| 1629 size_t expand_bytes = minimum_desired_capacity - capacity_after_gc; | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1630 ergo_verbose4(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1631 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1632 ergo_format_reason("capacity lower than " |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1633 "min desired capacity after Full GC") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1634 ergo_format_byte("capacity") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1635 ergo_format_byte("occupancy") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1636 ergo_format_byte_perc("min desired capacity"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1637 capacity_after_gc, used_after_gc, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1638 minimum_desired_capacity, (double) MinHeapFreeRatio); |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1639 expand(expand_bytes); |
| 342 | 1640 |
| 1641 // No expansion, now see if we want to shrink | |
|
1717
688c3755d7af
6959014: G1: assert(minimum_desired_capacity <= maximum_desired_capacity) failed: sanity check
tonyp
parents:
1709
diff
changeset
|
1642 } else if (capacity_after_gc > maximum_desired_capacity) { |
| 342 | 1643 // Capacity too large, compute shrinking size |
| 1644 size_t shrink_bytes = capacity_after_gc - maximum_desired_capacity; | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1645 ergo_verbose4(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1646 "attempt heap shrinking", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1647 ergo_format_reason("capacity higher than " |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1648 "max desired capacity after Full GC") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1649 ergo_format_byte("capacity") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1650 ergo_format_byte("occupancy") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1651 ergo_format_byte_perc("max desired capacity"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1652 capacity_after_gc, used_after_gc, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1653 maximum_desired_capacity, (double) MaxHeapFreeRatio); |
| 342 | 1654 shrink(shrink_bytes); |
| 1655 } | |
| 1656 } | |
| 1657 | |
| 1658 | |
| 1659 HeapWord* | |
| 1973 | 1660 G1CollectedHeap::satisfy_failed_allocation(size_t word_size, |
| 1661 bool* succeeded) { | |
| 2152 | 1662 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1973 | 1663 |
| 1664 *succeeded = true; | |
| 1665 // Let's attempt the allocation first. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1666 HeapWord* result = |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1667 attempt_allocation_at_safepoint(word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1668 false /* expect_null_mutator_alloc_region */); |
| 1973 | 1669 if (result != NULL) { |
| 1670 assert(*succeeded, "sanity"); | |
| 1671 return result; | |
| 1672 } | |
| 342 | 1673 |
| 1674 // In a G1 heap, we're supposed to keep allocation from failing by | |
| 1675 // incremental pauses. Therefore, at least for now, we'll favor | |
| 1676 // expansion over collection. (This might change in the future if we can | |
| 1677 // do something smarter than full collection to satisfy a failed alloc.) | |
| 1678 result = expand_and_allocate(word_size); | |
| 1679 if (result != NULL) { | |
| 1973 | 1680 assert(*succeeded, "sanity"); |
| 342 | 1681 return result; |
| 1682 } | |
| 1683 | |
| 1973 | 1684 // Expansion didn't work, we'll try to do a Full GC. |
| 1685 bool gc_succeeded = do_collection(false, /* explicit_gc */ | |
| 1686 false, /* clear_all_soft_refs */ | |
| 1687 word_size); | |
| 1688 if (!gc_succeeded) { | |
| 1689 *succeeded = false; | |
| 1690 return NULL; | |
| 1691 } | |
| 1692 | |
| 1693 // Retry the allocation | |
| 1694 result = attempt_allocation_at_safepoint(word_size, | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1695 true /* expect_null_mutator_alloc_region */); |
| 342 | 1696 if (result != NULL) { |
| 1973 | 1697 assert(*succeeded, "sanity"); |
| 342 | 1698 return result; |
| 1699 } | |
| 1700 | |
| 1973 | 1701 // Then, try a Full GC that will collect all soft references. |
| 1702 gc_succeeded = do_collection(false, /* explicit_gc */ | |
| 1703 true, /* clear_all_soft_refs */ | |
| 1704 word_size); | |
| 1705 if (!gc_succeeded) { | |
| 1706 *succeeded = false; | |
| 1707 return NULL; | |
| 1708 } | |
| 1709 | |
| 1710 // Retry the allocation once more | |
| 1711 result = attempt_allocation_at_safepoint(word_size, | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1712 true /* expect_null_mutator_alloc_region */); |
| 342 | 1713 if (result != NULL) { |
| 1973 | 1714 assert(*succeeded, "sanity"); |
| 342 | 1715 return result; |
| 1716 } | |
| 1717 | |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1718 assert(!collector_policy()->should_clear_all_soft_refs(), |
| 1973 | 1719 "Flag should have been handled and cleared prior to this point"); |
|
1387
0bfd3fb24150
6858496: Clear all SoftReferences before an out-of-memory due to GC overhead limit.
jmasa
parents:
1360
diff
changeset
|
1720 |
| 342 | 1721 // What else? We might try synchronous finalization later. If the total |
| 1722 // space available is large enough for the allocation, then a more | |
| 1723 // complete compaction phase than we've tried so far might be | |
| 1724 // appropriate. | |
| 1973 | 1725 assert(*succeeded, "sanity"); |
| 342 | 1726 return NULL; |
| 1727 } | |
| 1728 | |
| 1729 // Attempting to expand the heap sufficiently | |
| 1730 // to support an allocation of the given "word_size". If | |
| 1731 // successful, perform the allocation and return the address of the | |
| 1732 // allocated block, or else "NULL". | |
| 1733 | |
| 1734 HeapWord* G1CollectedHeap::expand_and_allocate(size_t word_size) { | |
| 2152 | 1735 assert_at_safepoint(true /* should_be_vm_thread */); |
| 1736 | |
| 1737 verify_region_sets_optional(); | |
| 1973 | 1738 |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1739 size_t expand_bytes = MAX2(word_size * HeapWordSize, MinHeapDeltaBytes); |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1740 ergo_verbose1(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1741 "attempt heap expansion", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1742 ergo_format_reason("allocation request failed") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1743 ergo_format_byte("allocation request"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1744 word_size * HeapWordSize); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1745 if (expand(expand_bytes)) { |
| 3766 | 1746 _hrs.verify_optional(); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1747 verify_region_sets_optional(); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1748 return attempt_allocation_at_safepoint(word_size, |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
1749 false /* expect_null_mutator_alloc_region */); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1750 } |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1751 return NULL; |
| 342 | 1752 } |
| 1753 | |
| 3766 | 1754 void G1CollectedHeap::update_committed_space(HeapWord* old_end, |
| 1755 HeapWord* new_end) { | |
| 1756 assert(old_end != new_end, "don't call this otherwise"); | |
| 1757 assert((HeapWord*) _g1_storage.high() == new_end, "invariant"); | |
| 1758 | |
| 1759 // Update the committed mem region. | |
| 1760 _g1_committed.set_end(new_end); | |
| 1761 // Tell the card table about the update. | |
| 1762 Universe::heap()->barrier_set()->resize_covered_region(_g1_committed); | |
| 1763 // Tell the BOT about the update. | |
| 1764 _bot_shared->resize(_g1_committed.word_size()); | |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
1765 // Tell the hot card cache about the update |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
1766 _cg1r->hot_card_cache()->resize_card_counts(capacity()); |
| 3766 | 1767 } |
| 1768 | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1769 bool G1CollectedHeap::expand(size_t expand_bytes) { |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1770 size_t aligned_expand_bytes = ReservedSpace::page_align_size_up(expand_bytes); |
| 342 | 1771 aligned_expand_bytes = align_size_up(aligned_expand_bytes, |
| 1772 HeapRegion::GrainBytes); | |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1773 ergo_verbose2(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1774 "expand the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1775 ergo_format_byte("requested expansion amount") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1776 ergo_format_byte("attempted expansion amount"), |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1777 expand_bytes, aligned_expand_bytes); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1778 |
|
12345
9de9169ddde6
8025605: G1: Heap expansion logging misleading for fully expanded heap
brutisso
parents:
12343
diff
changeset
|
1779 if (_g1_storage.uncommitted_size() == 0) { |
|
9de9169ddde6
8025605: G1: Heap expansion logging misleading for fully expanded heap
brutisso
parents:
12343
diff
changeset
|
1780 ergo_verbose0(ErgoHeapSizing, |
|
9de9169ddde6
8025605: G1: Heap expansion logging misleading for fully expanded heap
brutisso
parents:
12343
diff
changeset
|
1781 "did not expand the heap", |
|
9de9169ddde6
8025605: G1: Heap expansion logging misleading for fully expanded heap
brutisso
parents:
12343
diff
changeset
|
1782 ergo_format_reason("heap already fully expanded")); |
|
9de9169ddde6
8025605: G1: Heap expansion logging misleading for fully expanded heap
brutisso
parents:
12343
diff
changeset
|
1783 return false; |
|
9de9169ddde6
8025605: G1: Heap expansion logging misleading for fully expanded heap
brutisso
parents:
12343
diff
changeset
|
1784 } |
|
9de9169ddde6
8025605: G1: Heap expansion logging misleading for fully expanded heap
brutisso
parents:
12343
diff
changeset
|
1785 |
| 3766 | 1786 // First commit the memory. |
| 1787 HeapWord* old_end = (HeapWord*) _g1_storage.high(); | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1788 bool successful = _g1_storage.expand_by(aligned_expand_bytes); |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1789 if (successful) { |
| 3766 | 1790 // Then propagate this update to the necessary data structures. |
| 1791 HeapWord* new_end = (HeapWord*) _g1_storage.high(); | |
| 1792 update_committed_space(old_end, new_end); | |
| 1793 | |
| 1794 FreeRegionList expansion_list("Local Expansion List"); | |
| 1795 MemRegion mr = _hrs.expand_by(old_end, new_end, &expansion_list); | |
| 1796 assert(mr.start() == old_end, "post-condition"); | |
| 1797 // mr might be a smaller region than what was requested if | |
| 1798 // expand_by() was unable to allocate the HeapRegion instances | |
| 1799 assert(mr.end() <= new_end, "post-condition"); | |
| 1800 | |
| 1801 size_t actual_expand_bytes = mr.byte_size(); | |
| 1802 assert(actual_expand_bytes <= aligned_expand_bytes, "post-condition"); | |
| 1803 assert(actual_expand_bytes == expansion_list.total_capacity_bytes(), | |
| 1804 "post-condition"); | |
| 1805 if (actual_expand_bytes < aligned_expand_bytes) { | |
| 1806 // We could not expand _hrs to the desired size. In this case we | |
| 1807 // need to shrink the committed space accordingly. | |
| 1808 assert(mr.end() < new_end, "invariant"); | |
| 1809 | |
| 1810 size_t diff_bytes = aligned_expand_bytes - actual_expand_bytes; | |
| 1811 // First uncommit the memory. | |
| 1812 _g1_storage.shrink_by(diff_bytes); | |
| 1813 // Then propagate this update to the necessary data structures. | |
| 1814 update_committed_space(new_end, mr.end()); | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1815 } |
| 3766 | 1816 _free_list.add_as_tail(&expansion_list); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1817 |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1818 if (_hr_printer.is_active()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1819 HeapWord* curr = mr.start(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1820 while (curr < mr.end()) { |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1821 HeapWord* curr_end = curr + HeapRegion::GrainWords; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1822 _hr_printer.commit(curr, curr_end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1823 curr = curr_end; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1824 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1825 assert(curr == mr.end(), "post-condition"); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1826 } |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1827 g1_policy()->record_new_heap_size(n_regions()); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1828 } else { |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1829 ergo_verbose0(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1830 "did not expand the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1831 ergo_format_reason("heap expansion operation failed")); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1832 // The expansion of the virtual storage space was unsuccessful. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1833 // Let's see if it was because we ran out of swap. |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1834 if (G1ExitOnExpansionFailure && |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1835 _g1_storage.uncommitted_size() >= aligned_expand_bytes) { |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1836 // We had head room... |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10099
diff
changeset
|
1837 vm_exit_out_of_memory(aligned_expand_bytes, OOM_MMAP_ERROR, "G1 heap expansion"); |
| 342 | 1838 } |
| 1839 } | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
1840 return successful; |
| 342 | 1841 } |
| 1842 | |
| 3766 | 1843 void G1CollectedHeap::shrink_helper(size_t shrink_bytes) { |
| 342 | 1844 size_t aligned_shrink_bytes = |
| 1845 ReservedSpace::page_align_size_down(shrink_bytes); | |
| 1846 aligned_shrink_bytes = align_size_down(aligned_shrink_bytes, | |
| 1847 HeapRegion::GrainBytes); | |
|
10242
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1848 uint num_regions_to_remove = (uint)(shrink_bytes / HeapRegion::GrainBytes); |
|
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1849 |
|
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1850 uint num_regions_removed = _hrs.shrink_by(num_regions_to_remove); |
| 3766 | 1851 HeapWord* old_end = (HeapWord*) _g1_storage.high(); |
|
10242
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1852 size_t shrunk_bytes = num_regions_removed * HeapRegion::GrainBytes; |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1853 |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1854 ergo_verbose3(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1855 "shrink the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1856 ergo_format_byte("requested shrinking amount") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1857 ergo_format_byte("aligned shrinking amount") |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1858 ergo_format_byte("attempted shrinking amount"), |
|
10242
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1859 shrink_bytes, aligned_shrink_bytes, shrunk_bytes); |
|
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1860 if (num_regions_removed > 0) { |
|
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1861 _g1_storage.shrink_by(shrunk_bytes); |
|
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1862 HeapWord* new_end = (HeapWord*) _g1_storage.high(); |
|
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1863 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1864 if (_hr_printer.is_active()) { |
|
10242
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1865 HeapWord* curr = old_end; |
|
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1866 while (curr > new_end) { |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1867 HeapWord* curr_end = curr; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1868 curr -= HeapRegion::GrainWords; |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1869 _hr_printer.uncommit(curr, curr_end); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1870 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1871 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1872 |
|
10242
b0d20fa374b4
8013872: G1: HeapRegionSeq::shrink_by() has invalid assert
brutisso
parents:
10193
diff
changeset
|
1873 _expansion_regions += num_regions_removed; |
| 3766 | 1874 update_committed_space(old_end, new_end); |
| 1875 HeapRegionRemSet::shrink_heap(n_regions()); | |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
1876 g1_policy()->record_new_heap_size(n_regions()); |
|
3914
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1877 } else { |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1878 ergo_verbose0(ErgoHeapSizing, |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1879 "did not shrink the heap", |
|
20213c8a3c40
7050392: G1: Introduce flag to generate a log of the G1 ergonomic decisions
tonyp
parents:
3886
diff
changeset
|
1880 ergo_format_reason("heap shrinking operation failed")); |
| 342 | 1881 } |
| 1882 } | |
| 1883 | |
| 1884 void G1CollectedHeap::shrink(size_t shrink_bytes) { | |
| 2152 | 1885 verify_region_sets_optional(); |
| 1886 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1887 // We should only reach here at the end of a Full GC which means we |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1888 // should not not be holding to any GC alloc regions. The method |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1889 // below will make sure of that and do any remaining clean up. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1890 abandon_gc_alloc_regions(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1891 |
| 2152 | 1892 // Instead of tearing down / rebuilding the free lists here, we |
| 1893 // could instead use the remove_all_pending() method on free_list to | |
| 1894 // remove only the ones that we need to remove. | |
| 4072 | 1895 tear_down_region_sets(true /* free_list_only */); |
| 342 | 1896 shrink_helper(shrink_bytes); |
| 4072 | 1897 rebuild_region_sets(true /* free_list_only */); |
| 2152 | 1898 |
| 3766 | 1899 _hrs.verify_optional(); |
| 2152 | 1900 verify_region_sets_optional(); |
| 342 | 1901 } |
| 1902 | |
| 1903 // Public methods. | |
| 1904 | |
| 1905 #ifdef _MSC_VER // the use of 'this' below gets a warning, make it go away | |
| 1906 #pragma warning( disable:4355 ) // 'this' : used in base member initializer list | |
| 1907 #endif // _MSC_VER | |
| 1908 | |
| 1909 | |
| 1910 G1CollectedHeap::G1CollectedHeap(G1CollectorPolicy* policy_) : | |
| 1911 SharedHeap(policy_), | |
| 1912 _g1_policy(policy_), | |
| 1111 | 1913 _dirty_card_queue_set(false), |
| 1705 | 1914 _into_cset_dirty_card_queue_set(false), |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1915 _is_alive_closure_cm(this), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1916 _is_alive_closure_stw(this), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1917 _ref_processor_cm(NULL), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
1918 _ref_processor_stw(NULL), |
| 342 | 1919 _process_strong_tasks(new SubTasksDone(G1H_PS_NumElements)), |
| 1920 _bot_shared(NULL), | |
| 10405 | 1921 _evac_failure_scan_stack(NULL), |
| 342 | 1922 _mark_in_progress(false), |
| 2152 | 1923 _cg1r(NULL), _summary_bytes_used(0), |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
1924 _g1mm(NULL), |
| 342 | 1925 _refine_cte_cl(NULL), |
| 1926 _full_collection(false), | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
1927 _free_list("Master Free List", new MasterFreeRegionListMtSafeChecker()), |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
1928 _secondary_free_list("Secondary Free List", new SecondaryFreeRegionListMtSafeChecker()), |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
1929 _old_set("Old Set", false /* humongous */, new OldRegionSetMtSafeChecker()), |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
1930 _humongous_set("Master Humongous Set", true /* humongous */, new HumongousRegionSetMtSafeChecker()), |
| 2152 | 1931 _free_regions_coming(false), |
| 342 | 1932 _young_list(new YoungList(this)), |
| 1933 _gc_time_stamp(0), | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
1934 _retained_old_gc_alloc_region(NULL), |
| 6595 | 1935 _survivor_plab_stats(YoungPLABSize, PLABWeight), |
| 1936 _old_plab_stats(OldPLABSize, PLABWeight), | |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
1937 _expand_heap_after_alloc_failure(true), |
| 526 | 1938 _surviving_young_words(NULL), |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
1939 _old_marking_cycles_started(0), |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
1940 _old_marking_cycles_completed(0), |
| 10405 | 1941 _concurrent_cycle_started(false), |
|
20212
d7e2d5f2846b
8027553: Change the in_cset_fast_test functionality to use the G1BiasedArray abstraction
tschatzl
parents:
20198
diff
changeset
|
1942 _in_cset_fast_test(), |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1943 _dirty_cards_region_list(NULL), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1944 _worker_cset_start_region(NULL), |
| 10405 | 1945 _worker_cset_start_region_time_stamp(NULL), |
| 1946 _gc_timer_stw(new (ResourceObj::C_HEAP, mtGC) STWGCTimer()), | |
| 1947 _gc_timer_cm(new (ResourceObj::C_HEAP, mtGC) ConcurrentGCTimer()), | |
| 1948 _gc_tracer_stw(new (ResourceObj::C_HEAP, mtGC) G1NewTracer()), | |
| 1949 _gc_tracer_cm(new (ResourceObj::C_HEAP, mtGC) G1OldTracer()) { | |
| 1950 | |
| 1951 _g1h = this; | |
| 342 | 1952 if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) { |
| 1953 vm_exit_during_initialization("Failed necessary allocation."); | |
| 1954 } | |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1955 |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1956 _humongous_object_threshold_in_words = HeapRegion::GrainWords / 2; |
|
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
1957 |
| 342 | 1958 int n_queues = MAX2((int)ParallelGCThreads, 1); |
| 1959 _task_queues = new RefToScanQueueSet(n_queues); | |
| 1960 | |
|
17758
ae7336d6337e
8034868: Extract G1 From Card Cache into separate class
tschatzl
parents:
17757
diff
changeset
|
1961 uint n_rem_sets = HeapRegionRemSet::num_par_rem_sets(); |
| 342 | 1962 assert(n_rem_sets > 0, "Invariant."); |
| 1963 | |
| 6197 | 1964 _worker_cset_start_region = NEW_C_HEAP_ARRAY(HeapRegion*, n_queues, mtGC); |
| 1965 _worker_cset_start_region_time_stamp = NEW_C_HEAP_ARRAY(unsigned int, n_queues, mtGC); | |
| 10405 | 1966 _evacuation_failed_info_array = NEW_C_HEAP_ARRAY(EvacuationFailedInfo, n_queues, mtGC); |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1967 |
| 342 | 1968 for (int i = 0; i < n_queues; i++) { |
| 1969 RefToScanQueue* q = new RefToScanQueue(); | |
| 1970 q->initialize(); | |
| 1971 _task_queues->register_queue(i, q); | |
| 10405 | 1972 ::new (&_evacuation_failed_info_array[i]) EvacuationFailedInfo(); |
| 1973 } | |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1974 clear_cset_start_regions(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
1975 |
|
6629
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
1976 // Initialize the G1EvacuationFailureALot counters and flags. |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
1977 NOT_PRODUCT(reset_evacuation_should_fail();) |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
1978 |
| 342 | 1979 guarantee(_task_queues != NULL, "task_queues allocation failure."); |
| 1980 } | |
| 1981 | |
| 1982 jint G1CollectedHeap::initialize() { | |
| 1166 | 1983 CollectedHeap::pre_initialize(); |
| 342 | 1984 os::enable_vtime(); |
| 1985 | |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1986 G1Log::init(); |
|
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
1987 |
| 342 | 1988 // Necessary to satisfy locking discipline assertions. |
| 1989 | |
| 1990 MutexLocker x(Heap_lock); | |
| 1991 | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1992 // We have to initialize the printer before committing the heap, as |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1993 // it will be used then. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1994 _hr_printer.set_active(G1PrintHeapRegions); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
1995 |
| 342 | 1996 // While there are no constraints in the GC code that HeapWordSize |
| 1997 // be any particular value, there are multiple other areas in the | |
| 1998 // system which believe this to be true (e.g. oop->object_size in some | |
| 1999 // cases incorrectly returns the size in wordSize units rather than | |
| 2000 // HeapWordSize). | |
| 2001 guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize"); | |
| 2002 | |
| 2003 size_t init_byte_size = collector_policy()->initial_heap_byte_size(); | |
| 2004 size_t max_byte_size = collector_policy()->max_heap_byte_size(); | |
|
13060
8f07aa079343
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
jwilhelm
parents:
12840
diff
changeset
|
2005 size_t heap_alignment = collector_policy()->heap_alignment(); |
| 342 | 2006 |
| 2007 // Ensure that the sizes are properly aligned. | |
| 2008 Universe::check_alignment(init_byte_size, HeapRegion::GrainBytes, "g1 heap"); | |
| 2009 Universe::check_alignment(max_byte_size, HeapRegion::GrainBytes, "g1 heap"); | |
|
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12082
diff
changeset
|
2010 Universe::check_alignment(max_byte_size, heap_alignment, "g1 heap"); |
| 342 | 2011 |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
2012 _refine_cte_cl = new RefineCardTableEntryClosure(); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
2013 |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
2014 _cg1r = new ConcurrentG1Refine(this, _refine_cte_cl); |
| 342 | 2015 |
| 2016 // Reserve the maximum. | |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
620
diff
changeset
|
2017 |
|
3824
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2018 // When compressed oops are enabled, the preferred heap base |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2019 // is calculated by subtracting the requested size from the |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2020 // 32Gb boundary and using the result as the base address for |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2021 // heap reservation. If the requested size is not aligned to |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2022 // HeapRegion::GrainBytes (i.e. the alignment that is passed |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2023 // into the ReservedHeapSpace constructor) then the actual |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2024 // base of the reserved heap may end up differing from the |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2025 // address that was requested (i.e. the preferred heap base). |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2026 // If this happens then we could end up using a non-optimal |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2027 // compressed oops mode. |
|
6aa4feb8a366
7069863: G1: SIGSEGV running SPECjbb2011 and -UseBiasedLocking
johnc
parents:
3823
diff
changeset
|
2028 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
2029 ReservedSpace heap_rs = Universe::reserve_heap(max_byte_size, |
|
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12082
diff
changeset
|
2030 heap_alignment); |
| 342 | 2031 |
| 2032 // It is important to do this in a way such that concurrent readers can't | |
| 10405 | 2033 // temporarily think something is in the heap. (I've actually seen this |
| 342 | 2034 // happen in asserts: DLD.) |
| 2035 _reserved.set_word_size(0); | |
| 2036 _reserved.set_start((HeapWord*)heap_rs.base()); | |
| 2037 _reserved.set_end((HeapWord*)(heap_rs.base() + heap_rs.size())); | |
| 2038 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2039 _expansion_regions = (uint) (max_byte_size / HeapRegion::GrainBytes); |
| 342 | 2040 |
| 2041 // Create the gen rem set (and barrier set) for the entire reserved region. | |
| 2042 _rem_set = collector_policy()->create_rem_set(_reserved, 2); | |
| 2043 set_barrier_set(rem_set()->bs()); | |
| 12343 | 2044 if (!barrier_set()->is_a(BarrierSet::G1SATBCTLogging)) { |
| 2045 vm_exit_during_initialization("G1 requires a G1SATBLoggingCardTableModRefBS"); | |
| 342 | 2046 return JNI_ENOMEM; |
| 2047 } | |
| 2048 | |
| 2049 // Also create a G1 rem set. | |
| 12343 | 2050 _g1_rem_set = new G1RemSet(this, g1_barrier_set()); |
| 342 | 2051 |
| 2052 // Carve out the G1 part of the heap. | |
| 2053 | |
| 2054 ReservedSpace g1_rs = heap_rs.first_part(max_byte_size); | |
| 2055 _g1_reserved = MemRegion((HeapWord*)g1_rs.base(), | |
| 2056 g1_rs.size()/HeapWordSize); | |
| 2057 | |
| 2058 _g1_storage.initialize(g1_rs, 0); | |
| 2059 _g1_committed = MemRegion((HeapWord*)_g1_storage.low(), (size_t) 0); | |
| 3766 | 2060 _hrs.initialize((HeapWord*) _g1_reserved.start(), |
|
12305
a19bea467577
7163191: G1: introduce a "heap spanning table" abstraction
tschatzl
parents:
12233
diff
changeset
|
2061 (HeapWord*) _g1_reserved.end()); |
|
a19bea467577
7163191: G1: introduce a "heap spanning table" abstraction
tschatzl
parents:
12233
diff
changeset
|
2062 assert(_hrs.max_length() == _expansion_regions, |
|
a19bea467577
7163191: G1: introduce a "heap spanning table" abstraction
tschatzl
parents:
12233
diff
changeset
|
2063 err_msg("max length: %u expansion regions: %u", |
|
a19bea467577
7163191: G1: introduce a "heap spanning table" abstraction
tschatzl
parents:
12233
diff
changeset
|
2064 _hrs.max_length(), _expansion_regions)); |
| 342 | 2065 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
2066 // Do later initialization work for concurrent refinement. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
2067 _cg1r->init(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
2068 |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2069 // 6843694 - ensure that the maximum region index can fit |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2070 // in the remembered set structures. |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2071 const uint max_region_idx = (1U << (sizeof(RegionIdx_t)*BitsPerByte-1)) - 1; |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2072 guarantee((max_regions() - 1) <= max_region_idx, "too many regions"); |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2073 |
|
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2074 size_t max_cards_per_region = ((size_t)1 << (sizeof(CardIdx_t)*BitsPerByte-1)) - 1; |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
2075 guarantee(HeapRegion::CardsPerRegion > 0, "make sure it's initialized"); |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
2076 guarantee(HeapRegion::CardsPerRegion < max_cards_per_region, |
|
942
2c79770d1f6e
6819085: G1: use larger and/or user settable region size
tonyp
parents:
941
diff
changeset
|
2077 "too many cards per region"); |
|
807
d44bdab1c03d
6843694: G1: assert(index < _vs.committed_size(),"bad index"), g1BlockOffsetTable.inline.hpp:55
johnc
parents:
796
diff
changeset
|
2078 |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
2079 FreeRegionList::set_unrealistically_long_length(max_regions() + 1); |
| 2152 | 2080 |
| 342 | 2081 _bot_shared = new G1BlockOffsetSharedArray(_reserved, |
| 2082 heap_word_size(init_byte_size)); | |
| 2083 | |
| 2084 _g1h = this; | |
| 2085 | |
|
20212
d7e2d5f2846b
8027553: Change the in_cset_fast_test functionality to use the G1BiasedArray abstraction
tschatzl
parents:
20198
diff
changeset
|
2086 _in_cset_fast_test.initialize(_g1_reserved.start(), _g1_reserved.end(), HeapRegion::GrainBytes); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
2087 |
| 342 | 2088 // Create the ConcurrentMark data structure and thread. |
| 2089 // (Must do this late, so that "max_regions" is defined.) | |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7207
diff
changeset
|
2090 _cm = new ConcurrentMark(this, heap_rs); |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7207
diff
changeset
|
2091 if (_cm == NULL || !_cm->completed_initialization()) { |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7207
diff
changeset
|
2092 vm_shutdown_during_initialization("Could not create/initialize ConcurrentMark"); |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7207
diff
changeset
|
2093 return JNI_ENOMEM; |
|
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7207
diff
changeset
|
2094 } |
| 342 | 2095 _cmThread = _cm->cmThread(); |
| 2096 | |
| 2097 // Initialize the from_card cache structure of HeapRegionRemSet. | |
| 2098 HeapRegionRemSet::init_heap(max_regions()); | |
| 2099 | |
| 677 | 2100 // Now expand into the initial heap size. |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2101 if (!expand(init_byte_size)) { |
|
7397
442f942757c0
8000244: G1: Ergonomically set MarkStackSize and use virtual space for global marking stack
johnc
parents:
7207
diff
changeset
|
2102 vm_shutdown_during_initialization("Failed to allocate initial heap."); |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2103 return JNI_ENOMEM; |
|
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
2104 } |
| 342 | 2105 |
| 2106 // Perform any initialization actions delegated to the policy. | |
| 2107 g1_policy()->init(); | |
| 2108 | |
| 2109 JavaThread::satb_mark_queue_set().initialize(SATB_Q_CBL_mon, | |
| 2110 SATB_Q_FL_lock, | |
| 1111 | 2111 G1SATBProcessCompletedThreshold, |
| 342 | 2112 Shared_SATB_Q_lock); |
| 794 | 2113 |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
2114 JavaThread::dirty_card_queue_set().initialize(_refine_cte_cl, |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
2115 DirtyCardQ_CBL_mon, |
| 794 | 2116 DirtyCardQ_FL_lock, |
| 1111 | 2117 concurrent_g1_refine()->yellow_zone(), |
| 2118 concurrent_g1_refine()->red_zone(), | |
| 794 | 2119 Shared_DirtyCardQ_lock); |
| 2120 | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2121 if (G1DeferredRSUpdate) { |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
2122 dirty_card_queue_set().initialize(NULL, // Should never be called by the Java code |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
2123 DirtyCardQ_CBL_mon, |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2124 DirtyCardQ_FL_lock, |
| 1111 | 2125 -1, // never trigger processing |
| 2126 -1, // no limit on length | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2127 Shared_DirtyCardQ_lock, |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2128 &JavaThread::dirty_card_queue_set()); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
2129 } |
| 1705 | 2130 |
| 2131 // Initialize the card queue set used to hold cards containing | |
| 2132 // references into the collection set. | |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
2133 _into_cset_dirty_card_queue_set.initialize(NULL, // Should never be called by the Java code |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
2134 DirtyCardQ_CBL_mon, |
| 1705 | 2135 DirtyCardQ_FL_lock, |
| 2136 -1, // never trigger processing | |
| 2137 -1, // no limit on length | |
| 2138 Shared_DirtyCardQ_lock, | |
| 2139 &JavaThread::dirty_card_queue_set()); | |
| 2140 | |
| 342 | 2141 // In case we're keeping closure specialization stats, initialize those |
| 2142 // counts and that mechanism. | |
| 2143 SpecializationStats::clear(); | |
| 2144 | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2145 // Here we allocate the dummy full region that is required by the |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2146 // G1AllocRegion class. If we don't pass an address in the reserved |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2147 // space here, lots of asserts fire. |
| 3766 | 2148 |
| 2149 HeapRegion* dummy_region = new_heap_region(0 /* index of bottom region */, | |
| 2150 _g1_reserved.start()); | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2151 // We'll re-use the same region whether the alloc region will |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2152 // require BOT updates or not and, if it doesn't, then a non-young |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2153 // region will complain that it cannot support allocations without |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2154 // BOT updates. So we'll tag the dummy region as young to avoid that. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2155 dummy_region->set_young(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2156 // Make sure it's full. |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2157 dummy_region->set_top(dummy_region->end()); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2158 G1AllocRegion::setup(this, dummy_region); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2159 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2160 init_mutator_alloc_region(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2161 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2162 // Do create of the monitoring and management support so that |
|
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2163 // values in the heap have been properly initialized. |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
2164 _g1mm = new G1MonitoringSupport(this); |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
2165 |
| 17764 | 2166 G1StringDedup::initialize(); |
| 2167 | |
| 342 | 2168 return JNI_OK; |
| 2169 } | |
| 2170 | |
|
17947
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
17937
diff
changeset
|
2171 void G1CollectedHeap::stop() { |
| 17992 | 2172 // Stop all concurrent threads. We do this to make sure these threads |
| 2173 // do not continue to execute and access resources (e.g. gclog_or_tty) | |
|
17947
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
17937
diff
changeset
|
2174 // that are destroyed during shutdown. |
| 17992 | 2175 _cg1r->stop(); |
| 2176 _cmThread->stop(); | |
| 2177 if (G1StringDedup::is_enabled()) { | |
| 2178 G1StringDedup::stop(); | |
| 2179 } | |
|
17947
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
17937
diff
changeset
|
2180 } |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
17937
diff
changeset
|
2181 |
|
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12179
diff
changeset
|
2182 size_t G1CollectedHeap::conservative_max_heap_alignment() { |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12179
diff
changeset
|
2183 return HeapRegion::max_region_size(); |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12179
diff
changeset
|
2184 } |
|
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12179
diff
changeset
|
2185 |
| 342 | 2186 void G1CollectedHeap::ref_processing_init() { |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2187 // Reference processing in G1 currently works as follows: |
|
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2188 // |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2189 // * There are two reference processor instances. One is |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2190 // used to record and process discovered references |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2191 // during concurrent marking; the other is used to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2192 // record and process references during STW pauses |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2193 // (both full and incremental). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2194 // * Both ref processors need to 'span' the entire heap as |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2195 // the regions in the collection set may be dotted around. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2196 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2197 // * For the concurrent marking ref processor: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2198 // * Reference discovery is enabled at initial marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2199 // * Reference discovery is disabled and the discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2200 // references processed etc during remarking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2201 // * Reference discovery is MT (see below). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2202 // * Reference discovery requires a barrier (see below). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2203 // * Reference processing may or may not be MT |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2204 // (depending on the value of ParallelRefProcEnabled |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2205 // and ParallelGCThreads). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2206 // * A full GC disables reference discovery by the CM |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2207 // ref processor and abandons any entries on it's |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2208 // discovered lists. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2209 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2210 // * For the STW processor: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2211 // * Non MT discovery is enabled at the start of a full GC. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2212 // * Processing and enqueueing during a full GC is non-MT. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2213 // * During a full GC, references are processed after marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2214 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2215 // * Discovery (may or may not be MT) is enabled at the start |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2216 // of an incremental evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2217 // * References are processed near the end of a STW evacuation pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2218 // * For both types of GC: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2219 // * Discovery is atomic - i.e. not concurrent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2220 // * Reference discovery will not need a barrier. |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
2221 |
| 342 | 2222 SharedHeap::ref_processing_init(); |
| 2223 MemRegion mr = reserved_region(); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2224 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2225 // Concurrent Mark ref processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2226 _ref_processor_cm = |
|
2369
92da084fefc9
6668573: CMS: reference processing crash if ParallelCMSThreads > ParallelGCThreads
ysr
parents:
2361
diff
changeset
|
2227 new ReferenceProcessor(mr, // span |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2228 ParallelRefProcEnabled && (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2229 // mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2230 (int) ParallelGCThreads, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2231 // degree of mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2232 (ParallelGCThreads > 1) || (ConcGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2233 // mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2234 (int) MAX2(ParallelGCThreads, ConcGCThreads), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2235 // degree of mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2236 false, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2237 // Reference discovery is not atomic |
|
17976
8e20ef014b08
8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects
brutisso
parents:
17948
diff
changeset
|
2238 &_is_alive_closure_cm); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2239 // is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2240 // (for efficiency/performance) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2241 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2242 // STW ref processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2243 _ref_processor_stw = |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2244 new ReferenceProcessor(mr, // span |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2245 ParallelRefProcEnabled && (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2246 // mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2247 MAX2((int)ParallelGCThreads, 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2248 // degree of mt processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2249 (ParallelGCThreads > 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2250 // mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2251 MAX2((int)ParallelGCThreads, 1), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2252 // degree of mt discovery |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2253 true, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2254 // Reference discovery is atomic |
|
17976
8e20ef014b08
8043239: G1: Missing post barrier in processing of j.l.ref.Reference objects
brutisso
parents:
17948
diff
changeset
|
2255 &_is_alive_closure_stw); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2256 // is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
2257 // (for efficiency/performance) |
| 342 | 2258 } |
| 2259 | |
| 2260 size_t G1CollectedHeap::capacity() const { | |
| 2261 return _g1_committed.byte_size(); | |
| 2262 } | |
| 2263 | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2264 void G1CollectedHeap::reset_gc_time_stamps(HeapRegion* hr) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2265 assert(!hr->continuesHumongous(), "pre-condition"); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2266 hr->reset_gc_time_stamp(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2267 if (hr->startsHumongous()) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2268 uint first_index = hr->hrs_index() + 1; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2269 uint last_index = hr->last_hc_index(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2270 for (uint i = first_index; i < last_index; i += 1) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2271 HeapRegion* chr = region_at(i); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2272 assert(chr->continuesHumongous(), "sanity"); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2273 chr->reset_gc_time_stamp(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2274 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2275 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2276 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2277 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2278 #ifndef PRODUCT |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2279 class CheckGCTimeStampsHRClosure : public HeapRegionClosure { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2280 private: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2281 unsigned _gc_time_stamp; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2282 bool _failures; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2283 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2284 public: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2285 CheckGCTimeStampsHRClosure(unsigned gc_time_stamp) : |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2286 _gc_time_stamp(gc_time_stamp), _failures(false) { } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2287 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2288 virtual bool doHeapRegion(HeapRegion* hr) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2289 unsigned region_gc_time_stamp = hr->get_gc_time_stamp(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2290 if (_gc_time_stamp != region_gc_time_stamp) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2291 gclog_or_tty->print_cr("Region "HR_FORMAT" has GC time stamp = %d, " |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2292 "expected %d", HR_FORMAT_PARAMS(hr), |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2293 region_gc_time_stamp, _gc_time_stamp); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2294 _failures = true; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2295 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2296 return false; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2297 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2298 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2299 bool failures() { return _failures; } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2300 }; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2301 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2302 void G1CollectedHeap::check_gc_time_stamps() { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2303 CheckGCTimeStampsHRClosure cl(_gc_time_stamp); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2304 heap_region_iterate(&cl); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2305 guarantee(!cl.failures(), "all GC time stamps should have been reset"); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2306 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2307 #endif // PRODUCT |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2308 |
| 1705 | 2309 void G1CollectedHeap::iterate_dirty_card_closure(CardTableEntryClosure* cl, |
| 2310 DirtyCardQueue* into_cset_dcq, | |
| 2311 bool concurrent, | |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17833
diff
changeset
|
2312 uint worker_i) { |
| 889 | 2313 // Clean cards in the hot card cache |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
2314 G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
2315 hot_card_cache->drain(worker_i, g1_rem_set(), into_cset_dcq); |
| 889 | 2316 |
| 342 | 2317 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); |
| 2318 int n_completed_buffers = 0; | |
| 1705 | 2319 while (dcqs.apply_closure_to_completed_buffer(cl, worker_i, 0, true)) { |
| 342 | 2320 n_completed_buffers++; |
| 2321 } | |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
2322 g1_policy()->phase_times()->record_update_rs_processed_buffers(worker_i, n_completed_buffers); |
| 342 | 2323 dcqs.clear_n_completed_buffers(); |
| 2324 assert(!dcqs.completed_buffers_exist_dirty(), "Completed buffers exist!"); | |
| 2325 } | |
| 2326 | |
| 2327 | |
| 2328 // Computes the sum of the storage used by the various regions. | |
| 2329 | |
| 2330 size_t G1CollectedHeap::used() const { | |
|
862
36b5611220a7
6863216: Clean up debugging debris inadvertently pushed with 6700789
ysr
parents:
861
diff
changeset
|
2331 assert(Heap_lock->owner() != NULL, |
|
36b5611220a7
6863216: Clean up debugging debris inadvertently pushed with 6700789
ysr
parents:
861
diff
changeset
|
2332 "Should be owned on this thread's behalf."); |
| 342 | 2333 size_t result = _summary_bytes_used; |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2334 // Read only once in case it is set to NULL concurrently |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2335 HeapRegion* hr = _mutator_alloc_region.get(); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2336 if (hr != NULL) |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
2337 result += hr->used(); |
| 342 | 2338 return result; |
| 2339 } | |
| 2340 | |
|
846
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2341 size_t G1CollectedHeap::used_unlocked() const { |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2342 size_t result = _summary_bytes_used; |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2343 return result; |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2344 } |
|
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
2345 |
| 342 | 2346 class SumUsedClosure: public HeapRegionClosure { |
| 2347 size_t _used; | |
| 2348 public: | |
| 2349 SumUsedClosure() : _used(0) {} | |
| 2350 bool doHeapRegion(HeapRegion* r) { | |
| 2351 if (!r->continuesHumongous()) { | |
| 2352 _used += r->used(); | |
| 2353 } | |
| 2354 return false; | |
| 2355 } | |
| 2356 size_t result() { return _used; } | |
| 2357 }; | |
| 2358 | |
| 2359 size_t G1CollectedHeap::recalculate_used() const { | |
|
17757
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
17756
diff
changeset
|
2360 double recalculate_used_start = os::elapsedTime(); |
|
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
17756
diff
changeset
|
2361 |
| 342 | 2362 SumUsedClosure blk; |
| 3766 | 2363 heap_region_iterate(&blk); |
|
17757
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
17756
diff
changeset
|
2364 |
|
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
17756
diff
changeset
|
2365 g1_policy()->phase_times()->record_evac_fail_recalc_used_time((os::elapsedTime() - recalculate_used_start) * 1000.0); |
| 342 | 2366 return blk.result(); |
| 2367 } | |
| 2368 | |
| 2369 size_t G1CollectedHeap::unsafe_max_alloc() { | |
| 2152 | 2370 if (free_regions() > 0) return HeapRegion::GrainBytes; |
| 342 | 2371 // otherwise, is there space in the current allocation region? |
| 2372 | |
| 2373 // We need to store the current allocation region in a local variable | |
| 2374 // here. The problem is that this method doesn't take any locks and | |
| 2375 // there may be other threads which overwrite the current allocation | |
| 2376 // region field. attempt_allocation(), for example, sets it to NULL | |
| 2377 // and this can happen *after* the NULL check here but before the call | |
| 2378 // to free(), resulting in a SIGSEGV. Note that this doesn't appear | |
| 2379 // to be a problem in the optimized build, since the two loads of the | |
| 2380 // current allocation region field are optimized away. | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2381 HeapRegion* hr = _mutator_alloc_region.get(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2382 if (hr == NULL) { |
| 342 | 2383 return 0; |
| 2384 } | |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
2385 return hr->free(); |
| 342 | 2386 } |
| 2387 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2388 bool G1CollectedHeap::should_do_concurrent_full_gc(GCCause::Cause cause) { |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2389 switch (cause) { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2390 case GCCause::_gc_locker: return GCLockerInvokesConcurrent; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2391 case GCCause::_java_lang_system_gc: return ExplicitGCInvokesConcurrent; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2392 case GCCause::_g1_humongous_allocation: return true; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2393 default: return false; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2394 } |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2395 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2396 |
|
3285
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2397 #ifndef PRODUCT |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2398 void G1CollectedHeap::allocate_dummy_regions() { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2399 // Let's fill up most of the region |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2400 size_t word_size = HeapRegion::GrainWords - 1024; |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2401 // And as a result the region we'll allocate will be humongous. |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2402 guarantee(isHumongous(word_size), "sanity"); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2403 |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2404 for (uintx i = 0; i < G1DummyRegionsPerGC; ++i) { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2405 // Let's use the existing mechanism for the allocation |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2406 HeapWord* dummy_obj = humongous_obj_allocate(word_size); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2407 if (dummy_obj != NULL) { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2408 MemRegion mr(dummy_obj, word_size); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2409 CollectedHeap::fill_with_object(mr); |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2410 } else { |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2411 // If we can't allocate once, we probably cannot allocate |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2412 // again. Let's get out of the loop. |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2413 break; |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2414 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2415 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2416 } |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2417 #endif // !PRODUCT |
|
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
2418 |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2419 void G1CollectedHeap::increment_old_marking_cycles_started() { |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2420 assert(_old_marking_cycles_started == _old_marking_cycles_completed || |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2421 _old_marking_cycles_started == _old_marking_cycles_completed + 1, |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2422 err_msg("Wrong marking cycle count (started: %d, completed: %d)", |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2423 _old_marking_cycles_started, _old_marking_cycles_completed)); |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2424 |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2425 _old_marking_cycles_started++; |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2426 } |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2427 |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2428 void G1CollectedHeap::increment_old_marking_cycles_completed(bool concurrent) { |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2429 MonitorLockerEx x(FullGCCount_lock, Mutex::_no_safepoint_check_flag); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2430 |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2431 // We assume that if concurrent == true, then the caller is a |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2432 // concurrent thread that was joined the Suspendible Thread |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2433 // Set. If there's ever a cheap way to check this, we should add an |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2434 // assert here. |
|
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2435 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2436 // Given that this method is called at the end of a Full GC or of a |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2437 // concurrent cycle, and those can be nested (i.e., a Full GC can |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2438 // interrupt a concurrent cycle), the number of full collections |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2439 // completed should be either one (in the case where there was no |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2440 // nesting) or two (when a Full GC interrupted a concurrent cycle) |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2441 // behind the number of full collections started. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2442 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2443 // This is the case for the inner caller, i.e. a Full GC. |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2444 assert(concurrent || |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2445 (_old_marking_cycles_started == _old_marking_cycles_completed + 1) || |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2446 (_old_marking_cycles_started == _old_marking_cycles_completed + 2), |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2447 err_msg("for inner caller (Full GC): _old_marking_cycles_started = %u " |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2448 "is inconsistent with _old_marking_cycles_completed = %u", |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2449 _old_marking_cycles_started, _old_marking_cycles_completed)); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2450 |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2451 // This is the case for the outer caller, i.e. the concurrent cycle. |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2452 assert(!concurrent || |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2453 (_old_marking_cycles_started == _old_marking_cycles_completed + 1), |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2454 err_msg("for outer caller (concurrent cycle): " |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2455 "_old_marking_cycles_started = %u " |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2456 "is inconsistent with _old_marking_cycles_completed = %u", |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2457 _old_marking_cycles_started, _old_marking_cycles_completed)); |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2458 |
|
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2459 _old_marking_cycles_completed += 1; |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2460 |
|
1840
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2461 // We need to clear the "in_progress" flag in the CM thread before |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2462 // we wake up any waiters (especially when ExplicitInvokesConcurrent |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2463 // is set) so that if a waiter requests another System.gc() it doesn't |
| 10405 | 2464 // incorrectly see that a marking cycle is still in progress. |
|
2030
fb712ff22571
7000559: G1: assertion failure !outer || (full_collections_started == _full_collections_completed + 1)
tonyp
parents:
1995
diff
changeset
|
2465 if (concurrent) { |
|
1840
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2466 _cmThread->clear_in_progress(); |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2467 } |
|
4e0094bc41fa
6983311: G1: LoopTest hangs when run with -XX:+ExplicitInvokesConcurrent
johnc
parents:
1833
diff
changeset
|
2468 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2469 // This notify_all() will ensure that a thread that called |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2470 // System.gc() with (with ExplicitGCInvokesConcurrent set or not) |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2471 // and it's waiting for a full GC to finish will be woken up. It is |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2472 // waiting in VM_G1IncCollectionPause::doit_epilogue(). |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2473 FullGCCount_lock->notify_all(); |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2474 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2475 |
|
13400
86e6d691f2e1
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
13062
diff
changeset
|
2476 void G1CollectedHeap::register_concurrent_cycle_start(const Ticks& start_time) { |
| 10405 | 2477 _concurrent_cycle_started = true; |
| 2478 _gc_timer_cm->register_gc_start(start_time); | |
| 2479 | |
| 2480 _gc_tracer_cm->report_gc_start(gc_cause(), _gc_timer_cm->gc_start()); | |
| 2481 trace_heap_before_gc(_gc_tracer_cm); | |
| 2482 } | |
| 2483 | |
| 2484 void G1CollectedHeap::register_concurrent_cycle_end() { | |
| 2485 if (_concurrent_cycle_started) { | |
| 2486 if (_cm->has_aborted()) { | |
| 2487 _gc_tracer_cm->report_concurrent_mode_failure(); | |
| 2488 } | |
|
12179
f175e3678be2
8020692: TestGCEventMixed.java failed because of timestamp in event after end event
ehelin
parents:
12116
diff
changeset
|
2489 |
|
13400
86e6d691f2e1
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
13062
diff
changeset
|
2490 _gc_timer_cm->register_gc_end(); |
| 10405 | 2491 _gc_tracer_cm->report_gc_end(_gc_timer_cm->gc_end(), _gc_timer_cm->time_partitions()); |
| 2492 | |
| 2493 _concurrent_cycle_started = false; | |
| 2494 } | |
| 2495 } | |
| 2496 | |
| 2497 void G1CollectedHeap::trace_heap_after_concurrent_cycle() { | |
| 2498 if (_concurrent_cycle_started) { | |
| 2499 trace_heap_after_gc(_gc_tracer_cm); | |
| 2500 } | |
| 2501 } | |
| 2502 | |
| 2503 G1YCType G1CollectedHeap::yc_type() { | |
| 2504 bool is_young = g1_policy()->gcs_are_young(); | |
| 2505 bool is_initial_mark = g1_policy()->during_initial_mark_pause(); | |
| 2506 bool is_during_mark = mark_in_progress(); | |
| 2507 | |
| 2508 if (is_initial_mark) { | |
| 2509 return InitialMark; | |
| 2510 } else if (is_during_mark) { | |
| 2511 return DuringMark; | |
| 2512 } else if (is_young) { | |
| 2513 return Normal; | |
| 2514 } else { | |
| 2515 return Mixed; | |
| 2516 } | |
| 2517 } | |
| 2518 | |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2519 void G1CollectedHeap::collect(GCCause::Cause cause) { |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2520 assert_heap_not_locked(); |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2521 |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2522 unsigned int gc_count_before; |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2523 unsigned int old_marking_count_before; |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2524 bool retry_gc; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2525 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2526 do { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2527 retry_gc = false; |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2528 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2529 { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2530 MutexLocker ml(Heap_lock); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2531 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2532 // Read the GC count while holding the Heap_lock |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2533 gc_count_before = total_collections(); |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2534 old_marking_count_before = _old_marking_cycles_started; |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2535 } |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2536 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2537 if (should_do_concurrent_full_gc(cause)) { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2538 // Schedule an initial-mark evacuation pause that will start a |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2539 // concurrent cycle. We're setting word_size to 0 which means that |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2540 // we are not requesting a post-GC allocation. |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2541 VM_G1IncCollectionPause op(gc_count_before, |
| 1973 | 2542 0, /* word_size */ |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2543 true, /* should_initiate_conc_mark */ |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2544 g1_policy()->max_pause_time_ms(), |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2545 cause); |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2546 |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2547 VMThread::execute(&op); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2548 if (!op.pause_succeeded()) { |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2549 if (old_marking_count_before == _old_marking_cycles_started) { |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2550 retry_gc = op.should_retry_gc(); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2551 } else { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2552 // A Full GC happened while we were trying to schedule the |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2553 // initial-mark GC. No point in starting a new cycle given |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2554 // that the whole heap was collected anyway. |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2555 } |
|
5963
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2556 |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2557 if (retry_gc) { |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2558 if (GC_locker::is_active_and_needs_gc()) { |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2559 GC_locker::stall_until_clear(); |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2560 } |
|
64bf7c8270cb
7147724: G1: hang in SurrogateLockerThread::manipulatePLL
johnc
parents:
4912
diff
changeset
|
2561 } |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2562 } |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2563 } else { |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2564 if (cause == GCCause::_gc_locker |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2565 DEBUG_ONLY(|| cause == GCCause::_scavenge_alot)) { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2566 |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2567 // Schedule a standard evacuation pause. We're setting word_size |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2568 // to 0 which means that we are not requesting a post-GC allocation. |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2569 VM_G1IncCollectionPause op(gc_count_before, |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2570 0, /* word_size */ |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2571 false, /* should_initiate_conc_mark */ |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2572 g1_policy()->max_pause_time_ms(), |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2573 cause); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2574 VMThread::execute(&op); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2575 } else { |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2576 // Schedule a Full GC. |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
2577 VM_G1CollectFull op(gc_count_before, old_marking_count_before, cause); |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2578 VMThread::execute(&op); |
|
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2579 } |
|
1088
3fc996d4edd2
6902303: G1: ScavengeALot should cause an incremental, rather than a full, collection
ysr
parents:
1045
diff
changeset
|
2580 } |
|
4910
caa4652b4414
7129892: G1: explicit marking cycle initiation might fail to initiate a marking cycle
tonyp
parents:
4875
diff
changeset
|
2581 } while (retry_gc); |
| 342 | 2582 } |
| 2583 | |
| 2584 bool G1CollectedHeap::is_in(const void* p) const { | |
| 4708 | 2585 if (_g1_committed.contains(p)) { |
| 2586 // Given that we know that p is in the committed space, | |
| 2587 // heap_region_containing_raw() should successfully | |
| 2588 // return the containing region. | |
| 2589 HeapRegion* hr = heap_region_containing_raw(p); | |
| 342 | 2590 return hr->is_in(p); |
| 2591 } else { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
2592 return false; |
| 342 | 2593 } |
| 2594 } | |
| 2595 | |
| 2596 // Iteration functions. | |
| 2597 | |
| 2598 // Iterates an OopClosure over all ref-containing fields of objects | |
| 2599 // within a HeapRegion. | |
| 2600 | |
| 2601 class IterateOopClosureRegionClosure: public HeapRegionClosure { | |
| 2602 MemRegion _mr; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
2603 ExtendedOopClosure* _cl; |
| 342 | 2604 public: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
2605 IterateOopClosureRegionClosure(MemRegion mr, ExtendedOopClosure* cl) |
| 342 | 2606 : _mr(mr), _cl(cl) {} |
| 2607 bool doHeapRegion(HeapRegion* r) { | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2608 if (!r->continuesHumongous()) { |
| 342 | 2609 r->oop_iterate(_cl); |
| 2610 } | |
| 2611 return false; | |
| 2612 } | |
| 2613 }; | |
| 2614 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
2615 void G1CollectedHeap::oop_iterate(ExtendedOopClosure* cl) { |
| 342 | 2616 IterateOopClosureRegionClosure blk(_g1_committed, cl); |
| 3766 | 2617 heap_region_iterate(&blk); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
2618 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
2619 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
2620 void G1CollectedHeap::oop_iterate(MemRegion mr, ExtendedOopClosure* cl) { |
| 342 | 2621 IterateOopClosureRegionClosure blk(mr, cl); |
| 3766 | 2622 heap_region_iterate(&blk); |
| 342 | 2623 } |
| 2624 | |
| 2625 // Iterates an ObjectClosure over all objects within a HeapRegion. | |
| 2626 | |
| 2627 class IterateObjectClosureRegionClosure: public HeapRegionClosure { | |
| 2628 ObjectClosure* _cl; | |
| 2629 public: | |
| 2630 IterateObjectClosureRegionClosure(ObjectClosure* cl) : _cl(cl) {} | |
| 2631 bool doHeapRegion(HeapRegion* r) { | |
| 2632 if (! r->continuesHumongous()) { | |
| 2633 r->object_iterate(_cl); | |
| 2634 } | |
| 2635 return false; | |
| 2636 } | |
| 2637 }; | |
| 2638 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
2639 void G1CollectedHeap::object_iterate(ObjectClosure* cl) { |
| 342 | 2640 IterateObjectClosureRegionClosure blk(cl); |
| 3766 | 2641 heap_region_iterate(&blk); |
| 342 | 2642 } |
| 2643 | |
| 2644 // Calls a SpaceClosure on a HeapRegion. | |
| 2645 | |
| 2646 class SpaceClosureRegionClosure: public HeapRegionClosure { | |
| 2647 SpaceClosure* _cl; | |
| 2648 public: | |
| 2649 SpaceClosureRegionClosure(SpaceClosure* cl) : _cl(cl) {} | |
| 2650 bool doHeapRegion(HeapRegion* r) { | |
| 2651 _cl->do_space(r); | |
| 2652 return false; | |
| 2653 } | |
| 2654 }; | |
| 2655 | |
| 2656 void G1CollectedHeap::space_iterate(SpaceClosure* cl) { | |
| 2657 SpaceClosureRegionClosure blk(cl); | |
| 3766 | 2658 heap_region_iterate(&blk); |
| 342 | 2659 } |
| 2660 | |
| 3766 | 2661 void G1CollectedHeap::heap_region_iterate(HeapRegionClosure* cl) const { |
| 2662 _hrs.iterate(cl); | |
| 342 | 2663 } |
| 2664 | |
| 2665 void | |
| 2666 G1CollectedHeap::heap_region_par_iterate_chunked(HeapRegionClosure* cl, | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2667 uint worker_id, |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
2668 uint no_of_par_workers, |
| 342 | 2669 jint claim_value) { |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2670 const uint regions = n_regions(); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
2671 const uint max_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2672 no_of_par_workers : |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2673 1); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2674 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2675 no_of_par_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
2676 "Non dynamic should use fixed number of workers"); |
| 355 | 2677 // try to spread out the starting points of the workers |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2678 const HeapRegion* start_hr = |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2679 start_region_for_worker(worker_id, no_of_par_workers); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2680 const uint start_index = start_hr->hrs_index(); |
| 355 | 2681 |
| 2682 // each worker will actually look at all regions | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2683 for (uint count = 0; count < regions; ++count) { |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2684 const uint index = (start_index + count) % regions; |
| 355 | 2685 assert(0 <= index && index < regions, "sanity"); |
| 2686 HeapRegion* r = region_at(index); | |
| 2687 // we'll ignore "continues humongous" regions (we'll process them | |
| 2688 // when we come across their corresponding "start humongous" | |
| 2689 // region) and regions already claimed | |
| 2690 if (r->claim_value() == claim_value || r->continuesHumongous()) { | |
| 2691 continue; | |
| 2692 } | |
| 2693 // OK, try to claim it | |
| 342 | 2694 if (r->claimHeapRegion(claim_value)) { |
| 355 | 2695 // success! |
| 2696 assert(!r->continuesHumongous(), "sanity"); | |
| 2697 if (r->startsHumongous()) { | |
| 2698 // If the region is "starts humongous" we'll iterate over its | |
| 2699 // "continues humongous" first; in fact we'll do them | |
| 2700 // first. The order is important. In on case, calling the | |
| 2701 // closure on the "starts humongous" region might de-allocate | |
| 2702 // and clear all its "continues humongous" regions and, as a | |
| 2703 // result, we might end up processing them twice. So, we'll do | |
| 2704 // them first (notice: most closures will ignore them anyway) and | |
| 2705 // then we'll do the "starts humongous" region. | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2706 for (uint ch_index = index + 1; ch_index < regions; ++ch_index) { |
| 355 | 2707 HeapRegion* chr = region_at(ch_index); |
| 2708 | |
| 2709 // if the region has already been claimed or it's not | |
| 2710 // "continues humongous" we're done | |
| 2711 if (chr->claim_value() == claim_value || | |
| 2712 !chr->continuesHumongous()) { | |
| 2713 break; | |
| 2714 } | |
| 2715 | |
| 10405 | 2716 // No one should have claimed it directly. We can given |
| 355 | 2717 // that we claimed its "starts humongous" region. |
| 2718 assert(chr->claim_value() != claim_value, "sanity"); | |
| 2719 assert(chr->humongous_start_region() == r, "sanity"); | |
| 2720 | |
| 2721 if (chr->claimHeapRegion(claim_value)) { | |
| 10405 | 2722 // we should always be able to claim it; no one else should |
| 355 | 2723 // be trying to claim this region |
| 2724 | |
| 2725 bool res2 = cl->doHeapRegion(chr); | |
| 2726 assert(!res2, "Should not abort"); | |
| 2727 | |
| 2728 // Right now, this holds (i.e., no closure that actually | |
| 2729 // does something with "continues humongous" regions | |
| 2730 // clears them). We might have to weaken it in the future, | |
| 2731 // but let's leave these two asserts here for extra safety. | |
| 2732 assert(chr->continuesHumongous(), "should still be the case"); | |
| 2733 assert(chr->humongous_start_region() == r, "sanity"); | |
| 2734 } else { | |
| 2735 guarantee(false, "we should not reach here"); | |
| 2736 } | |
| 2737 } | |
| 2738 } | |
| 2739 | |
| 2740 assert(!r->continuesHumongous(), "sanity"); | |
| 2741 bool res = cl->doHeapRegion(r); | |
| 2742 assert(!res, "Should not abort"); | |
| 2743 } | |
| 2744 } | |
| 2745 } | |
| 2746 | |
| 390 | 2747 class ResetClaimValuesClosure: public HeapRegionClosure { |
| 2748 public: | |
| 2749 bool doHeapRegion(HeapRegion* r) { | |
| 2750 r->set_claim_value(HeapRegion::InitialClaimValue); | |
| 2751 return false; | |
| 2752 } | |
| 2753 }; | |
| 2754 | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2755 void G1CollectedHeap::reset_heap_region_claim_values() { |
| 390 | 2756 ResetClaimValuesClosure blk; |
| 2757 heap_region_iterate(&blk); | |
| 2758 } | |
| 2759 | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2760 void G1CollectedHeap::reset_cset_heap_region_claim_values() { |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2761 ResetClaimValuesClosure blk; |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2762 collection_set_iterate(&blk); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2763 } |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
2764 |
| 355 | 2765 #ifdef ASSERT |
| 2766 // This checks whether all regions in the heap have the correct claim | |
| 2767 // value. I also piggy-backed on this a check to ensure that the | |
| 2768 // humongous_start_region() information on "continues humongous" | |
| 2769 // regions is correct. | |
| 2770 | |
| 2771 class CheckClaimValuesClosure : public HeapRegionClosure { | |
| 2772 private: | |
| 2773 jint _claim_value; | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2774 uint _failures; |
| 355 | 2775 HeapRegion* _sh_region; |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2776 |
| 355 | 2777 public: |
| 2778 CheckClaimValuesClosure(jint claim_value) : | |
| 2779 _claim_value(claim_value), _failures(0), _sh_region(NULL) { } | |
| 2780 bool doHeapRegion(HeapRegion* r) { | |
| 2781 if (r->claim_value() != _claim_value) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2782 gclog_or_tty->print_cr("Region " HR_FORMAT ", " |
| 355 | 2783 "claim value = %d, should be %d", |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2784 HR_FORMAT_PARAMS(r), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2785 r->claim_value(), _claim_value); |
| 355 | 2786 ++_failures; |
| 2787 } | |
| 2788 if (!r->isHumongous()) { | |
| 2789 _sh_region = NULL; | |
| 2790 } else if (r->startsHumongous()) { | |
| 2791 _sh_region = r; | |
| 2792 } else if (r->continuesHumongous()) { | |
| 2793 if (r->humongous_start_region() != _sh_region) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2794 gclog_or_tty->print_cr("Region " HR_FORMAT ", " |
| 355 | 2795 "HS = "PTR_FORMAT", should be "PTR_FORMAT, |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2796 HR_FORMAT_PARAMS(r), |
| 355 | 2797 r->humongous_start_region(), |
| 2798 _sh_region); | |
| 2799 ++_failures; | |
| 342 | 2800 } |
| 2801 } | |
| 355 | 2802 return false; |
| 2803 } | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2804 uint failures() { return _failures; } |
| 355 | 2805 }; |
| 2806 | |
| 2807 bool G1CollectedHeap::check_heap_region_claim_values(jint claim_value) { | |
| 2808 CheckClaimValuesClosure cl(claim_value); | |
| 2809 heap_region_iterate(&cl); | |
| 2810 return cl.failures() == 0; | |
| 2811 } | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2812 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2813 class CheckClaimValuesInCSetHRClosure: public HeapRegionClosure { |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2814 private: |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2815 jint _claim_value; |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2816 uint _failures; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2817 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2818 public: |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2819 CheckClaimValuesInCSetHRClosure(jint claim_value) : |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2820 _claim_value(claim_value), _failures(0) { } |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2821 |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2822 uint failures() { return _failures; } |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2823 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2824 bool doHeapRegion(HeapRegion* hr) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2825 assert(hr->in_collection_set(), "how?"); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2826 assert(!hr->isHumongous(), "H-region in CSet"); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2827 if (hr->claim_value() != _claim_value) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2828 gclog_or_tty->print_cr("CSet Region " HR_FORMAT ", " |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2829 "claim value = %d, should be %d", |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2830 HR_FORMAT_PARAMS(hr), |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2831 hr->claim_value(), _claim_value); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2832 _failures += 1; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2833 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2834 return false; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2835 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2836 }; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2837 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2838 bool G1CollectedHeap::check_cset_heap_region_claim_values(jint claim_value) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2839 CheckClaimValuesInCSetHRClosure cl(claim_value); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2840 collection_set_iterate(&cl); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2841 return cl.failures() == 0; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2842 } |
| 355 | 2843 #endif // ASSERT |
| 342 | 2844 |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2845 // Clear the cached CSet starting regions and (more importantly) |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2846 // the time stamps. Called when we reset the GC time stamp. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2847 void G1CollectedHeap::clear_cset_start_regions() { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2848 assert(_worker_cset_start_region != NULL, "sanity"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2849 assert(_worker_cset_start_region_time_stamp != NULL, "sanity"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2850 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2851 int n_queues = MAX2((int)ParallelGCThreads, 1); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2852 for (int i = 0; i < n_queues; i++) { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2853 _worker_cset_start_region[i] = NULL; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2854 _worker_cset_start_region_time_stamp[i] = 0; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2855 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2856 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2857 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2858 // Given the id of a worker, obtain or calculate a suitable |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2859 // starting region for iterating over the current collection set. |
|
17844
8847586c9037
8016302: Change type of the number of GC workers to unsigned int (2)
vkempik
parents:
17833
diff
changeset
|
2860 HeapRegion* G1CollectedHeap::start_cset_region_for_worker(uint worker_i) { |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2861 assert(get_gc_time_stamp() > 0, "should have been updated by now"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2862 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2863 HeapRegion* result = NULL; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2864 unsigned gc_time_stamp = get_gc_time_stamp(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2865 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2866 if (_worker_cset_start_region_time_stamp[worker_i] == gc_time_stamp) { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2867 // Cached starting region for current worker was set |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2868 // during the current pause - so it's valid. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2869 // Note: the cached starting heap region may be NULL |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2870 // (when the collection set is empty). |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2871 result = _worker_cset_start_region[worker_i]; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2872 assert(result == NULL || result->in_collection_set(), "sanity"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2873 return result; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2874 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2875 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2876 // The cached entry was not valid so let's calculate |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2877 // a suitable starting heap region for this worker. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2878 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2879 // We want the parallel threads to start their collection |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2880 // set iteration at different collection set regions to |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2881 // avoid contention. |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2882 // If we have: |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2883 // n collection set regions |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2884 // p threads |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2885 // Then thread t will start at region floor ((t * n) / p) |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2886 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2887 result = g1_policy()->collection_set(); |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2888 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2889 uint cs_size = g1_policy()->cset_region_length(); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
2890 uint active_workers = workers()->active_workers(); |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2891 assert(UseDynamicNumberOfGCThreads || |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2892 active_workers == workers()->total_workers(), |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2893 "Unless dynamic should use total workers"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2894 |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2895 uint end_ind = (cs_size * worker_i) / active_workers; |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2896 uint start_ind = 0; |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2897 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2898 if (worker_i > 0 && |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2899 _worker_cset_start_region_time_stamp[worker_i - 1] == gc_time_stamp) { |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2900 // Previous workers starting region is valid |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2901 // so let's iterate from there |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2902 start_ind = (cs_size * (worker_i - 1)) / active_workers; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2903 result = _worker_cset_start_region[worker_i - 1]; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2904 } |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2905 |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
2906 for (uint i = start_ind; i < end_ind; i++) { |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2907 result = result->next_in_collection_set(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2908 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2909 } |
|
4709
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2910 |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2911 // Note: the calculated starting heap region may be NULL |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2912 // (when the collection set is empty). |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2913 assert(result == NULL || result->in_collection_set(), "sanity"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2914 assert(_worker_cset_start_region_time_stamp[worker_i] != gc_time_stamp, |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2915 "should be updated only once per pause"); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2916 _worker_cset_start_region[worker_i] = result; |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2917 OrderAccess::storestore(); |
|
fd2b426c30db
7119908: G1: Cache CSet start region for each worker for subsequent reuse
johnc
parents:
4708
diff
changeset
|
2918 _worker_cset_start_region_time_stamp[worker_i] = gc_time_stamp; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2919 return result; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2920 } |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
2921 |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2922 HeapRegion* G1CollectedHeap::start_region_for_worker(uint worker_i, |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2923 uint no_of_par_workers) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2924 uint worker_num = |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2925 G1CollectedHeap::use_parallel_gc_threads() ? no_of_par_workers : 1U; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2926 assert(UseDynamicNumberOfGCThreads || |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2927 no_of_par_workers == workers()->total_workers(), |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2928 "Non dynamic should use fixed number of workers"); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2929 const uint start_index = n_regions() * worker_i / worker_num; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2930 return region_at(start_index); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2931 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
2932 |
| 342 | 2933 void G1CollectedHeap::collection_set_iterate(HeapRegionClosure* cl) { |
| 2934 HeapRegion* r = g1_policy()->collection_set(); | |
| 2935 while (r != NULL) { | |
| 2936 HeapRegion* next = r->next_in_collection_set(); | |
| 2937 if (cl->doHeapRegion(r)) { | |
| 2938 cl->incomplete(); | |
| 2939 return; | |
| 2940 } | |
| 2941 r = next; | |
| 2942 } | |
| 2943 } | |
| 2944 | |
| 2945 void G1CollectedHeap::collection_set_iterate_from(HeapRegion* r, | |
| 2946 HeapRegionClosure *cl) { | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2947 if (r == NULL) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2948 // The CSet is empty so there's nothing to do. |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2949 return; |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2950 } |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
2951 |
| 342 | 2952 assert(r->in_collection_set(), |
| 2953 "Start region must be a member of the collection set."); | |
| 2954 HeapRegion* cur = r; | |
| 2955 while (cur != NULL) { | |
| 2956 HeapRegion* next = cur->next_in_collection_set(); | |
| 2957 if (cl->doHeapRegion(cur) && false) { | |
| 2958 cl->incomplete(); | |
| 2959 return; | |
| 2960 } | |
| 2961 cur = next; | |
| 2962 } | |
| 2963 cur = g1_policy()->collection_set(); | |
| 2964 while (cur != r) { | |
| 2965 HeapRegion* next = cur->next_in_collection_set(); | |
| 2966 if (cl->doHeapRegion(cur) && false) { | |
| 2967 cl->incomplete(); | |
| 2968 return; | |
| 2969 } | |
| 2970 cur = next; | |
| 2971 } | |
| 2972 } | |
| 2973 | |
|
20295
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2974 HeapRegion* G1CollectedHeap::next_compaction_region(const HeapRegion* from) const { |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2975 // We're not using an iterator given that it will wrap around when |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2976 // it reaches the last region and this is not what we want here. |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2977 for (uint index = from->hrs_index() + 1; index < n_regions(); index++) { |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2978 HeapRegion* hr = region_at(index); |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2979 if (!hr->isHumongous()) { |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2980 return hr; |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2981 } |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2982 } |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2983 return NULL; |
|
3f2894c5052e
8048112: G1 Full GC needs to support the case when the very first region is not available
tschatzl
parents:
20291
diff
changeset
|
2984 } |
| 342 | 2985 |
| 2986 Space* G1CollectedHeap::space_containing(const void* addr) const { | |
| 2987 Space* res = heap_region_containing(addr); | |
| 2988 return res; | |
| 2989 } | |
| 2990 | |
| 2991 HeapWord* G1CollectedHeap::block_start(const void* addr) const { | |
| 2992 Space* sp = space_containing(addr); | |
| 2993 if (sp != NULL) { | |
| 2994 return sp->block_start(addr); | |
| 2995 } | |
| 2996 return NULL; | |
| 2997 } | |
| 2998 | |
| 2999 size_t G1CollectedHeap::block_size(const HeapWord* addr) const { | |
| 3000 Space* sp = space_containing(addr); | |
| 3001 assert(sp != NULL, "block_size of address outside of heap"); | |
| 3002 return sp->block_size(addr); | |
| 3003 } | |
| 3004 | |
| 3005 bool G1CollectedHeap::block_is_obj(const HeapWord* addr) const { | |
| 3006 Space* sp = space_containing(addr); | |
| 3007 return sp->block_is_obj(addr); | |
| 3008 } | |
| 3009 | |
| 3010 bool G1CollectedHeap::supports_tlab_allocation() const { | |
| 3011 return true; | |
| 3012 } | |
| 3013 | |
| 3014 size_t G1CollectedHeap::tlab_capacity(Thread* ignored) const { | |
| 17727 | 3015 return (_g1_policy->young_list_target_length() - young_list()->survivor_length()) * HeapRegion::GrainBytes; |
| 3016 } | |
| 3017 | |
| 3018 size_t G1CollectedHeap::tlab_used(Thread* ignored) const { | |
| 3019 return young_list()->eden_used_bytes(); | |
| 3020 } | |
| 3021 | |
| 3022 // For G1 TLABs should not contain humongous objects, so the maximum TLAB size | |
| 3023 // must be smaller than the humongous object limit. | |
| 3024 size_t G1CollectedHeap::max_tlab_size() const { | |
| 3025 return align_size_down(_humongous_object_threshold_in_words - 1, MinObjAlignment); | |
| 342 | 3026 } |
| 3027 | |
| 3028 size_t G1CollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const { | |
| 3029 // Return the remaining space in the cur alloc region, but not less than | |
| 3030 // the min TLAB size. | |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
3031 |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
3032 // Also, this value can be at most the humongous object threshold, |
| 10405 | 3033 // since we can't allow tlabs to grow big enough to accommodate |
|
1313
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
3034 // humongous objects. |
|
664ae0c5e0e5
6755988: G1: assert(new_obj != 0 || ... "should be forwarded")
johnc
parents:
1282
diff
changeset
|
3035 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3036 HeapRegion* hr = _mutator_alloc_region.get(); |
| 17727 | 3037 size_t max_tlab = max_tlab_size() * wordSize; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3038 if (hr == NULL) { |
| 17727 | 3039 return max_tlab; |
| 342 | 3040 } else { |
| 17727 | 3041 return MIN2(MAX2(hr->free(), (size_t) MinTLABSize), max_tlab); |
| 342 | 3042 } |
| 3043 } | |
| 3044 | |
| 3045 size_t G1CollectedHeap::max_capacity() const { | |
|
2188
c33825b68624
6923430: G1: assert(res != 0,"This should have worked.")
johnc
parents:
2173
diff
changeset
|
3046 return _g1_reserved.byte_size(); |
| 342 | 3047 } |
| 3048 | |
| 3049 jlong G1CollectedHeap::millis_since_last_gc() { | |
| 3050 // assert(false, "NYI"); | |
| 3051 return 0; | |
| 3052 } | |
| 3053 | |
| 3054 void G1CollectedHeap::prepare_for_verify() { | |
| 3055 if (SafepointSynchronize::is_at_safepoint() || ! UseTLAB) { | |
| 3056 ensure_parsability(false); | |
| 3057 } | |
| 3058 g1_rem_set()->prepare_for_verify(); | |
| 3059 } | |
| 3060 | |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3061 bool G1CollectedHeap::allocated_since_marking(oop obj, HeapRegion* hr, |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3062 VerifyOption vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3063 switch (vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3064 case VerifyOption_G1UsePrevMarking: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3065 return hr->obj_allocated_since_prev_marking(obj); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3066 case VerifyOption_G1UseNextMarking: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3067 return hr->obj_allocated_since_next_marking(obj); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3068 case VerifyOption_G1UseMarkWord: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3069 return false; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3070 default: |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3071 ShouldNotReachHere(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3072 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3073 return false; // keep some compilers happy |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3074 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3075 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3076 HeapWord* G1CollectedHeap::top_at_mark_start(HeapRegion* hr, VerifyOption vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3077 switch (vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3078 case VerifyOption_G1UsePrevMarking: return hr->prev_top_at_mark_start(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3079 case VerifyOption_G1UseNextMarking: return hr->next_top_at_mark_start(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3080 case VerifyOption_G1UseMarkWord: return NULL; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3081 default: ShouldNotReachHere(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3082 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3083 return NULL; // keep some compilers happy |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3084 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3085 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3086 bool G1CollectedHeap::is_marked(oop obj, VerifyOption vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3087 switch (vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3088 case VerifyOption_G1UsePrevMarking: return isMarkedPrev(obj); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3089 case VerifyOption_G1UseNextMarking: return isMarkedNext(obj); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3090 case VerifyOption_G1UseMarkWord: return obj->is_gc_marked(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3091 default: ShouldNotReachHere(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3092 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3093 return false; // keep some compilers happy |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3094 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3095 |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3096 const char* G1CollectedHeap::top_at_mark_start_str(VerifyOption vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3097 switch (vo) { |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3098 case VerifyOption_G1UsePrevMarking: return "PTAMS"; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3099 case VerifyOption_G1UseNextMarking: return "NTAMS"; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3100 case VerifyOption_G1UseMarkWord: return "NONE"; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3101 default: ShouldNotReachHere(); |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3102 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3103 return NULL; // keep some compilers happy |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3104 } |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3105 |
|
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
17634
diff
changeset
|
3106 class VerifyRootsClosure: public OopClosure { |
| 12080 | 3107 private: |
| 3108 G1CollectedHeap* _g1h; | |
| 3109 VerifyOption _vo; | |
| 3110 bool _failures; | |
| 3111 public: | |
| 3112 // _vo == UsePrevMarking -> use "prev" marking information, | |
| 3113 // _vo == UseNextMarking -> use "next" marking information, | |
| 3114 // _vo == UseMarkWord -> use mark word from object header. | |
| 3115 VerifyRootsClosure(VerifyOption vo) : | |
| 3116 _g1h(G1CollectedHeap::heap()), | |
| 3117 _vo(vo), | |
| 3118 _failures(false) { } | |
| 3119 | |
| 3120 bool failures() { return _failures; } | |
| 3121 | |
| 3122 template <class T> void do_oop_nv(T* p) { | |
| 3123 T heap_oop = oopDesc::load_heap_oop(p); | |
| 3124 if (!oopDesc::is_null(heap_oop)) { | |
| 3125 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | |
| 3126 if (_g1h->is_obj_dead_cond(obj, _vo)) { | |
| 3127 gclog_or_tty->print_cr("Root location "PTR_FORMAT" " | |
| 3128 "points to dead obj "PTR_FORMAT, p, (void*) obj); | |
| 3129 if (_vo == VerifyOption_G1UseMarkWord) { | |
| 3130 gclog_or_tty->print_cr(" Mark word: "PTR_FORMAT, (void*)(obj->mark())); | |
| 3131 } | |
| 3132 obj->print_on(gclog_or_tty); | |
| 3133 _failures = true; | |
| 3134 } | |
| 3135 } | |
| 3136 } | |
| 3137 | |
| 3138 void do_oop(oop* p) { do_oop_nv(p); } | |
| 3139 void do_oop(narrowOop* p) { do_oop_nv(p); } | |
| 3140 }; | |
| 3141 | |
|
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
17634
diff
changeset
|
3142 class G1VerifyCodeRootOopClosure: public OopClosure { |
| 12080 | 3143 G1CollectedHeap* _g1h; |
| 3144 OopClosure* _root_cl; | |
| 3145 nmethod* _nm; | |
| 3146 VerifyOption _vo; | |
| 3147 bool _failures; | |
| 3148 | |
| 3149 template <class T> void do_oop_work(T* p) { | |
| 3150 // First verify that this root is live | |
| 3151 _root_cl->do_oop(p); | |
| 3152 | |
| 3153 if (!G1VerifyHeapRegionCodeRoots) { | |
| 3154 // We're not verifying the code roots attached to heap region. | |
| 3155 return; | |
| 3156 } | |
| 3157 | |
| 3158 // Don't check the code roots during marking verification in a full GC | |
| 3159 if (_vo == VerifyOption_G1UseMarkWord) { | |
| 3160 return; | |
| 3161 } | |
| 3162 | |
| 3163 // Now verify that the current nmethod (which contains p) is | |
| 3164 // in the code root list of the heap region containing the | |
| 3165 // object referenced by p. | |
| 3166 | |
| 3167 T heap_oop = oopDesc::load_heap_oop(p); | |
| 3168 if (!oopDesc::is_null(heap_oop)) { | |
| 3169 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | |
| 3170 | |
| 3171 // Now fetch the region containing the object | |
| 3172 HeapRegion* hr = _g1h->heap_region_containing(obj); | |
| 3173 HeapRegionRemSet* hrrs = hr->rem_set(); | |
| 3174 // Verify that the strong code root list for this region | |
| 3175 // contains the nmethod | |
| 3176 if (!hrrs->strong_code_roots_list_contains(_nm)) { | |
| 3177 gclog_or_tty->print_cr("Code root location "PTR_FORMAT" " | |
| 3178 "from nmethod "PTR_FORMAT" not in strong " | |
| 3179 "code roots for region ["PTR_FORMAT","PTR_FORMAT")", | |
| 3180 p, _nm, hr->bottom(), hr->end()); | |
| 3181 _failures = true; | |
| 3182 } | |
| 3183 } | |
| 3184 } | |
| 3185 | |
| 3186 public: | |
| 3187 G1VerifyCodeRootOopClosure(G1CollectedHeap* g1h, OopClosure* root_cl, VerifyOption vo): | |
| 3188 _g1h(g1h), _root_cl(root_cl), _vo(vo), _nm(NULL), _failures(false) {} | |
| 3189 | |
| 3190 void do_oop(oop* p) { do_oop_work(p); } | |
| 3191 void do_oop(narrowOop* p) { do_oop_work(p); } | |
| 3192 | |
| 3193 void set_nmethod(nmethod* nm) { _nm = nm; } | |
| 3194 bool failures() { return _failures; } | |
| 3195 }; | |
| 3196 | |
| 3197 class G1VerifyCodeRootBlobClosure: public CodeBlobClosure { | |
| 3198 G1VerifyCodeRootOopClosure* _oop_cl; | |
| 3199 | |
| 3200 public: | |
| 3201 G1VerifyCodeRootBlobClosure(G1VerifyCodeRootOopClosure* oop_cl): | |
| 3202 _oop_cl(oop_cl) {} | |
| 3203 | |
| 3204 void do_code_blob(CodeBlob* cb) { | |
| 3205 nmethod* nm = cb->as_nmethod_or_null(); | |
| 3206 if (nm != NULL) { | |
| 3207 _oop_cl->set_nmethod(nm); | |
| 3208 nm->oops_do(_oop_cl); | |
| 3209 } | |
| 3210 } | |
| 3211 }; | |
| 3212 | |
| 3213 class YoungRefCounterClosure : public OopClosure { | |
| 3214 G1CollectedHeap* _g1h; | |
| 3215 int _count; | |
| 3216 public: | |
| 3217 YoungRefCounterClosure(G1CollectedHeap* g1h) : _g1h(g1h), _count(0) {} | |
| 3218 void do_oop(oop* p) { if (_g1h->is_in_young(*p)) { _count++; } } | |
| 3219 void do_oop(narrowOop* p) { ShouldNotReachHere(); } | |
| 3220 | |
| 3221 int count() { return _count; } | |
| 3222 void reset_count() { _count = 0; }; | |
| 3223 }; | |
| 3224 | |
| 3225 class VerifyKlassClosure: public KlassClosure { | |
| 3226 YoungRefCounterClosure _young_ref_counter_closure; | |
| 3227 OopClosure *_oop_closure; | |
| 3228 public: | |
| 3229 VerifyKlassClosure(G1CollectedHeap* g1h, OopClosure* cl) : _young_ref_counter_closure(g1h), _oop_closure(cl) {} | |
| 3230 void do_klass(Klass* k) { | |
| 3231 k->oops_do(_oop_closure); | |
| 3232 | |
| 3233 _young_ref_counter_closure.reset_count(); | |
| 3234 k->oops_do(&_young_ref_counter_closure); | |
| 3235 if (_young_ref_counter_closure.count() > 0) { | |
| 3236 guarantee(k->has_modified_oops(), err_msg("Klass %p, has young refs but is not dirty.", k)); | |
| 3237 } | |
| 3238 } | |
| 3239 }; | |
| 3240 | |
| 342 | 3241 class VerifyLivenessOopClosure: public OopClosure { |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3242 G1CollectedHeap* _g1h; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3243 VerifyOption _vo; |
| 342 | 3244 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3245 VerifyLivenessOopClosure(G1CollectedHeap* g1h, VerifyOption vo): |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3246 _g1h(g1h), _vo(vo) |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3247 { } |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3248 void do_oop(narrowOop *p) { do_oop_work(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3249 void do_oop( oop *p) { do_oop_work(p); } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3250 |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3251 template <class T> void do_oop_work(T *p) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3252 oop obj = oopDesc::load_decode_heap_oop(p); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3253 guarantee(obj == NULL || !_g1h->is_obj_dead_cond(obj, _vo), |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3254 "Dead object referenced by a not dead object"); |
| 342 | 3255 } |
| 3256 }; | |
| 3257 | |
| 3258 class VerifyObjsInRegionClosure: public ObjectClosure { | |
| 811 | 3259 private: |
| 342 | 3260 G1CollectedHeap* _g1h; |
| 3261 size_t _live_bytes; | |
| 3262 HeapRegion *_hr; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3263 VerifyOption _vo; |
| 342 | 3264 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3265 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3266 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3267 // _vo == UseMarkWord -> use mark word from object header. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3268 VerifyObjsInRegionClosure(HeapRegion *hr, VerifyOption vo) |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3269 : _live_bytes(0), _hr(hr), _vo(vo) { |
| 342 | 3270 _g1h = G1CollectedHeap::heap(); |
| 3271 } | |
| 3272 void do_object(oop o) { | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3273 VerifyLivenessOopClosure isLive(_g1h, _vo); |
| 342 | 3274 assert(o != NULL, "Huh?"); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3275 if (!_g1h->is_obj_dead_cond(o, _vo)) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3276 // If the object is alive according to the mark word, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3277 // then verify that the marking information agrees. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3278 // Note we can't verify the contra-positive of the |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3279 // above: if the object is dead (according to the mark |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3280 // word), it may not be marked, or may have been marked |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3281 // but has since became dead, or may have been allocated |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3282 // since the last marking. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3283 if (_vo == VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3284 guarantee(!_g1h->is_obj_dead(o), "mark word and concurrent mark mismatch"); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3285 } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3286 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
3287 o->oop_iterate_no_header(&isLive); |
|
1389
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
3288 if (!_hr->obj_allocated_since_prev_marking(o)) { |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
3289 size_t obj_size = o->size(); // Make sure we don't overflow |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
3290 _live_bytes += (obj_size * HeapWordSize); |
|
5dbd9300cf9c
6943926: G1: Integer overflow during heap region verification
johnc
parents:
1388
diff
changeset
|
3291 } |
| 342 | 3292 } |
| 3293 } | |
| 3294 size_t live_bytes() { return _live_bytes; } | |
| 3295 }; | |
| 3296 | |
| 3297 class PrintObjsInRegionClosure : public ObjectClosure { | |
| 3298 HeapRegion *_hr; | |
| 3299 G1CollectedHeap *_g1; | |
| 3300 public: | |
| 3301 PrintObjsInRegionClosure(HeapRegion *hr) : _hr(hr) { | |
| 3302 _g1 = G1CollectedHeap::heap(); | |
| 3303 }; | |
| 3304 | |
| 3305 void do_object(oop o) { | |
| 3306 if (o != NULL) { | |
| 3307 HeapWord *start = (HeapWord *) o; | |
| 3308 size_t word_sz = o->size(); | |
| 3309 gclog_or_tty->print("\nPrinting obj "PTR_FORMAT" of size " SIZE_FORMAT | |
| 3310 " isMarkedPrev %d isMarkedNext %d isAllocSince %d\n", | |
| 3311 (void*) o, word_sz, | |
| 3312 _g1->isMarkedPrev(o), | |
| 3313 _g1->isMarkedNext(o), | |
| 3314 _hr->obj_allocated_since_prev_marking(o)); | |
| 3315 HeapWord *end = start + word_sz; | |
| 3316 HeapWord *cur; | |
| 3317 int *val; | |
| 3318 for (cur = start; cur < end; cur++) { | |
| 3319 val = (int *) cur; | |
| 3320 gclog_or_tty->print("\t "PTR_FORMAT":"PTR_FORMAT"\n", val, *val); | |
| 3321 } | |
| 3322 } | |
| 3323 } | |
| 3324 }; | |
| 3325 | |
| 3326 class VerifyRegionClosure: public HeapRegionClosure { | |
| 811 | 3327 private: |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3328 bool _par; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3329 VerifyOption _vo; |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
3330 bool _failures; |
| 811 | 3331 public: |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3332 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3333 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3334 // _vo == UseMarkWord -> use mark word from object header. |
| 6008 | 3335 VerifyRegionClosure(bool par, VerifyOption vo) |
| 3336 : _par(par), | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3337 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3338 _failures(false) {} |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3339 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3340 bool failures() { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3341 return _failures; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3342 } |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3343 |
| 342 | 3344 bool doHeapRegion(HeapRegion* r) { |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
3345 if (!r->continuesHumongous()) { |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3346 bool failures = false; |
| 6008 | 3347 r->verify(_vo, &failures); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3348 if (failures) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3349 _failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3350 } else { |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3351 VerifyObjsInRegionClosure not_dead_yet_cl(r, _vo); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3352 r->object_iterate(¬_dead_yet_cl); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3353 if (_vo != VerifyOption_G1UseNextMarking) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3354 if (r->max_live_bytes() < not_dead_yet_cl.live_bytes()) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3355 gclog_or_tty->print_cr("["PTR_FORMAT","PTR_FORMAT"] " |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3356 "max_live_bytes "SIZE_FORMAT" " |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3357 "< calculated "SIZE_FORMAT, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3358 r->bottom(), r->end(), |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3359 r->max_live_bytes(), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3360 not_dead_yet_cl.live_bytes()); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3361 _failures = true; |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3362 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3363 } else { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3364 // When vo == UseNextMarking we cannot currently do a sanity |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3365 // check on the live bytes as the calculation has not been |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
3366 // finalized yet. |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3367 } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3368 } |
| 342 | 3369 } |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3370 return false; // stop the region iteration if we hit a failure |
| 342 | 3371 } |
| 3372 }; | |
| 3373 | |
| 12080 | 3374 // This is the task used for parallel verification of the heap regions |
| 390 | 3375 |
| 3376 class G1ParVerifyTask: public AbstractGangTask { | |
| 3377 private: | |
| 3378 G1CollectedHeap* _g1h; | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3379 VerifyOption _vo; |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3380 bool _failures; |
| 390 | 3381 |
| 3382 public: | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3383 // _vo == UsePrevMarking -> use "prev" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3384 // _vo == UseNextMarking -> use "next" marking information, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3385 // _vo == UseMarkWord -> use mark word from object header. |
| 6008 | 3386 G1ParVerifyTask(G1CollectedHeap* g1h, VerifyOption vo) : |
| 390 | 3387 AbstractGangTask("Parallel verify task"), |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3388 _g1h(g1h), |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3389 _vo(vo), |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3390 _failures(false) { } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3391 |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3392 bool failures() { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3393 return _failures; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3394 } |
| 390 | 3395 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
3396 void work(uint worker_id) { |
|
637
25e146966e7c
6817419: G1: Enable extensive verification for humongous regions
iveresov
parents:
636
diff
changeset
|
3397 HandleMark hm; |
| 6008 | 3398 VerifyRegionClosure blk(true, _vo); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
3399 _g1h->heap_region_par_iterate_chunked(&blk, worker_id, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3400 _g1h->workers()->active_workers(), |
| 390 | 3401 HeapRegion::ParVerifyClaimValue); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3402 if (blk.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3403 _failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3404 } |
| 390 | 3405 } |
| 3406 }; | |
| 3407 | |
| 12080 | 3408 void G1CollectedHeap::verify(bool silent, VerifyOption vo) { |
|
8855
24ef5fb05e0f
8010463: G1: Crashes with -UseTLAB and heap verification
johnc
parents:
8853
diff
changeset
|
3409 if (SafepointSynchronize::is_at_safepoint()) { |
| 12080 | 3410 assert(Thread::current()->is_VM_thread(), |
| 3411 "Expected to be executed serially by the VM thread at this point"); | |
| 3412 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
3413 if (!silent) { gclog_or_tty->print("Roots "); } |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3414 VerifyRootsClosure rootsCl(vo); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
3415 VerifyKlassClosure klassCl(this, &rootsCl); |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
3416 CLDToKlassAndOopClosure cldCl(&klassCl, &rootsCl, false); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3417 |
|
3293
1f4413413144
7039089: G1: changeset for 7037276 broke heap verification, and related cleanups
ysr
parents:
3289
diff
changeset
|
3418 // We apply the relevant closures to all the oops in the |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
3419 // system dictionary, class loader data graph, the string table |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
3420 // and the nmethods in the code cache. |
|
20257
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20256
diff
changeset
|
3421 G1VerifyCodeRootOopClosure codeRootsCl(this, &rootsCl, vo); |
|
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20256
diff
changeset
|
3422 G1VerifyCodeRootBlobClosure blobsCl(&codeRootsCl); |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
3423 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
3424 process_all_roots(true, // activate StrongRootsScope |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
3425 SO_AllCodeCache, // roots scanning options |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
3426 &rootsCl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
3427 &cldCl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
3428 &blobsCl); |
|
20257
7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
stefank
parents:
20256
diff
changeset
|
3429 |
| 12080 | 3430 bool failures = rootsCl.failures() || codeRootsCl.failures(); |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3431 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3432 if (vo != VerifyOption_G1UseMarkWord) { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3433 // If we're verifying during a full GC then the region sets |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3434 // will have been torn down at the start of the GC. Therefore |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3435 // verifying the region sets will fail. So we only verify |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3436 // the region sets when not in a full GC. |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3437 if (!silent) { gclog_or_tty->print("HeapRegionSets "); } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3438 verify_region_sets(); |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3439 } |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3440 |
| 2152 | 3441 if (!silent) { gclog_or_tty->print("HeapRegions "); } |
| 390 | 3442 if (GCParallelVerificationEnabled && ParallelGCThreads > 1) { |
| 3443 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 3444 "sanity check"); | |
| 3445 | |
| 6008 | 3446 G1ParVerifyTask task(this, vo); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3447 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3448 workers()->active_workers() == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3449 "If not dynamic should be using all the workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3450 int n_workers = workers()->active_workers(); |
| 390 | 3451 set_par_threads(n_workers); |
| 3452 workers()->run_task(&task); | |
| 3453 set_par_threads(0); | |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3454 if (task.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3455 failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3456 } |
| 390 | 3457 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3458 // Checks that the expected amount of parallel work was done. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3459 // The implication is that n_workers is > 0. |
| 390 | 3460 assert(check_heap_region_claim_values(HeapRegion::ParVerifyClaimValue), |
| 3461 "sanity check"); | |
| 3462 | |
| 3463 reset_heap_region_claim_values(); | |
| 3464 | |
| 3465 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 3466 "sanity check"); | |
| 3467 } else { | |
| 6008 | 3468 VerifyRegionClosure blk(false, vo); |
| 3766 | 3469 heap_region_iterate(&blk); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3470 if (blk.failures()) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3471 failures = true; |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3472 } |
| 390 | 3473 } |
| 2152 | 3474 if (!silent) gclog_or_tty->print("RemSet "); |
| 342 | 3475 rem_set()->verify(); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3476 |
| 17764 | 3477 if (G1StringDedup::is_enabled()) { |
| 3478 if (!silent) gclog_or_tty->print("StrDedup "); | |
| 3479 G1StringDedup::verify(); | |
| 3480 } | |
| 3481 | |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3482 if (failures) { |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3483 gclog_or_tty->print_cr("Heap:"); |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3484 // It helps to have the per-region information in the output to |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3485 // help us track down what went wrong. This is why we call |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3486 // print_extended_on() instead of print_on(). |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3487 print_extended_on(gclog_or_tty); |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
3488 gclog_or_tty->cr(); |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1545
diff
changeset
|
3489 #ifndef PRODUCT |
| 1044 | 3490 if (VerifyDuringGC && G1VerifyDuringGCPrintReachable) { |
| 1388 | 3491 concurrent_mark()->print_reachable("at-verification-failure", |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
3766
diff
changeset
|
3492 vo, false /* all */); |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3493 } |
|
1547
fb1a39993f69
6951319: enable solaris builds using Sun Studio 12 update 1
jcoomes
parents:
1545
diff
changeset
|
3494 #endif |
|
1020
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3495 gclog_or_tty->flush(); |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3496 } |
|
ff2402f6a50b
6882730: G1: parallel heap verification messes up region dump
tonyp
parents:
1019
diff
changeset
|
3497 guarantee(!failures, "there should not have been any failures"); |
| 342 | 3498 } else { |
| 17764 | 3499 if (!silent) { |
| 3500 gclog_or_tty->print("(SKIPPING Roots, HeapRegionSets, HeapRegions, RemSet"); | |
| 3501 if (G1StringDedup::is_enabled()) { | |
| 3502 gclog_or_tty->print(", StrDedup"); | |
| 3503 } | |
| 3504 gclog_or_tty->print(") "); | |
| 3505 } | |
| 342 | 3506 } |
| 3507 } | |
| 3508 | |
| 12080 | 3509 void G1CollectedHeap::verify(bool silent) { |
| 3510 verify(silent, VerifyOption_G1UsePrevMarking); | |
| 3511 } | |
| 3512 | |
| 3513 double G1CollectedHeap::verify(bool guard, const char* msg) { | |
| 3514 double verify_time_ms = 0.0; | |
| 3515 | |
| 3516 if (guard && total_collections() >= VerifyGCStartAt) { | |
| 3517 double verify_start = os::elapsedTime(); | |
| 3518 HandleMark hm; // Discard invalid handles created during verification | |
| 3519 prepare_for_verify(); | |
| 3520 Universe::verify(VerifyOption_G1UsePrevMarking, msg); | |
| 3521 verify_time_ms = (os::elapsedTime() - verify_start) * 1000; | |
| 3522 } | |
| 3523 | |
| 3524 return verify_time_ms; | |
| 3525 } | |
| 3526 | |
| 3527 void G1CollectedHeap::verify_before_gc() { | |
| 3528 double verify_time_ms = verify(VerifyBeforeGC, " VerifyBeforeGC:"); | |
| 3529 g1_policy()->phase_times()->record_verify_before_time_ms(verify_time_ms); | |
| 3530 } | |
| 3531 | |
| 3532 void G1CollectedHeap::verify_after_gc() { | |
| 3533 double verify_time_ms = verify(VerifyAfterGC, " VerifyAfterGC:"); | |
| 3534 g1_policy()->phase_times()->record_verify_after_time_ms(verify_time_ms); | |
| 3535 } | |
| 3536 | |
| 342 | 3537 class PrintRegionClosure: public HeapRegionClosure { |
| 3538 outputStream* _st; | |
| 3539 public: | |
| 3540 PrintRegionClosure(outputStream* st) : _st(st) {} | |
| 3541 bool doHeapRegion(HeapRegion* r) { | |
| 3542 r->print_on(_st); | |
| 3543 return false; | |
| 3544 } | |
| 3545 }; | |
| 3546 | |
|
17833
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3547 bool G1CollectedHeap::is_obj_dead_cond(const oop obj, |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3548 const HeapRegion* hr, |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3549 const VerifyOption vo) const { |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3550 switch (vo) { |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3551 case VerifyOption_G1UsePrevMarking: return is_obj_dead(obj, hr); |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3552 case VerifyOption_G1UseNextMarking: return is_obj_ill(obj, hr); |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3553 case VerifyOption_G1UseMarkWord: return !obj->is_gc_marked(); |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3554 default: ShouldNotReachHere(); |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3555 } |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3556 return false; // keep some compilers happy |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3557 } |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3558 |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3559 bool G1CollectedHeap::is_obj_dead_cond(const oop obj, |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3560 const VerifyOption vo) const { |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3561 switch (vo) { |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3562 case VerifyOption_G1UsePrevMarking: return is_obj_dead(obj); |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3563 case VerifyOption_G1UseNextMarking: return is_obj_ill(obj); |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3564 case VerifyOption_G1UseMarkWord: return !obj->is_gc_marked(); |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3565 default: ShouldNotReachHere(); |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3566 } |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3567 return false; // keep some compilers happy |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3568 } |
|
bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
tschatzl
parents:
17774
diff
changeset
|
3569 |
| 342 | 3570 void G1CollectedHeap::print_on(outputStream* st) const { |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3571 st->print(" %-20s", "garbage-first heap"); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3572 st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K", |
|
846
42d84bbbecf4
6859911: G1: assert(Heap_lock->owner() = NULL, "Should be owned on this thread's behalf")
tonyp
parents:
845
diff
changeset
|
3573 capacity()/K, used_unlocked()/K); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3574 st->print(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")", |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3575 _g1_storage.low_boundary(), |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3576 _g1_storage.high(), |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3577 _g1_storage.high_boundary()); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3578 st->cr(); |
|
3986
65a8ff39a6da
7095194: G1: HeapRegion::GrainBytes, GrainWords, and CardsPerRegion should be size_t
johnc
parents:
3983
diff
changeset
|
3579 st->print(" region size " SIZE_FORMAT "K, ", HeapRegion::GrainBytes / K); |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3580 uint young_regions = _young_list->length(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3581 st->print("%u young (" SIZE_FORMAT "K), ", young_regions, |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3582 (size_t) young_regions * HeapRegion::GrainBytes / K); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3583 uint survivor_regions = g1_policy()->recorded_survivor_regions(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3584 st->print("%u survivors (" SIZE_FORMAT "K)", survivor_regions, |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3585 (size_t) survivor_regions * HeapRegion::GrainBytes / K); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3586 st->cr(); |
|
6863
04155d9c8c76
8000358: G1: metaspace information not printed in PrintHeapAtGC output nor in hs_err file
johnc
parents:
6819
diff
changeset
|
3587 MetaspaceAux::print_on(st); |
|
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3588 } |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3589 |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3590 void G1CollectedHeap::print_extended_on(outputStream* st) const { |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3591 print_on(st); |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3592 |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3593 // Print the per-region information. |
|
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4072
diff
changeset
|
3594 st->cr(); |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3595 st->print_cr("Heap Regions: (Y=young(eden), SU=young(survivor), " |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3596 "HS=humongous(starts), HC=humongous(continues), " |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3597 "CS=collection set, F=free, TS=gc time stamp, " |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3598 "PTAMS=previous top-at-mark-start, " |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3599 "NTAMS=next top-at-mark-start)"); |
| 342 | 3600 PrintRegionClosure blk(st); |
| 3766 | 3601 heap_region_iterate(&blk); |
| 342 | 3602 } |
| 3603 | |
|
9076
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8855
diff
changeset
|
3604 void G1CollectedHeap::print_on_error(outputStream* st) const { |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8855
diff
changeset
|
3605 this->CollectedHeap::print_on_error(st); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8855
diff
changeset
|
3606 |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8855
diff
changeset
|
3607 if (_cm != NULL) { |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8855
diff
changeset
|
3608 st->cr(); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8855
diff
changeset
|
3609 _cm->print_on_error(st); |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8855
diff
changeset
|
3610 } |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8855
diff
changeset
|
3611 } |
|
7b835924c31c
8011872: Include Bit Map addresses in the hs_err files
stefank
parents:
8855
diff
changeset
|
3612 |
| 342 | 3613 void G1CollectedHeap::print_gc_threads_on(outputStream* st) const { |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
3614 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 1019 | 3615 workers()->print_worker_threads_on(st); |
| 3616 } | |
| 3617 _cmThread->print_on(st); | |
| 342 | 3618 st->cr(); |
| 1019 | 3619 _cm->print_worker_threads_on(st); |
| 3620 _cg1r->print_worker_threads_on(st); | |
| 17764 | 3621 if (G1StringDedup::is_enabled()) { |
| 3622 G1StringDedup::print_worker_threads_on(st); | |
| 3623 } | |
| 342 | 3624 } |
| 3625 | |
| 3626 void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const { | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
3627 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 342 | 3628 workers()->threads_do(tc); |
| 3629 } | |
| 3630 tc->do_thread(_cmThread); | |
| 794 | 3631 _cg1r->threads_do(tc); |
| 17764 | 3632 if (G1StringDedup::is_enabled()) { |
| 3633 G1StringDedup::threads_do(tc); | |
| 3634 } | |
| 342 | 3635 } |
| 3636 | |
| 3637 void G1CollectedHeap::print_tracing_info() const { | |
| 3638 // We'll overload this to mean "trace GC pause statistics." | |
| 3639 if (TraceGen0Time || TraceGen1Time) { | |
| 3640 // The "G1CollectorPolicy" is keeping track of these stats, so delegate | |
| 3641 // to that. | |
| 3642 g1_policy()->print_tracing_info(); | |
| 3643 } | |
| 751 | 3644 if (G1SummarizeRSetStats) { |
| 342 | 3645 g1_rem_set()->print_summary_info(); |
| 3646 } | |
| 1282 | 3647 if (G1SummarizeConcMark) { |
| 342 | 3648 concurrent_mark()->print_summary_info(); |
| 3649 } | |
| 3650 g1_policy()->print_yg_surv_rate_info(); | |
| 3651 SpecializationStats::print(); | |
| 3652 } | |
| 3653 | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3654 #ifndef PRODUCT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3655 // Helpful for debugging RSet issues. |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3656 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3657 class PrintRSetsClosure : public HeapRegionClosure { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3658 private: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3659 const char* _msg; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3660 size_t _occupied_sum; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3661 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3662 public: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3663 bool doHeapRegion(HeapRegion* r) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3664 HeapRegionRemSet* hrrs = r->rem_set(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3665 size_t occupied = hrrs->occupied(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3666 _occupied_sum += occupied; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3667 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3668 gclog_or_tty->print_cr("Printing RSet for region "HR_FORMAT, |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3669 HR_FORMAT_PARAMS(r)); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3670 if (occupied == 0) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3671 gclog_or_tty->print_cr(" RSet is empty"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3672 } else { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3673 hrrs->print(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3674 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3675 gclog_or_tty->print_cr("----------"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3676 return false; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3677 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3678 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3679 PrintRSetsClosure(const char* msg) : _msg(msg), _occupied_sum(0) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3680 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3681 gclog_or_tty->print_cr("========================================"); |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
17935
diff
changeset
|
3682 gclog_or_tty->print_cr("%s", msg); |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3683 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3684 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3685 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3686 ~PrintRSetsClosure() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3687 gclog_or_tty->print_cr("Occupied Sum: "SIZE_FORMAT, _occupied_sum); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3688 gclog_or_tty->print_cr("========================================"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3689 gclog_or_tty->cr(); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3690 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3691 }; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3692 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3693 void G1CollectedHeap::print_cset_rsets() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3694 PrintRSetsClosure cl("Printing CSet RSets"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3695 collection_set_iterate(&cl); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3696 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3697 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3698 void G1CollectedHeap::print_all_rsets() { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3699 PrintRSetsClosure cl("Printing All RSets");; |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3700 heap_region_iterate(&cl); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3701 } |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3702 #endif // PRODUCT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3703 |
| 342 | 3704 G1CollectedHeap* G1CollectedHeap::heap() { |
| 3705 assert(_sh->kind() == CollectedHeap::G1CollectedHeap, | |
| 3706 "not a garbage-first heap"); | |
| 3707 return _g1h; | |
| 3708 } | |
| 3709 | |
| 3710 void G1CollectedHeap::gc_prologue(bool full /* Ignored */) { | |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1166
diff
changeset
|
3711 // always_do_update_barrier = false; |
| 342 | 3712 assert(InlineCacheBuffer::is_empty(), "should have cleaned up ICBuffer"); |
| 3713 // Fill TLAB's and such | |
| 17727 | 3714 accumulate_statistics_all_tlabs(); |
| 342 | 3715 ensure_parsability(true); |
|
12339
c319b188c7b2
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
12305
diff
changeset
|
3716 |
|
c319b188c7b2
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
12305
diff
changeset
|
3717 if (G1SummarizeRSetStats && (G1SummarizeRSetStatsPeriod > 0) && |
|
c319b188c7b2
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
12305
diff
changeset
|
3718 (total_collections() % G1SummarizeRSetStatsPeriod == 0)) { |
|
c319b188c7b2
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
12305
diff
changeset
|
3719 g1_rem_set()->print_periodic_summary_info("Before GC RS summary"); |
|
c319b188c7b2
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
12305
diff
changeset
|
3720 } |
| 342 | 3721 } |
| 3722 | |
| 3723 void G1CollectedHeap::gc_epilogue(bool full /* Ignored */) { | |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10327
diff
changeset
|
3724 |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10327
diff
changeset
|
3725 if (G1SummarizeRSetStats && |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10327
diff
changeset
|
3726 (G1SummarizeRSetStatsPeriod > 0) && |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10327
diff
changeset
|
3727 // we are at the end of the GC. Total collections has already been increased. |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10327
diff
changeset
|
3728 ((total_collections() - 1) % G1SummarizeRSetStatsPeriod == 0)) { |
|
12339
c319b188c7b2
8014078: G1: improve remembered set summary information by providing per region type information
tschatzl
parents:
12305
diff
changeset
|
3729 g1_rem_set()->print_periodic_summary_info("After GC RS summary"); |
|
10372
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10327
diff
changeset
|
3730 } |
|
e72f7eecc96d
8013895: G1: G1SummarizeRSetStats output on Linux needs improvemen
tschatzl
parents:
10327
diff
changeset
|
3731 |
| 342 | 3732 // FIXME: what is this about? |
| 3733 // I'm ignoring the "fill_newgen()" call if "alloc_event_enabled" | |
| 3734 // is set. | |
| 3735 COMPILER2_PRESENT(assert(DerivedPointerTable::is_empty(), | |
| 3736 "derived pointer present")); | |
|
1245
6484c4ee11cb
6904516: More object array barrier fixes, following up on 6906727
ysr
parents:
1166
diff
changeset
|
3737 // always_do_update_barrier = true; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3738 |
| 17727 | 3739 resize_all_tlabs(); |
| 3740 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3741 // We have just completed a GC. Update the soft reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3742 // policy with the new heap occupancy |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
3743 Universe::update_heap_info_at_gc(); |
| 342 | 3744 } |
| 3745 | |
| 1973 | 3746 HeapWord* G1CollectedHeap::do_collection_pause(size_t word_size, |
| 3747 unsigned int gc_count_before, | |
|
12113
f7d3b4387a16
8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents:
12082
diff
changeset
|
3748 bool* succeeded, |
|
f7d3b4387a16
8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents:
12082
diff
changeset
|
3749 GCCause::Cause gc_cause) { |
| 1973 | 3750 assert_heap_not_locked_and_not_at_safepoint(); |
| 342 | 3751 g1_policy()->record_stop_world_start(); |
| 1973 | 3752 VM_G1IncCollectionPause op(gc_count_before, |
| 3753 word_size, | |
| 3754 false, /* should_initiate_conc_mark */ | |
| 3755 g1_policy()->max_pause_time_ms(), | |
|
12113
f7d3b4387a16
8022872: G1: Use correct GC cause for young GC triggered by humongous allocations
brutisso
parents:
12082
diff
changeset
|
3756 gc_cause); |
| 1973 | 3757 VMThread::execute(&op); |
| 3758 | |
| 3759 HeapWord* result = op.result(); | |
| 3760 bool ret_succeeded = op.prologue_succeeded() && op.pause_succeeded(); | |
| 3761 assert(result == NULL || ret_succeeded, | |
| 3762 "the result should be NULL if the VM did not succeed"); | |
| 3763 *succeeded = ret_succeeded; | |
| 3764 | |
| 3765 assert_heap_not_locked(); | |
| 3766 return result; | |
| 342 | 3767 } |
| 3768 | |
| 3769 void | |
| 3770 G1CollectedHeap::doConcurrentMark() { | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3771 MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3772 if (!_cmThread->in_progress()) { |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3773 _cmThread->set_started(); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3774 CGC_lock->notify(); |
| 342 | 3775 } |
| 3776 } | |
| 3777 | |
| 3778 size_t G1CollectedHeap::pending_card_num() { | |
| 3779 size_t extra_cards = 0; | |
| 3780 JavaThread *curr = Threads::first(); | |
| 3781 while (curr != NULL) { | |
| 3782 DirtyCardQueue& dcq = curr->dirty_card_queue(); | |
| 3783 extra_cards += dcq.size(); | |
| 3784 curr = curr->next(); | |
| 3785 } | |
| 3786 DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set(); | |
| 3787 size_t buffer_size = dcqs.buffer_size(); | |
| 3788 size_t buffer_num = dcqs.completed_buffers_num(); | |
| 6611 | 3789 |
| 3790 // PtrQueueSet::buffer_size() and PtrQueue:size() return sizes | |
| 3791 // in bytes - not the number of 'entries'. We need to convert | |
| 3792 // into a number of cards. | |
| 3793 return (buffer_size * buffer_num + extra_cards) / oopSize; | |
| 342 | 3794 } |
| 3795 | |
| 3796 size_t G1CollectedHeap::cards_scanned() { | |
| 1861 | 3797 return g1_rem_set()->cardsScanned(); |
| 342 | 3798 } |
| 3799 | |
| 3800 void | |
| 3801 G1CollectedHeap::setup_surviving_young_words() { | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3802 assert(_surviving_young_words == NULL, "pre-condition"); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3803 uint array_length = g1_policy()->young_cset_region_length(); |
| 6197 | 3804 _surviving_young_words = NEW_C_HEAP_ARRAY(size_t, (size_t) array_length, mtGC); |
| 342 | 3805 if (_surviving_young_words == NULL) { |
|
10161
746b070f5022
8011661: Insufficient memory message says "malloc" when sometimes it should say "mmap"
ccheung
parents:
10099
diff
changeset
|
3806 vm_exit_out_of_memory(sizeof(size_t) * array_length, OOM_MALLOC_ERROR, |
| 342 | 3807 "Not enough space for young surv words summary."); |
| 3808 } | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3809 memset(_surviving_young_words, 0, (size_t) array_length * sizeof(size_t)); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3810 #ifdef ASSERT |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3811 for (uint i = 0; i < array_length; ++i) { |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3812 assert( _surviving_young_words[i] == 0, "memset above" ); |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3813 } |
|
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
3814 #endif // !ASSERT |
| 342 | 3815 } |
| 3816 | |
| 3817 void | |
| 3818 G1CollectedHeap::update_surviving_young_words(size_t* surv_young_words) { | |
| 3819 MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3820 uint array_length = g1_policy()->young_cset_region_length(); |
|
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3821 for (uint i = 0; i < array_length; ++i) { |
| 342 | 3822 _surviving_young_words[i] += surv_young_words[i]; |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
3823 } |
| 342 | 3824 } |
| 3825 | |
| 3826 void | |
| 3827 G1CollectedHeap::cleanup_surviving_young_words() { | |
| 3828 guarantee( _surviving_young_words != NULL, "pre-condition" ); | |
| 6197 | 3829 FREE_C_HEAP_ARRAY(size_t, _surviving_young_words, mtGC); |
| 342 | 3830 _surviving_young_words = NULL; |
| 3831 } | |
| 3832 | |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3833 #ifdef ASSERT |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3834 class VerifyCSetClosure: public HeapRegionClosure { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3835 public: |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3836 bool doHeapRegion(HeapRegion* hr) { |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3837 // Here we check that the CSet region's RSet is ready for parallel |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3838 // iteration. The fields that we'll verify are only manipulated |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3839 // when the region is part of a CSet and is collected. Afterwards, |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3840 // we reset these fields when we clear the region's RSet (when the |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3841 // region is freed) so they are ready when the region is |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3842 // re-allocated. The only exception to this is if there's an |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3843 // evacuation failure and instead of freeing the region we leave |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3844 // it in the heap. In that case, we reset these fields during |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3845 // evacuation failure handling. |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3846 guarantee(hr->rem_set()->verify_ready_for_par_iteration(), "verification"); |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3847 |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3848 // Here's a good place to add any other checks we'd like to |
|
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3849 // perform on CSet regions. |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3850 return false; |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3851 } |
|
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3852 }; |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
3853 #endif // ASSERT |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
3854 |
| 1709 | 3855 #if TASKQUEUE_STATS |
| 3856 void G1CollectedHeap::print_taskqueue_stats_hdr(outputStream* const st) { | |
| 3857 st->print_raw_cr("GC Task Stats"); | |
| 3858 st->print_raw("thr "); TaskQueueStats::print_header(1, st); st->cr(); | |
| 3859 st->print_raw("--- "); TaskQueueStats::print_header(2, st); st->cr(); | |
| 3860 } | |
| 3861 | |
| 3862 void G1CollectedHeap::print_taskqueue_stats(outputStream* const st) const { | |
| 3863 print_taskqueue_stats_hdr(st); | |
| 3864 | |
| 3865 TaskQueueStats totals; | |
|
1755
8e5955ddf8e4
6978300: G1: debug builds crash if ParallelGCThreads==0
jcoomes
parents:
1719
diff
changeset
|
3866 const int n = workers() != NULL ? workers()->total_workers() : 1; |
| 1709 | 3867 for (int i = 0; i < n; ++i) { |
| 3868 st->print("%3d ", i); task_queue(i)->stats.print(st); st->cr(); | |
| 3869 totals += task_queue(i)->stats; | |
| 3870 } | |
| 3871 st->print_raw("tot "); totals.print(st); st->cr(); | |
| 3872 | |
| 3873 DEBUG_ONLY(totals.verify()); | |
| 3874 } | |
| 3875 | |
| 3876 void G1CollectedHeap::reset_taskqueue_stats() { | |
|
1755
8e5955ddf8e4
6978300: G1: debug builds crash if ParallelGCThreads==0
jcoomes
parents:
1719
diff
changeset
|
3877 const int n = workers() != NULL ? workers()->total_workers() : 1; |
| 1709 | 3878 for (int i = 0; i < n; ++i) { |
| 3879 task_queue(i)->stats.reset(); | |
| 3880 } | |
| 3881 } | |
| 3882 #endif // TASKQUEUE_STATS | |
| 3883 | |
|
6752
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3884 void G1CollectedHeap::log_gc_header() { |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3885 if (!G1Log::fine()) { |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3886 return; |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3887 } |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3888 |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17992
diff
changeset
|
3889 gclog_or_tty->gclog_stamp(_gc_tracer_stw->gc_id()); |
|
6752
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3890 |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3891 GCCauseString gc_cause_str = GCCauseString("GC pause", gc_cause()) |
|
7455
0b54ffe4c2d3
8005672: Clean up some changes to GC logging with GCCause's
jmasa
parents:
7397
diff
changeset
|
3892 .append(g1_policy()->gcs_are_young() ? "(young)" : "(mixed)") |
|
6752
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3893 .append(g1_policy()->during_initial_mark_pause() ? " (initial-mark)" : ""); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3894 |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3895 gclog_or_tty->print("[%s", (const char*)gc_cause_str); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3896 } |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3897 |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3898 void G1CollectedHeap::log_gc_footer(double pause_time_sec) { |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3899 if (!G1Log::fine()) { |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3900 return; |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3901 } |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3902 |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3903 if (G1Log::finer()) { |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3904 if (evacuation_failed()) { |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3905 gclog_or_tty->print(" (to-space exhausted)"); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3906 } |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3907 gclog_or_tty->print_cr(", %3.7f secs]", pause_time_sec); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3908 g1_policy()->phase_times()->note_gc_end(); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3909 g1_policy()->phase_times()->print(pause_time_sec); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3910 g1_policy()->print_detailed_heap_transition(); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3911 } else { |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3912 if (evacuation_failed()) { |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3913 gclog_or_tty->print("--"); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3914 } |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3915 g1_policy()->print_heap_transition(); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3916 gclog_or_tty->print_cr(", %3.7f secs]", pause_time_sec); |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3917 } |
|
7207
0f80645e9c26
8004170: G1: Verbose GC output is not getting flushed to log file using JDK 8
johnc
parents:
6863
diff
changeset
|
3918 gclog_or_tty->flush(); |
|
6752
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3919 } |
|
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3920 |
| 1973 | 3921 bool |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3922 G1CollectedHeap::do_collection_pause_at_safepoint(double target_pause_time_ms) { |
| 2152 | 3923 assert_at_safepoint(true /* should_be_vm_thread */); |
| 3924 guarantee(!is_gc_active(), "collection is not reentrant"); | |
| 3925 | |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3926 if (GC_locker::check_active_before_gc()) { |
| 1973 | 3927 return false; |
|
1359
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3928 } |
|
23b1b27ac76c
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.")
tonyp
parents:
1313
diff
changeset
|
3929 |
|
13400
86e6d691f2e1
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
13062
diff
changeset
|
3930 _gc_timer_stw->register_gc_start(); |
| 10405 | 3931 |
| 3932 _gc_tracer_stw->report_gc_start(gc_cause(), _gc_timer_stw->gc_start()); | |
| 3933 | |
|
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
2039
diff
changeset
|
3934 SvcGCMarker sgcm(SvcGCMarker::MINOR); |
|
2039
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
2038
diff
changeset
|
3935 ResourceMark rm; |
|
7c5250dbd584
6896624: G1: hotspot:::gc and hotspot:::mem-pool-gc probes are not fired
tonyp
parents:
2038
diff
changeset
|
3936 |
|
4872
aa3d708d67c4
7141200: log some interesting information in ring buffers for crashes
never
parents:
4787
diff
changeset
|
3937 print_heap_before_gc(); |
| 10405 | 3938 trace_heap_before_gc(_gc_tracer_stw); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3939 |
| 2152 | 3940 verify_region_sets_optional(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
3941 verify_dirty_young_regions(); |
| 2152 | 3942 |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3943 // This call will decide whether this pause is an initial-mark |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3944 // pause. If it is, during_initial_mark_pause() will return true |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3945 // for the duration of this pause. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3946 g1_policy()->decide_on_conc_mark_initiation(); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3947 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3948 // We do not allow initial-mark to be piggy-backed on a mixed GC. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3949 assert(!g1_policy()->during_initial_mark_pause() || |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3950 g1_policy()->gcs_are_young(), "sanity"); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3951 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3952 // We also do not allow mixed GCs during marking. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3953 assert(!mark_in_progress() || g1_policy()->gcs_are_young(), "sanity"); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3954 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3955 // Record whether this pause is an initial mark. When the current |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3956 // thread has completed its logging output and it's safe to signal |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3957 // the CM thread, the flag's value in the policy has been reset. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3958 bool should_start_conc_mark = g1_policy()->during_initial_mark_pause(); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3959 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
3960 // Inner scope for scope based logging, timers, and stats collection |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3961 { |
| 10405 | 3962 EvacuationInfo evacuation_info; |
| 3963 | |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3964 if (g1_policy()->during_initial_mark_pause()) { |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3965 // We are about to start a marking cycle, so we increment the |
|
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3966 // full collection counter. |
|
6120
37552638d24a
7172388: G1: _total_full_collections should not be incremented for concurrent cycles
brutisso
parents:
6109
diff
changeset
|
3967 increment_old_marking_cycles_started(); |
| 10405 | 3968 register_concurrent_cycle_start(_gc_timer_stw->gc_start()); |
|
1656
4e5661ba9d98
6944166: G1: explicit GCs are not always handled correctly
tonyp
parents:
1611
diff
changeset
|
3969 } |
| 10405 | 3970 |
| 3971 _gc_tracer_stw->report_yc_type(yc_type()); | |
| 3972 | |
|
6007
5c86f8211d1e
7160728: Introduce an extra logging level for G1 logging
brutisso
parents:
5987
diff
changeset
|
3973 TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty); |
| 6030 | 3974 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3975 int active_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
3976 workers()->active_workers() : 1); |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
3977 double pause_start_sec = os::elapsedTime(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
3978 g1_policy()->phase_times()->note_gc_start(active_workers); |
|
6752
9646b7ff4d14
7198130: G1: PrintReferenceGC output comes out of order
brutisso
parents:
6725
diff
changeset
|
3979 log_gc_header(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3980 |
|
3289
b52782ae3880
6946417: G1: Java VisualVM does not support G1 properly.
jmasa
parents:
3285
diff
changeset
|
3981 TraceCollectorStats tcs(g1mm()->incremental_collection_counters()); |
|
3356
78542e2b5e35
7036199: Adding a notification to the implementation of GarbageCollectorMXBeans
fparain
parents:
3323
diff
changeset
|
3982 TraceMemoryManagerStats tms(false /* fullGC */, gc_cause()); |
|
1089
db0d5eba9d20
6815790: G1: Missing MemoryPoolMXBeans with -XX:+UseG1GC
tonyp
parents:
1088
diff
changeset
|
3983 |
| 2361 | 3984 // If the secondary_free_list is not empty, append it to the |
| 3985 // free_list. No need to wait for the cleanup operation to finish; | |
| 3986 // the region allocation code will check the secondary_free_list | |
| 3987 // and wait if necessary. If the G1StressConcRegionFreeing flag is | |
| 3988 // set, skip this step so that the region allocation code has to | |
| 3989 // get entries from the secondary_free_list. | |
| 2152 | 3990 if (!G1StressConcRegionFreeing) { |
| 2361 | 3991 append_secondary_free_list_if_not_empty_with_lock(); |
| 2152 | 3992 } |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3993 |
| 12080 | 3994 assert(check_young_list_well_formed(), "young list should be well formed"); |
| 3995 assert(check_heap_region_claim_values(HeapRegion::InitialClaimValue), | |
| 3996 "sanity check"); | |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
3997 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3998 // Don't dynamically change the number of GC threads this early. A value of |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
3999 // 0 is used to indicate serial work. When parallel work is done, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4000 // it will be set. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4001 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4002 { // Call to jvmpi::post_class_unload_events must occur outside of active GC |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4003 IsGCActiveMark x; |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4004 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4005 gc_prologue(false); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4006 increment_total_collections(false /* full gc */); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4007 increment_gc_time_stamp(); |
| 342 | 4008 |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4009 verify_before_gc(); |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
4010 check_bitmaps("GC Start"); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4011 |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4012 COMPILER2_PRESENT(DerivedPointerTable::clear()); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4013 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4014 // Please see comment in g1CollectedHeap.hpp and |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4015 // G1CollectedHeap::ref_processing_init() to see how |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4016 // reference processing currently works in G1. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4017 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4018 // Enable discovery in the STW reference processor |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4019 ref_processor_stw()->enable_discovery(true /*verify_disabled*/, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4020 true /*verify_no_refs*/); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4021 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4022 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4023 // We want to temporarily turn off discovery by the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4024 // CM ref processor, if necessary, and turn it back on |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4025 // on again later if we do. Using a scoped |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4026 // NoRefDiscovery object will do this. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4027 NoRefDiscovery no_cm_discovery(ref_processor_cm()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4028 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4029 // Forget the current alloc region (we might even choose it to be part |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4030 // of the collection set!). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4031 release_mutator_alloc_region(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4032 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4033 // We should call this after we retire the mutator alloc |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4034 // region(s) so that all the ALLOC / RETIRE events are generated |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4035 // before the start GC event. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4036 _hr_printer.start_gc(false /* full */, (size_t) total_collections()); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4037 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4038 // This timing is only used by the ergonomics to handle our pause target. |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4039 // It is unclear why this should not include the full pause. We will |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4040 // investigate this in CR 7178365. |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4041 // |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4042 // Preserving the old comment here if that helps the investigation: |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4043 // |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4044 // The elapsed time induced by the start time below deliberately elides |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4045 // the possible verification above. |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4046 double sample_start_time_sec = os::elapsedTime(); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4047 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4048 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4049 gclog_or_tty->print_cr("\nBefore recording pause start.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4050 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4051 g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4052 #endif // YOUNG_LIST_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4053 |
|
10098
71013d764f6e
8010780: G1: Eden occupancy/capacity output wrong after a full GC
johnc
parents:
8855
diff
changeset
|
4054 g1_policy()->record_collection_pause_start(sample_start_time_sec); |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4055 |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4056 double scan_wait_start = os::elapsedTime(); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4057 // We have to wait until the CM threads finish scanning the |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4058 // root regions as it's the only way to ensure that all the |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4059 // objects on them have been correctly scanned before we start |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4060 // moving them during the GC. |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4061 bool waited = _cm->root_regions()->wait_until_scan_finished(); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4062 double wait_time_ms = 0.0; |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4063 if (waited) { |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4064 double scan_wait_end = os::elapsedTime(); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4065 wait_time_ms = (scan_wait_end - scan_wait_start) * 1000.0; |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4066 } |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4067 g1_policy()->phase_times()->record_root_region_scan_wait_time(wait_time_ms); |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4068 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4069 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4070 gclog_or_tty->print_cr("\nAfter recording pause start.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4071 _young_list->print(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4072 #endif // YOUNG_LIST_VERBOSE |
| 342 | 4073 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4074 if (g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4075 concurrent_mark()->checkpointRootsInitialPre(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4076 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4077 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4078 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4079 gclog_or_tty->print_cr("\nBefore choosing collection set.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4080 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4081 g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4082 #endif // YOUNG_LIST_VERBOSE |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4083 |
| 10405 | 4084 g1_policy()->finalize_cset(target_pause_time_ms, evacuation_info); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4085 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4086 _cm->note_start_of_gc(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4087 // We should not verify the per-thread SATB buffers given that |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4088 // we have not filtered them yet (we'll do so during the |
|
4912
a9647476d1a4
7132029: G1: mixed GC phase lasts for longer than it should
tonyp
parents:
4910
diff
changeset
|
4089 // GC). We also call this after finalize_cset() to |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4090 // ensure that the CSet has been finalized. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4091 _cm->verify_no_cset_oops(true /* verify_stacks */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4092 true /* verify_enqueued_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4093 false /* verify_thread_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4094 true /* verify_fingers */); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4095 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4096 if (_hr_printer.is_active()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4097 HeapRegion* hr = g1_policy()->collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4098 while (hr != NULL) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4099 G1HRPrinter::RegionType type; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4100 if (!hr->is_young()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4101 type = G1HRPrinter::Old; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4102 } else if (hr->is_survivor()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4103 type = G1HRPrinter::Survivor; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4104 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4105 type = G1HRPrinter::Eden; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4106 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4107 _hr_printer.cset(hr); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4108 hr = hr->next_in_collection_set(); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4109 } |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4110 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4111 |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4112 #ifdef ASSERT |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4113 VerifyCSetClosure cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4114 collection_set_iterate(&cl); |
|
3777
e8b0b0392037
7046182: G1: remove unnecessary iterations over the collection set
tonyp
parents:
3774
diff
changeset
|
4115 #endif // ASSERT |
| 1707 | 4116 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4117 setup_surviving_young_words(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4118 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4119 // Initialize the GC alloc regions. |
| 10405 | 4120 init_gc_alloc_regions(evacuation_info); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4121 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4122 // Actually do the work... |
| 10405 | 4123 evacuate_collection_set(evacuation_info); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4124 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4125 // We do this to mainly verify the per-thread SATB buffers |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4126 // (which have been filtered by now) since we didn't verify |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4127 // them earlier. No point in re-checking the stacks / enqueued |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4128 // buffers given that the CSet has not changed since last time |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4129 // we checked. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4130 _cm->verify_no_cset_oops(false /* verify_stacks */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4131 false /* verify_enqueued_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4132 true /* verify_thread_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4133 true /* verify_fingers */); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4134 |
| 10405 | 4135 free_collection_set(g1_policy()->collection_set(), evacuation_info); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4136 g1_policy()->clear_collection_set(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4137 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4138 cleanup_surviving_young_words(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4139 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4140 // Start a new incremental collection set for the next pause. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4141 g1_policy()->start_incremental_cset_building(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4142 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4143 clear_cset_fast_test(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4144 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4145 _young_list->reset_sampled_info(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4146 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4147 // Don't check the whole heap at this point as the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4148 // GC alloc regions from this pause have been tagged |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4149 // as survivors and moved on to the survivor list. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4150 // Survivor regions will fail the !is_young() check. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4151 assert(check_young_list_empty(false /* check_heap */), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4152 "young list should be empty"); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4153 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4154 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4155 gclog_or_tty->print_cr("Before recording survivors.\nYoung List:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4156 _young_list->print(); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4157 #endif // YOUNG_LIST_VERBOSE |
| 342 | 4158 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4159 g1_policy()->record_survivor_regions(_young_list->survivor_length(), |
| 10405 | 4160 _young_list->first_survivor_region(), |
| 4161 _young_list->last_survivor_region()); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4162 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4163 _young_list->reset_auxilary_lists(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4164 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4165 if (evacuation_failed()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4166 _summary_bytes_used = recalculate_used(); |
| 10405 | 4167 uint n_queues = MAX2((int)ParallelGCThreads, 1); |
| 4168 for (uint i = 0; i < n_queues; i++) { | |
| 4169 if (_evacuation_failed_info_array[i].has_failed()) { | |
| 4170 _gc_tracer_stw->report_evacuation_failed(_evacuation_failed_info_array[i]); | |
| 4171 } | |
| 4172 } | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4173 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4174 // The "used" of the the collection set have already been subtracted |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4175 // when they were freed. Add in the bytes evacuated. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4176 _summary_bytes_used += g1_policy()->bytes_copied_during_gc(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4177 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4178 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4179 if (g1_policy()->during_initial_mark_pause()) { |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4180 // We have to do this before we notify the CM threads that |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4181 // they can start working to make sure that all the |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
4182 // appropriate initialization is done on the CM object. |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4183 concurrent_mark()->checkpointRootsInitialPost(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4184 set_marking_started(); |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4185 // Note that we don't actually trigger the CM thread at |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4186 // this point. We do that later when we're sure that |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4187 // the current thread has completed its logging output. |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4188 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4189 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4190 allocate_dummy_regions(); |
|
3285
49a67202bc67
7011855: G1: non-product flag to artificially grow the heap
tonyp
parents:
2433
diff
changeset
|
4191 |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4192 #if YOUNG_LIST_VERBOSE |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4193 gclog_or_tty->print_cr("\nEnd of the pause.\nYoung_list:"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4194 _young_list->print(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4195 g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4196 #endif // YOUNG_LIST_VERBOSE |
| 342 | 4197 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4198 init_mutator_alloc_region(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4199 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4200 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4201 size_t expand_bytes = g1_policy()->expansion_amount(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4202 if (expand_bytes > 0) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4203 size_t bytes_before = capacity(); |
| 4785 | 4204 // No need for an ergo verbose message here, |
| 4205 // expansion_amount() does this when it returns a value > 0. | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4206 if (!expand(expand_bytes)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4207 // We failed to expand the heap so let's verify that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4208 // committed/uncommitted amount match the backing store |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4209 assert(capacity() == _g1_storage.committed_size(), "committed size mismatch"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4210 assert(max_capacity() == _g1_storage.reserved_size(), "reserved size mismatch"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4211 } |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
4212 } |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
4213 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4214 |
| 10405 | 4215 // We redo the verification but now wrt to the new CSet which |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4216 // has just got initialized after the previous CSet was freed. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4217 _cm->verify_no_cset_oops(true /* verify_stacks */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4218 true /* verify_enqueued_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4219 true /* verify_thread_buffers */, |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4220 true /* verify_fingers */); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4221 _cm->note_end_of_gc(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4222 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4223 // This timing is only used by the ergonomics to handle our pause target. |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4224 // It is unclear why this should not include the full pause. We will |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4225 // investigate this in CR 7178365. |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4226 double sample_end_time_sec = os::elapsedTime(); |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4227 double pause_time_ms = (sample_end_time_sec - sample_start_time_sec) * MILLIUNITS; |
| 10405 | 4228 g1_policy()->record_collection_pause_end(pause_time_ms, evacuation_info); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4229 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4230 MemoryService::track_memory_usage(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4231 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4232 // In prepare_for_verify() below we'll need to scan the deferred |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4233 // update buffers to bring the RSets up-to-date if |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4234 // G1HRRSFlushLogBuffersOnVerify has been set. While scanning |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4235 // the update buffers we'll probably need to scan cards on the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4236 // regions we just allocated to (i.e., the GC alloc |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4237 // regions). However, during the last GC we called |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4238 // set_saved_mark() on all the GC alloc regions, so card |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4239 // scanning might skip the [saved_mark_word()...top()] area of |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4240 // those regions (i.e., the area we allocated objects into |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4241 // during the last GC). But it shouldn't. Given that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4242 // saved_mark_word() is conditional on whether the GC time stamp |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4243 // on the region is current or not, by incrementing the GC time |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4244 // stamp here we invalidate all the GC time stamps on all the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4245 // regions and saved_mark_word() will simply return top() for |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4246 // all the regions. This is a nicer way of ensuring this rather |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4247 // than iterating over the regions and fixing them. In fact, the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4248 // GC time stamp increment here also ensures that |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4249 // saved_mark_word() will return top() between pauses, i.e., |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4250 // during concurrent refinement. So we don't need the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4251 // is_gc_active() check to decided which top to use when |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4252 // scanning cards (see CR 7039627). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4253 increment_gc_time_stamp(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4254 |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4255 verify_after_gc(); |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
4256 check_bitmaps("GC End"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4257 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4258 assert(!ref_processor_stw()->discovery_enabled(), "Postcondition"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4259 ref_processor_stw()->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4260 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4261 // CM reference discovery will be re-enabled if necessary. |
|
3920
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
4262 } |
|
af2ab04e0038
6929868: G1: introduce min / max young gen size bounds
brutisso
parents:
3919
diff
changeset
|
4263 |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4264 // We should do this after we potentially expand the heap so |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4265 // that all the COMMIT events are generated before the end GC |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4266 // event, and after we retire the GC alloc regions so that all |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4267 // RETIRE events are generated before the end GC event. |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4268 _hr_printer.end_gc(false /* full */, (size_t) total_collections()); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4269 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4270 if (mark_in_progress()) { |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4271 concurrent_mark()->update_g1_committed(); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4272 } |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
4273 |
|
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
4274 #ifdef TRACESPINNING |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4275 ParallelTaskTerminator::print_termination_counts(); |
|
546
05c6d52fa7a9
6690928: Use spinning in combination with yields for workstealing termination.
jmasa
parents:
545
diff
changeset
|
4276 #endif |
| 342 | 4277 |
|
838
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4278 gc_epilogue(false); |
|
0316eac49d5a
6855834: G1: minimize the output when -XX:+PrintHeapAtGC is set
tonyp
parents:
811
diff
changeset
|
4279 } |
|
6121
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4280 |
|
7207
0f80645e9c26
8004170: G1: Verbose GC output is not getting flushed to log file using JDK 8
johnc
parents:
6863
diff
changeset
|
4281 // Print the remainder of the GC log output. |
|
0f80645e9c26
8004170: G1: Verbose GC output is not getting flushed to log file using JDK 8
johnc
parents:
6863
diff
changeset
|
4282 log_gc_footer(os::elapsedTime() - pause_start_sec); |
|
0f80645e9c26
8004170: G1: Verbose GC output is not getting flushed to log file using JDK 8
johnc
parents:
6863
diff
changeset
|
4283 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4284 // It is not yet to safe to tell the concurrent mark to |
|
6121
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4285 // start as we have some optional output below. We don't want the |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4286 // output from the concurrent mark thread interfering with this |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4287 // logging output either. |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4288 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4289 _hrs.verify_optional(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4290 verify_region_sets_optional(); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4291 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4292 TASKQUEUE_STATS_ONLY(if (ParallelGCVerbose) print_taskqueue_stats()); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4293 TASKQUEUE_STATS_ONLY(reset_taskqueue_stats()); |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4294 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4295 print_heap_after_gc(); |
| 10405 | 4296 trace_heap_after_gc(_gc_tracer_stw); |
|
6121
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4297 |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4298 // We must call G1MonitoringSupport::update_sizes() in the same scoping level |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4299 // as an active TraceMemoryManagerStats object (i.e. before the destructor for the |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4300 // TraceMemoryManagerStats is called) so that the G1 memory pools are updated |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4301 // before any GC notifications are raised. |
|
b9442ac22f59
7173460: G1: java/lang/management/MemoryMXBean/CollectionUsageThreshold.java failes with G1
brutisso
parents:
6120
diff
changeset
|
4302 g1mm()->update_sizes(); |
| 10405 | 4303 |
| 4304 _gc_tracer_stw->report_evacuation_info(&evacuation_info); | |
| 4305 _gc_tracer_stw->report_tenuring_threshold(_g1_policy->tenuring_threshold()); | |
|
13400
86e6d691f2e1
8028128: Add a type safe alternative for working with counter based data
mgronlun
parents:
13062
diff
changeset
|
4306 _gc_timer_stw->register_gc_end(); |
| 10405 | 4307 _gc_tracer_stw->report_gc_end(_gc_timer_stw->gc_end(), _gc_timer_stw->time_partitions()); |
| 4308 } | |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4309 // It should now be safe to tell the concurrent mark thread to start |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4310 // without its logging output interfering with the logging output |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4311 // that came from the pause. |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4312 |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4313 if (should_start_conc_mark) { |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4314 // CAUTION: after the doConcurrentMark() call below, |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4315 // the concurrent marking thread(s) could be running |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4316 // concurrently with us. Make sure that anything after |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4317 // this point does not assume that we are the only GC thread |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4318 // running. Note: of course, the actual marking work will |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4319 // not start until the safepoint itself is released in |
| 20192 | 4320 // SuspendibleThreadSet::desynchronize(). |
|
4831
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4321 doConcurrentMark(); |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4322 } |
|
7ca7be5a6a0b
7129271: G1: Interference from multiple threads in PrintGC/PrintGCDetails output
johnc
parents:
4829
diff
changeset
|
4323 |
| 1973 | 4324 return true; |
| 342 | 4325 } |
| 4326 | |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4327 size_t G1CollectedHeap::desired_plab_sz(GCAllocPurpose purpose) |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4328 { |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4329 size_t gclab_word_size; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4330 switch (purpose) { |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4331 case GCAllocForSurvived: |
| 6595 | 4332 gclab_word_size = _survivor_plab_stats.desired_plab_sz(); |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4333 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4334 case GCAllocForTenured: |
| 6595 | 4335 gclab_word_size = _old_plab_stats.desired_plab_sz(); |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4336 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4337 default: |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4338 assert(false, "unknown GCAllocPurpose"); |
| 6595 | 4339 gclab_word_size = _old_plab_stats.desired_plab_sz(); |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4340 break; |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4341 } |
| 6595 | 4342 |
| 4343 // Prevent humongous PLAB sizes for two reasons: | |
| 4344 // * PLABs are allocated using a similar paths as oops, but should | |
| 4345 // never be in a humongous region | |
| 4346 // * Allowing humongous PLABs needlessly churns the region free lists | |
| 4347 return MIN2(_humongous_object_threshold_in_words, gclab_word_size); | |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4348 } |
|
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4349 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4350 void G1CollectedHeap::init_mutator_alloc_region() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4351 assert(_mutator_alloc_region.get() == NULL, "pre-condition"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4352 _mutator_alloc_region.init(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4353 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4354 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4355 void G1CollectedHeap::release_mutator_alloc_region() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4356 _mutator_alloc_region.release(); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4357 assert(_mutator_alloc_region.get() == NULL, "post-condition"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
4358 } |
|
1391
79e419e5ea3b
6942253: G1: replace G1ParallelGCAllocBufferSize with YoungPLABSize and OldPLABSize
apetrusenko
parents:
1390
diff
changeset
|
4359 |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4360 void G1CollectedHeap::use_retained_old_gc_alloc_region(EvacuationInfo& evacuation_info) { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4361 HeapRegion* retained_region = _retained_old_gc_alloc_region; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4362 _retained_old_gc_alloc_region = NULL; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4363 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4364 // We will discard the current GC alloc region if: |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4365 // a) it's in the collection set (it can happen!), |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4366 // b) it's already full (no point in using it), |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4367 // c) it's empty (this means that it was emptied during |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4368 // a cleanup and it should be on the free list now), or |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4369 // d) it's humongous (this means that it was emptied |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4370 // during a cleanup and was added to the free list, but |
| 10405 | 4371 // has been subsequently used to allocate a humongous |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4372 // object that may be less than the region size). |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4373 if (retained_region != NULL && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4374 !retained_region->in_collection_set() && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4375 !(retained_region->top() == retained_region->end()) && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4376 !retained_region->is_empty() && |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4377 !retained_region->isHumongous()) { |
|
20274
a8137787acfe
8047821: G1 Does not use the save_marks functionality as intended
mgerdin
parents:
20270
diff
changeset
|
4378 retained_region->record_top_and_timestamp(); |
| 4072 | 4379 // The retained region was added to the old region set when it was |
| 4380 // retired. We have to remove it now, since we don't allow regions | |
| 4381 // we allocate to in the region sets. We'll re-add it later, when | |
| 4382 // it's retired again. | |
| 4383 _old_set.remove(retained_region); | |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4384 bool during_im = g1_policy()->during_initial_mark_pause(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4385 retained_region->note_start_of_copying(during_im); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4386 _old_gc_alloc_region.set(retained_region); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4387 _hr_printer.reuse(retained_region); |
| 10405 | 4388 evacuation_info.set_alloc_regions_used_before(retained_region->used()); |
| 4389 } | |
| 4390 } | |
| 4391 | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4392 void G1CollectedHeap::init_gc_alloc_regions(EvacuationInfo& evacuation_info) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4393 assert_at_safepoint(true /* should_be_vm_thread */); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4394 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4395 _survivor_gc_alloc_region.init(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4396 _old_gc_alloc_region.init(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4397 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4398 use_retained_old_gc_alloc_region(evacuation_info); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4399 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4400 |
| 10405 | 4401 void G1CollectedHeap::release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info) { |
| 4402 evacuation_info.set_allocation_regions(_survivor_gc_alloc_region.count() + | |
| 4403 _old_gc_alloc_region.count()); | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4404 _survivor_gc_alloc_region.release(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4405 // If we have an old GC alloc region to release, we'll save it in |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4406 // _retained_old_gc_alloc_region. If we don't |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4407 // _retained_old_gc_alloc_region will become NULL. This is what we |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4408 // want either way so no reason to check explicitly for either |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4409 // condition. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4410 _retained_old_gc_alloc_region = _old_gc_alloc_region.release(); |
| 6595 | 4411 |
| 4412 if (ResizePLAB) { | |
| 6819 | 4413 _survivor_plab_stats.adjust_desired_plab_sz(no_of_gc_workers); |
| 4414 _old_plab_stats.adjust_desired_plab_sz(no_of_gc_workers); | |
| 6595 | 4415 } |
| 342 | 4416 } |
| 4417 | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4418 void G1CollectedHeap::abandon_gc_alloc_regions() { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4419 assert(_survivor_gc_alloc_region.get() == NULL, "pre-condition"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4420 assert(_old_gc_alloc_region.get() == NULL, "pre-condition"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4421 _retained_old_gc_alloc_region = NULL; |
| 342 | 4422 } |
| 4423 | |
| 4424 void G1CollectedHeap::init_for_evac_failure(OopsInHeapRegionClosure* cl) { | |
| 4425 _drain_in_progress = false; | |
| 4426 set_evac_failure_closure(cl); | |
| 6197 | 4427 _evac_failure_scan_stack = new (ResourceObj::C_HEAP, mtGC) GrowableArray<oop>(40, true); |
| 342 | 4428 } |
| 4429 | |
| 4430 void G1CollectedHeap::finalize_for_evac_failure() { | |
| 4431 assert(_evac_failure_scan_stack != NULL && | |
| 4432 _evac_failure_scan_stack->length() == 0, | |
| 4433 "Postcondition"); | |
| 4434 assert(!_drain_in_progress, "Postcondition"); | |
| 1045 | 4435 delete _evac_failure_scan_stack; |
| 342 | 4436 _evac_failure_scan_stack = NULL; |
| 4437 } | |
| 4438 | |
| 4439 void G1CollectedHeap::remove_self_forwarding_pointers() { | |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4440 assert(check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity"); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4441 |
|
17757
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
17756
diff
changeset
|
4442 double remove_self_forwards_start = os::elapsedTime(); |
|
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
17756
diff
changeset
|
4443 |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4444 G1ParRemoveSelfForwardPtrsTask rsfp_task(this); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4445 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4446 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4447 set_par_threads(); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4448 workers()->run_task(&rsfp_task); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4449 set_par_threads(0); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
4450 } else { |
|
4783
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4451 rsfp_task.work(0); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4452 } |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4453 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4454 assert(check_cset_heap_region_claim_values(HeapRegion::ParEvacFailureClaimValue), "sanity"); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4455 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4456 // Reset the claim values in the regions in the collection set. |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4457 reset_cset_heap_region_claim_values(); |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4458 |
|
023652e49ac0
7121496: G1: do the per-region evacuation failure handling work in parallel
johnc
parents:
4781
diff
changeset
|
4459 assert(check_cset_heap_region_claim_values(HeapRegion::InitialClaimValue), "sanity"); |
| 342 | 4460 |
| 4461 // Now restore saved marks, if any. | |
|
8038
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4462 assert(_objs_with_preserved_marks.size() == |
|
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4463 _preserved_marks_of_objs.size(), "Both or none."); |
|
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4464 while (!_objs_with_preserved_marks.is_empty()) { |
|
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4465 oop obj = _objs_with_preserved_marks.pop(); |
|
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4466 markOop m = _preserved_marks_of_objs.pop(); |
|
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4467 obj->set_mark(m); |
|
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4468 } |
|
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4469 _objs_with_preserved_marks.clear(true); |
|
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4470 _preserved_marks_of_objs.clear(true); |
|
17757
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
17756
diff
changeset
|
4471 |
|
eff02b5bd56c
8035654: Add times for evacuation failure handling in "Other" time
tschatzl
parents:
17756
diff
changeset
|
4472 g1_policy()->phase_times()->record_evac_fail_remove_self_forwards((os::elapsedTime() - remove_self_forwards_start) * 1000.0); |
| 342 | 4473 } |
| 4474 | |
| 4475 void G1CollectedHeap::push_on_evac_failure_scan_stack(oop obj) { | |
| 4476 _evac_failure_scan_stack->push(obj); | |
| 4477 } | |
| 4478 | |
| 4479 void G1CollectedHeap::drain_evac_failure_scan_stack() { | |
| 4480 assert(_evac_failure_scan_stack != NULL, "precondition"); | |
| 4481 | |
| 4482 while (_evac_failure_scan_stack->length() > 0) { | |
| 4483 oop obj = _evac_failure_scan_stack->pop(); | |
| 4484 _evac_failure_closure->set_region(heap_region_containing(obj)); | |
| 4485 obj->oop_iterate_backwards(_evac_failure_closure); | |
| 4486 } | |
| 4487 } | |
| 4488 | |
| 4489 oop | |
| 10405 | 4490 G1CollectedHeap::handle_evacuation_failure_par(G1ParScanThreadState* _par_scan_state, |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4491 oop old) { |
|
3323
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4492 assert(obj_in_cs(old), |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4493 err_msg("obj: "PTR_FORMAT" should still be in the CSet", |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4494 (HeapWord*) old)); |
| 342 | 4495 markOop m = old->mark(); |
| 4496 oop forward_ptr = old->forward_to_atomic(old); | |
| 4497 if (forward_ptr == NULL) { | |
| 4498 // Forward-to-self succeeded. | |
| 10405 | 4499 assert(_par_scan_state != NULL, "par scan state"); |
| 4500 OopsInHeapRegionClosure* cl = _par_scan_state->evac_failure_closure(); | |
| 4501 uint queue_num = _par_scan_state->queue_num(); | |
| 4502 | |
| 4503 _evacuation_failed = true; | |
| 4504 _evacuation_failed_info_array[queue_num].register_copy_failure(old->size()); | |
| 342 | 4505 if (_evac_failure_closure != cl) { |
| 4506 MutexLockerEx x(EvacFailureStack_lock, Mutex::_no_safepoint_check_flag); | |
| 4507 assert(!_drain_in_progress, | |
| 4508 "Should only be true while someone holds the lock."); | |
| 4509 // Set the global evac-failure closure to the current thread's. | |
| 4510 assert(_evac_failure_closure == NULL, "Or locking has failed."); | |
| 4511 set_evac_failure_closure(cl); | |
| 4512 // Now do the common part. | |
| 4513 handle_evacuation_failure_common(old, m); | |
| 4514 // Reset to NULL. | |
| 4515 set_evac_failure_closure(NULL); | |
| 4516 } else { | |
| 4517 // The lock is already held, and this is recursive. | |
| 4518 assert(_drain_in_progress, "This should only be the recursive case."); | |
| 4519 handle_evacuation_failure_common(old, m); | |
| 4520 } | |
| 4521 return old; | |
| 4522 } else { | |
|
3323
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4523 // Forward-to-self failed. Either someone else managed to allocate |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4524 // space for this object (old != forward_ptr) or they beat us in |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4525 // self-forwarding it (old == forward_ptr). |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4526 assert(old == forward_ptr || !obj_in_cs(forward_ptr), |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4527 err_msg("obj: "PTR_FORMAT" forwarded to: "PTR_FORMAT" " |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4528 "should not be in the CSet", |
|
75af3e8de182
7040450: G1: assert((_g1->evacuation_failed()) || (!_g1->obj_in_cs(obj))) failed: shouldn't still be in ...
tonyp
parents:
3317
diff
changeset
|
4529 (HeapWord*) old, (HeapWord*) forward_ptr)); |
| 342 | 4530 return forward_ptr; |
| 4531 } | |
| 4532 } | |
| 4533 | |
| 4534 void G1CollectedHeap::handle_evacuation_failure_common(oop old, markOop m) { | |
| 4535 preserve_mark_if_necessary(old, m); | |
| 4536 | |
| 4537 HeapRegion* r = heap_region_containing(old); | |
| 4538 if (!r->evacuation_failed()) { | |
| 4539 r->set_evacuation_failed(true); | |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
4540 _hr_printer.evac_failure(r); |
| 342 | 4541 } |
| 4542 | |
| 4543 push_on_evac_failure_scan_stack(old); | |
| 4544 | |
| 4545 if (!_drain_in_progress) { | |
| 4546 // prevent recursion in copy_to_survivor_space() | |
| 4547 _drain_in_progress = true; | |
| 4548 drain_evac_failure_scan_stack(); | |
| 4549 _drain_in_progress = false; | |
| 4550 } | |
| 4551 } | |
| 4552 | |
| 4553 void G1CollectedHeap::preserve_mark_if_necessary(oop obj, markOop m) { | |
|
2038
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4554 assert(evacuation_failed(), "Oversaving!"); |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4555 // We want to call the "for_promotion_failure" version only in the |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4556 // case of a promotion failure. |
|
74ee0db180fa
6807801: CMS: could save/restore fewer header words during scavenge
ysr
parents:
2037
diff
changeset
|
4557 if (m->must_be_preserved_for_promotion_failure(obj)) { |
|
8038
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4558 _objs_with_preserved_marks.push(obj); |
|
ad747ee9d0b1
8002144: G1: large number of evacuation failures may lead to large c heap memory usage
brutisso
parents:
7455
diff
changeset
|
4559 _preserved_marks_of_objs.push(m); |
| 342 | 4560 } |
| 4561 } | |
| 4562 | |
| 4563 HeapWord* G1CollectedHeap::par_allocate_during_gc(GCAllocPurpose purpose, | |
| 4564 size_t word_size) { | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4565 if (purpose == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4566 HeapWord* result = survivor_attempt_allocation(word_size); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4567 if (result != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4568 return result; |
| 342 | 4569 } else { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4570 // Let's try to allocate in the old gen in case we can fit the |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4571 // object there. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4572 return old_attempt_allocation(word_size); |
| 342 | 4573 } |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4574 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4575 assert(purpose == GCAllocForTenured, "sanity"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4576 HeapWord* result = old_attempt_allocation(word_size); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4577 if (result != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4578 return result; |
| 342 | 4579 } else { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4580 // Let's try to allocate in the survivors in case we can fit the |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4581 // object there. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4582 return survivor_attempt_allocation(word_size); |
| 342 | 4583 } |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4584 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4585 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4586 ShouldNotReachHere(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4587 // Trying to keep some compilers happy. |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
4588 return NULL; |
| 342 | 4589 } |
| 4590 | |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4591 G1ParGCAllocBuffer::G1ParGCAllocBuffer(size_t gclab_word_size) : |
|
20215
983092f35ff7
8028710: G1 does not retire allocation buffers after reference processing work
tschatzl
parents:
20212
diff
changeset
|
4592 ParGCAllocBuffer(gclab_word_size), _retired(true) { } |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4593 |
|
17687
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17652
diff
changeset
|
4594 void G1ParCopyHelper::mark_object(oop obj) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4595 #ifdef ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4596 HeapRegion* hr = _g1->heap_region_containing(obj); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4597 assert(hr != NULL, "sanity"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4598 assert(!hr->in_collection_set(), "should not mark objects in the CSet"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4599 #endif // ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4600 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4601 // We know that the object is not moving so it's safe to read its size. |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4602 _cm->grayRoot(obj, (size_t) obj->size(), _worker_id); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4603 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4604 |
|
17687
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17652
diff
changeset
|
4605 void G1ParCopyHelper::mark_forwarded_object(oop from_obj, oop to_obj) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4606 #ifdef ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4607 assert(from_obj->is_forwarded(), "from obj should be forwarded"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4608 assert(from_obj->forwardee() == to_obj, "to obj should be the forwardee"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4609 assert(from_obj != to_obj, "should not be self-forwarded"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4610 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4611 HeapRegion* from_hr = _g1->heap_region_containing(from_obj); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4612 assert(from_hr != NULL, "sanity"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4613 assert(from_hr->in_collection_set(), "from obj should be in the CSet"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4614 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4615 HeapRegion* to_hr = _g1->heap_region_containing(to_obj); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4616 assert(to_hr != NULL, "sanity"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4617 assert(!to_hr->in_collection_set(), "should not mark objects in the CSet"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4618 #endif // ASSERT |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4619 |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4620 // The object might be in the process of being copied by another |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4621 // worker so we cannot trust that its to-space image is |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4622 // well-formed. So we have to read its size from its from-space |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4623 // image which we know should not be changing. |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4624 _cm->grayRoot(to_obj, (size_t) from_obj->size(), _worker_id); |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4625 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4626 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4627 template <class T> |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4628 void G1ParCopyHelper::do_klass_barrier(T* p, oop new_obj) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4629 if (_g1->heap_region_containing_raw(new_obj)->is_young()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4630 _scanned_klass->record_modified_oops(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4631 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4632 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4633 |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4634 template <G1Barrier barrier, G1Mark do_mark_object> |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4635 template <class T> |
|
17687
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17652
diff
changeset
|
4636 void G1ParCopyClosure<barrier, do_mark_object>::do_oop_work(T* p) { |
|
17688
2c2ae9e5f65d
8035326: Assume non-NULL references in G1CollectedHeap::in_cset_fast_test
tschatzl
parents:
17687
diff
changeset
|
4637 T heap_oop = oopDesc::load_heap_oop(p); |
|
2c2ae9e5f65d
8035326: Assume non-NULL references in G1CollectedHeap::in_cset_fast_test
tschatzl
parents:
17687
diff
changeset
|
4638 |
|
2c2ae9e5f65d
8035326: Assume non-NULL references in G1CollectedHeap::in_cset_fast_test
tschatzl
parents:
17687
diff
changeset
|
4639 if (oopDesc::is_null(heap_oop)) { |
|
2c2ae9e5f65d
8035326: Assume non-NULL references in G1CollectedHeap::in_cset_fast_test
tschatzl
parents:
17687
diff
changeset
|
4640 return; |
|
2c2ae9e5f65d
8035326: Assume non-NULL references in G1CollectedHeap::in_cset_fast_test
tschatzl
parents:
17687
diff
changeset
|
4641 } |
|
2c2ae9e5f65d
8035326: Assume non-NULL references in G1CollectedHeap::in_cset_fast_test
tschatzl
parents:
17687
diff
changeset
|
4642 |
|
2c2ae9e5f65d
8035326: Assume non-NULL references in G1CollectedHeap::in_cset_fast_test
tschatzl
parents:
17687
diff
changeset
|
4643 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4644 |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4645 assert(_worker_id == _par_scan_state->queue_num(), "sanity"); |
|
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4646 |
|
1261
0414c1049f15
6923991: G1: improve scalability of RSet scanning
iveresov
parents:
1245
diff
changeset
|
4647 if (_g1->in_cset_fast_test(obj)) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4648 oop forwardee; |
| 526 | 4649 if (obj->is_forwarded()) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4650 forwardee = obj->forwardee(); |
| 526 | 4651 } else { |
|
17689
5d492d192cbf
8035329: Move G1ParCopyClosure::copy_to_survivor_space into G1ParScanThreadState
tschatzl
parents:
17688
diff
changeset
|
4652 forwardee = _par_scan_state->copy_to_survivor_space(obj); |
| 342 | 4653 } |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4654 assert(forwardee != NULL, "forwardee should not be NULL"); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4655 oopDesc::encode_store_heap_oop(p, forwardee); |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4656 if (do_mark_object != G1MarkNone && forwardee != obj) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4657 // If the object is self-forwarded we don't need to explicitly |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4658 // mark it, the evacuation failure protocol will do so. |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4659 mark_forwarded_object(obj, forwardee); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4660 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4661 |
|
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
17634
diff
changeset
|
4662 if (barrier == G1BarrierKlass) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4663 do_klass_barrier(p, forwardee); |
| 342 | 4664 } |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4665 } else { |
|
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4666 // The object is not in collection set. If we're a root scanning |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4667 // closure during an initial mark pause then attempt to mark the object. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4668 if (do_mark_object == G1MarkFromRoot) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
4669 mark_object(obj); |
|
3886
eeae91c9baba
7080389: G1: refactor marking code in evacuation pause copy closures
johnc
parents:
3869
diff
changeset
|
4670 } |
| 526 | 4671 } |
| 4672 | |
|
17688
2c2ae9e5f65d
8035326: Assume non-NULL references in G1CollectedHeap::in_cset_fast_test
tschatzl
parents:
17687
diff
changeset
|
4673 if (barrier == G1BarrierEvac) { |
|
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4834
diff
changeset
|
4674 _par_scan_state->update_rs(_from, p, _worker_id); |
| 526 | 4675 } |
|
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
17634
diff
changeset
|
4676 } |
|
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
17634
diff
changeset
|
4677 |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4678 template void G1ParCopyClosure<G1BarrierEvac, G1MarkNone>::do_oop_work(oop* p); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4679 template void G1ParCopyClosure<G1BarrierEvac, G1MarkNone>::do_oop_work(narrowOop* p); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
838
diff
changeset
|
4680 |
| 342 | 4681 class G1ParEvacuateFollowersClosure : public VoidClosure { |
| 4682 protected: | |
| 4683 G1CollectedHeap* _g1h; | |
| 4684 G1ParScanThreadState* _par_scan_state; | |
| 4685 RefToScanQueueSet* _queues; | |
| 4686 ParallelTaskTerminator* _terminator; | |
| 4687 | |
| 4688 G1ParScanThreadState* par_scan_state() { return _par_scan_state; } | |
| 4689 RefToScanQueueSet* queues() { return _queues; } | |
| 4690 ParallelTaskTerminator* terminator() { return _terminator; } | |
| 4691 | |
| 4692 public: | |
| 4693 G1ParEvacuateFollowersClosure(G1CollectedHeap* g1h, | |
| 4694 G1ParScanThreadState* par_scan_state, | |
| 4695 RefToScanQueueSet* queues, | |
| 4696 ParallelTaskTerminator* terminator) | |
| 4697 : _g1h(g1h), _par_scan_state(par_scan_state), | |
| 4698 _queues(queues), _terminator(terminator) {} | |
| 4699 | |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4700 void do_void(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4701 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4702 private: |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4703 inline bool offer_termination(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4704 }; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4705 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4706 bool G1ParEvacuateFollowersClosure::offer_termination() { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4707 G1ParScanThreadState* const pss = par_scan_state(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4708 pss->start_term_time(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4709 const bool res = terminator()->offer_termination(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4710 pss->end_term_time(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4711 return res; |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4712 } |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4713 |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4714 void G1ParEvacuateFollowersClosure::do_void() { |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4715 G1ParScanThreadState* const pss = par_scan_state(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4716 pss->trim_queue(); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4717 do { |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
4718 pss->steal_and_trim_queue(queues()); |
|
1862
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4719 } while (!offer_termination()); |
|
b14ec34b1e07
6989448: G1: refactor and simplify G1ParScanThreadState
jcoomes
parents:
1861
diff
changeset
|
4720 } |
| 342 | 4721 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4722 class G1KlassScanClosure : public KlassClosure { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4723 G1ParCopyHelper* _closure; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4724 bool _process_only_dirty; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4725 int _count; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4726 public: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4727 G1KlassScanClosure(G1ParCopyHelper* closure, bool process_only_dirty) |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4728 : _process_only_dirty(process_only_dirty), _closure(closure), _count(0) {} |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4729 void do_klass(Klass* klass) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4730 // If the klass has not been dirtied we know that there's |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4731 // no references into the young gen and we can skip it. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4732 if (!_process_only_dirty || klass->has_modified_oops()) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4733 // Clean the klass since we're going to scavenge all the metadata. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4734 klass->clear_modified_oops(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4735 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4736 // Tell the closure that this klass is the Klass to scavenge |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4737 // and is the one to dirty if oops are left pointing into the young gen. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4738 _closure->set_scanned_klass(klass); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4739 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4740 klass->oops_do(_closure); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4741 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4742 _closure->set_scanned_klass(NULL); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4743 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4744 _count++; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4745 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4746 }; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4747 |
| 342 | 4748 class G1ParTask : public AbstractGangTask { |
| 4749 protected: | |
| 4750 G1CollectedHeap* _g1h; | |
| 4751 RefToScanQueueSet *_queues; | |
| 4752 ParallelTaskTerminator _terminator; | |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4753 uint _n_workers; |
| 342 | 4754 |
| 4755 Mutex _stats_lock; | |
| 4756 Mutex* stats_lock() { return &_stats_lock; } | |
| 4757 | |
| 4758 size_t getNCards() { | |
| 4759 return (_g1h->capacity() + G1BlockOffsetSharedArray::N_bytes - 1) | |
| 4760 / G1BlockOffsetSharedArray::N_bytes; | |
| 4761 } | |
| 4762 | |
| 4763 public: | |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
4764 G1ParTask(G1CollectedHeap* g1h, RefToScanQueueSet *task_queues) |
| 342 | 4765 : AbstractGangTask("G1 collection"), |
| 4766 _g1h(g1h), | |
| 4767 _queues(task_queues), | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4768 _terminator(0, _queues), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4769 _stats_lock(Mutex::leaf, "parallel G1 stats lock", true) |
| 342 | 4770 {} |
| 4771 | |
| 4772 RefToScanQueueSet* queues() { return _queues; } | |
| 4773 | |
| 4774 RefToScanQueue *work_queue(int i) { | |
| 4775 return queues()->queue(i); | |
| 4776 } | |
| 4777 | |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4778 ParallelTaskTerminator* terminator() { return &_terminator; } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4779 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4780 virtual void set_for_termination(int active_workers) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4781 // This task calls set_n_termination() in par_non_clean_card_iterate_work() |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4782 // in the young space (_par_seq_tasks) in the G1 heap |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4783 // for SequentialSubTasksDone. |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4784 // This task also uses SubTasksDone in SharedHeap and G1CollectedHeap |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4785 // both of which need setting by set_n_termination(). |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4786 _g1h->SharedHeap::set_n_termination(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4787 _g1h->set_n_termination(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4788 terminator()->reset_for_reuse(active_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4789 _n_workers = active_workers; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4790 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
4791 |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4792 // Helps out with CLD processing. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4793 // |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4794 // During InitialMark we need to: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4795 // 1) Scavenge all CLDs for the young GC. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4796 // 2) Mark all objects directly reachable from strong CLDs. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4797 template <G1Mark do_mark_object> |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4798 class G1CLDClosure : public CLDClosure { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4799 G1ParCopyClosure<G1BarrierNone, do_mark_object>* _oop_closure; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4800 G1ParCopyClosure<G1BarrierKlass, do_mark_object> _oop_in_klass_closure; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4801 G1KlassScanClosure _klass_in_cld_closure; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4802 bool _claim; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4803 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4804 public: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4805 G1CLDClosure(G1ParCopyClosure<G1BarrierNone, do_mark_object>* oop_closure, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4806 bool only_young, bool claim) |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4807 : _oop_closure(oop_closure), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4808 _oop_in_klass_closure(oop_closure->g1(), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4809 oop_closure->pss(), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4810 oop_closure->rp()), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4811 _klass_in_cld_closure(&_oop_in_klass_closure, only_young), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4812 _claim(claim) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4813 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4814 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4815 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4816 void do_cld(ClassLoaderData* cld) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4817 cld->oops_do(_oop_closure, &_klass_in_cld_closure, _claim); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4818 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4819 }; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4820 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4821 class G1CodeBlobClosure: public CodeBlobClosure { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4822 OopClosure* _f; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4823 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4824 public: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4825 G1CodeBlobClosure(OopClosure* f) : _f(f) {} |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4826 void do_code_blob(CodeBlob* blob) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4827 nmethod* that = blob->as_nmethod_or_null(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4828 if (that != NULL) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4829 if (!that->test_set_oops_do_mark()) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4830 that->oops_do(_f); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4831 that->fix_oop_relocations(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4832 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4833 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4834 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4835 }; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4836 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4837 void work(uint worker_id) { |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
4838 if (worker_id >= _n_workers) return; // no work needed this round |
| 1611 | 4839 |
| 4840 double start_time_ms = os::elapsedTime() * 1000.0; | |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4841 _g1h->g1_policy()->phase_times()->record_gc_worker_start_time(worker_id, start_time_ms); |
| 1611 | 4842 |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4843 { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4844 ResourceMark rm; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4845 HandleMark hm; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4846 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4847 ReferenceProcessor* rp = _g1h->ref_processor_stw(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4848 |
|
17689
5d492d192cbf
8035329: Move G1ParCopyClosure::copy_to_survivor_space into G1ParScanThreadState
tschatzl
parents:
17688
diff
changeset
|
4849 G1ParScanThreadState pss(_g1h, worker_id, rp); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4850 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, rp); |
|
17759
bc22cbb8b45a
8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure
tschatzl
parents:
17758
diff
changeset
|
4851 |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4852 pss.set_evac_failure_closure(&evac_failure_cl); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4853 |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4854 bool only_young = _g1h->g1_policy()->gcs_are_young(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4855 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4856 // Non-IM young GC. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4857 G1ParCopyClosure<G1BarrierNone, G1MarkNone> scan_only_root_cl(_g1h, &pss, rp); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4858 G1CLDClosure<G1MarkNone> scan_only_cld_cl(&scan_only_root_cl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4859 only_young, // Only process dirty klasses. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4860 false); // No need to claim CLDs. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4861 // IM young GC. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4862 // Strong roots closures. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4863 G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> scan_mark_root_cl(_g1h, &pss, rp); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4864 G1CLDClosure<G1MarkFromRoot> scan_mark_cld_cl(&scan_mark_root_cl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4865 false, // Process all klasses. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4866 true); // Need to claim CLDs. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4867 // Weak roots closures. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4868 G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> scan_mark_weak_root_cl(_g1h, &pss, rp); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4869 G1CLDClosure<G1MarkPromotedFromRoot> scan_mark_weak_cld_cl(&scan_mark_weak_root_cl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4870 false, // Process all klasses. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4871 true); // Need to claim CLDs. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4872 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4873 G1CodeBlobClosure scan_only_code_cl(&scan_only_root_cl); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4874 G1CodeBlobClosure scan_mark_code_cl(&scan_mark_root_cl); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4875 // IM Weak code roots are handled later. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4876 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4877 OopClosure* strong_root_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4878 OopClosure* weak_root_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4879 CLDClosure* strong_cld_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4880 CLDClosure* weak_cld_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4881 CodeBlobClosure* strong_code_cl; |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4882 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4883 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4884 // We also need to mark copied objects. |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4885 strong_root_cl = &scan_mark_root_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4886 strong_cld_cl = &scan_mark_cld_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4887 strong_code_cl = &scan_mark_code_cl; |
|
20282
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4888 if (ClassUnloadingWithConcurrentMark) { |
|
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4889 weak_root_cl = &scan_mark_weak_root_cl; |
|
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4890 weak_cld_cl = &scan_mark_weak_cld_cl; |
|
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4891 } else { |
|
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4892 weak_root_cl = &scan_mark_root_cl; |
|
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4893 weak_cld_cl = &scan_mark_cld_cl; |
|
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4894 } |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4895 } else { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4896 strong_root_cl = &scan_only_root_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4897 weak_root_cl = &scan_only_root_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4898 strong_cld_cl = &scan_only_cld_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4899 weak_cld_cl = &scan_only_cld_cl; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4900 strong_code_cl = &scan_only_code_cl; |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4901 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4902 |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4903 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4904 G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, &pss); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
4905 |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4906 pss.start_strong_roots(); |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4907 _g1h->g1_process_roots(strong_root_cl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4908 weak_root_cl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4909 &push_heap_rs_cl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4910 strong_cld_cl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4911 weak_cld_cl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4912 strong_code_cl, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4913 worker_id); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4914 |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4915 pss.end_strong_roots(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4916 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4917 { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4918 double start = os::elapsedTime(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4919 G1ParEvacuateFollowersClosure evac(_g1h, &pss, _queues, &_terminator); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4920 evac.do_void(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4921 double elapsed_ms = (os::elapsedTime()-start)*1000.0; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4922 double term_ms = pss.term_time()*1000.0; |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
4923 _g1h->g1_policy()->phase_times()->add_obj_copy_time(worker_id, elapsed_ms-term_ms); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4924 _g1h->g1_policy()->phase_times()->record_termination(worker_id, term_ms, pss.term_attempts()); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4925 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4926 _g1h->g1_policy()->record_thread_age_table(pss.age_table()); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4927 _g1h->update_surviving_young_words(pss.surviving_young_words()+1); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4928 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4929 if (ParallelGCVerbose) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4930 MutexLocker x(stats_lock()); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4931 pss.print_termination_stats(worker_id); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4932 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4933 |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
4934 assert(pss.queue_is_empty(), "should be empty"); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4935 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4936 // Close the inner scope so that the ResourceMark and HandleMark |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4937 // destructors are executed here and are included as part of the |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
4938 // "GC Worker Time". |
| 342 | 4939 } |
| 4940 | |
| 1611 | 4941 double end_time_ms = os::elapsedTime() * 1000.0; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
4942 _g1h->g1_policy()->phase_times()->record_gc_worker_end_time(worker_id, end_time_ms); |
| 342 | 4943 } |
| 4944 }; | |
| 4945 | |
| 4946 // *** Common G1 Evacuation Stuff | |
| 4947 | |
|
1833
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
4948 // This method is run in a GC worker. |
|
8b10f48633dc
6984287: Regularize how GC parallel workers are specified.
jmasa
parents:
1755
diff
changeset
|
4949 |
| 342 | 4950 void |
| 4951 G1CollectedHeap:: | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4952 g1_process_roots(OopClosure* scan_non_heap_roots, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4953 OopClosure* scan_non_heap_weak_roots, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4954 OopsInHeapRegionClosure* scan_rs, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4955 CLDClosure* scan_strong_clds, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4956 CLDClosure* scan_weak_clds, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4957 CodeBlobClosure* scan_strong_code, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4958 uint worker_i) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4959 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4960 // First scan the shared roots. |
| 342 | 4961 double ext_roots_start = os::elapsedTime(); |
| 4962 double closure_app_time_sec = 0.0; | |
| 4963 | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4964 bool during_im = _g1h->g1_policy()->during_initial_mark_pause(); |
|
20282
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4965 bool trace_metadata = during_im && ClassUnloadingWithConcurrentMark; |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4966 |
| 342 | 4967 BufferingOopClosure buf_scan_non_heap_roots(scan_non_heap_roots); |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4968 BufferingOopClosure buf_scan_non_heap_weak_roots(scan_non_heap_weak_roots); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4969 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4970 process_roots(false, // no scoping; this is parallel code |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4971 SharedHeap::SO_None, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4972 &buf_scan_non_heap_roots, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4973 &buf_scan_non_heap_weak_roots, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4974 scan_strong_clds, |
|
20282
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4975 // Unloading Initial Marks handle the weak CLDs separately. |
|
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4976 (trace_metadata ? NULL : scan_weak_clds), |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4977 scan_strong_code); |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
4978 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4979 // Now the CM ref_processor roots. |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4980 if (!_process_strong_tasks->is_task_claimed(G1H_PS_refProcessor_oops_do)) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4981 // We need to treat the discovered reference lists of the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4982 // concurrent mark ref processor as roots and keep entries |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4983 // (which are added by the marking threads) on them live |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4984 // until they can be processed at the end of marking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
4985 ref_processor_cm()->weak_oops_do(&buf_scan_non_heap_roots); |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4986 } |
|
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4987 |
|
20282
f3aeae1f9fc5
8048269: Add flag to turn off class unloading after G1 concurrent mark
stefank
parents:
20279
diff
changeset
|
4988 if (trace_metadata) { |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4989 // Barrier to make sure all workers passed |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4990 // the strong CLD and strong nmethods phases. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4991 active_strong_roots_scope()->wait_until_all_workers_done_with_threads(n_par_threads()); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4992 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4993 // Now take the complement of the strong CLDs. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4994 ClassLoaderDataGraph::roots_cld_do(NULL, scan_weak_clds); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4995 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4996 |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
4997 // Finish up any enqueued closure apps (attributed as object copy time). |
| 342 | 4998 buf_scan_non_heap_roots.done(); |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
4999 buf_scan_non_heap_weak_roots.done(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5000 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5001 double obj_copy_time_sec = buf_scan_non_heap_roots.closure_app_seconds() |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5002 + buf_scan_non_heap_weak_roots.closure_app_seconds(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
5003 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5004 g1_policy()->phase_times()->record_obj_copy_time(worker_i, obj_copy_time_sec * 1000.0); |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
5005 |
| 342 | 5006 double ext_root_time_ms = |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5007 ((os::elapsedTime() - ext_roots_start) - obj_copy_time_sec) * 1000.0; |
|
3823
14a2fd14c0db
7068240: G1: Long "parallel other time" and "ext root scanning" when running specific benchmark
johnc
parents:
3778
diff
changeset
|
5008 |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5009 g1_policy()->phase_times()->record_ext_root_scan_time(worker_i, ext_root_time_ms); |
| 342 | 5010 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5011 // During conc marking we have to filter the per-thread SATB buffers |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5012 // to make sure we remove any oops into the CSet (which will show up |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5013 // as implicitly live). |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5014 double satb_filtering_ms = 0.0; |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5015 if (!_process_strong_tasks->is_task_claimed(G1H_PS_filter_satb_buffers)) { |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5016 if (mark_in_progress()) { |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5017 double satb_filter_start = os::elapsedTime(); |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5018 |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5019 JavaThread::satb_mark_queue_set().filter_thread_buffers(); |
|
6628
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5020 |
|
bb3f6194fedb
7178363: G1: Remove the serial code for PrintGCDetails and make it a special case of the parallel code
brutisso
parents:
6611
diff
changeset
|
5021 satb_filtering_ms = (os::elapsedTime() - satb_filter_start) * 1000.0; |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5022 } |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
5023 } |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5024 g1_policy()->phase_times()->record_satb_filtering_time(worker_i, satb_filtering_ms); |
| 342 | 5025 |
| 5026 // Now scan the complement of the collection set. | |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5027 MarkingCodeBlobClosure scavenge_cs_nmethods(scan_non_heap_weak_roots, CodeBlobToOopClosure::FixRelocations); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5028 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5029 g1_rem_set()->oops_into_collection_set_do(scan_rs, &scavenge_cs_nmethods, worker_i); |
|
20256
b0b97602393a
8033923: Use BufferingOopClosure for G1 code root scanning
stefank
parents:
20254
diff
changeset
|
5030 |
| 342 | 5031 _process_strong_tasks->all_tasks_completed(); |
| 5032 } | |
| 5033 | |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5034 class G1StringSymbolTableUnlinkTask : public AbstractGangTask { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5035 private: |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5036 BoolObjectClosure* _is_alive; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5037 int _initial_string_table_size; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5038 int _initial_symbol_table_size; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5039 |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5040 bool _process_strings; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5041 int _strings_processed; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5042 int _strings_removed; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5043 |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5044 bool _process_symbols; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5045 int _symbols_processed; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5046 int _symbols_removed; |
|
17652
0eb64cfc0b76
8033443: Test8000311 fails after latest changes to parallelize string and symbol table unlink
tschatzl
parents:
17651
diff
changeset
|
5047 |
|
0eb64cfc0b76
8033443: Test8000311 fails after latest changes to parallelize string and symbol table unlink
tschatzl
parents:
17651
diff
changeset
|
5048 bool _do_in_parallel; |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5049 public: |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5050 G1StringSymbolTableUnlinkTask(BoolObjectClosure* is_alive, bool process_strings, bool process_symbols) : |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5051 AbstractGangTask("String/Symbol Unlinking"), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5052 _is_alive(is_alive), |
|
17652
0eb64cfc0b76
8033443: Test8000311 fails after latest changes to parallelize string and symbol table unlink
tschatzl
parents:
17651
diff
changeset
|
5053 _do_in_parallel(G1CollectedHeap::use_parallel_gc_threads()), |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5054 _process_strings(process_strings), _strings_processed(0), _strings_removed(0), |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5055 _process_symbols(process_symbols), _symbols_processed(0), _symbols_removed(0) { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5056 |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5057 _initial_string_table_size = StringTable::the_table()->table_size(); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5058 _initial_symbol_table_size = SymbolTable::the_table()->table_size(); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5059 if (process_strings) { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5060 StringTable::clear_parallel_claimed_index(); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5061 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5062 if (process_symbols) { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5063 SymbolTable::clear_parallel_claimed_index(); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5064 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5065 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5066 |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5067 ~G1StringSymbolTableUnlinkTask() { |
|
17652
0eb64cfc0b76
8033443: Test8000311 fails after latest changes to parallelize string and symbol table unlink
tschatzl
parents:
17651
diff
changeset
|
5068 guarantee(!_process_strings || !_do_in_parallel || StringTable::parallel_claimed_index() >= _initial_string_table_size, |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5069 err_msg("claim value "INT32_FORMAT" after unlink less than initial string table size "INT32_FORMAT, |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5070 StringTable::parallel_claimed_index(), _initial_string_table_size)); |
|
17652
0eb64cfc0b76
8033443: Test8000311 fails after latest changes to parallelize string and symbol table unlink
tschatzl
parents:
17651
diff
changeset
|
5071 guarantee(!_process_symbols || !_do_in_parallel || SymbolTable::parallel_claimed_index() >= _initial_symbol_table_size, |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5072 err_msg("claim value "INT32_FORMAT" after unlink less than initial symbol table size "INT32_FORMAT, |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5073 SymbolTable::parallel_claimed_index(), _initial_symbol_table_size)); |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5074 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5075 if (G1TraceStringSymbolTableScrubbing) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5076 gclog_or_tty->print_cr("Cleaned string and symbol table, " |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5077 "strings: "SIZE_FORMAT" processed, "SIZE_FORMAT" removed, " |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5078 "symbols: "SIZE_FORMAT" processed, "SIZE_FORMAT" removed", |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5079 strings_processed(), strings_removed(), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5080 symbols_processed(), symbols_removed()); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5081 } |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5082 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5083 |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5084 void work(uint worker_id) { |
|
17652
0eb64cfc0b76
8033443: Test8000311 fails after latest changes to parallelize string and symbol table unlink
tschatzl
parents:
17651
diff
changeset
|
5085 if (_do_in_parallel) { |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5086 int strings_processed = 0; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5087 int strings_removed = 0; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5088 int symbols_processed = 0; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5089 int symbols_removed = 0; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5090 if (_process_strings) { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5091 StringTable::possibly_parallel_unlink(_is_alive, &strings_processed, &strings_removed); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5092 Atomic::add(strings_processed, &_strings_processed); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5093 Atomic::add(strings_removed, &_strings_removed); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5094 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5095 if (_process_symbols) { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5096 SymbolTable::possibly_parallel_unlink(&symbols_processed, &symbols_removed); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5097 Atomic::add(symbols_processed, &_symbols_processed); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5098 Atomic::add(symbols_removed, &_symbols_removed); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5099 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5100 } else { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5101 if (_process_strings) { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5102 StringTable::unlink(_is_alive, &_strings_processed, &_strings_removed); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5103 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5104 if (_process_symbols) { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5105 SymbolTable::unlink(&_symbols_processed, &_symbols_removed); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5106 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5107 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5108 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5109 |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5110 size_t strings_processed() const { return (size_t)_strings_processed; } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5111 size_t strings_removed() const { return (size_t)_strings_removed; } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5112 |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5113 size_t symbols_processed() const { return (size_t)_symbols_processed; } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5114 size_t symbols_removed() const { return (size_t)_symbols_removed; } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5115 }; |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5116 |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5117 class G1CodeCacheUnloadingTask VALUE_OBJ_CLASS_SPEC { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5118 private: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5119 static Monitor* _lock; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5120 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5121 BoolObjectClosure* const _is_alive; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5122 const bool _unloading_occurred; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5123 const uint _num_workers; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5124 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5125 // Variables used to claim nmethods. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5126 nmethod* _first_nmethod; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5127 volatile nmethod* _claimed_nmethod; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5128 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5129 // The list of nmethods that need to be processed by the second pass. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5130 volatile nmethod* _postponed_list; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5131 volatile uint _num_entered_barrier; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5132 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5133 public: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5134 G1CodeCacheUnloadingTask(uint num_workers, BoolObjectClosure* is_alive, bool unloading_occurred) : |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5135 _is_alive(is_alive), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5136 _unloading_occurred(unloading_occurred), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5137 _num_workers(num_workers), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5138 _first_nmethod(NULL), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5139 _claimed_nmethod(NULL), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5140 _postponed_list(NULL), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5141 _num_entered_barrier(0) |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5142 { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5143 nmethod::increase_unloading_clock(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5144 _first_nmethod = CodeCache::alive_nmethod(CodeCache::first()); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5145 _claimed_nmethod = (volatile nmethod*)_first_nmethod; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5146 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5147 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5148 ~G1CodeCacheUnloadingTask() { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5149 CodeCache::verify_clean_inline_caches(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5150 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5151 CodeCache::set_needs_cache_clean(false); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5152 guarantee(CodeCache::scavenge_root_nmethods() == NULL, "Must be"); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5153 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5154 CodeCache::verify_icholder_relocations(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5155 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5156 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5157 private: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5158 void add_to_postponed_list(nmethod* nm) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5159 nmethod* old; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5160 do { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5161 old = (nmethod*)_postponed_list; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5162 nm->set_unloading_next(old); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5163 } while ((nmethod*)Atomic::cmpxchg_ptr(nm, &_postponed_list, old) != old); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5164 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5165 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5166 void clean_nmethod(nmethod* nm) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5167 bool postponed = nm->do_unloading_parallel(_is_alive, _unloading_occurred); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5168 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5169 if (postponed) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5170 // This nmethod referred to an nmethod that has not been cleaned/unloaded yet. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5171 add_to_postponed_list(nm); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5172 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5173 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5174 // Mark that this thread has been cleaned/unloaded. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5175 // After this call, it will be safe to ask if this nmethod was unloaded or not. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5176 nm->set_unloading_clock(nmethod::global_unloading_clock()); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5177 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5178 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5179 void clean_nmethod_postponed(nmethod* nm) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5180 nm->do_unloading_parallel_postponed(_is_alive, _unloading_occurred); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5181 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5182 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5183 static const int MaxClaimNmethods = 16; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5184 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5185 void claim_nmethods(nmethod** claimed_nmethods, int *num_claimed_nmethods) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5186 nmethod* first; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5187 nmethod* last; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5188 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5189 do { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5190 *num_claimed_nmethods = 0; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5191 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5192 first = last = (nmethod*)_claimed_nmethod; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5193 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5194 if (first != NULL) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5195 for (int i = 0; i < MaxClaimNmethods; i++) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5196 last = CodeCache::alive_nmethod(CodeCache::next(last)); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5197 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5198 if (last == NULL) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5199 break; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5200 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5201 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5202 claimed_nmethods[i] = last; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5203 (*num_claimed_nmethods)++; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5204 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5205 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5206 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5207 } while ((nmethod*)Atomic::cmpxchg_ptr(last, &_claimed_nmethod, first) != first); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5208 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5209 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5210 nmethod* claim_postponed_nmethod() { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5211 nmethod* claim; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5212 nmethod* next; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5213 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5214 do { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5215 claim = (nmethod*)_postponed_list; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5216 if (claim == NULL) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5217 return NULL; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5218 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5219 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5220 next = claim->unloading_next(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5221 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5222 } while ((nmethod*)Atomic::cmpxchg_ptr(next, &_postponed_list, claim) != claim); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5223 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5224 return claim; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5225 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5226 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5227 public: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5228 // Mark that we're done with the first pass of nmethod cleaning. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5229 void barrier_mark(uint worker_id) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5230 MonitorLockerEx ml(_lock, Mutex::_no_safepoint_check_flag); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5231 _num_entered_barrier++; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5232 if (_num_entered_barrier == _num_workers) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5233 ml.notify_all(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5234 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5235 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5236 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5237 // See if we have to wait for the other workers to |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5238 // finish their first-pass nmethod cleaning work. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5239 void barrier_wait(uint worker_id) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5240 if (_num_entered_barrier < _num_workers) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5241 MonitorLockerEx ml(_lock, Mutex::_no_safepoint_check_flag); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5242 while (_num_entered_barrier < _num_workers) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5243 ml.wait(Mutex::_no_safepoint_check_flag, 0, false); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5244 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5245 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5246 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5247 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5248 // Cleaning and unloading of nmethods. Some work has to be postponed |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5249 // to the second pass, when we know which nmethods survive. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5250 void work_first_pass(uint worker_id) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5251 // The first nmethods is claimed by the first worker. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5252 if (worker_id == 0 && _first_nmethod != NULL) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5253 clean_nmethod(_first_nmethod); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5254 _first_nmethod = NULL; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5255 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5256 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5257 int num_claimed_nmethods; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5258 nmethod* claimed_nmethods[MaxClaimNmethods]; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5259 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5260 while (true) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5261 claim_nmethods(claimed_nmethods, &num_claimed_nmethods); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5262 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5263 if (num_claimed_nmethods == 0) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5264 break; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5265 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5266 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5267 for (int i = 0; i < num_claimed_nmethods; i++) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5268 clean_nmethod(claimed_nmethods[i]); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5269 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5270 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5271 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5272 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5273 void work_second_pass(uint worker_id) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5274 nmethod* nm; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5275 // Take care of postponed nmethods. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5276 while ((nm = claim_postponed_nmethod()) != NULL) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5277 clean_nmethod_postponed(nm); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5278 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5279 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5280 }; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5281 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5282 Monitor* G1CodeCacheUnloadingTask::_lock = new Monitor(Mutex::leaf, "Code Cache Unload lock"); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5283 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5284 class G1KlassCleaningTask : public StackObj { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5285 BoolObjectClosure* _is_alive; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5286 volatile jint _clean_klass_tree_claimed; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5287 ClassLoaderDataGraphKlassIteratorAtomic _klass_iterator; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5288 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5289 public: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5290 G1KlassCleaningTask(BoolObjectClosure* is_alive) : |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5291 _is_alive(is_alive), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5292 _clean_klass_tree_claimed(0), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5293 _klass_iterator() { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5294 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5295 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5296 private: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5297 bool claim_clean_klass_tree_task() { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5298 if (_clean_klass_tree_claimed) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5299 return false; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5300 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5301 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5302 return Atomic::cmpxchg(1, (jint*)&_clean_klass_tree_claimed, 0) == 0; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5303 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5304 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5305 InstanceKlass* claim_next_klass() { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5306 Klass* klass; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5307 do { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5308 klass =_klass_iterator.next_klass(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5309 } while (klass != NULL && !klass->oop_is_instance()); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5310 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5311 return (InstanceKlass*)klass; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5312 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5313 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5314 public: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5315 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5316 void clean_klass(InstanceKlass* ik) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5317 ik->clean_implementors_list(_is_alive); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5318 ik->clean_method_data(_is_alive); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5319 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5320 // G1 specific cleanup work that has |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5321 // been moved here to be done in parallel. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5322 ik->clean_dependent_nmethods(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5323 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5324 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5325 void work() { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5326 ResourceMark rm; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5327 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5328 // One worker will clean the subklass/sibling klass tree. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5329 if (claim_clean_klass_tree_task()) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5330 Klass::clean_subklass_tree(_is_alive); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5331 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5332 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5333 // All workers will help cleaning the classes, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5334 InstanceKlass* klass; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5335 while ((klass = claim_next_klass()) != NULL) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5336 clean_klass(klass); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5337 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5338 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5339 }; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5340 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5341 // To minimize the remark pause times, the tasks below are done in parallel. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5342 class G1ParallelCleaningTask : public AbstractGangTask { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5343 private: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5344 G1StringSymbolTableUnlinkTask _string_symbol_task; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5345 G1CodeCacheUnloadingTask _code_cache_task; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5346 G1KlassCleaningTask _klass_cleaning_task; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5347 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5348 public: |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5349 // The constructor is run in the VMThread. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5350 G1ParallelCleaningTask(BoolObjectClosure* is_alive, bool process_strings, bool process_symbols, uint num_workers, bool unloading_occurred) : |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5351 AbstractGangTask("Parallel Cleaning"), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5352 _string_symbol_task(is_alive, process_strings, process_symbols), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5353 _code_cache_task(num_workers, is_alive, unloading_occurred), |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5354 _klass_cleaning_task(is_alive) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5355 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5356 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5357 // The parallel work done by all worker threads. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5358 void work(uint worker_id) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5359 // Do first pass of code cache cleaning. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5360 _code_cache_task.work_first_pass(worker_id); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5361 |
| 20279 | 5362 // Let the threads mark that the first pass is done. |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5363 _code_cache_task.barrier_mark(worker_id); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5364 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5365 // Clean the Strings and Symbols. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5366 _string_symbol_task.work(worker_id); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5367 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5368 // Wait for all workers to finish the first code cache cleaning pass. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5369 _code_cache_task.barrier_wait(worker_id); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5370 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5371 // Do the second code cache cleaning work, which realize on |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5372 // the liveness information gathered during the first pass. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5373 _code_cache_task.work_second_pass(worker_id); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5374 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5375 // Clean all klasses that were not unloaded. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5376 _klass_cleaning_task.work(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5377 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5378 }; |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5379 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5380 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5381 void G1CollectedHeap::parallel_cleaning(BoolObjectClosure* is_alive, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5382 bool process_strings, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5383 bool process_symbols, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5384 bool class_unloading_occurred) { |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5385 uint n_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5386 workers()->active_workers() : 1); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5387 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5388 G1ParallelCleaningTask g1_unlink_task(is_alive, process_strings, process_symbols, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5389 n_workers, class_unloading_occurred); |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5390 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5391 set_par_threads(n_workers); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5392 workers()->run_task(&g1_unlink_task); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5393 set_par_threads(0); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5394 } else { |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5395 g1_unlink_task.work(0); |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5396 } |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5397 } |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5398 |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5399 void G1CollectedHeap::unlink_string_and_symbol_table(BoolObjectClosure* is_alive, |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5400 bool process_strings, bool process_symbols) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5401 { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5402 uint n_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5403 _g1h->workers()->active_workers() : 1); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5404 G1StringSymbolTableUnlinkTask g1_unlink_task(is_alive, process_strings, process_symbols); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5405 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5406 set_par_threads(n_workers); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5407 workers()->run_task(&g1_unlink_task); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5408 set_par_threads(0); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5409 } else { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5410 g1_unlink_task.work(0); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
5411 } |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5412 } |
| 17764 | 5413 |
| 5414 if (G1StringDedup::is_enabled()) { | |
| 5415 G1StringDedup::unlink(is_alive); | |
| 5416 } | |
|
17634
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5417 } |
|
5a32d2a3cc1e
8027476: Improve performance of Stringtable unlink
tschatzl
parents:
13400
diff
changeset
|
5418 |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5419 class G1RedirtyLoggedCardsTask : public AbstractGangTask { |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5420 private: |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5421 DirtyCardQueueSet* _queue; |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5422 public: |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5423 G1RedirtyLoggedCardsTask(DirtyCardQueueSet* queue) : AbstractGangTask("Redirty Cards"), _queue(queue) { } |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5424 |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5425 virtual void work(uint worker_id) { |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5426 double start_time = os::elapsedTime(); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5427 |
|
20217
6b52700a896b
8040002: Clean up code and code duplication in re-diryting cards for verification
tschatzl
parents:
20216
diff
changeset
|
5428 RedirtyLoggedCardTableEntryClosure cl; |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5429 if (G1CollectedHeap::heap()->use_parallel_gc_threads()) { |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5430 _queue->par_apply_closure_to_all_completed_buffers(&cl); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5431 } else { |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5432 _queue->apply_closure_to_all_completed_buffers(&cl); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5433 } |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5434 |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5435 G1GCPhaseTimes* timer = G1CollectedHeap::heap()->g1_policy()->phase_times(); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5436 timer->record_redirty_logged_cards_time_ms(worker_id, (os::elapsedTime() - start_time) * 1000.0); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5437 timer->record_redirty_logged_cards_processed_cards(worker_id, cl.num_processed()); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5438 } |
|
17756
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5439 }; |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5440 |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5441 void G1CollectedHeap::redirty_logged_cards() { |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5442 guarantee(G1DeferredRSUpdate, "Must only be called when using deferred RS updates."); |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5443 double redirty_logged_cards_start = os::elapsedTime(); |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5444 |
|
20216
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5445 uint n_workers = (G1CollectedHeap::use_parallel_gc_threads() ? |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5446 _g1h->workers()->active_workers() : 1); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5447 |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5448 G1RedirtyLoggedCardsTask redirty_task(&dirty_card_queue_set()); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5449 dirty_card_queue_set().reset_for_par_iteration(); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5450 if (use_parallel_gc_threads()) { |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5451 set_par_threads(n_workers); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5452 workers()->run_task(&redirty_task); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5453 set_par_threads(0); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5454 } else { |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5455 redirty_task.work(0); |
|
570cb6369f17
8019342: G1: High "Other" time most likely due to card redirtying
tschatzl
parents:
20215
diff
changeset
|
5456 } |
|
17756
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5457 |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5458 DirtyCardQueueSet& dcq = JavaThread::dirty_card_queue_set(); |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5459 dcq.merge_bufferlists(&dirty_card_queue_set()); |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5460 assert(dirty_card_queue_set().completed_buffers_num() == 0, "All should be consumed"); |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5461 |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5462 g1_policy()->phase_times()->record_redirty_logged_cards_time_ms((os::elapsedTime() - redirty_logged_cards_start) * 1000.0); |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5463 } |
|
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
5464 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5465 // Weak Reference Processing support |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5466 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5467 // An always "is_alive" closure that is used to preserve referents. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5468 // If the object is non-null then it's alive. Used in the preservation |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5469 // of referent objects that are pointed to by reference objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5470 // discovered by the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5471 class G1AlwaysAliveClosure: public BoolObjectClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5472 G1CollectedHeap* _g1; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5473 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5474 G1AlwaysAliveClosure(G1CollectedHeap* g1) : _g1(g1) {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5475 bool do_object_b(oop p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5476 if (p != NULL) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5477 return true; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5478 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5479 return false; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5480 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5481 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5482 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5483 bool G1STWIsAliveClosure::do_object_b(oop p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5484 // An object is reachable if it is outside the collection set, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5485 // or is inside and copied. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5486 return !_g1->obj_in_cs(p) || p->is_forwarded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5487 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5488 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5489 // Non Copying Keep Alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5490 class G1KeepAliveClosure: public OopClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5491 G1CollectedHeap* _g1; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5492 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5493 G1KeepAliveClosure(G1CollectedHeap* g1) : _g1(g1) {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5494 void do_oop(narrowOop* p) { guarantee(false, "Not needed"); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5495 void do_oop( oop* p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5496 oop obj = *p; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5497 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5498 if (_g1->obj_in_cs(obj)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5499 assert( obj->is_forwarded(), "invariant" ); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5500 *p = obj->forwardee(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5501 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5502 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5503 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5504 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5505 // Copying Keep Alive closure - can be called from both |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5506 // serial and parallel code as long as different worker |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5507 // threads utilize different G1ParScanThreadState instances |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5508 // and different queues. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5509 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5510 class G1CopyingKeepAliveClosure: public OopClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5511 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5512 OopClosure* _copy_non_heap_obj_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5513 G1ParScanThreadState* _par_scan_state; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5514 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5515 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5516 G1CopyingKeepAliveClosure(G1CollectedHeap* g1h, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5517 OopClosure* non_heap_obj_cl, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5518 G1ParScanThreadState* pss): |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5519 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5520 _copy_non_heap_obj_cl(non_heap_obj_cl), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5521 _par_scan_state(pss) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5522 {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5523 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5524 virtual void do_oop(narrowOop* p) { do_oop_work(p); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5525 virtual void do_oop( oop* p) { do_oop_work(p); } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5526 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5527 template <class T> void do_oop_work(T* p) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5528 oop obj = oopDesc::load_decode_heap_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5529 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5530 if (_g1h->obj_in_cs(obj)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5531 // If the referent object has been forwarded (either copied |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5532 // to a new location or to itself in the event of an |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5533 // evacuation failure) then we need to update the reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5534 // field and, if both reference and referent are in the G1 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5535 // heap, update the RSet for the referent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5536 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5537 // If the referent has not been forwarded then we have to keep |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5538 // it alive by policy. Therefore we have copy the referent. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5539 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5540 // If the reference field is in the G1 heap then we can push |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5541 // on the PSS queue. When the queue is drained (after each |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5542 // phase of reference processing) the object and it's followers |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5543 // will be copied, the reference field set to point to the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5544 // new location, and the RSet updated. Otherwise we need to |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
5545 // use the the non-heap or metadata closures directly to copy |
| 10405 | 5546 // the referent object and update the pointer, while avoiding |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5547 // updating the RSet. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5548 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5549 if (_g1h->is_in_g1_reserved(p)) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5550 _par_scan_state->push_on_queue(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5551 } else { |
|
17935
7384f6a12fc1
8038212: Method::is_valid_method() check has performance regression impact for stackwalking
coleenp
parents:
17866
diff
changeset
|
5552 assert(!Metaspace::contains((const void*)p), |
|
20270
b7d24d2bc8be
8047323: Remove unused _copy_metadata_obj_cl in G1CopyingKeepAliveClosure
stefank
parents:
20257
diff
changeset
|
5553 err_msg("Unexpectedly found a pointer from metadata: " |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
5554 PTR_FORMAT, p)); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5555 _copy_non_heap_obj_cl->do_oop(p); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5556 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5557 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5558 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5559 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5560 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5561 // Serial drain queue closure. Called as the 'complete_gc' |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5562 // closure for each discovered list in some of the |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5563 // reference processing phases. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5564 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5565 class G1STWDrainQueueClosure: public VoidClosure { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5566 protected: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5567 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5568 G1ParScanThreadState* _par_scan_state; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5569 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5570 G1ParScanThreadState* par_scan_state() { return _par_scan_state; } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5571 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5572 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5573 G1STWDrainQueueClosure(G1CollectedHeap* g1h, G1ParScanThreadState* pss) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5574 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5575 _par_scan_state(pss) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5576 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5577 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5578 void do_void() { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5579 G1ParScanThreadState* const pss = par_scan_state(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5580 pss->trim_queue(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5581 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5582 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5583 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5584 // Parallel Reference Processing closures |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5585 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5586 // Implementation of AbstractRefProcTaskExecutor for parallel reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5587 // processing during G1 evacuation pauses. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5588 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5589 class G1STWRefProcTaskExecutor: public AbstractRefProcTaskExecutor { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5590 private: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5591 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5592 RefToScanQueueSet* _queues; |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5593 FlexibleWorkGang* _workers; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5594 int _active_workers; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5595 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5596 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5597 G1STWRefProcTaskExecutor(G1CollectedHeap* g1h, |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5598 FlexibleWorkGang* workers, |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5599 RefToScanQueueSet *task_queues, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5600 int n_workers) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5601 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5602 _queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5603 _workers(workers), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5604 _active_workers(n_workers) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5605 { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5606 assert(n_workers > 0, "shouldn't call this otherwise"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5607 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5608 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5609 // Executes the given task using concurrent marking worker threads. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5610 virtual void execute(ProcessTask& task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5611 virtual void execute(EnqueueTask& task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5612 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5613 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5614 // Gang task for possibly parallel reference processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5615 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5616 class G1STWRefProcTaskProxy: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5617 typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5618 ProcessTask& _proc_task; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5619 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5620 RefToScanQueueSet *_task_queues; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5621 ParallelTaskTerminator* _terminator; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5622 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5623 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5624 G1STWRefProcTaskProxy(ProcessTask& proc_task, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5625 G1CollectedHeap* g1h, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5626 RefToScanQueueSet *task_queues, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5627 ParallelTaskTerminator* terminator) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5628 AbstractGangTask("Process reference objects in parallel"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5629 _proc_task(proc_task), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5630 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5631 _task_queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5632 _terminator(terminator) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5633 {} |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5634 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5635 virtual void work(uint worker_id) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5636 // The reference processing task executed by a single worker. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5637 ResourceMark rm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5638 HandleMark hm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5639 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5640 G1STWIsAliveClosure is_alive(_g1h); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5641 |
|
17689
5d492d192cbf
8035329: Move G1ParCopyClosure::copy_to_survivor_space into G1ParScanThreadState
tschatzl
parents:
17688
diff
changeset
|
5642 G1ParScanThreadState pss(_g1h, worker_id, NULL); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5643 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); |
|
17759
bc22cbb8b45a
8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure
tschatzl
parents:
17758
diff
changeset
|
5644 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5645 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5646 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5647 G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5648 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5649 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5650 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5651 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5652 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5653 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5654 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5655 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5656 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5657 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5658 // Keep alive closure. |
|
20270
b7d24d2bc8be
8047323: Remove unused _copy_metadata_obj_cl in G1CopyingKeepAliveClosure
stefank
parents:
20257
diff
changeset
|
5659 G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, &pss); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5660 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5661 // Complete GC closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5662 G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _task_queues, _terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5663 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5664 // Call the reference processing task's work routine. |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5665 _proc_task.work(worker_id, is_alive, keep_alive, drain_queue); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5666 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5667 // Note we cannot assert that the refs array is empty here as not all |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5668 // of the processing tasks (specifically phase2 - pp2_work) execute |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5669 // the complete_gc closure (which ordinarily would drain the queue) so |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5670 // the queue may not be empty. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5671 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5672 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5673 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5674 // Driver routine for parallel reference processing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5675 // Creates an instance of the ref processing gang |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5676 // task and has the worker threads execute it. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5677 void G1STWRefProcTaskExecutor::execute(ProcessTask& proc_task) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5678 assert(_workers != NULL, "Need parallel worker threads."); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5679 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5680 ParallelTaskTerminator terminator(_active_workers, _queues); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5681 G1STWRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _queues, &terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5682 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5683 _g1h->set_par_threads(_active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5684 _workers->run_task(&proc_task_proxy); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5685 _g1h->set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5686 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5687 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5688 // Gang task for parallel reference enqueueing. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5689 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5690 class G1STWRefEnqueueTaskProxy: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5691 typedef AbstractRefProcTaskExecutor::EnqueueTask EnqueueTask; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5692 EnqueueTask& _enq_task; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5693 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5694 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5695 G1STWRefEnqueueTaskProxy(EnqueueTask& enq_task) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5696 AbstractGangTask("Enqueue reference objects in parallel"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5697 _enq_task(enq_task) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5698 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5699 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5700 virtual void work(uint worker_id) { |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5701 _enq_task.work(worker_id); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5702 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5703 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5704 |
| 10405 | 5705 // Driver routine for parallel reference enqueueing. |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5706 // Creates an instance of the ref enqueueing gang |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5707 // task and has the worker threads execute it. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5708 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5709 void G1STWRefProcTaskExecutor::execute(EnqueueTask& enq_task) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5710 assert(_workers != NULL, "Need parallel worker threads."); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5711 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5712 G1STWRefEnqueueTaskProxy enq_task_proxy(enq_task); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5713 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5714 _g1h->set_par_threads(_active_workers); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5715 _workers->run_task(&enq_task_proxy); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5716 _g1h->set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5717 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5718 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5719 // End of weak reference support closures |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5720 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5721 // Abstract task used to preserve (i.e. copy) any referent objects |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5722 // that are in the collection set and are pointed to by reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5723 // objects discovered by the CM ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5724 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5725 class G1ParPreserveCMReferentsTask: public AbstractGangTask { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5726 protected: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5727 G1CollectedHeap* _g1h; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5728 RefToScanQueueSet *_queues; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5729 ParallelTaskTerminator _terminator; |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5730 uint _n_workers; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5731 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5732 public: |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5733 G1ParPreserveCMReferentsTask(G1CollectedHeap* g1h,int workers, RefToScanQueueSet *task_queues) : |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5734 AbstractGangTask("ParPreserveCMReferents"), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5735 _g1h(g1h), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5736 _queues(task_queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5737 _terminator(workers, _queues), |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5738 _n_workers(workers) |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5739 { } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5740 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5741 void work(uint worker_id) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5742 ResourceMark rm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5743 HandleMark hm; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5744 |
|
17689
5d492d192cbf
8035329: Move G1ParCopyClosure::copy_to_survivor_space into G1ParScanThreadState
tschatzl
parents:
17688
diff
changeset
|
5745 G1ParScanThreadState pss(_g1h, worker_id, NULL); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5746 G1ParScanHeapEvacFailureClosure evac_failure_cl(_g1h, &pss, NULL); |
|
17759
bc22cbb8b45a
8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure
tschatzl
parents:
17758
diff
changeset
|
5747 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5748 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5749 |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
5750 assert(pss.queue_is_empty(), "both queue and overflow should be empty"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5751 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5752 G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5753 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5754 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5755 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5756 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5757 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5758 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5759 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5760 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5761 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5762 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5763 // Is alive closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5764 G1AlwaysAliveClosure always_alive(_g1h); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5765 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5766 // Copying keep alive closure. Applied to referent objects that need |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5767 // to be copied. |
|
20270
b7d24d2bc8be
8047323: Remove unused _copy_metadata_obj_cl in G1CopyingKeepAliveClosure
stefank
parents:
20257
diff
changeset
|
5768 G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, &pss); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5769 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5770 ReferenceProcessor* rp = _g1h->ref_processor_cm(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5771 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5772 uint limit = ReferenceProcessor::number_of_subclasses_of_ref() * rp->max_num_q(); |
|
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5773 uint stride = MIN2(MAX2(_n_workers, 1U), limit); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5774 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5775 // limit is set using max_num_q() - which was set using ParallelGCThreads. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5776 // So this must be true - but assert just in case someone decides to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5777 // change the worker ids. |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5778 assert(0 <= worker_id && worker_id < limit, "sanity"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5779 assert(!rp->discovery_is_atomic(), "check this code"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5780 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5781 // Select discovered lists [i, i+stride, i+2*stride,...,limit) |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5782 for (uint idx = worker_id; idx < limit; idx += stride) { |
|
4014
bf2d2b8b1726
7095243: Disambiguate ReferenceProcessor::_discoveredSoftRefs
johnc
parents:
4013
diff
changeset
|
5783 DiscoveredList& ref_list = rp->discovered_refs()[idx]; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5784 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5785 DiscoveredListIterator iter(ref_list, &keep_alive, &always_alive); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5786 while (iter.has_next()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5787 // Since discovery is not atomic for the CM ref processor, we |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5788 // can see some null referent objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5789 iter.load_ptrs(DEBUG_ONLY(true)); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5790 oop ref = iter.obj(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5791 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5792 // This will filter nulls. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5793 if (iter.is_referent_alive()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5794 iter.make_referent_alive(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5795 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5796 iter.move_to_next(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5797 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5798 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5799 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5800 // Drain the queue - which may cause stealing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5801 G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _queues, &_terminator); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5802 drain_queue.do_void(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5803 // Allocation buffers were retired at the end of G1ParEvacuateFollowersClosure |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
5804 assert(pss.queue_is_empty(), "should be"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5805 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5806 }; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5807 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5808 // Weak Reference processing during an evacuation pause (part 1). |
| 6819 | 5809 void G1CollectedHeap::process_discovered_references(uint no_of_gc_workers) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5810 double ref_proc_start = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5811 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5812 ReferenceProcessor* rp = _ref_processor_stw; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5813 assert(rp->discovery_enabled(), "should have been enabled"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5814 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5815 // Any reference objects, in the collection set, that were 'discovered' |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5816 // by the CM ref processor should have already been copied (either by |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5817 // applying the external root copy closure to the discovered lists, or |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5818 // by following an RSet entry). |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5819 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5820 // But some of the referents, that are in the collection set, that these |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5821 // reference objects point to may not have been copied: the STW ref |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5822 // processor would have seen that the reference object had already |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5823 // been 'discovered' and would have skipped discovering the reference, |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5824 // but would not have treated the reference object as a regular oop. |
| 10405 | 5825 // As a result the copy closure would not have been applied to the |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5826 // referent object. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5827 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5828 // We need to explicitly copy these referent objects - the references |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5829 // will be processed at the end of remarking. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5830 // |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5831 // We also need to do this copying before we process the reference |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5832 // objects discovered by the STW ref processor in case one of these |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5833 // referents points to another object which is also referenced by an |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5834 // object discovered by the STW ref processor. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5835 |
| 4711 | 5836 assert(!G1CollectedHeap::use_parallel_gc_threads() || |
| 6819 | 5837 no_of_gc_workers == workers()->active_workers(), |
| 5838 "Need to reset active GC workers"); | |
| 5839 | |
| 5840 set_par_threads(no_of_gc_workers); | |
| 5841 G1ParPreserveCMReferentsTask keep_cm_referents(this, | |
| 5842 no_of_gc_workers, | |
| 5843 _task_queues); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5844 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5845 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5846 workers()->run_task(&keep_cm_referents); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5847 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5848 keep_cm_referents.work(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5849 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5850 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5851 set_par_threads(0); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5852 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5853 // Closure to test whether a referent is alive. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5854 G1STWIsAliveClosure is_alive(this); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5855 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5856 // Even when parallel reference processing is enabled, the processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5857 // of JNI refs is serial and performed serially by the current thread |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5858 // rather than by a worker. The following PSS will be used for processing |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5859 // JNI refs. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5860 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5861 // Use only a single queue for this PSS. |
|
17689
5d492d192cbf
8035329: Move G1ParCopyClosure::copy_to_survivor_space into G1ParScanThreadState
tschatzl
parents:
17688
diff
changeset
|
5862 G1ParScanThreadState pss(this, 0, NULL); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5863 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5864 // We do not embed a reference processor in the copying/scanning |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5865 // closures while we're actually processing the discovered |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5866 // reference objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5867 G1ParScanHeapEvacFailureClosure evac_failure_cl(this, &pss, NULL); |
|
17759
bc22cbb8b45a
8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure
tschatzl
parents:
17758
diff
changeset
|
5868 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5869 pss.set_evac_failure_closure(&evac_failure_cl); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5870 |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
5871 assert(pss.queue_is_empty(), "pre-condition"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5872 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5873 G1ParScanExtRootClosure only_copy_non_heap_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5874 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5875 G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(this, &pss, NULL); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5876 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5877 OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5878 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5879 if (_g1h->g1_policy()->during_initial_mark_pause()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5880 // We also need to mark copied objects. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5881 copy_non_heap_cl = ©_mark_non_heap_cl; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5882 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5883 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5884 // Keep alive closure. |
|
20270
b7d24d2bc8be
8047323: Remove unused _copy_metadata_obj_cl in G1CopyingKeepAliveClosure
stefank
parents:
20257
diff
changeset
|
5885 G1CopyingKeepAliveClosure keep_alive(this, copy_non_heap_cl, &pss); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5886 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5887 // Serial Complete GC closure |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5888 G1STWDrainQueueClosure drain_queue(this, &pss); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5889 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5890 // Setup the soft refs policy... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5891 rp->setup_policy(false); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5892 |
| 10405 | 5893 ReferenceProcessorStats stats; |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5894 if (!rp->processing_is_mt()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5895 // Serial reference processing... |
| 10405 | 5896 stats = rp->process_discovered_references(&is_alive, |
| 5897 &keep_alive, | |
| 5898 &drain_queue, | |
| 5899 NULL, | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17992
diff
changeset
|
5900 _gc_timer_stw, |
|
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17992
diff
changeset
|
5901 _gc_tracer_stw->gc_id()); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5902 } else { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5903 // Parallel reference processing |
| 6819 | 5904 assert(rp->num_q() == no_of_gc_workers, "sanity"); |
| 5905 assert(no_of_gc_workers <= rp->max_num_q(), "sanity"); | |
| 5906 | |
| 5907 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, no_of_gc_workers); | |
| 10405 | 5908 stats = rp->process_discovered_references(&is_alive, |
| 5909 &keep_alive, | |
| 5910 &drain_queue, | |
| 5911 &par_task_executor, | |
|
20190
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17992
diff
changeset
|
5912 _gc_timer_stw, |
|
0982ec23da03
8043607: Add a GC id as a log decoration similar to PrintGCTimeStamps
brutisso
parents:
17992
diff
changeset
|
5913 _gc_tracer_stw->gc_id()); |
| 10405 | 5914 } |
| 5915 | |
| 5916 _gc_tracer_stw->report_gc_reference_stats(stats); | |
|
20215
983092f35ff7
8028710: G1 does not retire allocation buffers after reference processing work
tschatzl
parents:
20212
diff
changeset
|
5917 |
|
983092f35ff7
8028710: G1 does not retire allocation buffers after reference processing work
tschatzl
parents:
20212
diff
changeset
|
5918 // We have completed copying any necessary live referent objects. |
|
20224
a2328cbebb23
8035401: Fix visibility of G1ParScanThreadState members
tschatzl
parents:
20223
diff
changeset
|
5919 assert(pss.queue_is_empty(), "both queue and overflow should be empty"); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5920 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5921 double ref_proc_time = os::elapsedTime() - ref_proc_start; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5922 g1_policy()->phase_times()->record_ref_proc_time(ref_proc_time * 1000.0); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5923 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5924 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5925 // Weak Reference processing during an evacuation pause (part 2). |
| 6819 | 5926 void G1CollectedHeap::enqueue_discovered_references(uint no_of_gc_workers) { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5927 double ref_enq_start = os::elapsedTime(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5928 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5929 ReferenceProcessor* rp = _ref_processor_stw; |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5930 assert(!rp->discovery_enabled(), "should have been disabled as part of processing"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5931 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5932 // Now enqueue any remaining on the discovered lists on to |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5933 // the pending list. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5934 if (!rp->processing_is_mt()) { |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5935 // Serial reference processing... |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5936 rp->enqueue_discovered_references(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5937 } else { |
| 10405 | 5938 // Parallel reference enqueueing |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5939 |
| 6819 | 5940 assert(no_of_gc_workers == workers()->active_workers(), |
| 5941 "Need to reset active workers"); | |
| 5942 assert(rp->num_q() == no_of_gc_workers, "sanity"); | |
| 5943 assert(no_of_gc_workers <= rp->max_num_q(), "sanity"); | |
| 5944 | |
| 5945 G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, no_of_gc_workers); | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5946 rp->enqueue_discovered_references(&par_task_executor); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5947 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5948 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5949 rp->verify_no_references_recorded(); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5950 assert(!rp->discovery_enabled(), "should have been disabled"); |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5951 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5952 // FIXME |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5953 // CM's reference processing also cleans up the string and symbol tables. |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5954 // Should we do that here also? We could, but it is a serial operation |
| 10405 | 5955 // and could significantly increase the pause time. |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5956 |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5957 double ref_enq_time = os::elapsedTime() - ref_enq_start; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
5958 g1_policy()->phase_times()->record_ref_enq_time(ref_enq_time * 1000.0); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5959 } |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
5960 |
| 10405 | 5961 void G1CollectedHeap::evacuate_collection_set(EvacuationInfo& evacuation_info) { |
|
4781
bacb651cf5bf
7113006: G1: excessive ergo output when an evac failure happens
tonyp
parents:
4728
diff
changeset
|
5962 _expand_heap_after_alloc_failure = true; |
| 10405 | 5963 _evacuation_failed = false; |
| 342 | 5964 |
|
6629
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5965 // Should G1EvacuationFailureALot be in effect for this GC? |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5966 NOT_PRODUCT(set_evacuation_failure_alot_for_current_gc();) |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
5967 |
| 342 | 5968 g1_rem_set()->prepare_for_oops_into_collection_set_do(); |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
5969 |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
5970 // Disable the hot card cache. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
5971 G1HotCardCache* hot_card_cache = _cg1r->hot_card_cache(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
5972 hot_card_cache->reset_hot_cache_claimed_index(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
5973 hot_card_cache->set_use_cache(false); |
| 889 | 5974 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
5975 uint n_workers; |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5976 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5977 n_workers = |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5978 AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5979 workers()->active_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5980 Threads::number_of_non_daemon_threads()); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5981 assert(UseDynamicNumberOfGCThreads || |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5982 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5983 "If not dynamic should be using all the workers"); |
| 4711 | 5984 workers()->set_active_workers(n_workers); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5985 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5986 } else { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5987 assert(n_par_threads() == 0, |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5988 "Should be the original non-parallel value"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5989 n_workers = 1; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5990 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5991 |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
5992 G1ParTask g1_par_task(this, _task_queues); |
| 342 | 5993 |
| 5994 init_for_evac_failure(NULL); | |
| 5995 | |
| 5996 rem_set()->prepare_for_younger_refs_iterate(true); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5997 |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
5998 assert(dirty_card_queue_set().completed_buffers_num() == 0, "Should be empty"); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
5999 double start_par_time_sec = os::elapsedTime(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6000 double end_par_time_sec; |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6001 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6002 { |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
890
diff
changeset
|
6003 StrongRootsScope srs(this); |
|
20278
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
6004 // InitialMark needs claim bits to keep track of the marked-through CLDs. |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
6005 if (g1_policy()->during_initial_mark_pause()) { |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
6006 ClassLoaderDataGraph::clear_claimed_marks(); |
|
2c6ef90f030a
8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents:
20274
diff
changeset
|
6007 } |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6008 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6009 if (G1CollectedHeap::use_parallel_gc_threads()) { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6010 // The individual threads will set their evac-failure closures. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6011 if (ParallelGCVerbose) G1ParScanThreadState::print_termination_stats_hdr(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6012 // These tasks use ShareHeap::_process_strong_tasks |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6013 assert(UseDynamicNumberOfGCThreads || |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6014 workers()->active_workers() == workers()->total_workers(), |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6015 "If not dynamic should be using all the workers"); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6016 workers()->run_task(&g1_par_task); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6017 } else { |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6018 g1_par_task.set_for_termination(n_workers); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6019 g1_par_task.work(0); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6020 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6021 end_par_time_sec = os::elapsedTime(); |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6022 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6023 // Closing the inner scope will execute the destructor |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6024 // for the StrongRootsScope object. We record the current |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6025 // elapsed time before closing the scope so that time |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6026 // taken for the SRS destructor is NOT included in the |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6027 // reported parallel time. |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6028 } |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6029 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6030 double par_time_ms = (end_par_time_sec - start_par_time_sec) * 1000.0; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
6031 g1_policy()->phase_times()->record_par_time(par_time_ms); |
|
5986
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6032 |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6033 double code_root_fixup_time_ms = |
|
500023bd0818
7143511: G1: Another instance of high GC Worker Other time (50ms)
johnc
parents:
5963
diff
changeset
|
6034 (os::elapsedTime() - end_par_time_sec) * 1000.0; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
6035 g1_policy()->phase_times()->record_code_root_fixup_time(code_root_fixup_time_ms); |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6036 |
| 342 | 6037 set_par_threads(0); |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
6038 |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6039 // Process any discovered reference objects - we have |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6040 // to do this _before_ we retire the GC alloc regions |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6041 // as we may have to copy some 'reachable' referent |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6042 // objects (and their reachable sub-graphs) that were |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6043 // not copied during the pause. |
| 6819 | 6044 process_discovered_references(n_workers); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6045 |
|
1974
fd1d227ef1b9
6983204: G1: Nightly test nsk/regression/b4958615 failing with +ExplicitGCInvokesConcurrent
johnc
parents:
1973
diff
changeset
|
6046 // Weak root processing. |
| 342 | 6047 { |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6048 G1STWIsAliveClosure is_alive(this); |
| 342 | 6049 G1KeepAliveClosure keep_alive(this); |
| 6050 JNIHandles::weak_oops_do(&is_alive, &keep_alive); | |
| 17764 | 6051 if (G1StringDedup::is_enabled()) { |
| 6052 G1StringDedup::unlink_or_oops_do(&is_alive, &keep_alive); | |
| 6053 } | |
| 342 | 6054 } |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6055 |
| 10405 | 6056 release_gc_alloc_regions(n_workers, evacuation_info); |
| 342 | 6057 g1_rem_set()->cleanup_after_oops_into_collection_set_do(); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
6058 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6059 // Reset and re-enable the hot card cache. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6060 // Note the counts for the cards in the regions in the |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6061 // collection set are reset when the collection set is freed. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6062 hot_card_cache->reset_hot_cache(); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6063 hot_card_cache->set_use_cache(true); |
| 342 | 6064 |
| 12080 | 6065 // Migrate the strong code roots attached to each region in |
| 6066 // the collection set. Ideally we would like to do this | |
| 6067 // after we have finished the scanning/evacuation of the | |
| 6068 // strong code roots for a particular heap region. | |
| 6069 migrate_strong_code_roots(); | |
| 6070 | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
17749
diff
changeset
|
6071 purge_code_root_memory(); |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
17749
diff
changeset
|
6072 |
| 12080 | 6073 if (g1_policy()->during_initial_mark_pause()) { |
| 6074 // Reset the claim values set during marking the strong code roots | |
| 6075 reset_heap_region_claim_values(); | |
| 6076 } | |
| 6077 | |
| 342 | 6078 finalize_for_evac_failure(); |
| 6079 | |
| 6080 if (evacuation_failed()) { | |
| 6081 remove_self_forwarding_pointers(); | |
|
6629
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
6082 |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
6083 // Reset the G1EvacuationFailureALot counters and flags |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
6084 // Note: the values are reset only when an actual |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
6085 // evacuation failure occurs. |
|
c9814fadeb38
7041879: G1: introduce stress testing parameter to cause frequent evacuation failures
johnc
parents:
6628
diff
changeset
|
6086 NOT_PRODUCT(reset_evacuation_should_fail();) |
| 342 | 6087 } |
| 6088 | |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6089 // Enqueue any remaining references remaining on the STW |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6090 // reference processor's discovered lists. We need to do |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6091 // this after the card table is cleaned (and verified) as |
| 10405 | 6092 // the act of enqueueing entries on to the pending list |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6093 // will log these updates (and dirty their associated |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6094 // cards). We need these updates logged to update any |
|
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6095 // RSets. |
| 6819 | 6096 enqueue_discovered_references(n_workers); |
|
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
6097 |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
6098 if (G1DeferredRSUpdate) { |
|
17756
a07bea31ef35
8035398: Add card redirty time in "Other" time in G1
tschatzl
parents:
17755
diff
changeset
|
6099 redirty_logged_cards(); |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
595
diff
changeset
|
6100 } |
| 342 | 6101 COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); |
| 6102 } | |
| 6103 | |
| 2152 | 6104 void G1CollectedHeap::free_region(HeapRegion* hr, |
| 6105 FreeRegionList* free_list, | |
|
17755
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
6106 bool par, |
|
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
6107 bool locked) { |
| 2152 | 6108 assert(!hr->isHumongous(), "this is only for non-humongous regions"); |
| 6109 assert(!hr->is_empty(), "the region should not be empty"); | |
| 6110 assert(free_list != NULL, "pre-condition"); | |
| 6111 | |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6112 if (G1VerifyBitmaps) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6113 MemRegion mr(hr->bottom(), hr->end()); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6114 concurrent_mark()->clearRangePrevBitmap(mr); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6115 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6116 |
|
10246
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6117 // Clear the card counts for this region. |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6118 // Note: we only need to do this if the region is not young |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6119 // (since we don't refine cards in young regions). |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6120 if (!hr->is_young()) { |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6121 _cg1r->hot_card_cache()->reset_card_counts(hr); |
|
194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
johnc
parents:
10242
diff
changeset
|
6122 } |
|
17755
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
6123 hr->hr_clear(par, true /* clear_space */, locked /* locked */); |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
6124 free_list->add_ordered(hr); |
| 2152 | 6125 } |
| 6126 | |
| 6127 void G1CollectedHeap::free_humongous_region(HeapRegion* hr, | |
| 6128 FreeRegionList* free_list, | |
| 6129 bool par) { | |
| 6130 assert(hr->startsHumongous(), "this is only for starts humongous regions"); | |
| 6131 assert(free_list != NULL, "pre-condition"); | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6132 |
| 2152 | 6133 size_t hr_capacity = hr->capacity(); |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
6134 // We need to read this before we make the region non-humongous, |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
6135 // otherwise the information will be gone. |
|
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
6136 uint last_index = hr->last_hc_index(); |
| 2152 | 6137 hr->set_notHumongous(); |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6138 free_region(hr, free_list, par); |
| 2152 | 6139 |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
6140 uint i = hr->hrs_index() + 1; |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
6141 while (i < last_index) { |
| 3766 | 6142 HeapRegion* curr_hr = region_at(i); |
|
6254
a2f7274eb6ef
7114678: G1: various small fixes, code cleanup, and refactoring
tonyp
parents:
6220
diff
changeset
|
6143 assert(curr_hr->continuesHumongous(), "invariant"); |
| 2152 | 6144 curr_hr->set_notHumongous(); |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6145 free_region(curr_hr, free_list, par); |
| 2152 | 6146 i += 1; |
| 6147 } | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6148 } |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6149 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6150 void G1CollectedHeap::remove_from_old_sets(const HeapRegionSetCount& old_regions_removed, |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6151 const HeapRegionSetCount& humongous_regions_removed) { |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6152 if (old_regions_removed.length() > 0 || humongous_regions_removed.length() > 0) { |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6153 MutexLockerEx x(OldSets_lock, Mutex::_no_safepoint_check_flag); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6154 _old_set.bulk_remove(old_regions_removed); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6155 _humongous_set.bulk_remove(humongous_regions_removed); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6156 } |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6157 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6158 } |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6159 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6160 void G1CollectedHeap::prepend_to_freelist(FreeRegionList* list) { |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6161 assert(list != NULL, "list can't be null"); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6162 if (!list->is_empty()) { |
| 2152 | 6163 MutexLockerEx x(FreeList_lock, Mutex::_no_safepoint_check_flag); |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
6164 _free_list.add_ordered(list); |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6165 } |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6166 } |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6167 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6168 void G1CollectedHeap::decrement_summary_bytes(size_t bytes) { |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6169 assert(_summary_bytes_used >= bytes, |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6170 err_msg("invariant: _summary_bytes_used: "SIZE_FORMAT" should be >= bytes: "SIZE_FORMAT, |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6171 _summary_bytes_used, bytes)); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6172 _summary_bytes_used -= bytes; |
| 342 | 6173 } |
| 6174 | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6175 class G1ParCleanupCTTask : public AbstractGangTask { |
| 12343 | 6176 G1SATBCardTableModRefBS* _ct_bs; |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6177 G1CollectedHeap* _g1h; |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6178 HeapRegion* volatile _su_head; |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6179 public: |
| 12343 | 6180 G1ParCleanupCTTask(G1SATBCardTableModRefBS* ct_bs, |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6181 G1CollectedHeap* g1h) : |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6182 AbstractGangTask("G1 Par Cleanup CT Task"), |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6183 _ct_bs(ct_bs), _g1h(g1h) { } |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6184 |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
6185 void work(uint worker_id) { |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6186 HeapRegion* r; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6187 while (r = _g1h->pop_dirty_cards_region()) { |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6188 clear_cards(r); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6189 } |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6190 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6191 |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6192 void clear_cards(HeapRegion* r) { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6193 // Cards of the survivors should have already been dirtied. |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6194 if (!r->is_survivor()) { |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6195 _ct_bs->clear(MemRegion(r->bottom(), r->end())); |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6196 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6197 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6198 }; |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6199 |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6200 #ifndef PRODUCT |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6201 class G1VerifyCardTableCleanup: public HeapRegionClosure { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6202 G1CollectedHeap* _g1h; |
| 12343 | 6203 G1SATBCardTableModRefBS* _ct_bs; |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6204 public: |
| 12343 | 6205 G1VerifyCardTableCleanup(G1CollectedHeap* g1h, G1SATBCardTableModRefBS* ct_bs) |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6206 : _g1h(g1h), _ct_bs(ct_bs) { } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6207 virtual bool doHeapRegion(HeapRegion* r) { |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6208 if (r->is_survivor()) { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6209 _g1h->verify_dirty_region(r); |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6210 } else { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6211 _g1h->verify_not_dirty_region(r); |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6212 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6213 return false; |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6214 } |
|
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6215 }; |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6216 |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6217 void G1CollectedHeap::verify_not_dirty_region(HeapRegion* hr) { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6218 // All of the region should be clean. |
| 12343 | 6219 G1SATBCardTableModRefBS* ct_bs = g1_barrier_set(); |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6220 MemRegion mr(hr->bottom(), hr->end()); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6221 ct_bs->verify_not_dirty_region(mr); |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6222 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6223 |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6224 void G1CollectedHeap::verify_dirty_region(HeapRegion* hr) { |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6225 // We cannot guarantee that [bottom(),end()] is dirty. Threads |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6226 // dirty allocated blocks as they allocate them. The thread that |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6227 // retires each region and replaces it with a new one will do a |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6228 // maximal allocation to fill in [pre_dummy_top(),end()] but will |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6229 // not dirty that area (one less thing to have to do while holding |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6230 // a lock). So we can only verify that [bottom(),pre_dummy_top()] |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6231 // is dirty. |
| 12343 | 6232 G1SATBCardTableModRefBS* ct_bs = g1_barrier_set(); |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6233 MemRegion mr(hr->bottom(), hr->pre_dummy_top()); |
|
12835
69944b868a32
8014555: G1: Memory ordering problem with Conc refinement and card marking
mgerdin
parents:
12345
diff
changeset
|
6234 if (hr->is_young()) { |
|
69944b868a32
8014555: G1: Memory ordering problem with Conc refinement and card marking
mgerdin
parents:
12345
diff
changeset
|
6235 ct_bs->verify_g1_young_region(mr); |
|
69944b868a32
8014555: G1: Memory ordering problem with Conc refinement and card marking
mgerdin
parents:
12345
diff
changeset
|
6236 } else { |
|
69944b868a32
8014555: G1: Memory ordering problem with Conc refinement and card marking
mgerdin
parents:
12345
diff
changeset
|
6237 ct_bs->verify_dirty_region(mr); |
|
69944b868a32
8014555: G1: Memory ordering problem with Conc refinement and card marking
mgerdin
parents:
12345
diff
changeset
|
6238 } |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6239 } |
|
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6240 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6241 void G1CollectedHeap::verify_dirty_young_list(HeapRegion* head) { |
| 12343 | 6242 G1SATBCardTableModRefBS* ct_bs = g1_barrier_set(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6243 for (HeapRegion* hr = head; hr != NULL; hr = hr->get_next_young_region()) { |
|
3317
063382f9b575
7035144: G1: nightly failure: Non-dirty cards in region that should be dirty (failures still exist...)
tonyp
parents:
3293
diff
changeset
|
6244 verify_dirty_region(hr); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6245 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6246 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6247 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6248 void G1CollectedHeap::verify_dirty_young_regions() { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6249 verify_dirty_young_list(_young_list->first_region()); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6250 } |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6251 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6252 bool G1CollectedHeap::verify_no_bits_over_tams(const char* bitmap_name, CMBitMapRO* bitmap, |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6253 HeapWord* tams, HeapWord* end) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6254 guarantee(tams <= end, |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6255 err_msg("tams: "PTR_FORMAT" end: "PTR_FORMAT, tams, end)); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6256 HeapWord* result = bitmap->getNextMarkedWordAddress(tams, end); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6257 if (result < end) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6258 gclog_or_tty->cr(); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6259 gclog_or_tty->print_cr("## wrong marked address on %s bitmap: "PTR_FORMAT, |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6260 bitmap_name, result); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6261 gclog_or_tty->print_cr("## %s tams: "PTR_FORMAT" end: "PTR_FORMAT, |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6262 bitmap_name, tams, end); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6263 return false; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6264 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6265 return true; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6266 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6267 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6268 bool G1CollectedHeap::verify_bitmaps(const char* caller, HeapRegion* hr) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6269 CMBitMapRO* prev_bitmap = concurrent_mark()->prevMarkBitMap(); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6270 CMBitMapRO* next_bitmap = (CMBitMapRO*) concurrent_mark()->nextMarkBitMap(); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6271 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6272 HeapWord* bottom = hr->bottom(); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6273 HeapWord* ptams = hr->prev_top_at_mark_start(); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6274 HeapWord* ntams = hr->next_top_at_mark_start(); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6275 HeapWord* end = hr->end(); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6276 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6277 bool res_p = verify_no_bits_over_tams("prev", prev_bitmap, ptams, end); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6278 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6279 bool res_n = true; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6280 // We reset mark_in_progress() before we reset _cmThread->in_progress() and in this window |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6281 // we do the clearing of the next bitmap concurrently. Thus, we can not verify the bitmap |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6282 // if we happen to be in that state. |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6283 if (mark_in_progress() || !_cmThread->in_progress()) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6284 res_n = verify_no_bits_over_tams("next", next_bitmap, ntams, end); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6285 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6286 if (!res_p || !res_n) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6287 gclog_or_tty->print_cr("#### Bitmap verification failed for "HR_FORMAT, |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6288 HR_FORMAT_PARAMS(hr)); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6289 gclog_or_tty->print_cr("#### Caller: %s", caller); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6290 return false; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6291 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6292 return true; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6293 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6294 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6295 void G1CollectedHeap::check_bitmaps(const char* caller, HeapRegion* hr) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6296 if (!G1VerifyBitmaps) return; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6297 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6298 guarantee(verify_bitmaps(caller, hr), "bitmap verification"); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6299 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6300 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6301 class G1VerifyBitmapClosure : public HeapRegionClosure { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6302 private: |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6303 const char* _caller; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6304 G1CollectedHeap* _g1h; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6305 bool _failures; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6306 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6307 public: |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6308 G1VerifyBitmapClosure(const char* caller, G1CollectedHeap* g1h) : |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6309 _caller(caller), _g1h(g1h), _failures(false) { } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6310 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6311 bool failures() { return _failures; } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6312 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6313 virtual bool doHeapRegion(HeapRegion* hr) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6314 if (hr->continuesHumongous()) return false; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6315 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6316 bool result = _g1h->verify_bitmaps(_caller, hr); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6317 if (!result) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6318 _failures = true; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6319 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6320 return false; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6321 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6322 }; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6323 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6324 void G1CollectedHeap::check_bitmaps(const char* caller) { |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6325 if (!G1VerifyBitmaps) return; |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6326 |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6327 G1VerifyBitmapClosure cl(caller, this); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6328 heap_region_iterate(&cl); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6329 guarantee(!cl.failures(), "bitmap verification"); |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6330 } |
|
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6331 #endif // PRODUCT |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6332 |
| 342 | 6333 void G1CollectedHeap::cleanUpCardTable() { |
| 12343 | 6334 G1SATBCardTableModRefBS* ct_bs = g1_barrier_set(); |
| 342 | 6335 double start = os::elapsedTime(); |
| 6336 | |
| 4023 | 6337 { |
| 6338 // Iterate over the dirty cards region list. | |
| 6339 G1ParCleanupCTTask cleanup_task(ct_bs, this); | |
| 6340 | |
| 4711 | 6341 if (G1CollectedHeap::use_parallel_gc_threads()) { |
| 6342 set_par_threads(); | |
| 4023 | 6343 workers()->run_task(&cleanup_task); |
| 6344 set_par_threads(0); | |
| 6345 } else { | |
| 6346 while (_dirty_cards_region_list) { | |
| 6347 HeapRegion* r = _dirty_cards_region_list; | |
| 6348 cleanup_task.clear_cards(r); | |
| 6349 _dirty_cards_region_list = r->get_next_dirty_cards_region(); | |
| 6350 if (_dirty_cards_region_list == r) { | |
| 6351 // The last region. | |
| 6352 _dirty_cards_region_list = NULL; | |
| 6353 } | |
| 6354 r->set_next_dirty_cards_region(NULL); | |
|
796
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6355 } |
|
29e7d79232b9
6819065: G1: eliminate high serial card table clearing time
apetrusenko
parents:
794
diff
changeset
|
6356 } |
| 4023 | 6357 #ifndef PRODUCT |
| 6358 if (G1VerifyCTCleanup || VerifyAfterGC) { | |
| 6359 G1VerifyCardTableCleanup cleanup_verifier(this, ct_bs); | |
| 6360 heap_region_iterate(&cleanup_verifier); | |
| 6361 } | |
| 6362 #endif | |
|
940
8624da129f0b
6841313: G1: dirty cards of survivor regions in parallel
apetrusenko
parents:
936
diff
changeset
|
6363 } |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6364 |
| 342 | 6365 double elapsed = os::elapsedTime() - start; |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
6366 g1_policy()->phase_times()->record_clear_ct_time(elapsed * 1000.0); |
| 342 | 6367 } |
| 6368 | |
| 10405 | 6369 void G1CollectedHeap::free_collection_set(HeapRegion* cs_head, EvacuationInfo& evacuation_info) { |
| 2152 | 6370 size_t pre_used = 0; |
| 6371 FreeRegionList local_free_list("Local List for CSet Freeing"); | |
| 6372 | |
| 342 | 6373 double young_time_ms = 0.0; |
| 6374 double non_young_time_ms = 0.0; | |
| 6375 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6376 // Since the collection set is a superset of the the young list, |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6377 // all we need to do to clear the young list is clear its |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6378 // head and length, and unlink any young regions in the code below |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6379 _young_list->clear(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6380 |
| 342 | 6381 G1CollectorPolicy* policy = g1_policy(); |
| 6382 | |
| 6383 double start_sec = os::elapsedTime(); | |
| 6384 bool non_young = true; | |
| 6385 | |
| 6386 HeapRegion* cur = cs_head; | |
| 6387 int age_bound = -1; | |
| 6388 size_t rs_lengths = 0; | |
| 6389 | |
| 6390 while (cur != NULL) { | |
| 2361 | 6391 assert(!is_on_master_free_list(cur), "sanity"); |
| 342 | 6392 if (non_young) { |
| 6393 if (cur->is_young()) { | |
| 6394 double end_sec = os::elapsedTime(); | |
| 6395 double elapsed_ms = (end_sec - start_sec) * 1000.0; | |
| 6396 non_young_time_ms += elapsed_ms; | |
| 6397 | |
| 6398 start_sec = os::elapsedTime(); | |
| 6399 non_young = false; | |
| 6400 } | |
| 6401 } else { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6402 if (!cur->is_young()) { |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6403 double end_sec = os::elapsedTime(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6404 double elapsed_ms = (end_sec - start_sec) * 1000.0; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6405 young_time_ms += elapsed_ms; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6406 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6407 start_sec = os::elapsedTime(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6408 non_young = true; |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6409 } |
| 342 | 6410 } |
| 6411 | |
|
17755
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
6412 rs_lengths += cur->rem_set()->occupied_locked(); |
| 342 | 6413 |
| 6414 HeapRegion* next = cur->next_in_collection_set(); | |
| 6415 assert(cur->in_collection_set(), "bad CS"); | |
| 6416 cur->set_next_in_collection_set(NULL); | |
| 6417 cur->set_in_collection_set(false); | |
| 6418 | |
| 6419 if (cur->is_young()) { | |
| 6420 int index = cur->young_index_in_cset(); | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
6421 assert(index != -1, "invariant"); |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
6422 assert((uint) index < policy->young_cset_region_length(), "invariant"); |
| 342 | 6423 size_t words_survived = _surviving_young_words[index]; |
| 6424 cur->record_surv_words_in_group(words_survived); | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6425 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6426 // At this point the we have 'popped' cur from the collection set |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6427 // (linked via next_in_collection_set()) but it is still in the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6428 // young list (linked via next_young_region()). Clear the |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6429 // _next_young_region field. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6430 cur->set_next_young_region(NULL); |
| 342 | 6431 } else { |
| 6432 int index = cur->young_index_in_cset(); | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
6433 assert(index == -1, "invariant"); |
| 342 | 6434 } |
| 6435 | |
| 6436 assert( (cur->is_young() && cur->young_index_in_cset() > -1) || | |
| 6437 (!cur->is_young() && cur->young_index_in_cset() == -1), | |
| 6438 "invariant" ); | |
| 6439 | |
| 6440 if (!cur->evacuation_failed()) { | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6441 MemRegion used_mr = cur->used_region(); |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6442 |
| 342 | 6443 // And the region is empty. |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6444 assert(!used_mr.is_empty(), "Should not have empty regions in a CS."); |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6445 pre_used += cur->used(); |
|
17755
96b1c2e06e25
8027295: Free CSet takes ~50% of young pause time
tschatzl
parents:
17753
diff
changeset
|
6446 free_region(cur, &local_free_list, false /* par */, true /* locked */); |
| 342 | 6447 } else { |
| 6448 cur->uninstall_surv_rate_group(); | |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
6449 if (cur->is_young()) { |
| 342 | 6450 cur->set_young_index_in_cset(-1); |
|
4090
a88de71c4e3a
7097002: G1: remove a lot of unused / redundant code from the G1CollectorPolicy class
tonyp
parents:
4073
diff
changeset
|
6451 } |
| 342 | 6452 cur->set_not_young(); |
| 6453 cur->set_evacuation_failed(false); | |
| 4072 | 6454 // The region is now considered to be old. |
| 6455 _old_set.add(cur); | |
| 10405 | 6456 evacuation_info.increment_collectionset_used_after(cur->used()); |
| 342 | 6457 } |
| 6458 cur = next; | |
| 6459 } | |
| 6460 | |
| 10405 | 6461 evacuation_info.set_regions_freed(local_free_list.length()); |
| 342 | 6462 policy->record_max_rs_lengths(rs_lengths); |
| 6463 policy->cset_regions_freed(); | |
| 6464 | |
| 6465 double end_sec = os::elapsedTime(); | |
| 6466 double elapsed_ms = (end_sec - start_sec) * 1000.0; | |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6467 |
|
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6468 if (non_young) { |
| 342 | 6469 non_young_time_ms += elapsed_ms; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6470 } else { |
| 342 | 6471 young_time_ms += elapsed_ms; |
|
4097
dc467e8b2c5e
7112743: G1: Reduce overhead of marking closure during evacuation pauses
johnc
parents:
4095
diff
changeset
|
6472 } |
| 342 | 6473 |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6474 prepend_to_freelist(&local_free_list); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6475 decrement_summary_bytes(pre_used); |
|
6219
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
6476 policy->phase_times()->record_young_free_cset_time_ms(young_time_ms); |
|
922993931b3d
7178361: G1: Make sure that PrintGC and PrintGCDetails use the same timing for the GC pause
brutisso
parents:
6188
diff
changeset
|
6477 policy->phase_times()->record_non_young_free_cset_time_ms(non_young_time_ms); |
| 342 | 6478 } |
| 6479 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6480 // This routine is similar to the above but does not record |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6481 // any policy statistics or update free lists; we are abandoning |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6482 // the current incremental collection set in preparation of a |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6483 // full collection. After the full GC we will start to build up |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6484 // the incremental collection set again. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6485 // This is only called when we're doing a full collection |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6486 // and is immediately followed by the tearing down of the young list. |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6487 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6488 void G1CollectedHeap::abandon_collection_set(HeapRegion* cs_head) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6489 HeapRegion* cur = cs_head; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6490 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6491 while (cur != NULL) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6492 HeapRegion* next = cur->next_in_collection_set(); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6493 assert(cur->in_collection_set(), "bad CS"); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6494 cur->set_next_in_collection_set(NULL); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6495 cur->set_in_collection_set(false); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6496 cur->set_young_index_in_cset(-1); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6497 cur = next; |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6498 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6499 } |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6500 |
| 2152 | 6501 void G1CollectedHeap::set_free_regions_coming() { |
| 6502 if (G1ConcRegionFreeingVerbose) { | |
| 6503 gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " | |
| 6504 "setting free regions coming"); | |
| 6505 } | |
| 6506 | |
| 6507 assert(!free_regions_coming(), "pre-condition"); | |
| 6508 _free_regions_coming = true; | |
| 342 | 6509 } |
| 6510 | |
| 2152 | 6511 void G1CollectedHeap::reset_free_regions_coming() { |
|
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
6512 assert(free_regions_coming(), "pre-condition"); |
|
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
6513 |
| 2152 | 6514 { |
| 6515 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); | |
| 6516 _free_regions_coming = false; | |
| 6517 SecondaryFreeList_lock->notify_all(); | |
| 6518 } | |
| 6519 | |
| 6520 if (G1ConcRegionFreeingVerbose) { | |
| 6521 gclog_or_tty->print_cr("G1ConcRegionFreeing [cm thread] : " | |
| 6522 "reset free regions coming"); | |
| 342 | 6523 } |
| 6524 } | |
| 6525 | |
| 2152 | 6526 void G1CollectedHeap::wait_while_free_regions_coming() { |
| 6527 // Most of the time we won't have to wait, so let's do a quick test | |
| 6528 // first before we take the lock. | |
| 6529 if (!free_regions_coming()) { | |
| 6530 return; | |
| 6531 } | |
| 6532 | |
| 6533 if (G1ConcRegionFreeingVerbose) { | |
| 6534 gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " | |
| 6535 "waiting for free regions"); | |
| 342 | 6536 } |
| 6537 | |
| 6538 { | |
| 2152 | 6539 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); |
| 6540 while (free_regions_coming()) { | |
| 6541 SecondaryFreeList_lock->wait(Mutex::_no_safepoint_check_flag); | |
| 342 | 6542 } |
| 2152 | 6543 } |
| 6544 | |
| 6545 if (G1ConcRegionFreeingVerbose) { | |
| 6546 gclog_or_tty->print_cr("G1ConcRegionFreeing [other] : " | |
| 6547 "done waiting for free regions"); | |
| 6548 } | |
| 342 | 6549 } |
| 6550 | |
| 6551 void G1CollectedHeap::set_region_short_lived_locked(HeapRegion* hr) { | |
| 6552 assert(heap_lock_held_for_gc(), | |
| 6553 "the heap lock should already be held by or for this thread"); | |
| 6554 _young_list->push_region(hr); | |
| 6555 } | |
| 6556 | |
| 6557 class NoYoungRegionsClosure: public HeapRegionClosure { | |
| 6558 private: | |
| 6559 bool _success; | |
| 6560 public: | |
| 6561 NoYoungRegionsClosure() : _success(true) { } | |
| 6562 bool doHeapRegion(HeapRegion* r) { | |
| 6563 if (r->is_young()) { | |
| 6564 gclog_or_tty->print_cr("Region ["PTR_FORMAT", "PTR_FORMAT") tagged as young", | |
| 6565 r->bottom(), r->end()); | |
| 6566 _success = false; | |
| 6567 } | |
| 6568 return false; | |
| 6569 } | |
| 6570 bool success() { return _success; } | |
| 6571 }; | |
| 6572 | |
|
1394
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6573 bool G1CollectedHeap::check_young_list_empty(bool check_heap, bool check_sample) { |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6574 bool ret = _young_list->check_list_empty(check_sample); |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6575 |
|
1316cec51b4d
6819061: G1: eliminate serial Other times that are proportional to the collection set length
johnc
parents:
1391
diff
changeset
|
6576 if (check_heap) { |
| 342 | 6577 NoYoungRegionsClosure closure; |
| 6578 heap_region_iterate(&closure); | |
| 6579 ret = ret && closure.success(); | |
| 6580 } | |
| 6581 | |
| 6582 return ret; | |
| 6583 } | |
| 6584 | |
| 4072 | 6585 class TearDownRegionSetsClosure : public HeapRegionClosure { |
| 6586 private: | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6587 HeapRegionSet *_old_set; |
| 2152 | 6588 |
| 342 | 6589 public: |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6590 TearDownRegionSetsClosure(HeapRegionSet* old_set) : _old_set(old_set) { } |
| 2152 | 6591 |
| 342 | 6592 bool doHeapRegion(HeapRegion* r) { |
| 4072 | 6593 if (r->is_empty()) { |
| 6594 // We ignore empty regions, we'll empty the free list afterwards | |
| 6595 } else if (r->is_young()) { | |
| 6596 // We ignore young regions, we'll empty the young list afterwards | |
| 6597 } else if (r->isHumongous()) { | |
| 6598 // We ignore humongous regions, we're not tearing down the | |
| 6599 // humongous region set | |
| 342 | 6600 } else { |
| 4072 | 6601 // The rest should be old |
| 6602 _old_set->remove(r); | |
| 342 | 6603 } |
| 6604 return false; | |
| 6605 } | |
| 6606 | |
| 4072 | 6607 ~TearDownRegionSetsClosure() { |
| 6608 assert(_old_set->is_empty(), "post-condition"); | |
| 2152 | 6609 } |
| 342 | 6610 }; |
| 6611 | |
| 4072 | 6612 void G1CollectedHeap::tear_down_region_sets(bool free_list_only) { |
| 6613 assert_at_safepoint(true /* should_be_vm_thread */); | |
| 6614 | |
| 6615 if (!free_list_only) { | |
| 6616 TearDownRegionSetsClosure cl(&_old_set); | |
| 6617 heap_region_iterate(&cl); | |
| 6618 | |
| 17764 | 6619 // Note that emptying the _young_list is postponed and instead done as |
| 6620 // the first step when rebuilding the regions sets again. The reason for | |
| 6621 // this is that during a full GC string deduplication needs to know if | |
| 6622 // a collected region was young or old when the full GC was initiated. | |
| 4072 | 6623 } |
| 6624 _free_list.remove_all(); | |
| 6625 } | |
| 6626 | |
| 6627 class RebuildRegionSetsClosure : public HeapRegionClosure { | |
| 6628 private: | |
| 6629 bool _free_list_only; | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6630 HeapRegionSet* _old_set; |
| 4072 | 6631 FreeRegionList* _free_list; |
| 6632 size_t _total_used; | |
| 6633 | |
| 6634 public: | |
| 6635 RebuildRegionSetsClosure(bool free_list_only, | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6636 HeapRegionSet* old_set, FreeRegionList* free_list) : |
| 4072 | 6637 _free_list_only(free_list_only), |
| 6638 _old_set(old_set), _free_list(free_list), _total_used(0) { | |
| 6639 assert(_free_list->is_empty(), "pre-condition"); | |
| 6640 if (!free_list_only) { | |
| 6641 assert(_old_set->is_empty(), "pre-condition"); | |
| 6642 } | |
| 6643 } | |
| 6644 | |
| 6645 bool doHeapRegion(HeapRegion* r) { | |
| 6646 if (r->continuesHumongous()) { | |
| 6647 return false; | |
| 6648 } | |
| 6649 | |
| 6650 if (r->is_empty()) { | |
| 6651 // Add free regions to the free list | |
| 6652 _free_list->add_as_tail(r); | |
| 6653 } else if (!_free_list_only) { | |
| 6654 assert(!r->is_young(), "we should not come across young regions"); | |
| 6655 | |
| 6656 if (r->isHumongous()) { | |
| 6657 // We ignore humongous regions, we left the humongous set unchanged | |
| 6658 } else { | |
| 6659 // The rest should be old, add them to the old set | |
| 6660 _old_set->add(r); | |
| 6661 } | |
| 6662 _total_used += r->used(); | |
| 6663 } | |
| 6664 | |
| 6665 return false; | |
| 6666 } | |
| 6667 | |
| 6668 size_t total_used() { | |
| 6669 return _total_used; | |
| 6670 } | |
| 6671 }; | |
| 6672 | |
| 6673 void G1CollectedHeap::rebuild_region_sets(bool free_list_only) { | |
| 6674 assert_at_safepoint(true /* should_be_vm_thread */); | |
| 6675 | |
| 17764 | 6676 if (!free_list_only) { |
| 6677 _young_list->empty_list(); | |
| 6678 } | |
| 6679 | |
| 4072 | 6680 RebuildRegionSetsClosure cl(free_list_only, &_old_set, &_free_list); |
| 6681 heap_region_iterate(&cl); | |
| 6682 | |
| 6683 if (!free_list_only) { | |
| 6684 _summary_bytes_used = cl.total_used(); | |
| 6685 } | |
| 6686 assert(_summary_bytes_used == recalculate_used(), | |
| 6687 err_msg("inconsistent _summary_bytes_used, " | |
| 6688 "value: "SIZE_FORMAT" recalculated: "SIZE_FORMAT, | |
| 6689 _summary_bytes_used, recalculate_used())); | |
| 342 | 6690 } |
| 6691 | |
| 6692 void G1CollectedHeap::set_refine_cte_cl_concurrency(bool concurrent) { | |
| 6693 _refine_cte_cl->set_concurrent(concurrent); | |
| 6694 } | |
| 6695 | |
| 6696 bool G1CollectedHeap::is_in_closed_subset(const void* p) const { | |
| 6697 HeapRegion* hr = heap_region_containing(p); | |
| 6698 if (hr == NULL) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6629
diff
changeset
|
6699 return false; |
| 342 | 6700 } else { |
| 6701 return hr->is_in(p); | |
| 6702 } | |
| 6703 } | |
| 2152 | 6704 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6705 // Methods for the mutator alloc region |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6706 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6707 HeapRegion* G1CollectedHeap::new_mutator_alloc_region(size_t word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6708 bool force) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6709 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6710 assert(!force || g1_policy()->can_expand_young_list(), |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6711 "if force is true we should be able to expand the young list"); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6712 bool young_list_full = g1_policy()->is_young_list_full(); |
|
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6713 if (force || !young_list_full) { |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6714 HeapRegion* new_alloc_region = new_region(word_size, |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
6715 false /* is_old */, |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6716 false /* do_expand */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6717 if (new_alloc_region != NULL) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6718 set_region_short_lived_locked(new_alloc_region); |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6719 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Eden, young_list_full); |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6720 check_bitmaps("Mutator Region Allocation", new_alloc_region); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6721 return new_alloc_region; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6722 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6723 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6724 return NULL; |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6725 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6726 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6727 void G1CollectedHeap::retire_mutator_alloc_region(HeapRegion* alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6728 size_t allocated_bytes) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6729 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6730 assert(alloc_region->is_young(), "all mutator alloc regions should be young"); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6731 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6732 g1_policy()->add_region_to_incremental_cset_lhs(alloc_region); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6733 _summary_bytes_used += allocated_bytes; |
|
3778
5f6f2615433a
7049999: G1: Make the G1PrintHeapRegions output consistent and complete
tonyp
parents:
3777
diff
changeset
|
6734 _hr_printer.retire(alloc_region); |
|
3980
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6735 // We update the eden sizes here, when the region is retired, |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6736 // instead of when it's allocated, since this is the point that its |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6737 // used space has been recored in _summary_bytes_used. |
|
8229bd737950
7075646: G1: fix inconsistencies in the monitoring data
tonyp
parents:
3979
diff
changeset
|
6738 g1mm()->update_eden_size(); |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6739 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6740 |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6741 HeapRegion* MutatorAllocRegion::allocate_new_region(size_t word_size, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6742 bool force) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6743 return _g1h->new_mutator_alloc_region(word_size, force); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6744 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6745 |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6746 void G1CollectedHeap::set_par_threads() { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6747 // Don't change the number of workers. Use the value previously set |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6748 // in the workgroup. |
| 4711 | 6749 assert(G1CollectedHeap::use_parallel_gc_threads(), "shouldn't be here otherwise"); |
|
4728
441e946dc1af
7121618: Change type of number of GC workers to unsigned int.
jmasa
parents:
4711
diff
changeset
|
6750 uint n_workers = workers()->active_workers(); |
| 4711 | 6751 assert(UseDynamicNumberOfGCThreads || |
|
4095
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6752 n_workers == workers()->total_workers(), |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6753 "Otherwise should be using the total number of workers"); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6754 if (n_workers == 0) { |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6755 assert(false, "Should have been set in prior evacuation pause."); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6756 n_workers = ParallelGCThreads; |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6757 workers()->set_active_workers(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6758 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6759 set_par_threads(n_workers); |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6760 } |
|
bca17e38de00
6593758: RFE: Enhance GC ergonomics to dynamically choose ParallelGCThreads
jmasa
parents:
4090
diff
changeset
|
6761 |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6762 void MutatorAllocRegion::retire_region(HeapRegion* alloc_region, |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6763 size_t allocated_bytes) { |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6764 _g1h->retire_mutator_alloc_region(alloc_region, allocated_bytes); |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6765 } |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6766 |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6767 // Methods for the GC alloc regions |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6768 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6769 HeapRegion* G1CollectedHeap::new_gc_alloc_region(size_t word_size, |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
6770 uint count, |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6771 GCAllocPurpose ap) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6772 assert(FreeList_lock->owned_by_self(), "pre-condition"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6773 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6774 if (count < g1_policy()->max_regions(ap)) { |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
6775 bool survivor = (ap == GCAllocForSurvived); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6776 HeapRegion* new_alloc_region = new_region(word_size, |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
6777 !survivor, |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6778 true /* do_expand */); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6779 if (new_alloc_region != NULL) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6780 // We really only need to do this for old regions given that we |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6781 // should never scan survivors. But it doesn't hurt to do it |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6782 // for survivors too. |
|
20274
a8137787acfe
8047821: G1 Does not use the save_marks functionality as intended
mgerdin
parents:
20270
diff
changeset
|
6783 new_alloc_region->record_top_and_timestamp(); |
|
17773
8ee855b4e667
8036025: Sort the freelist in order to shrink the heap
jwilhelm
parents:
17759
diff
changeset
|
6784 if (survivor) { |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6785 new_alloc_region->set_survivor(); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6786 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Survivor); |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6787 check_bitmaps("Survivor Region Allocation", new_alloc_region); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6788 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6789 _hr_printer.alloc(new_alloc_region, G1HRPrinter::Old); |
|
20291
e0954897238a
7132678: G1: verify that the marking bitmaps have no marks for objects over TAMS
brutisso
parents:
20282
diff
changeset
|
6790 check_bitmaps("Old Region Allocation", new_alloc_region); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6791 } |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6792 bool during_im = g1_policy()->during_initial_mark_pause(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6793 new_alloc_region->note_start_of_copying(during_im); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6794 return new_alloc_region; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6795 } else { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6796 g1_policy()->note_alloc_region_limit_reached(ap); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6797 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6798 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6799 return NULL; |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6800 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6801 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6802 void G1CollectedHeap::retire_gc_alloc_region(HeapRegion* alloc_region, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6803 size_t allocated_bytes, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6804 GCAllocPurpose ap) { |
|
4787
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6805 bool during_im = g1_policy()->during_initial_mark_pause(); |
|
2ace1c4ee8da
6888336: G1: avoid explicitly marking and pushing objects in survivor spaces
tonyp
parents:
4785
diff
changeset
|
6806 alloc_region->note_end_of_copying(during_im); |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6807 g1_policy()->record_bytes_copied_during_gc(allocated_bytes); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6808 if (ap == GCAllocForSurvived) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6809 young_list()->add_survivor_region(alloc_region); |
| 4072 | 6810 } else { |
| 6811 _old_set.add(alloc_region); | |
|
3830
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6812 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6813 _hr_printer.retire(alloc_region); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6814 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6815 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6816 HeapRegion* SurvivorGCAllocRegion::allocate_new_region(size_t word_size, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6817 bool force) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6818 assert(!force, "not supported for GC alloc regions"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6819 return _g1h->new_gc_alloc_region(word_size, count(), GCAllocForSurvived); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6820 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6821 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6822 void SurvivorGCAllocRegion::retire_region(HeapRegion* alloc_region, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6823 size_t allocated_bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6824 _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6825 GCAllocForSurvived); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6826 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6827 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6828 HeapRegion* OldGCAllocRegion::allocate_new_region(size_t word_size, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6829 bool force) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6830 assert(!force, "not supported for GC alloc regions"); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6831 return _g1h->new_gc_alloc_region(word_size, count(), GCAllocForTenured); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6832 } |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6833 |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6834 void OldGCAllocRegion::retire_region(HeapRegion* alloc_region, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6835 size_t allocated_bytes) { |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6836 _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes, |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6837 GCAllocForTenured); |
|
f44782f04dd4
7039627: G1: avoid BOT updates for survivor allocations and dirty survivor regions incrementally
tonyp
parents:
3824
diff
changeset
|
6838 } |
|
2433
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6839 // Heap region set verification |
|
abdfc822206f
7023069: G1: Introduce symmetric locking in the slow allocation path
tonyp
parents:
2432
diff
changeset
|
6840 |
| 2152 | 6841 class VerifyRegionListsClosure : public HeapRegionClosure { |
| 6842 private: | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6843 HeapRegionSet* _old_set; |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6844 HeapRegionSet* _humongous_set; |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6845 FreeRegionList* _free_list; |
| 2152 | 6846 |
| 6847 public: | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6848 HeapRegionSetCount _old_count; |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6849 HeapRegionSetCount _humongous_count; |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6850 HeapRegionSetCount _free_count; |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6851 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6852 VerifyRegionListsClosure(HeapRegionSet* old_set, |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6853 HeapRegionSet* humongous_set, |
| 2152 | 6854 FreeRegionList* free_list) : |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6855 _old_set(old_set), _humongous_set(humongous_set), _free_list(free_list), |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6856 _old_count(), _humongous_count(), _free_count(){ } |
| 2152 | 6857 |
| 6858 bool doHeapRegion(HeapRegion* hr) { | |
| 6859 if (hr->continuesHumongous()) { | |
| 6860 return false; | |
| 6861 } | |
| 6862 | |
| 6863 if (hr->is_young()) { | |
| 6864 // TODO | |
| 6865 } else if (hr->startsHumongous()) { | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6866 assert(hr->containing_set() == _humongous_set, err_msg("Heap region %u is starts humongous but not in humongous set.", hr->region_num())); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6867 _humongous_count.increment(1u, hr->capacity()); |
| 2152 | 6868 } else if (hr->is_empty()) { |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6869 assert(hr->containing_set() == _free_list, err_msg("Heap region %u is empty but not on the free list.", hr->region_num())); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6870 _free_count.increment(1u, hr->capacity()); |
| 4072 | 6871 } else { |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6872 assert(hr->containing_set() == _old_set, err_msg("Heap region %u is old but not in the old set.", hr->region_num())); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6873 _old_count.increment(1u, hr->capacity()); |
| 2152 | 6874 } |
| 6875 return false; | |
| 6876 } | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6877 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6878 void verify_counts(HeapRegionSet* old_set, HeapRegionSet* humongous_set, FreeRegionList* free_list) { |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6879 guarantee(old_set->length() == _old_count.length(), err_msg("Old set count mismatch. Expected %u, actual %u.", old_set->length(), _old_count.length())); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6880 guarantee(old_set->total_capacity_bytes() == _old_count.capacity(), err_msg("Old set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT, |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6881 old_set->total_capacity_bytes(), _old_count.capacity())); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6882 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6883 guarantee(humongous_set->length() == _humongous_count.length(), err_msg("Hum set count mismatch. Expected %u, actual %u.", humongous_set->length(), _humongous_count.length())); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6884 guarantee(humongous_set->total_capacity_bytes() == _humongous_count.capacity(), err_msg("Hum set capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT, |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6885 humongous_set->total_capacity_bytes(), _humongous_count.capacity())); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6886 |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6887 guarantee(free_list->length() == _free_count.length(), err_msg("Free list count mismatch. Expected %u, actual %u.", free_list->length(), _free_count.length())); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6888 guarantee(free_list->total_capacity_bytes() == _free_count.capacity(), err_msg("Free list capacity mismatch. Expected " SIZE_FORMAT ", actual " SIZE_FORMAT, |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6889 free_list->total_capacity_bytes(), _free_count.capacity())); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6890 } |
| 2152 | 6891 }; |
| 6892 | |
|
6010
720b6a76dd9d
7157073: G1: type change size_t -> uint for region counts / indexes
tonyp
parents:
6008
diff
changeset
|
6893 HeapRegion* G1CollectedHeap::new_heap_region(uint hrs_index, |
| 3766 | 6894 HeapWord* bottom) { |
| 6895 HeapWord* end = bottom + HeapRegion::GrainWords; | |
| 6896 MemRegion mr(bottom, end); | |
| 6897 assert(_g1_reserved.contains(mr), "invariant"); | |
| 6898 // This might return NULL if the allocation fails | |
|
6754
8fbf05030e24
7016955: G1: remove the is_zeroed parameter from the HeapRegion constructor
johnc
parents:
6752
diff
changeset
|
6899 return new HeapRegion(hrs_index, _bot_shared, mr); |
| 3766 | 6900 } |
| 6901 | |
| 2152 | 6902 void G1CollectedHeap::verify_region_sets() { |
| 6903 assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */); | |
| 6904 | |
| 6905 // First, check the explicit lists. | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6906 _free_list.verify_list(); |
| 2152 | 6907 { |
| 6908 // Given that a concurrent operation might be adding regions to | |
| 6909 // the secondary free list we have to take the lock before | |
| 6910 // verifying it. | |
| 6911 MutexLockerEx x(SecondaryFreeList_lock, Mutex::_no_safepoint_check_flag); | |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6912 _secondary_free_list.verify_list(); |
|
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6913 } |
| 2152 | 6914 |
| 6915 // If a concurrent region freeing operation is in progress it will | |
| 6916 // be difficult to correctly attributed any free regions we come | |
| 6917 // across to the correct free list given that they might belong to | |
| 6918 // one of several (free_list, secondary_free_list, any local lists, | |
| 6919 // etc.). So, if that's the case we will skip the rest of the | |
| 6920 // verification operation. Alternatively, waiting for the concurrent | |
| 6921 // operation to complete will have a non-trivial effect on the GC's | |
| 6922 // operation (no concurrent operation will last longer than the | |
| 6923 // interval between two calls to verification) and it might hide | |
| 6924 // any issues that we would like to catch during testing. | |
| 6925 if (free_regions_coming()) { | |
| 6926 return; | |
| 6927 } | |
| 6928 | |
| 2361 | 6929 // Make sure we append the secondary_free_list on the free_list so |
| 6930 // that all free regions we will come across can be safely | |
| 6931 // attributed to the free_list. | |
| 6932 append_secondary_free_list_if_not_empty_with_lock(); | |
| 2152 | 6933 |
| 6934 // Finally, make sure that the region accounting in the lists is | |
| 6935 // consistent with what we see in the heap. | |
| 6936 | |
| 4072 | 6937 VerifyRegionListsClosure cl(&_old_set, &_humongous_set, &_free_list); |
| 2152 | 6938 heap_region_iterate(&cl); |
|
17736
58fc1b1523dc
8034079: G1: Refactor the HeapRegionSet hierarchy
brutisso
parents:
17727
diff
changeset
|
6939 cl.verify_counts(&_old_set, &_humongous_set, &_free_list); |
| 342 | 6940 } |
| 12080 | 6941 |
| 6942 // Optimized nmethod scanning | |
| 6943 | |
| 6944 class RegisterNMethodOopClosure: public OopClosure { | |
| 6945 G1CollectedHeap* _g1h; | |
| 6946 nmethod* _nm; | |
| 6947 | |
| 6948 template <class T> void do_oop_work(T* p) { | |
| 6949 T heap_oop = oopDesc::load_heap_oop(p); | |
| 6950 if (!oopDesc::is_null(heap_oop)) { | |
| 6951 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | |
| 6952 HeapRegion* hr = _g1h->heap_region_containing(obj); | |
|
13062
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6953 assert(!hr->continuesHumongous(), |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6954 err_msg("trying to add code root "PTR_FORMAT" in continuation of humongous region "HR_FORMAT |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6955 " starting at "HR_FORMAT, |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6956 _nm, HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region()))); |
| 12080 | 6957 |
| 6958 // HeapRegion::add_strong_code_root() avoids adding duplicate | |
| 6959 // entries but having duplicates is OK since we "mark" nmethods | |
| 6960 // as visited when we scan the strong code root lists during the GC. | |
| 6961 hr->add_strong_code_root(_nm); | |
|
13062
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6962 assert(hr->rem_set()->strong_code_roots_list_contains(_nm), |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6963 err_msg("failed to add code root "PTR_FORMAT" to remembered set of region "HR_FORMAT, |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6964 _nm, HR_FORMAT_PARAMS(hr))); |
| 12080 | 6965 } |
| 6966 } | |
| 6967 | |
| 6968 public: | |
| 6969 RegisterNMethodOopClosure(G1CollectedHeap* g1h, nmethod* nm) : | |
| 6970 _g1h(g1h), _nm(nm) {} | |
| 6971 | |
| 6972 void do_oop(oop* p) { do_oop_work(p); } | |
| 6973 void do_oop(narrowOop* p) { do_oop_work(p); } | |
| 6974 }; | |
| 6975 | |
| 6976 class UnregisterNMethodOopClosure: public OopClosure { | |
| 6977 G1CollectedHeap* _g1h; | |
| 6978 nmethod* _nm; | |
| 6979 | |
| 6980 template <class T> void do_oop_work(T* p) { | |
| 6981 T heap_oop = oopDesc::load_heap_oop(p); | |
| 6982 if (!oopDesc::is_null(heap_oop)) { | |
| 6983 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); | |
| 6984 HeapRegion* hr = _g1h->heap_region_containing(obj); | |
|
13062
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6985 assert(!hr->continuesHumongous(), |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6986 err_msg("trying to remove code root "PTR_FORMAT" in continuation of humongous region "HR_FORMAT |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6987 " starting at "HR_FORMAT, |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6988 _nm, HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region()))); |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6989 |
| 12080 | 6990 hr->remove_strong_code_root(_nm); |
|
13062
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6991 assert(!hr->rem_set()->strong_code_roots_list_contains(_nm), |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6992 err_msg("failed to remove code root "PTR_FORMAT" of region "HR_FORMAT, |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
6993 _nm, HR_FORMAT_PARAMS(hr))); |
| 12080 | 6994 } |
| 6995 } | |
| 6996 | |
| 6997 public: | |
| 6998 UnregisterNMethodOopClosure(G1CollectedHeap* g1h, nmethod* nm) : | |
| 6999 _g1h(g1h), _nm(nm) {} | |
| 7000 | |
| 7001 void do_oop(oop* p) { do_oop_work(p); } | |
| 7002 void do_oop(narrowOop* p) { do_oop_work(p); } | |
| 7003 }; | |
| 7004 | |
| 7005 void G1CollectedHeap::register_nmethod(nmethod* nm) { | |
| 7006 CollectedHeap::register_nmethod(nm); | |
| 7007 | |
| 7008 guarantee(nm != NULL, "sanity"); | |
| 7009 RegisterNMethodOopClosure reg_cl(this, nm); | |
| 7010 nm->oops_do(®_cl); | |
| 7011 } | |
| 7012 | |
| 7013 void G1CollectedHeap::unregister_nmethod(nmethod* nm) { | |
| 7014 CollectedHeap::unregister_nmethod(nm); | |
| 7015 | |
| 7016 guarantee(nm != NULL, "sanity"); | |
| 7017 UnregisterNMethodOopClosure reg_cl(this, nm); | |
| 7018 nm->oops_do(®_cl, true); | |
| 7019 } | |
| 7020 | |
| 7021 class MigrateCodeRootsHeapRegionClosure: public HeapRegionClosure { | |
| 7022 public: | |
| 7023 bool doHeapRegion(HeapRegion *hr) { | |
|
13062
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
7024 assert(!hr->isHumongous(), |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
7025 err_msg("humongous region "HR_FORMAT" should not have been added to collection set", |
|
28674af341ac
8027756: assert(!hr->isHumongous()) failed: code root in humongous region?
tschatzl
parents:
13060
diff
changeset
|
7026 HR_FORMAT_PARAMS(hr))); |
| 12080 | 7027 hr->migrate_strong_code_roots(); |
| 7028 return false; | |
| 7029 } | |
| 7030 }; | |
| 7031 | |
| 7032 void G1CollectedHeap::migrate_strong_code_roots() { | |
| 7033 MigrateCodeRootsHeapRegionClosure cl; | |
| 7034 double migrate_start = os::elapsedTime(); | |
| 7035 collection_set_iterate(&cl); | |
| 7036 double migration_time_ms = (os::elapsedTime() - migrate_start) * 1000.0; | |
| 7037 g1_policy()->phase_times()->record_strong_code_root_migration_time(migration_time_ms); | |
| 7038 } | |
| 7039 | |
|
17753
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
17749
diff
changeset
|
7040 void G1CollectedHeap::purge_code_root_memory() { |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
17749
diff
changeset
|
7041 double purge_start = os::elapsedTime(); |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
17749
diff
changeset
|
7042 G1CodeRootSet::purge_chunks(G1CodeRootsChunkCacheKeepPercent); |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
17749
diff
changeset
|
7043 double purge_time_ms = (os::elapsedTime() - purge_start) * 1000.0; |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
17749
diff
changeset
|
7044 g1_policy()->phase_times()->record_strong_code_root_purge_time(purge_time_ms); |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
17749
diff
changeset
|
7045 } |
|
191174b49bec
8035406: Improve data structure for Code Cache remembered sets
tschatzl
parents:
17749
diff
changeset
|
7046 |
| 12080 | 7047 class RebuildStrongCodeRootClosure: public CodeBlobClosure { |
| 7048 G1CollectedHeap* _g1h; | |
| 7049 | |
| 7050 public: | |
| 7051 RebuildStrongCodeRootClosure(G1CollectedHeap* g1h) : | |
| 7052 _g1h(g1h) {} | |
| 7053 | |
| 7054 void do_code_blob(CodeBlob* cb) { | |
| 7055 nmethod* nm = (cb != NULL) ? cb->as_nmethod_or_null() : NULL; | |
| 7056 if (nm == NULL) { | |
| 7057 return; | |
| 7058 } | |
| 7059 | |
|
20191
fd81a5764900
8046231: G1: Code root location ... from nmethod ... not in strong code roots for region
pliden
parents:
20190
diff
changeset
|
7060 if (ScavengeRootsInCode) { |
| 12080 | 7061 _g1h->register_nmethod(nm); |
| 7062 } | |
| 7063 } | |
| 7064 }; | |
| 7065 | |
| 7066 void G1CollectedHeap::rebuild_strong_code_roots() { | |
| 7067 RebuildStrongCodeRootClosure blob_cl(this); | |
| 7068 CodeCache::blobs_do(&blob_cl); | |
| 7069 } |