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