< prev index next >

src/hotspot/share/gc/shenandoah/shenandoahWorkerPolicy.cpp

Print this page
rev 55401 : 8225582: Shenandoah: Enable concurrent evacuation of JNIHandles


  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;


< prev index next >