1 /* 2 * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "gc_implementation/parallelScavenge/gcTaskManager.hpp" 27 #include "gc_implementation/parallelScavenge/gcTaskThread.hpp" 28 #include "gc_implementation/shared/adaptiveSizePolicy.hpp" 29 #include "memory/allocation.hpp" 30 #include "memory/allocation.inline.hpp" 31 #include "runtime/mutex.hpp" 32 #include "runtime/mutexLocker.hpp" 33 34 // 35 // GCTask 36 // 37 38 const char* GCTask::Kind::to_string(kind value) { 39 const char* result = "unknown GCTask kind"; 40 switch (value) { 41 default: 42 result = "unknown GCTask kind"; 43 break; 44 case unknown_task: 45 result = "unknown task"; 46 break; 47 case ordinary_task: 48 result = "ordinary task"; 49 break; 50 case barrier_task: 51 result = "barrier task"; 52 break; 53 case noop_task: 54 result = "noop task"; 55 break; 56 case idle_task: 57 result = "idle task"; 58 break; 59 } 60 return result; 61 }; 62 63 GCTask::GCTask() : 64 _kind(Kind::ordinary_task), 65 _affinity(GCTaskManager::sentinel_worker()){ 66 initialize(); 67 } 68 69 GCTask::GCTask(Kind::kind kind) : 70 _kind(kind), 71 _affinity(GCTaskManager::sentinel_worker()) { 72 initialize(); 73 } 74 75 GCTask::GCTask(uint affinity) : 76 _kind(Kind::ordinary_task), 77 _affinity(affinity) { 78 initialize(); 79 } 80 81 GCTask::GCTask(Kind::kind kind, uint affinity) : 82 _kind(kind), 83 _affinity(affinity) { 84 initialize(); 85 } 86 87 void GCTask::initialize() { 88 _older = NULL; 89 _newer = NULL; 90 } 91 92 void GCTask::destruct() { 93 assert(older() == NULL, "shouldn't have an older task"); 94 assert(newer() == NULL, "shouldn't have a newer task"); 95 // Nothing to do. 96 } 97 98 NOT_PRODUCT( 99 void GCTask::print(const char* message) const { 100 tty->print(INTPTR_FORMAT " <- " INTPTR_FORMAT "(%u) -> " INTPTR_FORMAT, 101 newer(), this, affinity(), older()); 102 } 103 ) 104 105 // 106 // GCTaskQueue 107 // 108 109 GCTaskQueue* GCTaskQueue::create() { 110 GCTaskQueue* result = new GCTaskQueue(false); 111 if (TraceGCTaskQueue) { 112 tty->print_cr("GCTaskQueue::create()" 113 " returns " INTPTR_FORMAT, result); 114 } 115 return result; 116 } 117 118 GCTaskQueue* GCTaskQueue::create_on_c_heap() { 119 GCTaskQueue* result = new(ResourceObj::C_HEAP, mtGC) GCTaskQueue(true); 120 if (TraceGCTaskQueue) { 121 tty->print_cr("GCTaskQueue::create_on_c_heap()" 122 " returns " INTPTR_FORMAT, 123 result); 124 } 125 return result; 126 } 127 128 GCTaskQueue::GCTaskQueue(bool on_c_heap) : 129 _is_c_heap_obj(on_c_heap) { 130 initialize(); 131 if (TraceGCTaskQueue) { 132 tty->print_cr("[" INTPTR_FORMAT "]" 133 " GCTaskQueue::GCTaskQueue() constructor", 134 this); 135 } 136 } 137 138 void GCTaskQueue::destruct() { 139 // Nothing to do. 140 } 141 142 void GCTaskQueue::destroy(GCTaskQueue* that) { 143 if (TraceGCTaskQueue) { 144 tty->print_cr("[" INTPTR_FORMAT "]" 145 " GCTaskQueue::destroy()" 146 " is_c_heap_obj: %s", 147 that, 148 that->is_c_heap_obj() ? "true" : "false"); 149 } 150 // That instance may have been allocated as a CHeapObj, 151 // in which case we have to free it explicitly. 152 if (that != NULL) { 153 that->destruct(); 154 assert(that->is_empty(), "should be empty"); 155 if (that->is_c_heap_obj()) { 156 FreeHeap(that); 157 } 158 } 159 } 160 161 void GCTaskQueue::initialize() { 162 set_insert_end(NULL); 163 set_remove_end(NULL); 164 set_length(0); 165 } 166 167 // Enqueue one task. 168 void GCTaskQueue::enqueue(GCTask* task) { 169 if (TraceGCTaskQueue) { 170 tty->print_cr("[" INTPTR_FORMAT "]" 171 " GCTaskQueue::enqueue(task: " 172 INTPTR_FORMAT ")", 173 this, task); 174 print("before:"); 175 } 176 assert(task != NULL, "shouldn't have null task"); 177 assert(task->older() == NULL, "shouldn't be on queue"); 178 assert(task->newer() == NULL, "shouldn't be on queue"); 179 task->set_newer(NULL); 180 task->set_older(insert_end()); 181 if (is_empty()) { 182 set_remove_end(task); 183 } else { 184 insert_end()->set_newer(task); 185 } 186 set_insert_end(task); 187 increment_length(); 188 verify_length(); 189 if (TraceGCTaskQueue) { 190 print("after:"); 191 } 192 } 193 194 // Enqueue a whole list of tasks. Empties the argument list. 195 void GCTaskQueue::enqueue(GCTaskQueue* list) { 196 if (TraceGCTaskQueue) { 197 tty->print_cr("[" INTPTR_FORMAT "]" 198 " GCTaskQueue::enqueue(list: " 199 INTPTR_FORMAT ")", 200 this, list); 201 print("before:"); 202 list->print("list:"); 203 } 204 if (list->is_empty()) { 205 // Enqueueing the empty list: nothing to do. 206 return; 207 } 208 uint list_length = list->length(); 209 if (is_empty()) { 210 // Enqueueing to empty list: just acquire elements. 211 set_insert_end(list->insert_end()); 212 set_remove_end(list->remove_end()); 213 set_length(list_length); 214 } else { 215 // Prepend argument list to our queue. 216 list->remove_end()->set_older(insert_end()); 217 insert_end()->set_newer(list->remove_end()); 218 set_insert_end(list->insert_end()); 219 set_length(length() + list_length); 220 // empty the argument list. 221 } 222 list->initialize(); 223 if (TraceGCTaskQueue) { 224 print("after:"); 225 list->print("list:"); 226 } 227 verify_length(); 228 } 229 230 // Dequeue one task. 231 GCTask* GCTaskQueue::dequeue() { 232 if (TraceGCTaskQueue) { 233 tty->print_cr("[" INTPTR_FORMAT "]" 234 " GCTaskQueue::dequeue()", this); 235 print("before:"); 236 } 237 assert(!is_empty(), "shouldn't dequeue from empty list"); 238 GCTask* result = remove(); 239 assert(result != NULL, "shouldn't have NULL task"); 240 if (TraceGCTaskQueue) { 241 tty->print_cr(" return: " INTPTR_FORMAT, result); 242 print("after:"); 243 } 244 return result; 245 } 246 247 // Dequeue one task, preferring one with affinity. 248 GCTask* GCTaskQueue::dequeue(uint affinity) { 249 if (TraceGCTaskQueue) { 250 tty->print_cr("[" INTPTR_FORMAT "]" 251 " GCTaskQueue::dequeue(%u)", this, affinity); 252 print("before:"); 253 } 254 assert(!is_empty(), "shouldn't dequeue from empty list"); 255 // Look down to the next barrier for a task with this affinity. 256 GCTask* result = NULL; 257 for (GCTask* element = remove_end(); 258 element != NULL; 259 element = element->newer()) { 260 if (element->is_barrier_task()) { 261 // Don't consider barrier tasks, nor past them. 262 result = NULL; 263 break; 264 } 265 if (element->affinity() == affinity) { 266 result = remove(element); 267 break; 268 } 269 } 270 // If we didn't find anything with affinity, just take the next task. 271 if (result == NULL) { 272 result = remove(); 273 } 274 if (TraceGCTaskQueue) { 275 tty->print_cr(" return: " INTPTR_FORMAT, result); 276 print("after:"); 277 } 278 return result; 279 } 280 281 GCTask* GCTaskQueue::remove() { 282 // Dequeue from remove end. 283 GCTask* result = remove_end(); 284 assert(result != NULL, "shouldn't have null task"); 285 assert(result->older() == NULL, "not the remove_end"); 286 set_remove_end(result->newer()); 287 if (remove_end() == NULL) { 288 assert(insert_end() == result, "not a singleton"); 289 set_insert_end(NULL); 290 } else { 291 remove_end()->set_older(NULL); 292 } 293 result->set_newer(NULL); 294 decrement_length(); 295 assert(result->newer() == NULL, "shouldn't be on queue"); 296 assert(result->older() == NULL, "shouldn't be on queue"); 297 verify_length(); 298 return result; 299 } 300 301 GCTask* GCTaskQueue::remove(GCTask* task) { 302 // This is slightly more work, and has slightly fewer asserts 303 // than removing from the remove end. 304 assert(task != NULL, "shouldn't have null task"); 305 GCTask* result = task; 306 if (result->newer() != NULL) { 307 result->newer()->set_older(result->older()); 308 } else { 309 assert(insert_end() == result, "not youngest"); 310 set_insert_end(result->older()); 311 } 312 if (result->older() != NULL) { 313 result->older()->set_newer(result->newer()); 314 } else { 315 assert(remove_end() == result, "not oldest"); 316 set_remove_end(result->newer()); 317 } 318 result->set_newer(NULL); 319 result->set_older(NULL); 320 decrement_length(); 321 verify_length(); 322 return result; 323 } 324 325 NOT_PRODUCT( 326 // Count the elements in the queue and verify the length against 327 // that count. 328 void GCTaskQueue::verify_length() const { 329 uint count = 0; 330 for (GCTask* element = insert_end(); 331 element != NULL; 332 element = element->older()) { 333 334 count++; 335 } 336 assert(count == length(), "Length does not match queue"); 337 } 338 339 void GCTaskQueue::print(const char* message) const { 340 tty->print_cr("[" INTPTR_FORMAT "] GCTaskQueue:" 341 " insert_end: " INTPTR_FORMAT 342 " remove_end: " INTPTR_FORMAT 343 " length: %d" 344 " %s", 345 this, insert_end(), remove_end(), length(), message); 346 uint count = 0; 347 for (GCTask* element = insert_end(); 348 element != NULL; 349 element = element->older()) { 350 element->print(" "); 351 count++; 352 tty->cr(); 353 } 354 tty->print("Total tasks: %d", count); 355 } 356 ) 357 358 // 359 // SynchronizedGCTaskQueue 360 // 361 362 SynchronizedGCTaskQueue::SynchronizedGCTaskQueue(GCTaskQueue* queue_arg, 363 Monitor * lock_arg) : 364 _unsynchronized_queue(queue_arg), 365 _lock(lock_arg) { 366 assert(unsynchronized_queue() != NULL, "null queue"); 367 assert(lock() != NULL, "null lock"); 368 } 369 370 SynchronizedGCTaskQueue::~SynchronizedGCTaskQueue() { 371 // Nothing to do. 372 } 373 374 // 375 // GCTaskManager 376 // 377 GCTaskManager::GCTaskManager(uint workers) : 378 _workers(workers), 379 _active_workers(0), 380 _idle_workers(0), 381 _ndc(NULL) { 382 initialize(); 383 } 384 385 GCTaskManager::GCTaskManager(uint workers, NotifyDoneClosure* ndc) : 386 _workers(workers), 387 _active_workers(0), 388 _idle_workers(0), 389 _ndc(ndc) { 390 initialize(); 391 } 392 393 void GCTaskManager::initialize() { 394 if (TraceGCTaskManager) { 395 tty->print_cr("GCTaskManager::initialize: workers: %u", workers()); 396 } 397 assert(workers() != 0, "no workers"); 398 _monitor = new Monitor(Mutex::barrier, // rank 399 "GCTaskManager monitor", // name 400 Mutex::_allow_vm_block_flag); // allow_vm_block 401 // The queue for the GCTaskManager must be a CHeapObj. 402 GCTaskQueue* unsynchronized_queue = GCTaskQueue::create_on_c_heap(); 403 _queue = SynchronizedGCTaskQueue::create(unsynchronized_queue, lock()); 404 _noop_task = NoopGCTask::create_on_c_heap(); 405 _idle_inactive_task = WaitForBarrierGCTask::create_on_c_heap(); 406 _resource_flag = NEW_C_HEAP_ARRAY(bool, workers(), mtGC); 407 { 408 // Set up worker threads. 409 // Distribute the workers among the available processors, 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(), mtGC); 412 if (!BindGCTaskThreadsToCPUs || 413 !os::distribute_processes(workers(), processor_assignment)) { 414 for (uint a = 0; a < workers(); a += 1) { 415 processor_assignment[a] = sentinel_worker(); 416 } 417 } 418 _thread = NEW_C_HEAP_ARRAY(GCTaskThread*, workers(), mtGC); 419 for (uint t = 0; t < workers(); t += 1) { 420 set_thread(t, GCTaskThread::create(this, t, processor_assignment[t])); 421 } 422 if (TraceGCTaskThread) { 423 tty->print("GCTaskManager::initialize: distribution:"); 424 for (uint t = 0; t < workers(); t += 1) { 425 tty->print(" %u", processor_assignment[t]); 426 } 427 tty->cr(); 428 } 429 FREE_C_HEAP_ARRAY(uint, processor_assignment, mtGC); 430 } 431 reset_busy_workers(); 432 set_unblocked(); 433 for (uint w = 0; w < workers(); w += 1) { 434 set_resource_flag(w, false); 435 } 436 reset_delivered_tasks(); 437 reset_completed_tasks(); 438 reset_noop_tasks(); 439 reset_barriers(); 440 reset_emptied_queue(); 441 for (uint s = 0; s < workers(); s += 1) { 442 thread(s)->start(); 443 } 444 } 445 446 GCTaskManager::~GCTaskManager() { 447 assert(busy_workers() == 0, "still have busy workers"); 448 assert(queue()->is_empty(), "still have queued work"); 449 NoopGCTask::destroy(_noop_task); 450 _noop_task = NULL; 451 WaitForBarrierGCTask::destroy(_idle_inactive_task); 452 _idle_inactive_task = NULL; 453 if (_thread != NULL) { 454 for (uint i = 0; i < workers(); i += 1) { 455 GCTaskThread::destroy(thread(i)); 456 set_thread(i, NULL); 457 } 458 FREE_C_HEAP_ARRAY(GCTaskThread*, _thread, mtGC); 459 _thread = NULL; 460 } 461 if (_resource_flag != NULL) { 462 FREE_C_HEAP_ARRAY(bool, _resource_flag, mtGC); 463 _resource_flag = NULL; 464 } 465 if (queue() != NULL) { 466 GCTaskQueue* unsynchronized_queue = queue()->unsynchronized_queue(); 467 GCTaskQueue::destroy(unsynchronized_queue); 468 SynchronizedGCTaskQueue::destroy(queue()); 469 _queue = NULL; 470 } 471 if (monitor() != NULL) { 472 delete monitor(); 473 _monitor = NULL; 474 } 475 } 476 477 void GCTaskManager::set_active_gang() { 478 _active_workers = 479 AdaptiveSizePolicy::calc_active_workers(workers(), 480 active_workers(), 481 Threads::number_of_non_daemon_threads()); 482 483 assert(!all_workers_active() || active_workers() == ParallelGCThreads, 484 err_msg("all_workers_active() is incorrect: " 485 "active %d ParallelGCThreads %d", active_workers(), 486 ParallelGCThreads)); 487 if (TraceDynamicGCThreads) { 488 gclog_or_tty->print_cr("GCTaskManager::set_active_gang(): " 489 "all_workers_active() %d workers %d " 490 "active %d ParallelGCThreads %d ", 491 all_workers_active(), workers(), active_workers(), 492 ParallelGCThreads); 493 } 494 } 495 496 // Create IdleGCTasks for inactive workers. 497 // Creates tasks in a ResourceArea and assumes 498 // an appropriate ResourceMark. 499 void GCTaskManager::task_idle_workers() { 500 { 501 int more_inactive_workers = 0; 502 { 503 // Stop any idle tasks from exiting their IdleGCTask's 504 // and get the count for additional IdleGCTask's under 505 // the GCTaskManager's monitor so that the "more_inactive_workers" 506 // count is correct. 507 MutexLockerEx ml(monitor(), Mutex::_no_safepoint_check_flag); 508 _idle_inactive_task->set_should_wait(true); 509 // active_workers are a number being requested. idle_workers 510 // are the number currently idle. If all the workers are being 511 // requested to be active but some are already idle, reduce 512 // the number of active_workers to be consistent with the 513 // number of idle_workers. The idle_workers are stuck in 514 // idle tasks and will no longer be release (since a new GC 515 // is starting). Try later to release enough idle_workers 516 // to allow the desired number of active_workers. 517 more_inactive_workers = 518 workers() - active_workers() - idle_workers(); 519 if (more_inactive_workers < 0) { 520 int reduced_active_workers = active_workers() + more_inactive_workers; 521 set_active_workers(reduced_active_workers); 522 more_inactive_workers = 0; 523 } 524 if (TraceDynamicGCThreads) { 525 gclog_or_tty->print_cr("JT: %d workers %d active %d " 526 "idle %d more %d", 527 Threads::number_of_non_daemon_threads(), 528 workers(), 529 active_workers(), 530 idle_workers(), 531 more_inactive_workers); 532 } 533 } 534 GCTaskQueue* q = GCTaskQueue::create(); 535 for(uint i = 0; i < (uint) more_inactive_workers; i++) { 536 q->enqueue(IdleGCTask::create_on_c_heap()); 537 increment_idle_workers(); 538 } 539 assert(workers() == active_workers() + idle_workers(), 540 "total workers should equal active + inactive"); 541 add_list(q); 542 // GCTaskQueue* q was created in a ResourceArea so a 543 // destroy() call is not needed. 544 } 545 } 546 547 void GCTaskManager::release_idle_workers() { 548 { 549 MutexLockerEx ml(monitor(), 550 Mutex::_no_safepoint_check_flag); 551 _idle_inactive_task->set_should_wait(false); 552 monitor()->notify_all(); 553 // Release monitor 554 } 555 } 556 557 void GCTaskManager::print_task_time_stamps() { 558 for(uint i=0; i<ParallelGCThreads; i++) { 559 GCTaskThread* t = thread(i); 560 t->print_task_time_stamps(); 561 } 562 } 563 564 void GCTaskManager::print_threads_on(outputStream* st) { 565 uint num_thr = workers(); 566 for (uint i = 0; i < num_thr; i++) { 567 thread(i)->print_on(st); 568 st->cr(); 569 } 570 } 571 572 void GCTaskManager::threads_do(ThreadClosure* tc) { 573 assert(tc != NULL, "Null ThreadClosure"); 574 uint num_thr = workers(); 575 for (uint i = 0; i < num_thr; i++) { 576 tc->do_thread(thread(i)); 577 } 578 } 579 580 GCTaskThread* GCTaskManager::thread(uint which) { 581 assert(which < workers(), "index out of bounds"); 582 assert(_thread[which] != NULL, "shouldn't have null thread"); 583 return _thread[which]; 584 } 585 586 void GCTaskManager::set_thread(uint which, GCTaskThread* value) { 587 assert(which < workers(), "index out of bounds"); 588 assert(value != NULL, "shouldn't have null thread"); 589 _thread[which] = value; 590 } 591 592 void GCTaskManager::add_task(GCTask* task) { 593 assert(task != NULL, "shouldn't have null task"); 594 MutexLockerEx ml(monitor(), Mutex::_no_safepoint_check_flag); 595 if (TraceGCTaskManager) { 596 tty->print_cr("GCTaskManager::add_task(" INTPTR_FORMAT " [%s])", 597 task, GCTask::Kind::to_string(task->kind())); 598 } 599 queue()->enqueue(task); 600 // Notify with the lock held to avoid missed notifies. 601 if (TraceGCTaskManager) { 602 tty->print_cr(" GCTaskManager::add_task (%s)->notify_all", 603 monitor()->name()); 604 } 605 (void) monitor()->notify_all(); 606 // Release monitor(). 607 } 608 609 void GCTaskManager::add_list(GCTaskQueue* list) { 610 assert(list != NULL, "shouldn't have null task"); 611 MutexLockerEx ml(monitor(), Mutex::_no_safepoint_check_flag); 612 if (TraceGCTaskManager) { 613 tty->print_cr("GCTaskManager::add_list(%u)", list->length()); 614 } 615 queue()->enqueue(list); 616 // Notify with the lock held to avoid missed notifies. 617 if (TraceGCTaskManager) { 618 tty->print_cr(" GCTaskManager::add_list (%s)->notify_all", 619 monitor()->name()); 620 } 621 (void) monitor()->notify_all(); 622 // Release monitor(). 623 } 624 625 // GC workers wait in get_task() for new work to be added 626 // to the GCTaskManager's queue. When new work is added, 627 // a notify is sent to the waiting GC workers which then 628 // compete to get tasks. If a GC worker wakes up and there 629 // is no work on the queue, it is given a noop_task to execute 630 // and then loops to find more work. 631 632 GCTask* GCTaskManager::get_task(uint which) { 633 GCTask* result = NULL; 634 // Grab the queue lock. 635 MutexLockerEx ml(monitor(), Mutex::_no_safepoint_check_flag); 636 // Wait while the queue is block or 637 // there is nothing to do, except maybe release resources. 638 while (is_blocked() || 639 (queue()->is_empty() && !should_release_resources(which))) { 640 if (TraceGCTaskManager) { 641 tty->print_cr("GCTaskManager::get_task(%u)" 642 " blocked: %s" 643 " empty: %s" 644 " release: %s", 645 which, 646 is_blocked() ? "true" : "false", 647 queue()->is_empty() ? "true" : "false", 648 should_release_resources(which) ? "true" : "false"); 649 tty->print_cr(" => (%s)->wait()", 650 monitor()->name()); 651 } 652 monitor()->wait(Mutex::_no_safepoint_check_flag, 0); 653 } 654 // We've reacquired the queue lock here. 655 // Figure out which condition caused us to exit the loop above. 656 if (!queue()->is_empty()) { 657 if (UseGCTaskAffinity) { 658 result = queue()->dequeue(which); 659 } else { 660 result = queue()->dequeue(); 661 } 662 if (result->is_barrier_task()) { 663 assert(which != sentinel_worker(), 664 "blocker shouldn't be bogus"); 665 set_blocking_worker(which); 666 } 667 } else { 668 // The queue is empty, but we were woken up. 669 // Just hand back a Noop task, 670 // in case someone wanted us to release resources, or whatever. 671 result = noop_task(); 672 increment_noop_tasks(); 673 } 674 assert(result != NULL, "shouldn't have null task"); 675 if (TraceGCTaskManager) { 676 tty->print_cr("GCTaskManager::get_task(%u) => " INTPTR_FORMAT " [%s]", 677 which, result, GCTask::Kind::to_string(result->kind())); 678 tty->print_cr(" %s", result->name()); 679 } 680 if (!result->is_idle_task()) { 681 increment_busy_workers(); 682 increment_delivered_tasks(); 683 } 684 return result; 685 // Release monitor(). 686 } 687 688 void GCTaskManager::note_completion(uint which) { 689 MutexLockerEx ml(monitor(), Mutex::_no_safepoint_check_flag); 690 if (TraceGCTaskManager) { 691 tty->print_cr("GCTaskManager::note_completion(%u)", which); 692 } 693 // If we are blocked, check if the completing thread is the blocker. 694 if (blocking_worker() == which) { 695 assert(blocking_worker() != sentinel_worker(), 696 "blocker shouldn't be bogus"); 697 increment_barriers(); 698 set_unblocked(); 699 } 700 increment_completed_tasks(); 701 uint active = decrement_busy_workers(); 702 if ((active == 0) && (queue()->is_empty())) { 703 increment_emptied_queue(); 704 if (TraceGCTaskManager) { 705 tty->print_cr(" GCTaskManager::note_completion(%u) done", which); 706 } 707 // Notify client that we are done. 708 NotifyDoneClosure* ndc = notify_done_closure(); 709 if (ndc != NULL) { 710 ndc->notify(this); 711 } 712 } 713 if (TraceGCTaskManager) { 714 tty->print_cr(" GCTaskManager::note_completion(%u) (%s)->notify_all", 715 which, monitor()->name()); 716 tty->print_cr(" " 717 " blocked: %s" 718 " empty: %s" 719 " release: %s", 720 is_blocked() ? "true" : "false", 721 queue()->is_empty() ? "true" : "false", 722 should_release_resources(which) ? "true" : "false"); 723 tty->print_cr(" " 724 " delivered: %u" 725 " completed: %u" 726 " barriers: %u" 727 " emptied: %u", 728 delivered_tasks(), 729 completed_tasks(), 730 barriers(), 731 emptied_queue()); 732 } 733 // Tell everyone that a task has completed. 734 (void) monitor()->notify_all(); 735 // Release monitor(). 736 } 737 738 uint GCTaskManager::increment_busy_workers() { 739 assert(queue()->own_lock(), "don't own the lock"); 740 _busy_workers += 1; 741 return _busy_workers; 742 } 743 744 uint GCTaskManager::decrement_busy_workers() { 745 assert(queue()->own_lock(), "don't own the lock"); 746 assert(_busy_workers > 0, "About to make a mistake"); 747 _busy_workers -= 1; 748 return _busy_workers; 749 } 750 751 void GCTaskManager::release_all_resources() { 752 // If you want this to be done atomically, do it in a BarrierGCTask. 753 for (uint i = 0; i < workers(); i += 1) { 754 set_resource_flag(i, true); 755 } 756 } 757 758 bool GCTaskManager::should_release_resources(uint which) { 759 // This can be done without a lock because each thread reads one element. 760 return resource_flag(which); 761 } 762 763 void GCTaskManager::note_release(uint which) { 764 // This can be done without a lock because each thread writes one element. 765 set_resource_flag(which, false); 766 } 767 768 // "list" contains tasks that are ready to execute. Those 769 // tasks are added to the GCTaskManager's queue of tasks and 770 // then the GC workers are notified that there is new work to 771 // do. 772 // 773 // Typically different types of tasks can be added to the "list". 774 // For example in PSScavenge OldToYoungRootsTask, SerialOldToYoungRootsTask, 775 // ScavengeRootsTask, and StealTask tasks are all added to the list 776 // and then the GC workers are notified of new work. The tasks are 777 // handed out in the order in which they are added to the list 778 // (although execution is not necessarily in that order). As long 779 // as any tasks are running the GCTaskManager will wait for execution 780 // to complete. GC workers that execute a stealing task remain in 781 // the stealing task until all stealing tasks have completed. The load 782 // balancing afforded by the stealing tasks work best if the stealing 783 // tasks are added last to the list. 784 785 void GCTaskManager::execute_and_wait(GCTaskQueue* list) { 786 WaitForBarrierGCTask* fin = WaitForBarrierGCTask::create(); 787 list->enqueue(fin); 788 // The barrier task will be read by one of the GC 789 // workers once it is added to the list of tasks. 790 // Be sure that is globally visible before the 791 // GC worker reads it (which is after the task is added 792 // to the list of tasks below). 793 OrderAccess::storestore(); 794 add_list(list); 795 fin->wait_for(true /* reset */); 796 // We have to release the barrier tasks! 797 WaitForBarrierGCTask::destroy(fin); 798 } 799 800 bool GCTaskManager::resource_flag(uint which) { 801 assert(which < workers(), "index out of bounds"); 802 return _resource_flag[which]; 803 } 804 805 void GCTaskManager::set_resource_flag(uint which, bool value) { 806 assert(which < workers(), "index out of bounds"); 807 _resource_flag[which] = value; 808 } 809 810 // 811 // NoopGCTask 812 // 813 814 NoopGCTask* NoopGCTask::create() { 815 NoopGCTask* result = new NoopGCTask(false); 816 return result; 817 } 818 819 NoopGCTask* NoopGCTask::create_on_c_heap() { 820 NoopGCTask* result = new(ResourceObj::C_HEAP, mtGC) NoopGCTask(true); 821 return result; 822 } 823 824 void NoopGCTask::destroy(NoopGCTask* that) { 825 if (that != NULL) { 826 that->destruct(); 827 if (that->is_c_heap_obj()) { 828 FreeHeap(that); 829 } 830 } 831 } 832 833 void NoopGCTask::destruct() { 834 // This has to know it's superclass structure, just like the constructor. 835 this->GCTask::destruct(); 836 // Nothing else to do. 837 } 838 839 // 840 // IdleGCTask 841 // 842 843 IdleGCTask* IdleGCTask::create() { 844 IdleGCTask* result = new IdleGCTask(false); 845 assert(UseDynamicNumberOfGCThreads, 846 "Should only be used with dynamic GC thread"); 847 return result; 848 } 849 850 IdleGCTask* IdleGCTask::create_on_c_heap() { 851 IdleGCTask* result = new(ResourceObj::C_HEAP, mtGC) IdleGCTask(true); 852 assert(UseDynamicNumberOfGCThreads, 853 "Should only be used with dynamic GC thread"); 854 return result; 855 } 856 857 void IdleGCTask::do_it(GCTaskManager* manager, uint which) { 858 WaitForBarrierGCTask* wait_for_task = manager->idle_inactive_task(); 859 if (TraceGCTaskManager) { 860 tty->print_cr("[" INTPTR_FORMAT "]" 861 " IdleGCTask:::do_it()" 862 " should_wait: %s", 863 this, wait_for_task->should_wait() ? "true" : "false"); 864 } 865 MutexLockerEx ml(manager->monitor(), Mutex::_no_safepoint_check_flag); 866 if (TraceDynamicGCThreads) { 867 gclog_or_tty->print_cr("--- idle %d", which); 868 } 869 // Increment has to be done when the idle tasks are created. 870 // manager->increment_idle_workers(); 871 manager->monitor()->notify_all(); 872 while (wait_for_task->should_wait()) { 873 if (TraceGCTaskManager) { 874 tty->print_cr("[" INTPTR_FORMAT "]" 875 " IdleGCTask::do_it()" 876 " [" INTPTR_FORMAT "] (%s)->wait()", 877 this, manager->monitor(), manager->monitor()->name()); 878 } 879 manager->monitor()->wait(Mutex::_no_safepoint_check_flag, 0); 880 } 881 manager->decrement_idle_workers(); 882 if (TraceDynamicGCThreads) { 883 gclog_or_tty->print_cr("--- release %d", which); 884 } 885 if (TraceGCTaskManager) { 886 tty->print_cr("[" INTPTR_FORMAT "]" 887 " IdleGCTask::do_it() returns" 888 " should_wait: %s", 889 this, wait_for_task->should_wait() ? "true" : "false"); 890 } 891 // Release monitor(). 892 } 893 894 void IdleGCTask::destroy(IdleGCTask* that) { 895 if (that != NULL) { 896 that->destruct(); 897 if (that->is_c_heap_obj()) { 898 FreeHeap(that); 899 } 900 } 901 } 902 903 void IdleGCTask::destruct() { 904 // This has to know it's superclass structure, just like the constructor. 905 this->GCTask::destruct(); 906 // Nothing else to do. 907 } 908 909 // 910 // BarrierGCTask 911 // 912 913 void BarrierGCTask::do_it(GCTaskManager* manager, uint which) { 914 // Wait for this to be the only busy worker. 915 // ??? I thought of having a StackObj class 916 // whose constructor would grab the lock and come to the barrier, 917 // and whose destructor would release the lock, 918 // but that seems like too much mechanism for two lines of code. 919 MutexLockerEx ml(manager->lock(), Mutex::_no_safepoint_check_flag); 920 do_it_internal(manager, which); 921 // Release manager->lock(). 922 } 923 924 void BarrierGCTask::do_it_internal(GCTaskManager* manager, uint which) { 925 // Wait for this to be the only busy worker. 926 assert(manager->monitor()->owned_by_self(), "don't own the lock"); 927 assert(manager->is_blocked(), "manager isn't blocked"); 928 while (manager->busy_workers() > 1) { 929 if (TraceGCTaskManager) { 930 tty->print_cr("BarrierGCTask::do_it(%u) waiting on %u workers", 931 which, manager->busy_workers()); 932 } 933 manager->monitor()->wait(Mutex::_no_safepoint_check_flag, 0); 934 } 935 } 936 937 void BarrierGCTask::destruct() { 938 this->GCTask::destruct(); 939 // Nothing else to do. 940 } 941 942 // 943 // ReleasingBarrierGCTask 944 // 945 946 void ReleasingBarrierGCTask::do_it(GCTaskManager* manager, uint which) { 947 MutexLockerEx ml(manager->lock(), Mutex::_no_safepoint_check_flag); 948 do_it_internal(manager, which); 949 manager->release_all_resources(); 950 // Release manager->lock(). 951 } 952 953 void ReleasingBarrierGCTask::destruct() { 954 this->BarrierGCTask::destruct(); 955 // Nothing else to do. 956 } 957 958 // 959 // NotifyingBarrierGCTask 960 // 961 962 void NotifyingBarrierGCTask::do_it(GCTaskManager* manager, uint which) { 963 MutexLockerEx ml(manager->lock(), Mutex::_no_safepoint_check_flag); 964 do_it_internal(manager, which); 965 NotifyDoneClosure* ndc = notify_done_closure(); 966 if (ndc != NULL) { 967 ndc->notify(manager); 968 } 969 // Release manager->lock(). 970 } 971 972 void NotifyingBarrierGCTask::destruct() { 973 this->BarrierGCTask::destruct(); 974 // Nothing else to do. 975 } 976 977 // 978 // WaitForBarrierGCTask 979 // 980 WaitForBarrierGCTask* WaitForBarrierGCTask::create() { 981 WaitForBarrierGCTask* result = new WaitForBarrierGCTask(false); 982 return result; 983 } 984 985 WaitForBarrierGCTask* WaitForBarrierGCTask::create_on_c_heap() { 986 WaitForBarrierGCTask* result = 987 new (ResourceObj::C_HEAP, mtGC) WaitForBarrierGCTask(true); 988 return result; 989 } 990 991 WaitForBarrierGCTask::WaitForBarrierGCTask(bool on_c_heap) : 992 _is_c_heap_obj(on_c_heap) { 993 _monitor = MonitorSupply::reserve(); 994 set_should_wait(true); 995 if (TraceGCTaskManager) { 996 tty->print_cr("[" INTPTR_FORMAT "]" 997 " WaitForBarrierGCTask::WaitForBarrierGCTask()" 998 " monitor: " INTPTR_FORMAT, 999 this, monitor()); 1000 } 1001 } 1002 1003 void WaitForBarrierGCTask::destroy(WaitForBarrierGCTask* that) { 1004 if (that != NULL) { 1005 if (TraceGCTaskManager) { 1006 tty->print_cr("[" INTPTR_FORMAT "]" 1007 " WaitForBarrierGCTask::destroy()" 1008 " is_c_heap_obj: %s" 1009 " monitor: " INTPTR_FORMAT, 1010 that, 1011 that->is_c_heap_obj() ? "true" : "false", 1012 that->monitor()); 1013 } 1014 that->destruct(); 1015 if (that->is_c_heap_obj()) { 1016 FreeHeap(that); 1017 } 1018 } 1019 } 1020 1021 void WaitForBarrierGCTask::destruct() { 1022 assert(monitor() != NULL, "monitor should not be NULL"); 1023 if (TraceGCTaskManager) { 1024 tty->print_cr("[" INTPTR_FORMAT "]" 1025 " WaitForBarrierGCTask::destruct()" 1026 " monitor: " INTPTR_FORMAT, 1027 this, monitor()); 1028 } 1029 this->BarrierGCTask::destruct(); 1030 // Clean up that should be in the destructor, 1031 // except that ResourceMarks don't call destructors. 1032 if (monitor() != NULL) { 1033 MonitorSupply::release(monitor()); 1034 } 1035 _monitor = (Monitor*) 0xDEAD000F; 1036 } 1037 1038 void WaitForBarrierGCTask::do_it(GCTaskManager* manager, uint which) { 1039 if (TraceGCTaskManager) { 1040 tty->print_cr("[" INTPTR_FORMAT "]" 1041 " WaitForBarrierGCTask::do_it() waiting for idle" 1042 " monitor: " INTPTR_FORMAT, 1043 this, monitor()); 1044 } 1045 { 1046 // First, wait for the barrier to arrive. 1047 MutexLockerEx ml(manager->lock(), Mutex::_no_safepoint_check_flag); 1048 do_it_internal(manager, which); 1049 // Release manager->lock(). 1050 } 1051 { 1052 // Then notify the waiter. 1053 MutexLockerEx ml(monitor(), Mutex::_no_safepoint_check_flag); 1054 set_should_wait(false); 1055 // Waiter doesn't miss the notify in the wait_for method 1056 // since it checks the flag after grabbing the monitor. 1057 if (TraceGCTaskManager) { 1058 tty->print_cr("[" INTPTR_FORMAT "]" 1059 " WaitForBarrierGCTask::do_it()" 1060 " [" INTPTR_FORMAT "] (%s)->notify_all()", 1061 this, monitor(), monitor()->name()); 1062 } 1063 monitor()->notify_all(); 1064 // Release monitor(). 1065 } 1066 } 1067 1068 void WaitForBarrierGCTask::wait_for(bool reset) { 1069 if (TraceGCTaskManager) { 1070 tty->print_cr("[" INTPTR_FORMAT "]" 1071 " WaitForBarrierGCTask::wait_for()" 1072 " should_wait: %s", 1073 this, should_wait() ? "true" : "false"); 1074 } 1075 { 1076 // Grab the lock and check again. 1077 MutexLockerEx ml(monitor(), Mutex::_no_safepoint_check_flag); 1078 while (should_wait()) { 1079 if (TraceGCTaskManager) { 1080 tty->print_cr("[" INTPTR_FORMAT "]" 1081 " WaitForBarrierGCTask::wait_for()" 1082 " [" INTPTR_FORMAT "] (%s)->wait()", 1083 this, monitor(), monitor()->name()); 1084 } 1085 monitor()->wait(Mutex::_no_safepoint_check_flag, 0); 1086 } 1087 // Reset the flag in case someone reuses this task. 1088 if (reset) { 1089 set_should_wait(true); 1090 } 1091 if (TraceGCTaskManager) { 1092 tty->print_cr("[" INTPTR_FORMAT "]" 1093 " WaitForBarrierGCTask::wait_for() returns" 1094 " should_wait: %s", 1095 this, should_wait() ? "true" : "false"); 1096 } 1097 // Release monitor(). 1098 } 1099 } 1100 1101 Mutex* MonitorSupply::_lock = NULL; 1102 GrowableArray<Monitor*>* MonitorSupply::_freelist = NULL; 1103 1104 Monitor* MonitorSupply::reserve() { 1105 Monitor* result = NULL; 1106 // Lazy initialization: possible race. 1107 if (lock() == NULL) { 1108 _lock = new Mutex(Mutex::barrier, // rank 1109 "MonitorSupply mutex", // name 1110 Mutex::_allow_vm_block_flag); // allow_vm_block 1111 } 1112 { 1113 MutexLockerEx ml(lock()); 1114 // Lazy initialization. 1115 if (freelist() == NULL) { 1116 _freelist = 1117 new(ResourceObj::C_HEAP, mtGC) GrowableArray<Monitor*>(ParallelGCThreads, 1118 true); 1119 } 1120 if (! freelist()->is_empty()) { 1121 result = freelist()->pop(); 1122 } else { 1123 result = new Monitor(Mutex::barrier, // rank 1124 "MonitorSupply monitor", // name 1125 Mutex::_allow_vm_block_flag); // allow_vm_block 1126 } 1127 guarantee(result != NULL, "shouldn't return NULL"); 1128 assert(!result->is_locked(), "shouldn't be locked"); 1129 // release lock(). 1130 } 1131 return result; 1132 } 1133 1134 void MonitorSupply::release(Monitor* instance) { 1135 assert(instance != NULL, "shouldn't release NULL"); 1136 assert(!instance->is_locked(), "shouldn't be locked"); 1137 { 1138 MutexLockerEx ml(lock()); 1139 freelist()->push(instance); 1140 // release lock(). 1141 } 1142 }