Mercurial > hg > truffle
annotate src/share/vm/runtime/safepoint.hpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | d2a62e0f25eb |
| children | 63a4eb8bcd23 78bbf4d43a14 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
1972
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1291
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1291
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1291
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_RUNTIME_SAFEPOINT_HPP |
| 26 #define SHARE_VM_RUNTIME_SAFEPOINT_HPP | |
| 27 | |
| 28 #include "asm/assembler.hpp" | |
| 29 #include "code/nmethod.hpp" | |
| 30 #include "memory/allocation.hpp" | |
| 31 #include "runtime/extendedPC.hpp" | |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
1972
diff
changeset
|
32 #include "runtime/mutexLocker.hpp" |
| 1972 | 33 #include "runtime/os.hpp" |
| 34 #include "utilities/ostream.hpp" | |
| 35 | |
| 0 | 36 // |
| 37 // Safepoint synchronization | |
| 38 //// | |
| 39 // The VMThread or CMS_thread uses the SafepointSynchronize::begin/end | |
| 40 // methods to enter/exit a safepoint region. The begin method will roll | |
| 41 // all JavaThreads forward to a safepoint. | |
| 42 // | |
| 43 // JavaThreads must use the ThreadSafepointState abstraction (defined in | |
| 44 // thread.hpp) to indicate that that they are at a safepoint. | |
| 45 // | |
| 46 // The Mutex/Condition variable and ObjectLocker classes calls the enter/ | |
| 47 // exit safepoint methods, when a thread is blocked/restarted. Hence, all mutex exter/ | |
| 48 // exit points *must* be at a safepoint. | |
| 49 | |
| 50 | |
| 51 class ThreadSafepointState; | |
| 52 class SnippetCache; | |
| 53 class nmethod; | |
| 54 | |
| 55 // | |
| 56 // Implements roll-forward to safepoint (safepoint synchronization) | |
| 57 // | |
| 58 class SafepointSynchronize : AllStatic { | |
| 59 public: | |
| 60 enum SynchronizeState { | |
| 61 _not_synchronized = 0, // Threads not synchronized at a safepoint | |
| 62 // Keep this value 0. See the coment in do_call_back() | |
| 63 _synchronizing = 1, // Synchronizing in progress | |
| 64 _synchronized = 2 // All Java threads are stopped at a safepoint. Only VM thread is running | |
| 65 }; | |
| 66 | |
| 67 enum SafepointingThread { | |
| 68 _null_thread = 0, | |
| 69 _vm_thread = 1, | |
| 70 _other_thread = 2 | |
| 71 }; | |
| 72 | |
| 73 enum SafepointTimeoutReason { | |
| 74 _spinning_timeout = 0, | |
| 75 _blocking_timeout = 1 | |
| 76 }; | |
| 77 | |
| 78 typedef struct { | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
79 float _time_stamp; // record when the current safepoint occurs in seconds |
| 0 | 80 int _vmop_type; // type of VM operation triggers the safepoint |
| 81 int _nof_total_threads; // total number of Java threads | |
| 82 int _nof_initial_running_threads; // total number of initially seen running threads | |
| 83 int _nof_threads_wait_to_block; // total number of threads waiting for to block | |
| 84 bool _page_armed; // true if polling page is armed, false otherwise | |
| 85 int _nof_threads_hit_page_trap; // total number of threads hitting the page trap | |
| 86 jlong _time_to_spin; // total time in millis spent in spinning | |
| 87 jlong _time_to_wait_to_block; // total time in millis spent in waiting for to block | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
88 jlong _time_to_do_cleanups; // total time in millis spent in performing cleanups |
| 0 | 89 jlong _time_to_sync; // total time in millis spent in getting to _synchronized |
| 90 jlong _time_to_exec_vmop; // total time in millis spent in vm operation itself | |
| 91 } SafepointStats; | |
| 92 | |
| 93 private: | |
| 94 static volatile SynchronizeState _state; // Threads might read this flag directly, without acquireing the Threads_lock | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
95 static volatile int _waiting_to_block; // number of threads we are waiting for to block |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
1972
diff
changeset
|
96 static int _current_jni_active_count; // Counts the number of active critical natives during the safepoint |
| 0 | 97 |
| 98 // This counter is used for fast versions of jni_Get<Primitive>Field. | |
| 99 // An even value means there is no ongoing safepoint operations. | |
| 100 // The counter is incremented ONLY at the beginning and end of each | |
| 101 // safepoint. The fact that Threads_lock is held throughout each pair of | |
| 102 // increments (at the beginning and end of each safepoint) guarantees | |
| 103 // race freedom. | |
| 104 public: | |
| 105 static volatile int _safepoint_counter; | |
| 106 private: | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
107 static long _end_of_last_safepoint; // Time of last safepoint in milliseconds |
| 0 | 108 |
| 109 // statistics | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
110 static jlong _safepoint_begin_time; // time when safepoint begins |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
111 static SafepointStats* _safepoint_stats; // array of SafepointStats struct |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
112 static int _cur_stat_index; // current index to the above array |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
113 static julong _safepoint_reasons[]; // safepoint count for each VM op |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
114 static julong _coalesced_vmop_count; // coalesced vmop count |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
115 static jlong _max_sync_time; // maximum sync time in nanos |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
116 static jlong _max_vmop_time; // maximum vm operation time in nanos |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
117 static float _ts_of_current_safepoint; // time stamp of current safepoint in seconds |
| 0 | 118 |
| 119 static void begin_statistics(int nof_threads, int nof_running); | |
| 120 static void update_statistics_on_spin_end(); | |
| 121 static void update_statistics_on_sync_end(jlong end_time); | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
122 static void update_statistics_on_cleanup_end(jlong end_time); |
| 0 | 123 static void end_statistics(jlong end_time); |
| 124 static void print_statistics(); | |
| 125 inline static void inc_page_trap_count() { | |
| 126 Atomic::inc(&_safepoint_stats[_cur_stat_index]._nof_threads_hit_page_trap); | |
| 127 } | |
| 128 | |
| 129 // For debug long safepoint | |
| 130 static void print_safepoint_timeout(SafepointTimeoutReason timeout_reason); | |
| 131 | |
| 132 public: | |
| 133 | |
| 134 // Main entry points | |
| 135 | |
| 136 // Roll all threads forward to safepoint. Must be called by the | |
| 137 // VMThread or CMS_thread. | |
| 138 static void begin(); | |
| 139 static void end(); // Start all suspended threads again... | |
| 140 | |
| 141 static bool safepoint_safe(JavaThread *thread, JavaThreadState state); | |
| 142 | |
|
4873
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
143 static void check_for_lazy_critical_native(JavaThread *thread, JavaThreadState state); |
|
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
4867
diff
changeset
|
144 |
| 0 | 145 // Query |
| 146 inline static bool is_at_safepoint() { return _state == _synchronized; } | |
| 147 inline static bool is_synchronizing() { return _state == _synchronizing; } | |
| 148 | |
| 149 inline static bool do_call_back() { | |
| 150 return (_state != _not_synchronized); | |
| 151 } | |
| 152 | |
|
4867
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
1972
diff
changeset
|
153 inline static void increment_jni_active_count() { |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
1972
diff
changeset
|
154 assert_locked_or_safepoint(Safepoint_lock); |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
1972
diff
changeset
|
155 _current_jni_active_count++; |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
1972
diff
changeset
|
156 } |
|
1a2723f7ad8e
7129164: JNI Get/ReleasePrimitiveArrayCritical doesn't scale
never
parents:
1972
diff
changeset
|
157 |
| 0 | 158 // Called when a thread volantary blocks |
| 159 static void block(JavaThread *thread); | |
| 160 static void signal_thread_at_safepoint() { _waiting_to_block--; } | |
| 161 | |
| 162 // Exception handling for page polling | |
| 163 static void handle_polling_page_exception(JavaThread *thread); | |
| 164 | |
| 165 // VM Thread interface for determining safepoint rate | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
166 static long last_non_safepoint_interval() { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
167 return os::javaTimeMillis() - _end_of_last_safepoint; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
168 } |
| 1783 | 169 static long end_of_last_safepoint() { |
| 170 return _end_of_last_safepoint; | |
| 171 } | |
| 0 | 172 static bool is_cleanup_needed(); |
| 173 static void do_cleanup_tasks(); | |
| 174 | |
| 175 // debugging | |
| 176 static void print_state() PRODUCT_RETURN; | |
| 177 static void safepoint_msg(const char* format, ...) PRODUCT_RETURN; | |
| 178 | |
| 179 static void deferred_initialize_stat(); | |
| 180 static void print_stat_on_exit(); | |
| 181 inline static void inc_vmop_coalesced_count() { _coalesced_vmop_count++; } | |
| 182 | |
| 183 static void set_is_at_safepoint() { _state = _synchronized; } | |
| 184 static void set_is_not_at_safepoint() { _state = _not_synchronized; } | |
| 185 | |
| 186 // assembly support | |
| 187 static address address_of_state() { return (address)&_state; } | |
| 188 | |
| 189 static address safepoint_counter_addr() { return (address)&_safepoint_counter; } | |
| 190 }; | |
| 191 | |
| 192 // State class for a thread suspended at a safepoint | |
| 6197 | 193 class ThreadSafepointState: public CHeapObj<mtInternal> { |
| 0 | 194 public: |
| 195 // These states are maintained by VM thread while threads are being brought | |
| 196 // to a safepoint. After SafepointSynchronize::end(), they are reset to | |
| 197 // _running. | |
| 198 enum suspend_type { | |
| 199 _running = 0, // Thread state not yet determined (i.e., not at a safepoint yet) | |
| 200 _at_safepoint = 1, // Thread at a safepoint (f.ex., when blocked on a lock) | |
| 201 _call_back = 2 // Keep executing and wait for callback (if thread is in interpreted or vm) | |
| 202 }; | |
| 203 private: | |
| 204 volatile bool _at_poll_safepoint; // At polling page safepoint (NOT a poll return safepoint) | |
| 205 // Thread has called back the safepoint code (for debugging) | |
| 206 bool _has_called_back; | |
| 207 | |
| 208 JavaThread * _thread; | |
| 209 volatile suspend_type _type; | |
|
1727
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
210 JavaThreadState _orig_thread_state; |
| 0 | 211 |
| 212 | |
| 213 public: | |
| 214 ThreadSafepointState(JavaThread *thread); | |
| 215 | |
| 216 // examine/roll-forward/restart | |
| 217 void examine_state_of_thread(); | |
| 218 void roll_forward(suspend_type type); | |
| 219 void restart(); | |
| 220 | |
| 221 // Query | |
| 222 JavaThread* thread() const { return _thread; } | |
| 223 suspend_type type() const { return _type; } | |
| 224 bool is_running() const { return (_type==_running); } | |
|
1727
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
225 JavaThreadState orig_thread_state() const { return _orig_thread_state; } |
| 0 | 226 |
| 227 // Support for safepoint timeout (debugging) | |
| 228 bool has_called_back() const { return _has_called_back; } | |
| 229 void set_has_called_back(bool val) { _has_called_back = val; } | |
| 230 bool is_at_poll_safepoint() { return _at_poll_safepoint; } | |
| 231 void set_at_poll_safepoint(bool val) { _at_poll_safepoint = val; } | |
| 232 | |
| 233 void handle_polling_page_exception(); | |
| 234 | |
| 235 // debugging | |
| 236 void print_on(outputStream* st) const; | |
| 237 void print() const { print_on(tty); } | |
| 238 | |
| 239 // Initialize | |
| 240 static void create(JavaThread *thread); | |
| 241 static void destroy(JavaThread *thread); | |
| 242 | |
| 243 void safepoint_msg(const char* format, ...) { | |
| 244 if (ShowSafepointMsgs) { | |
| 245 va_list ap; | |
| 246 va_start(ap, format); | |
| 247 tty->vprint_cr(format, ap); | |
| 248 va_end(ap); | |
| 249 } | |
| 250 } | |
| 251 }; | |
| 252 | |
| 1783 | 253 |
| 1972 | 254 |
| 255 #endif // SHARE_VM_RUNTIME_SAFEPOINT_HPP |