< prev index next >

src/hotspot/share/gc/g1/g1ConcurrentRefine.cpp

Print this page
rev 58017 : [mq]: 8238854-remove-superfluous-alloc-checks


  55   _threads(NULL),
  56   _num_max_threads(0)
  57 {
  58 }
  59 
  60 G1ConcurrentRefineThreadControl::~G1ConcurrentRefineThreadControl() {
  61   for (uint i = 0; i < _num_max_threads; i++) {
  62     G1ConcurrentRefineThread* t = _threads[i];
  63     if (t != NULL) {
  64       delete t;
  65     }
  66   }
  67   FREE_C_HEAP_ARRAY(G1ConcurrentRefineThread*, _threads);
  68 }
  69 
  70 jint G1ConcurrentRefineThreadControl::initialize(G1ConcurrentRefine* cr, uint num_max_threads) {
  71   assert(cr != NULL, "G1ConcurrentRefine must not be NULL");
  72   _cr = cr;
  73   _num_max_threads = num_max_threads;
  74 
  75   _threads = NEW_C_HEAP_ARRAY_RETURN_NULL(G1ConcurrentRefineThread*, num_max_threads, mtGC);
  76   if (_threads == NULL) {
  77     vm_shutdown_during_initialization("Could not allocate thread holder array.");
  78     return JNI_ENOMEM;
  79   }
  80 
  81   for (uint i = 0; i < num_max_threads; i++) {
  82     if (UseDynamicNumberOfGCThreads && i != 0 /* Always start first thread. */) {
  83       _threads[i] = NULL;
  84     } else {
  85       _threads[i] = create_refinement_thread(i, true);
  86       if (_threads[i] == NULL) {
  87         vm_shutdown_during_initialization("Could not allocate refinement threads.");
  88         return JNI_ENOMEM;
  89       }
  90     }
  91   }
  92 
  93   if (num_max_threads > 0) {
  94     G1BarrierSet::dirty_card_queue_set().set_primary_refinement_thread(_threads[0]);
  95   }
  96 
  97   return JNI_OK;
  98 }
  99 


 286   return MIN2(yellow + size, max_red_zone);
 287 }
 288 
 289 G1ConcurrentRefine* G1ConcurrentRefine::create(jint* ecode) {
 290   size_t min_yellow_zone_size = calc_min_yellow_zone_size();
 291   size_t green_zone = calc_init_green_zone();
 292   size_t yellow_zone = calc_init_yellow_zone(green_zone, min_yellow_zone_size);
 293   size_t red_zone = calc_init_red_zone(green_zone, yellow_zone);
 294 
 295   LOG_ZONES("Initial Refinement Zones: "
 296             "green: " SIZE_FORMAT ", "
 297             "yellow: " SIZE_FORMAT ", "
 298             "red: " SIZE_FORMAT ", "
 299             "min yellow size: " SIZE_FORMAT,
 300             green_zone, yellow_zone, red_zone, min_yellow_zone_size);
 301 
 302   G1ConcurrentRefine* cr = new G1ConcurrentRefine(green_zone,
 303                                                   yellow_zone,
 304                                                   red_zone,
 305                                                   min_yellow_zone_size);
 306 
 307   if (cr == NULL) {
 308     *ecode = JNI_ENOMEM;
 309     vm_shutdown_during_initialization("Could not create G1ConcurrentRefine");
 310     return NULL;
 311   }
 312 
 313   *ecode = cr->initialize();
 314   return cr;
 315 }
 316 
 317 void G1ConcurrentRefine::stop() {
 318   _thread_control.stop();
 319 }
 320 
 321 G1ConcurrentRefine::~G1ConcurrentRefine() {
 322 }
 323 
 324 void G1ConcurrentRefine::threads_do(ThreadClosure *tc) {
 325   _thread_control.worker_threads_do(tc);
 326 }
 327 
 328 uint G1ConcurrentRefine::max_num_threads() {
 329   return G1ConcRefinementThreads;
 330 }
 331 
 332 void G1ConcurrentRefine::print_threads_on(outputStream* st) const {




  55   _threads(NULL),
  56   _num_max_threads(0)
  57 {
  58 }
  59 
  60 G1ConcurrentRefineThreadControl::~G1ConcurrentRefineThreadControl() {
  61   for (uint i = 0; i < _num_max_threads; i++) {
  62     G1ConcurrentRefineThread* t = _threads[i];
  63     if (t != NULL) {
  64       delete t;
  65     }
  66   }
  67   FREE_C_HEAP_ARRAY(G1ConcurrentRefineThread*, _threads);
  68 }
  69 
  70 jint G1ConcurrentRefineThreadControl::initialize(G1ConcurrentRefine* cr, uint num_max_threads) {
  71   assert(cr != NULL, "G1ConcurrentRefine must not be NULL");
  72   _cr = cr;
  73   _num_max_threads = num_max_threads;
  74 
  75   _threads = NEW_C_HEAP_ARRAY(G1ConcurrentRefineThread*, num_max_threads, mtGC);




  76 
  77   for (uint i = 0; i < num_max_threads; i++) {
  78     if (UseDynamicNumberOfGCThreads && i != 0 /* Always start first thread. */) {
  79       _threads[i] = NULL;
  80     } else {
  81       _threads[i] = create_refinement_thread(i, true);
  82       if (_threads[i] == NULL) {
  83         vm_shutdown_during_initialization("Could not allocate refinement threads.");
  84         return JNI_ENOMEM;
  85       }
  86     }
  87   }
  88 
  89   if (num_max_threads > 0) {
  90     G1BarrierSet::dirty_card_queue_set().set_primary_refinement_thread(_threads[0]);
  91   }
  92 
  93   return JNI_OK;
  94 }
  95 


 282   return MIN2(yellow + size, max_red_zone);
 283 }
 284 
 285 G1ConcurrentRefine* G1ConcurrentRefine::create(jint* ecode) {
 286   size_t min_yellow_zone_size = calc_min_yellow_zone_size();
 287   size_t green_zone = calc_init_green_zone();
 288   size_t yellow_zone = calc_init_yellow_zone(green_zone, min_yellow_zone_size);
 289   size_t red_zone = calc_init_red_zone(green_zone, yellow_zone);
 290 
 291   LOG_ZONES("Initial Refinement Zones: "
 292             "green: " SIZE_FORMAT ", "
 293             "yellow: " SIZE_FORMAT ", "
 294             "red: " SIZE_FORMAT ", "
 295             "min yellow size: " SIZE_FORMAT,
 296             green_zone, yellow_zone, red_zone, min_yellow_zone_size);
 297 
 298   G1ConcurrentRefine* cr = new G1ConcurrentRefine(green_zone,
 299                                                   yellow_zone,
 300                                                   red_zone,
 301                                                   min_yellow_zone_size);







 302   *ecode = cr->initialize();
 303   return cr;
 304 }
 305 
 306 void G1ConcurrentRefine::stop() {
 307   _thread_control.stop();
 308 }
 309 
 310 G1ConcurrentRefine::~G1ConcurrentRefine() {
 311 }
 312 
 313 void G1ConcurrentRefine::threads_do(ThreadClosure *tc) {
 314   _thread_control.worker_threads_do(tc);
 315 }
 316 
 317 uint G1ConcurrentRefine::max_num_threads() {
 318   return G1ConcRefinementThreads;
 319 }
 320 
 321 void G1ConcurrentRefine::print_threads_on(outputStream* st) const {


< prev index next >