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 {
|