rev 60497 : [mq]: 8245721-kbarrett-review2

   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
--- EOF ---