concurrentG1Refine.cpp revision 8413:92457dfb91bd 
1/*
2 * Copyright (c) 2001, 2015, 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/g1/concurrentG1Refine.hpp"
27#include "gc/g1/concurrentG1RefineThread.hpp"
28#include "gc/g1/g1CollectedHeap.inline.hpp"
29#include "gc/g1/g1HotCardCache.hpp"
30#include "runtime/java.hpp"
31
32ConcurrentG1Refine::ConcurrentG1Refine(G1CollectedHeap* g1h, CardTableEntryClosure* refine_closure) :
33  _threads(NULL), _n_threads(0),
34  _hot_card_cache(g1h)
35{
36  // Ergonomically 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, refine_closure, 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
76void 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
84void ConcurrentG1Refine::init(G1RegionToSpaceMapper* card_counts_storage) {
85  _hot_card_cache.initialize(card_counts_storage);
86}
87
88void ConcurrentG1Refine::stop() {
89  if (_threads != NULL) {
90    for (uint i = 0; i < _n_threads; i++) {
91      _threads[i]->stop();
92    }
93  }
94}
95
96void 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
105ConcurrentG1Refine::~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);
111  }
112}
113
114void 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
122void 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
130uint ConcurrentG1Refine::thread_num() {
131  return G1ConcRefinementThreads;
132}
133
134void ConcurrentG1Refine::print_worker_threads_on(outputStream* st) const {
135  for (uint i = 0; i < _n_threads; ++i) {
136    _threads[i]->print_on(st);
137    st->cr();
138  }
139}
140
141ConcurrentG1RefineThread * ConcurrentG1Refine::sampling_thread() const {
142  return _threads[worker_thread_num()];
143}
144