1 /*
   2  * Copyright (c) 1997, 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 #ifndef SHARE_RUNTIME_SAFEPOINT_HPP
  26 #define SHARE_RUNTIME_SAFEPOINT_HPP
  27 
  28 #include "memory/allocation.hpp"
  29 #include "runtime/os.hpp"
  30 #include "runtime/thread.hpp"
  31 #include "runtime/vmOperations.hpp"
  32 #include "utilities/ostream.hpp"
  33 #include "utilities/waitBarrier.hpp"
  34 
  35 //
  36 // Safepoint synchronization
  37 ////
  38 // The VMThread uses the SafepointSynchronize::begin/end
  39 // methods to enter/exit a safepoint region. The begin method will roll
  40 // all JavaThreads forward to a safepoint.
  41 //
  42 // JavaThreads must use the ThreadSafepointState abstraction (defined in
  43 // thread.hpp) to indicate that that they are at a safepoint.
  44 //
  45 // The Mutex/Condition variable and ObjectLocker classes calls the enter/
  46 // exit safepoint methods, when a thread is blocked/restarted. Hence, all mutex exter/
  47 // exit points *must* be at a safepoint.
  48 
  49 class ThreadSafepointState;
  50 
  51 class SafepointStateTracker {
  52   uint64_t _safepoint_id;
  53   bool     _at_safepoint;
  54 public:
  55   SafepointStateTracker(uint64_t safepoint_id, bool at_safepoint);
  56   bool safepoint_state_changed();
  57 };
  58 
  59 //
  60 // Implements roll-forward to safepoint (safepoint synchronization)
  61 //
  62 class SafepointSynchronize : AllStatic {
  63  public:
  64   enum SynchronizeState {
  65       _not_synchronized = 0,                   // Threads not synchronized at a safepoint. Keep this value 0.
  66       _synchronizing    = 1,                   // Synchronizing in progress
  67       _synchronized     = 2                    // All Java threads are running in native, blocked in OS or stopped at safepoint.
  68                                                // VM thread and any NonJavaThread may be running.
  69   };
  70 
  71   // The enums are listed in the order of the tasks when done serially.
  72   enum SafepointCleanupTasks {
  73     SAFEPOINT_CLEANUP_DEFLATE_MONITORS,
  74     SAFEPOINT_CLEANUP_UPDATE_INLINE_CACHES,
  75     SAFEPOINT_CLEANUP_COMPILATION_POLICY,
  76     SAFEPOINT_CLEANUP_SYMBOL_TABLE_REHASH,
  77     SAFEPOINT_CLEANUP_STRING_TABLE_REHASH,
  78     SAFEPOINT_CLEANUP_CLD_PURGE,
  79     SAFEPOINT_CLEANUP_SYSTEM_DICTIONARY_RESIZE,
  80     SAFEPOINT_CLEANUP_REQUEST_OOPSTORAGE_CLEANUP,
  81     SAFEPOINT_CLEANUP_KEEPALIVES,
  82     // Leave this one last.
  83     SAFEPOINT_CLEANUP_NUM_TASKS
  84   };
  85 
  86  private:
  87   friend class SafepointMechanism;
  88   friend class ThreadSafepointState;
  89   friend class HandshakeState;
  90   friend class SafepointStateTracker;
  91 
  92   // Threads might read this flag directly, without acquiring the Threads_lock:
  93   static volatile SynchronizeState _state;
  94   // Number of threads we are waiting for to block:
  95   static int              _waiting_to_block;
  96   // Counts the number of active critical natives during the safepoint:
  97   static int              _current_jni_active_count;
  98 
  99   // This counter is used for fast versions of jni_Get<Primitive>Field.
 100   // An even value means there are no ongoing safepoint operations.
 101   // The counter is incremented ONLY at the beginning and end of each
 102   // safepoint.
 103   static volatile uint64_t _safepoint_counter;
 104 
 105   // A change in this counter or a change in the result of
 106   // is_at_safepoint() are used by SafepointStateTracker::
 107   // safepoint_state_changed() to determine its answer.
 108   static uint64_t _safepoint_id;
 109 
 110   // JavaThreads that need to block for the safepoint will stop on the
 111   // _wait_barrier, where they can quickly be started again.
 112   static WaitBarrier* _wait_barrier;
 113   static long         _end_of_last_safepoint;     // Time of last safepoint in milliseconds
 114   static julong       _coalesced_vmop_count;     // coalesced vmop count
 115 
 116   // Statistics
 117   static void begin_statistics(int nof_threads, int nof_running);
 118   static void update_statistics_on_spin_end();
 119   static void update_statistics_on_sync_end(jlong end_time);
 120   static void update_statistics_on_cleanup_end(jlong end_time);
 121   static void end_statistics(jlong end_time);
 122   static void print_statistics();
 123 
 124   // For debug long safepoint
 125   static void print_safepoint_timeout();
 126 
 127   // Helper methods for safepoint procedure:
 128   static void arm_safepoint();
 129   static int synchronize_threads(jlong safepoint_limit_time, int nof_threads, int* initial_running);
 130   static void disarm_safepoint();
 131   static void increment_jni_active_count();
 132   static void decrement_waiting_to_block();
 133   static bool thread_not_running(ThreadSafepointState *cur_state);
 134 
 135   // Used in safepoint_safe to do a stable load of the thread state.
 136   static bool try_stable_load_state(JavaThreadState *state,
 137                                     JavaThread *thread,
 138                                     uint64_t safepoint_count);
 139 
 140   // Called when a thread voluntarily blocks
 141   static void block(JavaThread *thread);
 142 
 143   // Called from VMThread during handshakes.
 144   // If true the VMThread may safely process the handshake operation for the JavaThread.
 145   static bool handshake_safe(JavaThread *thread);
 146 
 147 public:
 148 
 149   static uint64_t safepoint_counter()             { return _safepoint_counter; }
 150 
 151   static void init(Thread* vmthread);
 152 
 153   // Roll all threads forward to safepoint. Must be called by the VMThread.
 154   static void begin();
 155   static void end();                    // Start all suspended threads again...
 156 
 157   // The value for a not set safepoint id.
 158   static const uint64_t InactiveSafepointCounter;
 159 
 160   // Query
 161   static bool is_at_safepoint()                   { return _state == _synchronized; }
 162   static bool is_synchronizing()                  { return _state == _synchronizing; }
 163 
 164   static uint64_t safepoint_id() {
 165     return _safepoint_id;
 166   }
 167 
 168   static SafepointStateTracker safepoint_state_tracker() {
 169     return SafepointStateTracker(safepoint_id(), is_at_safepoint());
 170   }
 171 
 172   // Exception handling for page polling
 173   static void handle_polling_page_exception(JavaThread *thread);
 174 
 175   static bool is_cleanup_needed();
 176   static void do_cleanup_tasks();
 177 
 178   static void set_is_at_safepoint()             { _state = _synchronized; }
 179   static void set_is_not_at_safepoint()         { _state = _not_synchronized; }
 180 
 181   // Assembly support
 182   static address address_of_state()             { return (address)&_state; }
 183 
 184   // Only used for making sure that no safepoint has happened in
 185   // JNI_FastGetField. Therefore only the low 32-bits are needed
 186   // even if this is a 64-bit counter.
 187   static address safepoint_counter_addr() {
 188 #ifdef VM_LITTLE_ENDIAN
 189     return (address)&_safepoint_counter;
 190 #else /* BIG */
 191     // Return pointer to the 32 LSB:
 192     return (address) (((uint32_t*)(&_safepoint_counter)) + 1);
 193 #endif
 194   }
 195 };
 196 
 197 // Some helper assert macros for safepoint checks.
 198 
 199 #define assert_at_safepoint()                                           \
 200   assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint")
 201 
 202 #define assert_at_safepoint_msg(...)                                    \
 203   assert(SafepointSynchronize::is_at_safepoint(), __VA_ARGS__)
 204 
 205 #define assert_not_at_safepoint()                                       \
 206   assert(!SafepointSynchronize::is_at_safepoint(), "should not be at a safepoint")
 207 
 208 #define assert_not_at_safepoint_msg(...)                                \
 209   assert(!SafepointSynchronize::is_at_safepoint(), __VA_ARGS__)
 210 
 211 // State class for a thread suspended at a safepoint
 212 class ThreadSafepointState: public CHeapObj<mtThread> {
 213  private:
 214   // At polling page safepoint (NOT a poll return safepoint):
 215   volatile bool                   _at_poll_safepoint;
 216   JavaThread*                     _thread;
 217   bool                            _safepoint_safe;
 218   volatile uint64_t               _safepoint_id;
 219   JavaThreadState                 _orig_thread_state;
 220 
 221   ThreadSafepointState*           _next;
 222 
 223   void account_safe_thread();
 224 
 225  public:
 226   ThreadSafepointState(JavaThread *thread);
 227 
 228   // Linked list support:
 229   ThreadSafepointState* get_next() const { return _next; }
 230   void set_next(ThreadSafepointState* value) { _next = value; }
 231   ThreadSafepointState** next_ptr() { return &_next; }
 232 
 233   // examine/restart
 234   void examine_state_of_thread(uint64_t safepoint_count);
 235   void restart();
 236 
 237   // Query
 238   JavaThread*  thread() const         { return _thread; }
 239   bool         is_running() const     { return !_safepoint_safe; }
 240 
 241   uint64_t get_safepoint_id() const;
 242   void     reset_safepoint_id();
 243   void     set_safepoint_id(uint64_t sid);
 244 
 245   JavaThreadState orig_thread_state() const { return _orig_thread_state; }
 246 
 247   // Support for safepoint timeout (debugging)
 248   bool is_at_poll_safepoint()           { return _at_poll_safepoint; }
 249   void set_at_poll_safepoint(bool val)  { _at_poll_safepoint = val; }
 250 
 251   void handle_polling_page_exception();
 252 
 253   // debugging
 254   void print_on(outputStream* st) const;
 255   void print() const;
 256 
 257   // Initialize
 258   static void create(JavaThread *thread);
 259   static void destroy(JavaThread *thread);
 260 };
 261 
 262 class SafepointTracing : public AllStatic {
 263 private:
 264   // Absolute
 265   static jlong _last_safepoint_begin_time_ns;
 266   static jlong _last_safepoint_sync_time_ns;
 267   static jlong _last_safepoint_cleanup_time_ns;
 268   static jlong _last_safepoint_end_time_ns;
 269   // amount of ms since epoch
 270   static jlong _last_safepoint_end_time_epoch_ms;
 271   // Relative
 272   static jlong _last_app_time_ns;
 273 
 274   static int _nof_threads;
 275   static int _nof_running;
 276   static int _page_trap;
 277 
 278   static VM_Operation::VMOp_Type _current_type;
 279   static jlong     _max_sync_time;
 280   static jlong     _max_vmop_time;
 281   static uint64_t  _op_count[VM_Operation::VMOp_Terminating];
 282 
 283   static void statistics_log();
 284 
 285 public:
 286   static void init();
 287 
 288   static void begin(VM_Operation::VMOp_Type type);
 289   static void synchronized(int nof_threads, int nof_running, int traps);
 290   static void cleanup();
 291   static void end();
 292 
 293   static void statistics_exit_log();
 294 
 295   static jlong time_since_last_safepoint_ms() {
 296     return (os::javaTimeNanos() - _last_safepoint_end_time_ns) / (NANOUNITS / MILLIUNITS);
 297   }
 298 
 299   static jlong end_of_last_safepoint_epoch_ms() {
 300     return _last_safepoint_end_time_epoch_ms;
 301   }
 302 
 303   static jlong start_of_safepoint() {
 304     return _last_safepoint_begin_time_ns;
 305   }
 306 };
 307 
 308 #endif // SHARE_RUNTIME_SAFEPOINT_HPP