Mercurial > jdk8-mips64-public > hotspot / file comparison
comparison: src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp
src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp
- changeset 0
- f90c822e73f8
- child 6876
- 710a3c8b516e
equal
deleted
inserted
replaced
| -1:000000000000 | 0:f90c822e73f8 |
|---|---|
| 1 /* | |
| 2 * Copyright (c) 2001, 2013, 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 "gc_implementation/g1/concurrentG1Refine.hpp" | |
| 27 #include "gc_implementation/g1/concurrentG1RefineThread.hpp" | |
| 28 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
| 29 #include "gc_implementation/g1/g1HotCardCache.hpp" | |
| 30 #include "runtime/java.hpp" | |
| 31 | |
| 32 ConcurrentG1Refine::ConcurrentG1Refine(G1CollectedHeap* g1h) : | |
| 33 _threads(NULL), _n_threads(0), | |
| 34 _hot_card_cache(g1h) | |
| 35 { | |
| 36 // Ergomonically select initial concurrent refinement parameters | |
| 37 if (FLAG_IS_DEFAULT(G1ConcRefinementGreenZone)) { | |
| 38 FLAG_SET_DEFAULT(G1ConcRefinementGreenZone, MAX2<int>(ParallelGCThreads, 1)); | |
| 39 } | |
| 40 set_green_zone(G1ConcRefinementGreenZone); | |
| 41 | |
| 42 if (FLAG_IS_DEFAULT(G1ConcRefinementYellowZone)) { | |
| 43 FLAG_SET_DEFAULT(G1ConcRefinementYellowZone, green_zone() * 3); | |
| 44 } | |
| 45 set_yellow_zone(MAX2<int>(G1ConcRefinementYellowZone, green_zone())); | |
| 46 | |
| 47 if (FLAG_IS_DEFAULT(G1ConcRefinementRedZone)) { | |
| 48 FLAG_SET_DEFAULT(G1ConcRefinementRedZone, yellow_zone() * 2); | |
| 49 } | |
| 50 set_red_zone(MAX2<int>(G1ConcRefinementRedZone, yellow_zone())); | |
| 51 | |
| 52 _n_worker_threads = thread_num(); | |
| 53 // We need one extra thread to do the young gen rset size sampling. | |
| 54 _n_threads = _n_worker_threads + 1; | |
| 55 | |
| 56 reset_threshold_step(); | |
| 57 | |
| 58 _threads = NEW_C_HEAP_ARRAY(ConcurrentG1RefineThread*, _n_threads, mtGC); | |
| 59 | |
| 60 uint worker_id_offset = DirtyCardQueueSet::num_par_ids(); | |
| 61 | |
| 62 ConcurrentG1RefineThread *next = NULL; | |
| 63 for (uint i = _n_threads - 1; i != UINT_MAX; i--) { | |
| 64 ConcurrentG1RefineThread* t = new ConcurrentG1RefineThread(this, next, worker_id_offset, i); | |
| 65 assert(t != NULL, "Conc refine should have been created"); | |
| 66 if (t->osthread() == NULL) { | |
| 67 vm_shutdown_during_initialization("Could not create ConcurrentG1RefineThread"); | |
| 68 } | |
| 69 | |
| 70 assert(t->cg1r() == this, "Conc refine thread should refer to this"); | |
| 71 _threads[i] = t; | |
| 72 next = t; | |
| 73 } | |
| 74 } | |
| 75 | |
| 76 void ConcurrentG1Refine::reset_threshold_step() { | |
| 77 if (FLAG_IS_DEFAULT(G1ConcRefinementThresholdStep)) { | |
| 78 _thread_threshold_step = (yellow_zone() - green_zone()) / (worker_thread_num() + 1); | |
| 79 } else { | |
| 80 _thread_threshold_step = G1ConcRefinementThresholdStep; | |
| 81 } | |
| 82 } | |
| 83 | |
| 84 void ConcurrentG1Refine::init() { | |
| 85 _hot_card_cache.initialize(); | |
| 86 } | |
| 87 | |
| 88 void ConcurrentG1Refine::stop() { | |
| 89 if (_threads != NULL) { | |
| 90 for (uint i = 0; i < _n_threads; i++) { | |
| 91 _threads[i]->stop(); | |
| 92 } | |
| 93 } | |
| 94 } | |
| 95 | |
| 96 void ConcurrentG1Refine::reinitialize_threads() { | |
| 97 reset_threshold_step(); | |
| 98 if (_threads != NULL) { | |
| 99 for (uint i = 0; i < _n_threads; i++) { | |
| 100 _threads[i]->initialize(); | |
| 101 } | |
| 102 } | |
| 103 } | |
| 104 | |
| 105 ConcurrentG1Refine::~ConcurrentG1Refine() { | |
| 106 if (_threads != NULL) { | |
| 107 for (uint i = 0; i < _n_threads; i++) { | |
| 108 delete _threads[i]; | |
| 109 } | |
| 110 FREE_C_HEAP_ARRAY(ConcurrentG1RefineThread*, _threads, mtGC); | |
| 111 } | |
| 112 } | |
| 113 | |
| 114 void ConcurrentG1Refine::threads_do(ThreadClosure *tc) { | |
| 115 if (_threads != NULL) { | |
| 116 for (uint i = 0; i < _n_threads; i++) { | |
| 117 tc->do_thread(_threads[i]); | |
| 118 } | |
| 119 } | |
| 120 } | |
| 121 | |
| 122 void ConcurrentG1Refine::worker_threads_do(ThreadClosure * tc) { | |
| 123 if (_threads != NULL) { | |
| 124 for (uint i = 0; i < worker_thread_num(); i++) { | |
| 125 tc->do_thread(_threads[i]); | |
| 126 } | |
| 127 } | |
| 128 } | |
| 129 | |
| 130 uint ConcurrentG1Refine::thread_num() { | |
| 131 uint n_threads = (G1ConcRefinementThreads > 0) ? G1ConcRefinementThreads | |
| 132 : ParallelGCThreads; | |
| 133 return MAX2<uint>(n_threads, 1); | |
| 134 } | |
| 135 | |
| 136 void ConcurrentG1Refine::print_worker_threads_on(outputStream* st) const { | |
| 137 for (uint i = 0; i < _n_threads; ++i) { | |
| 138 _threads[i]->print_on(st); | |
| 139 st->cr(); | |
| 140 } | |
| 141 } | |
| 142 | |
| 143 ConcurrentG1RefineThread * ConcurrentG1Refine::sampling_thread() const { | |
| 144 return _threads[worker_thread_num()]; | |
| 145 } |
