13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19 * or visit www.oracle.com if you need additional information or have any
20 * questions.
21 *
22 */
23
24 #include "precompiled.hpp"
25
26 #include "gc/shared/workerPolicy.hpp"
27 #include "gc/shenandoah/shenandoahWorkerPolicy.hpp"
28 #include "runtime/thread.hpp"
29
30 uint ShenandoahWorkerPolicy::_prev_par_marking = 0;
31 uint ShenandoahWorkerPolicy::_prev_conc_marking = 0;
32 uint ShenandoahWorkerPolicy::_prev_conc_evac = 0;
33 uint ShenandoahWorkerPolicy::_prev_fullgc = 0;
34 uint ShenandoahWorkerPolicy::_prev_degengc = 0;
35 uint ShenandoahWorkerPolicy::_prev_stw_traversal = 0;
36 uint ShenandoahWorkerPolicy::_prev_conc_traversal = 0;
37 uint ShenandoahWorkerPolicy::_prev_conc_update_ref = 0;
38 uint ShenandoahWorkerPolicy::_prev_par_update_ref = 0;
39 uint ShenandoahWorkerPolicy::_prev_conc_cleanup = 0;
40 uint ShenandoahWorkerPolicy::_prev_conc_reset = 0;
41
42 uint ShenandoahWorkerPolicy::calc_workers_for_init_marking() {
43 uint active_workers = (_prev_par_marking == 0) ? ParallelGCThreads : _prev_par_marking;
44
45 _prev_par_marking =
46 WorkerPolicy::calc_active_workers(ParallelGCThreads,
47 active_workers,
48 Threads::number_of_non_daemon_threads());
49 return _prev_par_marking;
50 }
51
52 uint ShenandoahWorkerPolicy::calc_workers_for_conc_marking() {
53 uint active_workers = (_prev_conc_marking == 0) ? ConcGCThreads : _prev_conc_marking;
54 _prev_conc_marking =
55 WorkerPolicy::calc_active_conc_workers(ConcGCThreads,
56 active_workers,
57 Threads::number_of_non_daemon_threads());
58 return _prev_conc_marking;
59 }
60
61 // Reuse the calculation result from init marking
62 uint ShenandoahWorkerPolicy::calc_workers_for_final_marking() {
63 return _prev_par_marking;
64 }
65
66 // Calculate workers for concurrent evacuation (concurrent GC)
67 uint ShenandoahWorkerPolicy::calc_workers_for_conc_evac() {
68 uint active_workers = (_prev_conc_evac == 0) ? ConcGCThreads : _prev_conc_evac;
69 _prev_conc_evac =
70 WorkerPolicy::calc_active_conc_workers(ConcGCThreads,
71 active_workers,
72 Threads::number_of_non_daemon_threads());
73 return _prev_conc_evac;
74 }
75
76 // Calculate workers for parallel fullgc
77 uint ShenandoahWorkerPolicy::calc_workers_for_fullgc() {
78 uint active_workers = (_prev_fullgc == 0) ? ParallelGCThreads : _prev_fullgc;
79 _prev_fullgc =
80 WorkerPolicy::calc_active_workers(ParallelGCThreads,
81 active_workers,
82 Threads::number_of_non_daemon_threads());
83 return _prev_fullgc;
|
13 *
14 * You should have received a copy of the GNU General Public License version
15 * 2 along with this work; if not, write to the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19 * or visit www.oracle.com if you need additional information or have any
20 * questions.
21 *
22 */
23
24 #include "precompiled.hpp"
25
26 #include "gc/shared/workerPolicy.hpp"
27 #include "gc/shenandoah/shenandoahWorkerPolicy.hpp"
28 #include "runtime/thread.hpp"
29
30 uint ShenandoahWorkerPolicy::_prev_par_marking = 0;
31 uint ShenandoahWorkerPolicy::_prev_conc_marking = 0;
32 uint ShenandoahWorkerPolicy::_prev_conc_evac = 0;
33 uint ShenandoahWorkerPolicy::_prev_conc_root_proc = 0;
34 uint ShenandoahWorkerPolicy::_prev_fullgc = 0;
35 uint ShenandoahWorkerPolicy::_prev_degengc = 0;
36 uint ShenandoahWorkerPolicy::_prev_stw_traversal = 0;
37 uint ShenandoahWorkerPolicy::_prev_conc_traversal = 0;
38 uint ShenandoahWorkerPolicy::_prev_conc_update_ref = 0;
39 uint ShenandoahWorkerPolicy::_prev_par_update_ref = 0;
40 uint ShenandoahWorkerPolicy::_prev_conc_cleanup = 0;
41 uint ShenandoahWorkerPolicy::_prev_conc_reset = 0;
42
43 uint ShenandoahWorkerPolicy::calc_workers_for_init_marking() {
44 uint active_workers = (_prev_par_marking == 0) ? ParallelGCThreads : _prev_par_marking;
45
46 _prev_par_marking =
47 WorkerPolicy::calc_active_workers(ParallelGCThreads,
48 active_workers,
49 Threads::number_of_non_daemon_threads());
50 return _prev_par_marking;
51 }
52
53 uint ShenandoahWorkerPolicy::calc_workers_for_conc_marking() {
54 uint active_workers = (_prev_conc_marking == 0) ? ConcGCThreads : _prev_conc_marking;
55 _prev_conc_marking =
56 WorkerPolicy::calc_active_conc_workers(ConcGCThreads,
57 active_workers,
58 Threads::number_of_non_daemon_threads());
59 return _prev_conc_marking;
60 }
61
62 // Reuse the calculation result from init marking
63 uint ShenandoahWorkerPolicy::calc_workers_for_final_marking() {
64 return _prev_par_marking;
65 }
66
67 // Calculate workers for concurrent root processing
68 uint ShenandoahWorkerPolicy::calc_workers_for_conc_root_processing() {
69 uint active_workers = (_prev_conc_root_proc == 0) ? ConcGCThreads : _prev_conc_root_proc;
70 _prev_conc_root_proc =
71 WorkerPolicy::calc_active_conc_workers(ConcGCThreads,
72 active_workers,
73 Threads::number_of_non_daemon_threads());
74 return _prev_conc_root_proc;
75 }
76
77 // Calculate workers for concurrent evacuation (concurrent GC)
78 uint ShenandoahWorkerPolicy::calc_workers_for_conc_evac() {
79 uint active_workers = (_prev_conc_evac == 0) ? ConcGCThreads : _prev_conc_evac;
80 _prev_conc_evac =
81 WorkerPolicy::calc_active_conc_workers(ConcGCThreads,
82 active_workers,
83 Threads::number_of_non_daemon_threads());
84 return _prev_conc_evac;
85 }
86
87 // Calculate workers for parallel fullgc
88 uint ShenandoahWorkerPolicy::calc_workers_for_fullgc() {
89 uint active_workers = (_prev_fullgc == 0) ? ParallelGCThreads : _prev_fullgc;
90 _prev_fullgc =
91 WorkerPolicy::calc_active_workers(ParallelGCThreads,
92 active_workers,
93 Threads::number_of_non_daemon_threads());
94 return _prev_fullgc;
|