Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.cpp @ 6197:d2a62e0f25eb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6995781: Native Memory Tracking (Phase 1) 7151532: DCmd for hotspot native memory tracking Summary: Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd Reviewed-by: acorn, coleenp, fparain
author zgu
date Thu, 28 Jun 2012 17:03:16 -0400
parents 6d7d0790074d
children b9a9ed0f8eeb
comparison
equal deleted inserted replaced
6174:74533f63b116 6197:d2a62e0f25eb
114 } 114 }
115 return result; 115 return result;
116 } 116 }
117 117
118 GCTaskQueue* GCTaskQueue::create_on_c_heap() { 118 GCTaskQueue* GCTaskQueue::create_on_c_heap() {
119 GCTaskQueue* result = new(ResourceObj::C_HEAP) GCTaskQueue(true); 119 GCTaskQueue* result = new(ResourceObj::C_HEAP, mtGC) GCTaskQueue(true);
120 if (TraceGCTaskQueue) { 120 if (TraceGCTaskQueue) {
121 tty->print_cr("GCTaskQueue::create_on_c_heap()" 121 tty->print_cr("GCTaskQueue::create_on_c_heap()"
122 " returns " INTPTR_FORMAT, 122 " returns " INTPTR_FORMAT,
123 result); 123 result);
124 } 124 }
401 // The queue for the GCTaskManager must be a CHeapObj. 401 // The queue for the GCTaskManager must be a CHeapObj.
402 GCTaskQueue* unsynchronized_queue = GCTaskQueue::create_on_c_heap(); 402 GCTaskQueue* unsynchronized_queue = GCTaskQueue::create_on_c_heap();
403 _queue = SynchronizedGCTaskQueue::create(unsynchronized_queue, lock()); 403 _queue = SynchronizedGCTaskQueue::create(unsynchronized_queue, lock());
404 _noop_task = NoopGCTask::create_on_c_heap(); 404 _noop_task = NoopGCTask::create_on_c_heap();
405 _idle_inactive_task = WaitForBarrierGCTask::create_on_c_heap(); 405 _idle_inactive_task = WaitForBarrierGCTask::create_on_c_heap();
406 _resource_flag = NEW_C_HEAP_ARRAY(bool, workers()); 406 _resource_flag = NEW_C_HEAP_ARRAY(bool, workers(), mtGC);
407 { 407 {
408 // Set up worker threads. 408 // Set up worker threads.
409 // Distribute the workers among the available processors, 409 // Distribute the workers among the available processors,
410 // unless we were told not to, or if the os doesn't want to. 410 // unless we were told not to, or if the os doesn't want to.
411 uint* processor_assignment = NEW_C_HEAP_ARRAY(uint, workers()); 411 uint* processor_assignment = NEW_C_HEAP_ARRAY(uint, workers(), mtGC);
412 if (!BindGCTaskThreadsToCPUs || 412 if (!BindGCTaskThreadsToCPUs ||
413 !os::distribute_processes(workers(), processor_assignment)) { 413 !os::distribute_processes(workers(), processor_assignment)) {
414 for (uint a = 0; a < workers(); a += 1) { 414 for (uint a = 0; a < workers(); a += 1) {
415 processor_assignment[a] = sentinel_worker(); 415 processor_assignment[a] = sentinel_worker();
416 } 416 }
417 } 417 }
418 _thread = NEW_C_HEAP_ARRAY(GCTaskThread*, workers()); 418 _thread = NEW_C_HEAP_ARRAY(GCTaskThread*, workers(), mtGC);
419 for (uint t = 0; t < workers(); t += 1) { 419 for (uint t = 0; t < workers(); t += 1) {
420 set_thread(t, GCTaskThread::create(this, t, processor_assignment[t])); 420 set_thread(t, GCTaskThread::create(this, t, processor_assignment[t]));
421 } 421 }
422 if (TraceGCTaskThread) { 422 if (TraceGCTaskThread) {
423 tty->print("GCTaskManager::initialize: distribution:"); 423 tty->print("GCTaskManager::initialize: distribution:");
424 for (uint t = 0; t < workers(); t += 1) { 424 for (uint t = 0; t < workers(); t += 1) {
425 tty->print(" %u", processor_assignment[t]); 425 tty->print(" %u", processor_assignment[t]);
426 } 426 }
427 tty->cr(); 427 tty->cr();
428 } 428 }
429 FREE_C_HEAP_ARRAY(uint, processor_assignment); 429 FREE_C_HEAP_ARRAY(uint, processor_assignment, mtGC);
430 } 430 }
431 reset_busy_workers(); 431 reset_busy_workers();
432 set_unblocked(); 432 set_unblocked();
433 for (uint w = 0; w < workers(); w += 1) { 433 for (uint w = 0; w < workers(); w += 1) {
434 set_resource_flag(w, false); 434 set_resource_flag(w, false);
453 if (_thread != NULL) { 453 if (_thread != NULL) {
454 for (uint i = 0; i < workers(); i += 1) { 454 for (uint i = 0; i < workers(); i += 1) {
455 GCTaskThread::destroy(thread(i)); 455 GCTaskThread::destroy(thread(i));
456 set_thread(i, NULL); 456 set_thread(i, NULL);
457 } 457 }
458 FREE_C_HEAP_ARRAY(GCTaskThread*, _thread); 458 FREE_C_HEAP_ARRAY(GCTaskThread*, _thread, mtGC);
459 _thread = NULL; 459 _thread = NULL;
460 } 460 }
461 if (_resource_flag != NULL) { 461 if (_resource_flag != NULL) {
462 FREE_C_HEAP_ARRAY(bool, _resource_flag); 462 FREE_C_HEAP_ARRAY(bool, _resource_flag, mtGC);
463 _resource_flag = NULL; 463 _resource_flag = NULL;
464 } 464 }
465 if (queue() != NULL) { 465 if (queue() != NULL) {
466 GCTaskQueue* unsynchronized_queue = queue()->unsynchronized_queue(); 466 GCTaskQueue* unsynchronized_queue = queue()->unsynchronized_queue();
467 GCTaskQueue::destroy(unsynchronized_queue); 467 GCTaskQueue::destroy(unsynchronized_queue);
815 NoopGCTask* result = new NoopGCTask(false); 815 NoopGCTask* result = new NoopGCTask(false);
816 return result; 816 return result;
817 } 817 }
818 818
819 NoopGCTask* NoopGCTask::create_on_c_heap() { 819 NoopGCTask* NoopGCTask::create_on_c_heap() {
820 NoopGCTask* result = new(ResourceObj::C_HEAP) NoopGCTask(true); 820 NoopGCTask* result = new(ResourceObj::C_HEAP, mtGC) NoopGCTask(true);
821 return result; 821 return result;
822 } 822 }
823 823
824 void NoopGCTask::destroy(NoopGCTask* that) { 824 void NoopGCTask::destroy(NoopGCTask* that) {
825 if (that != NULL) { 825 if (that != NULL) {
846 "Should only be used with dynamic GC thread"); 846 "Should only be used with dynamic GC thread");
847 return result; 847 return result;
848 } 848 }
849 849
850 IdleGCTask* IdleGCTask::create_on_c_heap() { 850 IdleGCTask* IdleGCTask::create_on_c_heap() {
851 IdleGCTask* result = new(ResourceObj::C_HEAP) IdleGCTask(true); 851 IdleGCTask* result = new(ResourceObj::C_HEAP, mtGC) IdleGCTask(true);
852 assert(UseDynamicNumberOfGCThreads, 852 assert(UseDynamicNumberOfGCThreads,
853 "Should only be used with dynamic GC thread"); 853 "Should only be used with dynamic GC thread");
854 return result; 854 return result;
855 } 855 }
856 856
982 return result; 982 return result;
983 } 983 }
984 984
985 WaitForBarrierGCTask* WaitForBarrierGCTask::create_on_c_heap() { 985 WaitForBarrierGCTask* WaitForBarrierGCTask::create_on_c_heap() {
986 WaitForBarrierGCTask* result = 986 WaitForBarrierGCTask* result =
987 new (ResourceObj::C_HEAP) WaitForBarrierGCTask(true); 987 new (ResourceObj::C_HEAP, mtGC) WaitForBarrierGCTask(true);
988 return result; 988 return result;
989 } 989 }
990 990
991 WaitForBarrierGCTask::WaitForBarrierGCTask(bool on_c_heap) : 991 WaitForBarrierGCTask::WaitForBarrierGCTask(bool on_c_heap) :
992 _is_c_heap_obj(on_c_heap) { 992 _is_c_heap_obj(on_c_heap) {
1112 { 1112 {
1113 MutexLockerEx ml(lock()); 1113 MutexLockerEx ml(lock());
1114 // Lazy initialization. 1114 // Lazy initialization.
1115 if (freelist() == NULL) { 1115 if (freelist() == NULL) {
1116 _freelist = 1116 _freelist =
1117 new(ResourceObj::C_HEAP) GrowableArray<Monitor*>(ParallelGCThreads, 1117 new(ResourceObj::C_HEAP, mtGC) GrowableArray<Monitor*>(ParallelGCThreads,
1118 true); 1118 true);
1119 } 1119 }
1120 if (! freelist()->is_empty()) { 1120 if (! freelist()->is_empty()) {
1121 result = freelist()->pop(); 1121 result = freelist()->pop();
1122 } else { 1122 } else {