Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/safepoint.hpp @ 3979:4dfb2df418f2
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
| author | johnc |
|---|---|
| date | Thu, 22 Sep 2011 10:57:37 -0700 |
| parents | f95d63e2154a |
| children | 1a2723f7ad8e |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1783 | 2 * Copyright (c) 1997, 2010, 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" | |
| 32 #include "runtime/os.hpp" | |
| 33 #include "utilities/ostream.hpp" | |
| 34 | |
| 0 | 35 // |
| 36 // Safepoint synchronization | |
| 37 //// | |
| 38 // The VMThread or CMS_thread 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 | |
| 50 class ThreadSafepointState; | |
| 51 class SnippetCache; | |
| 52 class nmethod; | |
| 53 | |
| 54 // | |
| 55 // Implements roll-forward to safepoint (safepoint synchronization) | |
| 56 // | |
| 57 class SafepointSynchronize : AllStatic { | |
| 58 public: | |
| 59 enum SynchronizeState { | |
| 60 _not_synchronized = 0, // Threads not synchronized at a safepoint | |
| 61 // Keep this value 0. See the coment in do_call_back() | |
| 62 _synchronizing = 1, // Synchronizing in progress | |
| 63 _synchronized = 2 // All Java threads are stopped at a safepoint. Only VM thread is running | |
| 64 }; | |
| 65 | |
| 66 enum SafepointingThread { | |
| 67 _null_thread = 0, | |
| 68 _vm_thread = 1, | |
| 69 _other_thread = 2 | |
| 70 }; | |
| 71 | |
| 72 enum SafepointTimeoutReason { | |
| 73 _spinning_timeout = 0, | |
| 74 _blocking_timeout = 1 | |
| 75 }; | |
| 76 | |
| 77 typedef struct { | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
78 float _time_stamp; // record when the current safepoint occurs in seconds |
| 0 | 79 int _vmop_type; // type of VM operation triggers the safepoint |
| 80 int _nof_total_threads; // total number of Java threads | |
| 81 int _nof_initial_running_threads; // total number of initially seen running threads | |
| 82 int _nof_threads_wait_to_block; // total number of threads waiting for to block | |
| 83 bool _page_armed; // true if polling page is armed, false otherwise | |
| 84 int _nof_threads_hit_page_trap; // total number of threads hitting the page trap | |
| 85 jlong _time_to_spin; // total time in millis spent in spinning | |
| 86 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
|
87 jlong _time_to_do_cleanups; // total time in millis spent in performing cleanups |
| 0 | 88 jlong _time_to_sync; // total time in millis spent in getting to _synchronized |
| 89 jlong _time_to_exec_vmop; // total time in millis spent in vm operation itself | |
| 90 } SafepointStats; | |
| 91 | |
| 92 private: | |
| 93 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
|
94 static volatile int _waiting_to_block; // number of threads we are waiting for to block |
| 0 | 95 |
| 96 // This counter is used for fast versions of jni_Get<Primitive>Field. | |
| 97 // An even value means there is no ongoing safepoint operations. | |
| 98 // The counter is incremented ONLY at the beginning and end of each | |
| 99 // safepoint. The fact that Threads_lock is held throughout each pair of | |
| 100 // increments (at the beginning and end of each safepoint) guarantees | |
| 101 // race freedom. | |
| 102 public: | |
| 103 static volatile int _safepoint_counter; | |
| 104 private: | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
105 static long _end_of_last_safepoint; // Time of last safepoint in milliseconds |
| 0 | 106 |
| 107 // statistics | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
108 static jlong _safepoint_begin_time; // time when safepoint begins |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
109 static SafepointStats* _safepoint_stats; // array of SafepointStats struct |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
110 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
|
111 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
|
112 static julong _coalesced_vmop_count; // coalesced vmop count |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
113 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
|
114 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
|
115 static float _ts_of_current_safepoint; // time stamp of current safepoint in seconds |
| 0 | 116 |
| 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); | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
120 static void update_statistics_on_cleanup_end(jlong end_time); |
| 0 | 121 static void end_statistics(jlong end_time); |
| 122 static void print_statistics(); | |
| 123 inline static void inc_page_trap_count() { | |
| 124 Atomic::inc(&_safepoint_stats[_cur_stat_index]._nof_threads_hit_page_trap); | |
| 125 } | |
| 126 | |
| 127 // For debug long safepoint | |
| 128 static void print_safepoint_timeout(SafepointTimeoutReason timeout_reason); | |
| 129 | |
| 130 public: | |
| 131 | |
| 132 // Main entry points | |
| 133 | |
| 134 // Roll all threads forward to safepoint. Must be called by the | |
| 135 // VMThread or CMS_thread. | |
| 136 static void begin(); | |
| 137 static void end(); // Start all suspended threads again... | |
| 138 | |
| 139 static bool safepoint_safe(JavaThread *thread, JavaThreadState state); | |
| 140 | |
| 141 // Query | |
| 142 inline static bool is_at_safepoint() { return _state == _synchronized; } | |
| 143 inline static bool is_synchronizing() { return _state == _synchronizing; } | |
| 144 | |
| 145 inline static bool do_call_back() { | |
| 146 return (_state != _not_synchronized); | |
| 147 } | |
| 148 | |
| 149 // Called when a thread volantary blocks | |
| 150 static void block(JavaThread *thread); | |
| 151 static void signal_thread_at_safepoint() { _waiting_to_block--; } | |
| 152 | |
| 153 // Exception handling for page polling | |
| 154 static void handle_polling_page_exception(JavaThread *thread); | |
| 155 | |
| 156 // VM Thread interface for determining safepoint rate | |
|
1291
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
157 static long last_non_safepoint_interval() { |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
158 return os::javaTimeMillis() - _end_of_last_safepoint; |
|
4b0f2f4918ed
6933402: RFE: Improve PrintSafepointStatistics output to track cleanup time
xlu
parents:
0
diff
changeset
|
159 } |
| 1783 | 160 static long end_of_last_safepoint() { |
| 161 return _end_of_last_safepoint; | |
| 162 } | |
| 0 | 163 static bool is_cleanup_needed(); |
| 164 static void do_cleanup_tasks(); | |
| 165 | |
| 166 // debugging | |
| 167 static void print_state() PRODUCT_RETURN; | |
| 168 static void safepoint_msg(const char* format, ...) PRODUCT_RETURN; | |
| 169 | |
| 170 static void deferred_initialize_stat(); | |
| 171 static void print_stat_on_exit(); | |
| 172 inline static void inc_vmop_coalesced_count() { _coalesced_vmop_count++; } | |
| 173 | |
| 174 static void set_is_at_safepoint() { _state = _synchronized; } | |
| 175 static void set_is_not_at_safepoint() { _state = _not_synchronized; } | |
| 176 | |
| 177 // assembly support | |
| 178 static address address_of_state() { return (address)&_state; } | |
| 179 | |
| 180 static address safepoint_counter_addr() { return (address)&_safepoint_counter; } | |
| 181 }; | |
| 182 | |
| 183 // State class for a thread suspended at a safepoint | |
| 184 class ThreadSafepointState: public CHeapObj { | |
| 185 public: | |
| 186 // These states are maintained by VM thread while threads are being brought | |
| 187 // to a safepoint. After SafepointSynchronize::end(), they are reset to | |
| 188 // _running. | |
| 189 enum suspend_type { | |
| 190 _running = 0, // Thread state not yet determined (i.e., not at a safepoint yet) | |
| 191 _at_safepoint = 1, // Thread at a safepoint (f.ex., when blocked on a lock) | |
| 192 _call_back = 2 // Keep executing and wait for callback (if thread is in interpreted or vm) | |
| 193 }; | |
| 194 private: | |
| 195 volatile bool _at_poll_safepoint; // At polling page safepoint (NOT a poll return safepoint) | |
| 196 // Thread has called back the safepoint code (for debugging) | |
| 197 bool _has_called_back; | |
| 198 | |
| 199 JavaThread * _thread; | |
| 200 volatile suspend_type _type; | |
|
1727
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
201 JavaThreadState _orig_thread_state; |
| 0 | 202 |
| 203 | |
| 204 public: | |
| 205 ThreadSafepointState(JavaThread *thread); | |
| 206 | |
| 207 // examine/roll-forward/restart | |
| 208 void examine_state_of_thread(); | |
| 209 void roll_forward(suspend_type type); | |
| 210 void restart(); | |
| 211 | |
| 212 // Query | |
| 213 JavaThread* thread() const { return _thread; } | |
| 214 suspend_type type() const { return _type; } | |
| 215 bool is_running() const { return (_type==_running); } | |
|
1727
da877bdc9000
6975006: assert(check.is_deoptimized_frame()) failed: missed deopt
never
parents:
1552
diff
changeset
|
216 JavaThreadState orig_thread_state() const { return _orig_thread_state; } |
| 0 | 217 |
| 218 // Support for safepoint timeout (debugging) | |
| 219 bool has_called_back() const { return _has_called_back; } | |
| 220 void set_has_called_back(bool val) { _has_called_back = val; } | |
| 221 bool is_at_poll_safepoint() { return _at_poll_safepoint; } | |
| 222 void set_at_poll_safepoint(bool val) { _at_poll_safepoint = val; } | |
| 223 | |
| 224 void handle_polling_page_exception(); | |
| 225 | |
| 226 // debugging | |
| 227 void print_on(outputStream* st) const; | |
| 228 void print() const { print_on(tty); } | |
| 229 | |
| 230 // Initialize | |
| 231 static void create(JavaThread *thread); | |
| 232 static void destroy(JavaThread *thread); | |
| 233 | |
| 234 void safepoint_msg(const char* format, ...) { | |
| 235 if (ShowSafepointMsgs) { | |
| 236 va_list ap; | |
| 237 va_start(ap, format); | |
| 238 tty->vprint_cr(format, ap); | |
| 239 va_end(ap); | |
| 240 } | |
| 241 } | |
| 242 }; | |
| 243 | |
| 1783 | 244 |
| 1972 | 245 |
| 246 #endif // SHARE_VM_RUNTIME_SAFEPOINT_HPP |