Mercurial > hg > truffle
annotate src/share/vm/utilities/ostream.hpp @ 14649:f6301b007a16
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | de6a9e811145 |
| children | 4ca6dc0799b6 f42c10a3d4b1 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
14223
de6a9e811145
8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013
mikael
parents:
12215
diff
changeset
|
2 * Copyright (c) 1997, 2013, 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:
356
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
356
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:
356
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_UTILITIES_OSTREAM_HPP |
| 26 #define SHARE_VM_UTILITIES_OSTREAM_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
| 29 #include "runtime/timer.hpp" | |
| 30 | |
|
11136
dbc0b5dc08f5
7143807: ResourceMark nesting problem in stringStream
fparain
parents:
10195
diff
changeset
|
31 DEBUG_ONLY(class ResourceMark;) |
|
dbc0b5dc08f5
7143807: ResourceMark nesting problem in stringStream
fparain
parents:
10195
diff
changeset
|
32 |
| 0 | 33 // Output streams for printing |
| 34 // | |
| 35 // Printing guidelines: | |
| 36 // Where possible, please use tty->print() and tty->print_cr(). | |
| 37 // For product mode VM warnings use warning() which internally uses tty. | |
| 38 // In places where tty is not initialized yet or too much overhead, | |
| 39 // we may use jio_printf: | |
| 40 // jio_fprintf(defaultStream::output_stream(), "Message"); | |
| 41 // This allows for redirection via -XX:+DisplayVMOutputToStdout and | |
| 42 // -XX:+DisplayVMOutputToStderr | |
| 43 class outputStream : public ResourceObj { | |
| 44 protected: | |
| 45 int _indentation; // current indentation | |
| 46 int _width; // width of the page | |
| 47 int _position; // position on the current line | |
| 48 int _newlines; // number of '\n' output so far | |
| 49 julong _precount; // number of chars output, less _position | |
| 50 TimeStamp _stamp; // for time stamps | |
| 51 | |
| 52 void update_position(const char* s, size_t len); | |
| 53 static const char* do_vsnprintf(char* buffer, size_t buflen, | |
| 54 const char* format, va_list ap, | |
| 55 bool add_cr, | |
| 56 size_t& result_len); | |
| 57 | |
| 58 public: | |
| 59 // creation | |
| 60 outputStream(int width = 80); | |
| 61 outputStream(int width, bool has_time_stamps); | |
| 62 | |
| 63 // indentation | |
| 6605 | 64 outputStream& indent(); |
| 0 | 65 void inc() { _indentation++; }; |
| 66 void dec() { _indentation--; }; | |
| 6605 | 67 void inc(int n) { _indentation += n; }; |
| 68 void dec(int n) { _indentation -= n; }; | |
| 0 | 69 int indentation() const { return _indentation; } |
| 70 void set_indentation(int i) { _indentation = i; } | |
| 71 void fill_to(int col); | |
|
100
c7c777385a15
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
0
diff
changeset
|
72 void move_to(int col, int slop = 6, int min_space = 2); |
| 0 | 73 |
| 74 // sizing | |
| 75 int width() const { return _width; } | |
| 76 int position() const { return _position; } | |
| 77 int newlines() const { return _newlines; } | |
| 78 julong count() const { return _precount + _position; } | |
| 79 void set_count(julong count) { _precount = count - _position; } | |
| 80 void set_position(int pos) { _position = pos; } | |
| 81 | |
| 82 // printing | |
| 83 void print(const char* format, ...); | |
| 84 void print_cr(const char* format, ...); | |
| 85 void vprint(const char *format, va_list argptr); | |
| 86 void vprint_cr(const char* format, va_list argptr); | |
| 87 void print_raw(const char* str) { write(str, strlen(str)); } | |
| 88 void print_raw(const char* str, int len) { write(str, len); } | |
| 89 void print_raw_cr(const char* str) { write(str, strlen(str)); cr(); } | |
| 90 void print_raw_cr(const char* str, int len){ write(str, len); cr(); } | |
| 6605 | 91 void print_data(void* data, size_t len, bool with_ascii); |
| 0 | 92 void put(char ch); |
|
100
c7c777385a15
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
0
diff
changeset
|
93 void sp(int count = 1); |
| 0 | 94 void cr(); |
| 95 void bol() { if (_position > 0) cr(); } | |
| 96 | |
| 97 // Time stamp | |
| 98 TimeStamp& time_stamp() { return _stamp; } | |
| 99 void stamp(); | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
100
diff
changeset
|
100 void stamp(bool guard, const char* prefix, const char* suffix); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
100
diff
changeset
|
101 void stamp(bool guard) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
100
diff
changeset
|
102 stamp(guard, "", ": "); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
100
diff
changeset
|
103 } |
| 0 | 104 // Date stamp |
| 105 void date_stamp(bool guard, const char* prefix, const char* suffix); | |
| 106 // A simplified call that includes a suffix of ": " | |
| 107 void date_stamp(bool guard) { | |
| 108 date_stamp(guard, "", ": "); | |
| 109 } | |
| 110 | |
| 111 // portable printing of 64 bit integers | |
| 112 void print_jlong(jlong value); | |
| 113 void print_julong(julong value); | |
| 114 | |
| 115 // flushing | |
| 116 virtual void flush() {} | |
| 117 virtual void write(const char* str, size_t len) = 0; | |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
118 virtual void rotate_log() {} // GC log rotation |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
119 virtual ~outputStream() {} // close properly on deletion |
| 0 | 120 |
| 121 void dec_cr() { dec(); cr(); } | |
| 122 void inc_cr() { inc(); cr(); } | |
| 123 }; | |
| 124 | |
| 125 // standard output | |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
126 // ANSI C++ name collision |
| 0 | 127 extern outputStream* tty; // tty output |
| 128 extern outputStream* gclog_or_tty; // stream for gc log if -Xloggc:<f>, or tty | |
| 129 | |
| 6605 | 130 class streamIndentor : public StackObj { |
| 131 private: | |
| 132 outputStream* _str; | |
| 133 int _amount; | |
| 134 | |
| 135 public: | |
| 136 streamIndentor(outputStream* str, int amt = 2) : _str(str), _amount(amt) { | |
| 137 _str->inc(_amount); | |
| 138 } | |
| 139 ~streamIndentor() { _str->dec(_amount); } | |
| 140 }; | |
| 141 | |
| 142 | |
| 0 | 143 // advisory locking for the shared tty stream: |
| 144 class ttyLocker: StackObj { | |
|
2263
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
145 friend class ttyUnlocker; |
| 0 | 146 private: |
| 147 intx _holder; | |
| 148 | |
| 149 public: | |
| 150 static intx hold_tty(); // returns a "holder" token | |
| 151 static void release_tty(intx holder); // must witness same token | |
|
2263
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
152 static bool release_tty_if_locked(); // returns true if lock was released |
| 0 | 153 static void break_tty_lock_for_safepoint(intx holder); |
| 154 | |
| 155 ttyLocker() { _holder = hold_tty(); } | |
| 156 ~ttyLocker() { release_tty(_holder); } | |
| 157 }; | |
| 158 | |
|
2263
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
159 // Release the tty lock if it's held and reacquire it if it was |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
160 // locked. Used to avoid lock ordering problems. |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
161 class ttyUnlocker: StackObj { |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
162 private: |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
163 bool _was_locked; |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
164 public: |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
165 ttyUnlocker() { |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
166 _was_locked = ttyLocker::release_tty_if_locked(); |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
167 } |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
168 ~ttyUnlocker() { |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
169 if (_was_locked) { |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
170 ttyLocker::hold_tty(); |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
171 } |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
172 } |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
173 }; |
|
5841dc1964f0
7021531: lock ordering problems after fix for 6354181
never
parents:
2199
diff
changeset
|
174 |
| 0 | 175 // for writing to strings; buffer will expand automatically |
| 176 class stringStream : public outputStream { | |
| 177 protected: | |
| 178 char* buffer; | |
| 179 size_t buffer_pos; | |
| 180 size_t buffer_length; | |
| 181 bool buffer_fixed; | |
|
11136
dbc0b5dc08f5
7143807: ResourceMark nesting problem in stringStream
fparain
parents:
10195
diff
changeset
|
182 DEBUG_ONLY(ResourceMark* rm;) |
| 0 | 183 public: |
| 184 stringStream(size_t initial_bufsize = 256); | |
| 185 stringStream(char* fixed_buffer, size_t fixed_buffer_size); | |
| 186 ~stringStream(); | |
| 187 virtual void write(const char* c, size_t len); | |
| 188 size_t size() { return buffer_pos; } | |
| 189 const char* base() { return buffer; } | |
| 190 void reset() { buffer_pos = 0; _precount = 0; _position = 0; } | |
| 191 char* as_string(); | |
| 192 }; | |
| 193 | |
| 194 class fileStream : public outputStream { | |
| 195 protected: | |
| 196 FILE* _file; | |
| 197 bool _need_close; | |
| 198 public: | |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
199 fileStream() { _file = NULL; _need_close = false; } |
| 0 | 200 fileStream(const char* file_name); |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
1972
diff
changeset
|
201 fileStream(const char* file_name, const char* opentype); |
|
10195
e12c9b3740db
8012260: ciReplay: Include PID into the name of replay data file
vlivanov
parents:
8108
diff
changeset
|
202 fileStream(FILE* file, bool need_close = false) { _file = file; _need_close = need_close; } |
| 0 | 203 ~fileStream(); |
| 204 bool is_open() const { return _file != NULL; } | |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
1972
diff
changeset
|
205 void set_need_close(bool b) { _need_close = b;} |
| 0 | 206 virtual void write(const char* c, size_t len); |
|
2199
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
1972
diff
changeset
|
207 size_t read(void *data, size_t size, size_t count) { return ::fread(data, size, count, _file); } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
1972
diff
changeset
|
208 char* readln(char *data, int count); |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
1972
diff
changeset
|
209 int eof() { return feof(_file); } |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
1972
diff
changeset
|
210 long fileSize(); |
|
d8a72fbc4be7
7003401: Implement VM error-reporting functionality on erroneous termination
kamg
parents:
1972
diff
changeset
|
211 void rewind() { ::rewind(_file); } |
| 0 | 212 void flush(); |
| 213 }; | |
| 214 | |
| 215 // unlike fileStream, fdStream does unbuffered I/O by calling | |
| 216 // open() and write() directly. It is async-safe, but output | |
| 217 // from multiple thread may be mixed together. Used by fatal | |
| 218 // error handler. | |
| 219 class fdStream : public outputStream { | |
| 220 protected: | |
| 221 int _fd; | |
| 222 bool _need_close; | |
| 223 public: | |
| 224 fdStream(const char* file_name); | |
| 225 fdStream(int fd = -1) { _fd = fd; _need_close = false; } | |
| 226 ~fdStream(); | |
| 227 bool is_open() const { return _fd != -1; } | |
| 228 void set_fd(int fd) { _fd = fd; _need_close = false; } | |
| 229 int fd() const { return _fd; } | |
| 230 virtual void write(const char* c, size_t len); | |
| 231 void flush() {}; | |
| 232 }; | |
| 233 | |
| 12215 | 234 class gcLogFileStream : public fileStream { |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
235 protected: |
| 12215 | 236 const char* _file_name; |
|
8108
0598674c0056
8008314: Unimplemented() Atomic::load breaks the applications
jwilhelm
parents:
6605
diff
changeset
|
237 jlong _bytes_written; |
| 12215 | 238 uintx _cur_file_num; // current logfile rotation number, from 0 to NumberOfGCLogFiles-1 |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
239 public: |
| 12215 | 240 gcLogFileStream(const char* file_name); |
| 241 ~gcLogFileStream(); | |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
242 virtual void write(const char* c, size_t len); |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
243 virtual void rotate_log(); |
| 12215 | 244 void dump_loggc_header(); |
|
3767
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
245 }; |
|
2a241e764894
6941923: RFE: Handling large log files produced by long running Java Applications
minqi
parents:
2426
diff
changeset
|
246 |
| 12215 | 247 #ifndef PRODUCT |
| 248 // unit test for checking -Xloggc:<filename> parsing result | |
| 249 void test_loggc_filename(); | |
| 250 #endif | |
| 251 | |
| 0 | 252 void ostream_init(); |
| 253 void ostream_init_log(); | |
| 254 void ostream_exit(); | |
| 255 void ostream_abort(); | |
| 256 | |
| 257 // staticBufferStream uses a user-supplied buffer for all formatting. | |
| 258 // Used for safe formatting during fatal error handling. Not MT safe. | |
| 259 // Do not share the stream between multiple threads. | |
| 260 class staticBufferStream : public outputStream { | |
| 261 private: | |
| 262 char* _buffer; | |
| 263 size_t _buflen; | |
| 264 outputStream* _outer_stream; | |
| 265 public: | |
| 266 staticBufferStream(char* buffer, size_t buflen, | |
| 267 outputStream *outer_stream); | |
| 268 ~staticBufferStream() {}; | |
| 269 virtual void write(const char* c, size_t len); | |
| 270 void flush(); | |
| 271 void print(const char* format, ...); | |
| 272 void print_cr(const char* format, ...); | |
| 273 void vprint(const char *format, va_list argptr); | |
| 274 void vprint_cr(const char* format, va_list argptr); | |
| 275 }; | |
| 276 | |
| 277 // In the non-fixed buffer case an underlying buffer will be created and | |
| 278 // managed in C heap. Not MT-safe. | |
| 279 class bufferedStream : public outputStream { | |
| 280 protected: | |
| 281 char* buffer; | |
| 282 size_t buffer_pos; | |
| 222 | 283 size_t buffer_max; |
| 0 | 284 size_t buffer_length; |
| 285 bool buffer_fixed; | |
| 286 public: | |
| 222 | 287 bufferedStream(size_t initial_bufsize = 256, size_t bufmax = 1024*1024*10); |
| 288 bufferedStream(char* fixed_buffer, size_t fixed_buffer_size, size_t bufmax = 1024*1024*10); | |
| 0 | 289 ~bufferedStream(); |
| 290 virtual void write(const char* c, size_t len); | |
| 291 size_t size() { return buffer_pos; } | |
| 292 const char* base() { return buffer; } | |
| 293 void reset() { buffer_pos = 0; _precount = 0; _position = 0; } | |
| 294 char* as_string(); | |
| 295 }; | |
| 296 | |
| 297 #define O_BUFLEN 2000 // max size of output of individual print() methods | |
| 298 | |
| 299 #ifndef PRODUCT | |
| 300 | |
| 301 class networkStream : public bufferedStream { | |
| 302 | |
| 303 private: | |
| 304 int _socket; | |
| 305 | |
| 306 public: | |
| 307 networkStream(); | |
| 308 ~networkStream(); | |
| 309 | |
| 310 bool connect(const char *host, short port); | |
| 311 bool is_open() const { return _socket != -1; } | |
| 312 int read(char *buf, size_t len); | |
| 313 void close(); | |
| 314 virtual void flush(); | |
| 315 }; | |
| 316 | |
| 317 #endif | |
| 1972 | 318 |
| 319 #endif // SHARE_VM_UTILITIES_OSTREAM_HPP |