Mercurial > hg > graal-jvmci-8
annotate src/share/vm/gc_implementation/g1/g1StringDedup.cpp @ 20211:82693fb204a5
8038930: G1CodeRootSet::test fails with assert(_num_chunks_handed_out == 0) failed: No elements must have been handed out yet
Summary: The test incorrectly assumed that it had been started with no other previous compilation activity. Fix this by allowing multiple code root free chunk lists, and use one separate from the global one to perform the test.
Reviewed-by: brutisso
| author | tschatzl |
|---|---|
| date | Wed, 16 Apr 2014 10:14:50 +0200 |
| parents | 1772223a25a2 |
| children | c3fcc09c9239 |
| rev | line source |
|---|---|
| 17764 | 1 /* |
| 2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. | |
| 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
| 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| 20 * or visit www.oracle.com if you need additional information or have any | |
| 21 * questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 #include "precompiled.hpp" | |
| 26 #include "classfile/javaClasses.hpp" | |
| 27 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
| 28 #include "gc_implementation/g1/g1GCPhaseTimes.hpp" | |
| 29 #include "gc_implementation/g1/g1StringDedup.hpp" | |
| 30 #include "gc_implementation/g1/g1StringDedupQueue.hpp" | |
| 31 #include "gc_implementation/g1/g1StringDedupStat.hpp" | |
| 32 #include "gc_implementation/g1/g1StringDedupTable.hpp" | |
| 33 #include "gc_implementation/g1/g1StringDedupThread.hpp" | |
| 34 | |
| 35 bool G1StringDedup::_enabled = false; | |
| 36 | |
| 37 void G1StringDedup::initialize() { | |
| 38 assert(UseG1GC, "String deduplication only available with G1"); | |
| 39 if (UseStringDeduplication) { | |
| 40 _enabled = true; | |
| 41 G1StringDedupQueue::create(); | |
| 42 G1StringDedupTable::create(); | |
| 43 G1StringDedupThread::create(); | |
| 44 } | |
| 45 } | |
| 46 | |
|
17947
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
17764
diff
changeset
|
47 void G1StringDedup::stop() { |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
17764
diff
changeset
|
48 assert(is_enabled(), "String deduplication not enabled"); |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
17764
diff
changeset
|
49 G1StringDedupThread::stop(); |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
17764
diff
changeset
|
50 } |
|
1772223a25a2
8037112: gc/g1/TestHumongousAllocInitialMark.java caused SIGSEGV
pliden
parents:
17764
diff
changeset
|
51 |
| 17764 | 52 bool G1StringDedup::is_candidate_from_mark(oop obj) { |
| 53 if (java_lang_String::is_instance(obj)) { | |
| 54 bool from_young = G1CollectedHeap::heap()->heap_region_containing_raw(obj)->is_young(); | |
| 55 if (from_young && obj->age() < StringDeduplicationAgeThreshold) { | |
| 56 // Candidate found. String is being evacuated from young to old but has not | |
| 57 // reached the deduplication age threshold, i.e. has not previously been a | |
| 58 // candidate during its life in the young generation. | |
| 59 return true; | |
| 60 } | |
| 61 } | |
| 62 | |
| 63 // Not a candidate | |
| 64 return false; | |
| 65 } | |
| 66 | |
| 67 void G1StringDedup::enqueue_from_mark(oop java_string) { | |
| 68 assert(is_enabled(), "String deduplication not enabled"); | |
| 69 if (is_candidate_from_mark(java_string)) { | |
| 70 G1StringDedupQueue::push(0 /* worker_id */, java_string); | |
| 71 } | |
| 72 } | |
| 73 | |
| 74 bool G1StringDedup::is_candidate_from_evacuation(bool from_young, bool to_young, oop obj) { | |
| 75 if (from_young && java_lang_String::is_instance(obj)) { | |
| 76 if (to_young && obj->age() == StringDeduplicationAgeThreshold) { | |
| 77 // Candidate found. String is being evacuated from young to young and just | |
| 78 // reached the deduplication age threshold. | |
| 79 return true; | |
| 80 } | |
| 81 if (!to_young && obj->age() < StringDeduplicationAgeThreshold) { | |
| 82 // Candidate found. String is being evacuated from young to old but has not | |
| 83 // reached the deduplication age threshold, i.e. has not previously been a | |
| 84 // candidate during its life in the young generation. | |
| 85 return true; | |
| 86 } | |
| 87 } | |
| 88 | |
| 89 // Not a candidate | |
| 90 return false; | |
| 91 } | |
| 92 | |
| 93 void G1StringDedup::enqueue_from_evacuation(bool from_young, bool to_young, uint worker_id, oop java_string) { | |
| 94 assert(is_enabled(), "String deduplication not enabled"); | |
| 95 if (is_candidate_from_evacuation(from_young, to_young, java_string)) { | |
| 96 G1StringDedupQueue::push(worker_id, java_string); | |
| 97 } | |
| 98 } | |
| 99 | |
| 100 void G1StringDedup::deduplicate(oop java_string) { | |
| 101 assert(is_enabled(), "String deduplication not enabled"); | |
| 102 G1StringDedupStat dummy; // Statistics from this path is never used | |
| 103 G1StringDedupTable::deduplicate(java_string, dummy); | |
| 104 } | |
| 105 | |
| 106 void G1StringDedup::oops_do(OopClosure* keep_alive) { | |
| 107 assert(is_enabled(), "String deduplication not enabled"); | |
| 108 unlink_or_oops_do(NULL, keep_alive); | |
| 109 } | |
| 110 | |
| 111 void G1StringDedup::unlink(BoolObjectClosure* is_alive) { | |
| 112 assert(is_enabled(), "String deduplication not enabled"); | |
| 113 // Don't allow a potential resize or rehash during unlink, as the unlink | |
| 114 // operation itself might remove enough entries to invalidate such a decision. | |
| 115 unlink_or_oops_do(is_alive, NULL, false /* allow_resize_and_rehash */); | |
| 116 } | |
| 117 | |
| 118 // | |
| 119 // Task for parallel unlink_or_oops_do() operation on the deduplication queue | |
| 120 // and table. | |
| 121 // | |
| 122 class G1StringDedupUnlinkOrOopsDoTask : public AbstractGangTask { | |
| 123 private: | |
| 124 G1StringDedupUnlinkOrOopsDoClosure _cl; | |
| 125 | |
| 126 public: | |
| 127 G1StringDedupUnlinkOrOopsDoTask(BoolObjectClosure* is_alive, | |
| 128 OopClosure* keep_alive, | |
| 129 bool allow_resize_and_rehash) : | |
| 130 AbstractGangTask("G1StringDedupUnlinkOrOopsDoTask"), | |
| 131 _cl(is_alive, keep_alive, allow_resize_and_rehash) { | |
| 132 } | |
| 133 | |
| 134 virtual void work(uint worker_id) { | |
| 135 double queue_fixup_start = os::elapsedTime(); | |
| 136 G1StringDedupQueue::unlink_or_oops_do(&_cl); | |
| 137 | |
| 138 double table_fixup_start = os::elapsedTime(); | |
| 139 G1StringDedupTable::unlink_or_oops_do(&_cl, worker_id); | |
| 140 | |
| 141 double queue_fixup_time_ms = (table_fixup_start - queue_fixup_start) * 1000.0; | |
| 142 double table_fixup_time_ms = (os::elapsedTime() - table_fixup_start) * 1000.0; | |
| 143 G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy(); | |
| 144 g1p->phase_times()->record_string_dedup_queue_fixup_worker_time(worker_id, queue_fixup_time_ms); | |
| 145 g1p->phase_times()->record_string_dedup_table_fixup_worker_time(worker_id, table_fixup_time_ms); | |
| 146 } | |
| 147 }; | |
| 148 | |
| 149 void G1StringDedup::unlink_or_oops_do(BoolObjectClosure* is_alive, OopClosure* keep_alive, bool allow_resize_and_rehash) { | |
| 150 assert(is_enabled(), "String deduplication not enabled"); | |
| 151 G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy(); | |
| 152 g1p->phase_times()->note_string_dedup_fixup_start(); | |
| 153 double fixup_start = os::elapsedTime(); | |
| 154 | |
| 155 G1StringDedupUnlinkOrOopsDoTask task(is_alive, keep_alive, allow_resize_and_rehash); | |
| 156 if (G1CollectedHeap::use_parallel_gc_threads()) { | |
| 157 G1CollectedHeap* g1h = G1CollectedHeap::heap(); | |
| 158 g1h->set_par_threads(); | |
| 159 g1h->workers()->run_task(&task); | |
| 160 g1h->set_par_threads(0); | |
| 161 } else { | |
| 162 task.work(0); | |
| 163 } | |
| 164 | |
| 165 double fixup_time_ms = (os::elapsedTime() - fixup_start) * 1000.0; | |
| 166 g1p->phase_times()->record_string_dedup_fixup_time(fixup_time_ms); | |
| 167 g1p->phase_times()->note_string_dedup_fixup_end(); | |
| 168 } | |
| 169 | |
| 170 void G1StringDedup::threads_do(ThreadClosure* tc) { | |
| 171 assert(is_enabled(), "String deduplication not enabled"); | |
| 172 tc->do_thread(G1StringDedupThread::thread()); | |
| 173 } | |
| 174 | |
| 175 void G1StringDedup::print_worker_threads_on(outputStream* st) { | |
| 176 assert(is_enabled(), "String deduplication not enabled"); | |
| 177 G1StringDedupThread::thread()->print_on(st); | |
| 178 st->cr(); | |
| 179 } | |
| 180 | |
| 181 void G1StringDedup::verify() { | |
| 182 assert(is_enabled(), "String deduplication not enabled"); | |
| 183 G1StringDedupQueue::verify(); | |
| 184 G1StringDedupTable::verify(); | |
| 185 } | |
| 186 | |
| 187 G1StringDedupUnlinkOrOopsDoClosure::G1StringDedupUnlinkOrOopsDoClosure(BoolObjectClosure* is_alive, | |
| 188 OopClosure* keep_alive, | |
| 189 bool allow_resize_and_rehash) : | |
| 190 _is_alive(is_alive), | |
| 191 _keep_alive(keep_alive), | |
| 192 _resized_table(NULL), | |
| 193 _rehashed_table(NULL), | |
| 194 _next_queue(0), | |
| 195 _next_bucket(0) { | |
| 196 if (allow_resize_and_rehash) { | |
| 197 // If both resize and rehash is needed, only do resize. Rehash of | |
| 198 // the table will eventually happen if the situation persists. | |
| 199 _resized_table = G1StringDedupTable::prepare_resize(); | |
| 200 if (!is_resizing()) { | |
| 201 _rehashed_table = G1StringDedupTable::prepare_rehash(); | |
| 202 } | |
| 203 } | |
| 204 } | |
| 205 | |
| 206 G1StringDedupUnlinkOrOopsDoClosure::~G1StringDedupUnlinkOrOopsDoClosure() { | |
| 207 assert(!is_resizing() || !is_rehashing(), "Can not both resize and rehash"); | |
| 208 if (is_resizing()) { | |
| 209 G1StringDedupTable::finish_resize(_resized_table); | |
| 210 } else if (is_rehashing()) { | |
| 211 G1StringDedupTable::finish_rehash(_rehashed_table); | |
| 212 } | |
| 213 } |