1 /*
  2  * Copyright (c) 1997, 2021, 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/vmOperation.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_LAZY_ROOT_PROCESSING,
 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_SYSTEM_DICTIONARY_RESIZE,
 79     SAFEPOINT_CLEANUP_REQUEST_OOPSTORAGE_CLEANUP,
 80     // Leave this one last.
 81     SAFEPOINT_CLEANUP_NUM_TASKS
 82   };
 83 
 84  private:
 85   friend class SafepointMechanism;
 86   friend class ThreadSafepointState;
 87   friend class HandshakeState;
 88   friend class SafepointStateTracker;
 89 
 90   // Threads might read this flag directly, without acquiring the Threads_lock:
 91   static volatile SynchronizeState _state;
 92   // Number of threads we are waiting for to block:
 93   static int              _waiting_to_block;
 94   // Counts the number of active critical natives during the safepoint:
 95   static int              _current_jni_active_count;
 96 
 97   // This counter is used for fast versions of jni_Get<Primitive>Field.
 98   // An even value means there are no ongoing safepoint operations.
 99   // The counter is incremented ONLY at the beginning and end of each
100   // safepoint.
101   static volatile uint64_t _safepoint_counter;
102 
103   // A change in this counter or a change in the result of
104   // is_at_safepoint() are used by SafepointStateTracker::
105   // safepoint_state_changed() to determine its answer.
106   static uint64_t _safepoint_id;
107 
108   // JavaThreads that need to block for the safepoint will stop on the
109   // _wait_barrier, where they can quickly be started again.
110   static WaitBarrier* _wait_barrier;
111   static julong       _coalesced_vmop_count;     // coalesced vmop count
112 
113   // For debug long safepoint
114   static void print_safepoint_timeout();
115 
116   // Helper methods for safepoint procedure:
117   static void arm_safepoint();
118   static int synchronize_threads(jlong safepoint_limit_time, int nof_threads, int* initial_running);
119   static void disarm_safepoint();
120   static void increment_jni_active_count();
121   static void decrement_waiting_to_block();
122   static bool thread_not_running(ThreadSafepointState *cur_state);
123 
124   // Used in safepoint_safe to do a stable load of the thread state.
125   static bool try_stable_load_state(JavaThreadState *state,
126                                     JavaThread *thread,
127                                     uint64_t safepoint_count);
128 
129   static bool is_a_block_safe_state(JavaThreadState state) {
130     // Check that we have a valid thread_state before blocking for safepoints
131     switch(state) {
132       case _thread_in_vm:
133       case _thread_in_Java:        // From compiled code
134       case _thread_blocked_trans:
135         return true;
136       default:
137         return false;
138     }
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   static uint64_t safepoint_counter()             { return _safepoint_counter; }
148 
149 public:
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 
220   ThreadSafepointState*           _next;
221 
222   void account_safe_thread();
223 
224  public:
225   ThreadSafepointState(JavaThread *thread);
226 
227   // Linked list support:
228   ThreadSafepointState* get_next() const { return _next; }
229   void set_next(ThreadSafepointState* value) { _next = value; }
230   ThreadSafepointState** next_ptr() { return &_next; }
231 
232   // examine/restart
233   void examine_state_of_thread(uint64_t safepoint_count);
234   void restart();
235 
236   // Query
237   JavaThread*  thread() const         { return _thread; }
238   bool         is_running() const     { return !_safepoint_safe; }
239 
240   uint64_t get_safepoint_id() const;
241   void     reset_safepoint_id();
242   void     set_safepoint_id(uint64_t sid);
243 
244   // Support for safepoint timeout (debugging)
245   bool is_at_poll_safepoint()           { return _at_poll_safepoint; }
246   void set_at_poll_safepoint(bool val)  { _at_poll_safepoint = val; }
247 
248   void handle_polling_page_exception();
249 
250   // debugging
251   void print_on(outputStream* st) const;
252 
253   // Initialize
254   static void create(JavaThread *thread);
255   static void destroy(JavaThread *thread);
256 };
257 
258 class SafepointTracing : public AllStatic {
259 private:
260   // Absolute
261   static jlong _last_safepoint_begin_time_ns;
262   static jlong _last_safepoint_sync_time_ns;
263   static jlong _last_safepoint_cleanup_time_ns;
264   static jlong _last_safepoint_end_time_ns;
265 
266   // Relative
267   static jlong _last_app_time_ns;
268 
269   static int _nof_threads;
270   static int _nof_running;
271   static int _page_trap;
272 
273   static VM_Operation::VMOp_Type _current_type;
274   static jlong     _max_sync_time;
275   static jlong     _max_vmop_time;
276   static uint64_t  _op_count[VM_Operation::VMOp_Terminating];
277 
278   static void statistics_log();
279 
280 public:
281   static void init();
282 
283   static void begin(VM_Operation::VMOp_Type type);
284   static void synchronized(int nof_threads, int nof_running, int traps);
285   static void cleanup();
286   static void end();
287 
288   static void statistics_exit_log();
289 
290   static jlong time_since_last_safepoint_ms() {
291     return nanos_to_millis(os::javaTimeNanos() - _last_safepoint_end_time_ns);
292   }
293 
294   static jlong end_of_last_safepoint_ms() {
295     return nanos_to_millis(_last_safepoint_end_time_ns);
296   }
297 
298   static jlong start_of_safepoint() {
299     return _last_safepoint_begin_time_ns;
300   }
301 };
302 
303 #endif // SHARE_RUNTIME_SAFEPOINT_HPP