1 /* 2 * Copyright (c) 2018, 2020, Red Hat, Inc. All rights reserved. 3 * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 #ifndef SHARE_GC_SHARED_TASKTERMINATOR_HPP 26 #define SHARE_GC_SHARED_TASKTERMINATOR_HPP 27 28 #include "memory/allocation.hpp" 29 #include "memory/padded.hpp" 30 #include "runtime/mutex.hpp" 31 32 class TaskQueueSetSuper; 33 class TerminatorTerminator; 34 class Thread; 35 36 /* 37 * Provides a task termination protocol. 38 * 39 * This is an enhanced implementation of Google's OWST work stealing task termination 40 * protocol (OWST stands for Optimized Work Stealing Threads). 41 * 42 * It is described in the paper: 43 * "Wessam Hassanein. 2016. Understanding and improving JVM GC work 44 * stealing at the data center scale. In Proceedings of the 2016 ACM 45 * SIGPLAN International Symposium on Memory Management (ISMM 2016). ACM, 46 * New York, NY, USA, 46-54. DOI: https://doi.org/10.1145/2926697.2926706" 47 * 48 * Instead of a dedicated spin-master, our implementation will let spin-master 49 * relinquish the role before it goes to sleep/wait, allowing newly arrived 50 * threads to compete for the role. 51 * The intention of above enhancement is to reduce spin-master's latency on 52 * detecting new tasks for stealing and termination condition. 53 */ 54 class TaskTerminator : public CHeapObj<mtGC> { 55 class DelayContext { 56 uint _yield_count; 57 // Number of hard spin loops done since last yield 58 uint _hard_spin_count; 59 // Number of iterations in the current hard spin loop. 60 uint _hard_spin_limit; 61 62 void reset_hard_spin_information(); 63 public: 64 DelayContext(); 65 66 // Should the caller sleep (wait) or perform a spin step? 67 bool needs_sleep() const; 68 // Perform one delay iteration. 69 void do_step(); 70 }; 71 72 uint _n_threads; 73 TaskQueueSetSuper* _queue_set; 74 75 DEFINE_PAD_MINUS_SIZE(0, DEFAULT_CACHE_LINE_SIZE, 0); 76 volatile uint _offered_termination; 77 DEFINE_PAD_MINUS_SIZE(1, DEFAULT_CACHE_LINE_SIZE, sizeof(volatile uint)); 78 79 Monitor _blocker; 80 Thread* _spin_master; 81 82 void assert_queue_set_empty() const NOT_DEBUG_RETURN; 83 84 // Prepare for return from offer_termination. Gives up the spin master token 85 // and wakes up up to tasks threads waiting on _blocker (the default value 86 // means to wake up everyone). 87 void prepare_for_return(Thread* this_thread, size_t tasks = SIZE_MAX); 88 89 // If we should exit current termination protocol 90 bool exit_termination(size_t tasks, TerminatorTerminator* terminator); 91 92 size_t tasks_in_queue_set() const; 93 94 // Perform one iteration of spin-master work. 95 void do_delay_step(DelayContext& delay_context); 96 97 NONCOPYABLE(TaskTerminator); 98 99 public: 100 TaskTerminator(uint n_threads, TaskQueueSetSuper* queue_set); 101 ~TaskTerminator(); 102 103 // The current thread has no work, and is ready to terminate if everyone 104 // else is. If returns "true", all threads are terminated. If returns 105 // "false", available work has been observed in one of the task queues, 106 // so the global task is not complete. 107 bool offer_termination() { 108 return offer_termination(NULL); 109 } 110 111 // As above, but it also terminates if the should_exit_termination() 112 // method of the terminator parameter returns true. If terminator is 113 // NULL, then it is ignored. 114 bool offer_termination(TerminatorTerminator* terminator); 115 116 // Reset the terminator, so that it may be reused again. 117 // The caller is responsible for ensuring that this is done 118 // in an MT-safe manner, once the previous round of use of 119 // the terminator is finished. 120 void reset_for_reuse(); 121 // Same as above but the number of parallel threads is set to the 122 // given number. 123 void reset_for_reuse(uint n_threads); 124 }; 125 126 #endif // SHARE_GC_SHARED_TASKTERMINATOR_HPP