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     return state == _thread_in_vm || state == _thread_in_Java;
132   }
133   // Called when a thread voluntarily blocks
134   static void block(JavaThread *thread);
135 
136   // Called from VMThread during handshakes.
137   // If true the VMThread may safely process the handshake operation for the JavaThread.
138   static bool handshake_safe(JavaThread *thread);
139 
140   static uint64_t safepoint_counter()             { return _safepoint_counter; }
141 
142 public:
143 
144   static void init(Thread* vmthread);
145 
146   // Roll all threads forward to safepoint. Must be called by the VMThread.
147   static void begin();
148   static void end();                    // Start all suspended threads again...
149 
150   // The value for a not set safepoint id.
151   static const uint64_t InactiveSafepointCounter;
152 
153   // Query
154   static bool is_at_safepoint()                   { return _state == _synchronized; }
155   static bool is_synchronizing()                  { return _state == _synchronizing; }
156 
157   static uint64_t safepoint_id() {
158     return _safepoint_id;
159   }
160 
161   static SafepointStateTracker safepoint_state_tracker() {
162     return SafepointStateTracker(safepoint_id(), is_at_safepoint());
163   }
164 
165   // Exception handling for page polling
166   static void handle_polling_page_exception(JavaThread *thread);
167 
168   static bool is_cleanup_needed();
169   static void do_cleanup_tasks();
170 
171   static void set_is_at_safepoint()             { _state = _synchronized; }
172   static void set_is_not_at_safepoint()         { _state = _not_synchronized; }
173 
174   // Assembly support
175   static address address_of_state()             { return (address)&_state; }
176 
177   // Only used for making sure that no safepoint has happened in
178   // JNI_FastGetField. Therefore only the low 32-bits are needed
179   // even if this is a 64-bit counter.
180   static address safepoint_counter_addr() {
181 #ifdef VM_LITTLE_ENDIAN
182     return (address)&_safepoint_counter;
183 #else /* BIG */
184     // Return pointer to the 32 LSB:
185     return (address) (((uint32_t*)(&_safepoint_counter)) + 1);
186 #endif
187   }
188 };
189 
190 // Some helper assert macros for safepoint checks.
191 
192 #define assert_at_safepoint()                                           \
193   assert(SafepointSynchronize::is_at_safepoint(), "should be at a safepoint")
194 
195 #define assert_at_safepoint_msg(...)                                    \
196   assert(SafepointSynchronize::is_at_safepoint(), __VA_ARGS__)
197 
198 #define assert_not_at_safepoint()                                       \
199   assert(!SafepointSynchronize::is_at_safepoint(), "should not be at a safepoint")
200 
201 #define assert_not_at_safepoint_msg(...)                                \
202   assert(!SafepointSynchronize::is_at_safepoint(), __VA_ARGS__)
203 
204 // State class for a thread suspended at a safepoint
205 class ThreadSafepointState: public CHeapObj<mtThread> {
206  private:
207   // At polling page safepoint (NOT a poll return safepoint):
208   volatile bool                   _at_poll_safepoint;
209   JavaThread*                     _thread;
210   bool                            _safepoint_safe;
211   volatile uint64_t               _safepoint_id;
212 
213   ThreadSafepointState*           _next;
214 
215   void account_safe_thread();
216 
217  public:
218   ThreadSafepointState(JavaThread *thread);
219 
220   // Linked list support:
221   ThreadSafepointState* get_next() const { return _next; }
222   void set_next(ThreadSafepointState* value) { _next = value; }
223   ThreadSafepointState** next_ptr() { return &_next; }
224 
225   // examine/restart
226   void examine_state_of_thread(uint64_t safepoint_count);
227   void restart();
228 
229   // Query
230   JavaThread*  thread() const         { return _thread; }
231   bool         is_running() const     { return !_safepoint_safe; }
232 
233   uint64_t get_safepoint_id() const;
234   void     reset_safepoint_id();
235   void     set_safepoint_id(uint64_t sid);
236 
237   // Support for safepoint timeout (debugging)
238   bool is_at_poll_safepoint()           { return _at_poll_safepoint; }
239   void set_at_poll_safepoint(bool val)  { _at_poll_safepoint = val; }
240 
241   void handle_polling_page_exception();
242 
243   // debugging
244   void print_on(outputStream* st) const;
245 
246   // Initialize
247   static void create(JavaThread *thread);
248   static void destroy(JavaThread *thread);
249 };
250 
251 class SafepointTracing : public AllStatic {
252 private:
253   // Absolute
254   static jlong _last_safepoint_begin_time_ns;
255   static jlong _last_safepoint_sync_time_ns;
256   static jlong _last_safepoint_cleanup_time_ns;
257   static jlong _last_safepoint_end_time_ns;
258 
259   // Relative
260   static jlong _last_app_time_ns;
261 
262   static int _nof_threads;
263   static int _nof_running;
264   static int _page_trap;
265 
266   static VM_Operation::VMOp_Type _current_type;
267   static jlong     _max_sync_time;
268   static jlong     _max_vmop_time;
269   static uint64_t  _op_count[VM_Operation::VMOp_Terminating];
270 
271   static void statistics_log();
272 
273 public:
274   static void init();
275 
276   static void begin(VM_Operation::VMOp_Type type);
277   static void synchronized(int nof_threads, int nof_running, int traps);
278   static void cleanup();
279   static void end();
280 
281   static void statistics_exit_log();
282 
283   static jlong time_since_last_safepoint_ms() {
284     return nanos_to_millis(os::javaTimeNanos() - _last_safepoint_end_time_ns);
285   }
286 
287   static jlong end_of_last_safepoint_ms() {
288     return nanos_to_millis(_last_safepoint_end_time_ns);
289   }
290 
291   static jlong start_of_safepoint() {
292     return _last_safepoint_begin_time_ns;
293   }
294 };
295 
296 #endif // SHARE_RUNTIME_SAFEPOINT_HPP