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