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     SAFEPOINT_CLEANUP_KEEPALIVES,
 81     // Leave this one last.
 82     SAFEPOINT_CLEANUP_NUM_TASKS
 83   };
 84 
 85  private:
 86   friend class SafepointMechanism;
 87   friend class ThreadSafepointState;
 88   friend class HandshakeState;
 89   friend class SafepointStateTracker;
 90 
 91   // Threads might read this flag directly, without acquiring the Threads_lock:
 92   static volatile SynchronizeState _state;
 93   // Number of threads we are waiting for to block:
 94   static int              _waiting_to_block;
 95   // Counts the number of active critical natives during the safepoint:
 96   static int              _current_jni_active_count;
 97 
 98   // This counter is used for fast versions of jni_Get<Primitive>Field.
 99   // An even value means there are no ongoing safepoint operations.
100   // The counter is incremented ONLY at the beginning and end of each
101   // safepoint.
102   static volatile uint64_t _safepoint_counter;
103 
104   // A change in this counter or a change in the result of
105   // is_at_safepoint() are used by SafepointStateTracker::
106   // safepoint_state_changed() to determine its answer.
107   static uint64_t _safepoint_id;
108 
109   // JavaThreads that need to block for the safepoint will stop on the
110   // _wait_barrier, where they can quickly be started again.
111   static WaitBarrier* _wait_barrier;
112   static julong       _coalesced_vmop_count;     // coalesced vmop count
113 
114   // For debug long safepoint
115   static void print_safepoint_timeout();
116 
117   // Helper methods for safepoint procedure:
118   static void arm_safepoint();
119   static int synchronize_threads(jlong safepoint_limit_time, int nof_threads, int* initial_running);
120   static void disarm_safepoint();
121   static void increment_jni_active_count();
122   static void decrement_waiting_to_block();
123   static bool thread_not_running(ThreadSafepointState *cur_state);
124 
125   // Used in safepoint_safe to do a stable load of the thread state.
126   static bool try_stable_load_state(JavaThreadState *state,
127                                     JavaThread *thread,
128                                     uint64_t safepoint_count);
129 
130   static bool is_a_block_safe_state(JavaThreadState state) {
131     // Check that we have a valid thread_state before blocking for safepoints
132     switch(state) {
133       case _thread_in_vm:
134       case _thread_in_Java:        // From compiled code
135       case _thread_blocked_trans:
136         return true;
137       default:
138         return false;
139     }
140   }
141   // Called when a thread voluntarily blocks
142   static void block(JavaThread *thread);
143 
144   // Called from VMThread during handshakes.
145   // If true the VMThread may safely process the handshake operation for the JavaThread.
146   static bool handshake_safe(JavaThread *thread);
147 
148 public:
149 
150   static uint64_t safepoint_counter()             { return _safepoint_counter; }
151 
152   static void init(Thread* vmthread);
153 
154   // Roll all threads forward to safepoint. Must be called by the VMThread.
155   static void begin();
156   static void end();                    // Start all suspended threads again...
157 
158   // The value for a not set safepoint id.
159   static const uint64_t InactiveSafepointCounter;
160 
161   // Query
162   static bool is_at_safepoint()                   { return _state == _synchronized; }
163   static bool is_synchronizing()                  { return _state == _synchronizing; }
164 
165   static uint64_t safepoint_id() {
166     return _safepoint_id;
167   }
168 
169   static SafepointStateTracker safepoint_state_tracker() {
170     return SafepointStateTracker(safepoint_id(), is_at_safepoint());
171   }
172 
173   // Exception handling for page polling
174   static void handle_polling_page_exception(JavaThread *thread);
175 
176   static bool is_cleanup_needed();
177   static void do_cleanup_tasks();
178 
179   static void set_is_at_safepoint()             { _state = _synchronized; }
180   static void set_is_not_at_safepoint()         { _state = _not_synchronized; }
181 
182   // Assembly support
183   static address address_of_state()             { return (address)&_state; }
184 
185   // Only used for making sure that no safepoint has happened in
186   // JNI_FastGetField. Therefore only the low 32-bits are needed
187   // even if this is a 64-bit counter.
188   static address safepoint_counter_addr() {
189 #ifdef VM_LITTLE_ENDIAN
190     return (address)&_safepoint_counter;
191 #else /* BIG */
192     // Return pointer to the 32 LSB:
193     return (address) (((uint32_t*)(&_safepoint_counter)) + 1);
194 #endif
195   }
196 };
197 
198 // Some helper assert macros for safepoint checks.
199 
200 #define assert_at_safepoint()                                           \
201   assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint")
202 
203 #define assert_at_safepoint_msg(...)                                    \
204   assert(SafepointSynchronize::is_at_safepoint(), __VA_ARGS__)
205 
206 #define assert_not_at_safepoint()                                       \
207   assert(!SafepointSynchronize::is_at_safepoint(), "should not be at a safepoint")
208 
209 #define assert_not_at_safepoint_msg(...)                                \
210   assert(!SafepointSynchronize::is_at_safepoint(), __VA_ARGS__)
211 
212 // State class for a thread suspended at a safepoint
213 class ThreadSafepointState: public CHeapObj<mtThread> {
214  private:
215   // At polling page safepoint (NOT a poll return safepoint):
216   volatile bool                   _at_poll_safepoint;
217   JavaThread*                     _thread;
218   bool                            _safepoint_safe;
219   volatile uint64_t               _safepoint_id;
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   // Support for safepoint timeout (debugging)
246   bool is_at_poll_safepoint()           { return _at_poll_safepoint; }
247   void set_at_poll_safepoint(bool val)  { _at_poll_safepoint = val; }
248 
249   void handle_polling_page_exception();
250 
251   // debugging
252   void print_on(outputStream* st) const;
253 
254   // Initialize
255   static void create(JavaThread *thread);
256   static void destroy(JavaThread *thread);
257 };
258 
259 class SafepointTracing : public AllStatic {
260 private:
261   // Absolute
262   static jlong _last_safepoint_begin_time_ns;
263   static jlong _last_safepoint_sync_time_ns;
264   static jlong _last_safepoint_cleanup_time_ns;
265   static jlong _last_safepoint_end_time_ns;
266 
267   // Relative
268   static jlong _last_app_time_ns;
269 
270   static int _nof_threads;
271   static int _nof_running;
272   static int _page_trap;
273 
274   static VM_Operation::VMOp_Type _current_type;
275   static jlong     _max_sync_time;
276   static jlong     _max_vmop_time;
277   static uint64_t  _op_count[VM_Operation::VMOp_Terminating];
278 
279   static void statistics_log();
280 
281 public:
282   static void init();
283 
284   static void begin(VM_Operation::VMOp_Type type);
285   static void synchronized(int nof_threads, int nof_running, int traps);
286   static void cleanup();
287   static void end();
288 
289   static void statistics_exit_log();
290 
291   static jlong time_since_last_safepoint_ms() {
292     return nanos_to_millis(os::javaTimeNanos() - _last_safepoint_end_time_ns);
293   }
294 
295   static jlong end_of_last_safepoint_ms() {
296     return nanos_to_millis(_last_safepoint_end_time_ns);
297   }
298 
299   static jlong start_of_safepoint() {
300     return _last_safepoint_begin_time_ns;
301   }
302 };
303 
304 #endif // SHARE_RUNTIME_SAFEPOINT_HPP