Mercurial > hg > truffle
view src/share/vm/utilities/ostream.hpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
author | tamao |
---|---|
date | Tue, 05 Mar 2013 15:36:56 -0800 |
parents | 0598674c0056 |
children | e12c9b3740db |
line wrap: on
line source
/* * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. * */ #ifndef SHARE_VM_UTILITIES_OSTREAM_HPP #define SHARE_VM_UTILITIES_OSTREAM_HPP #include "memory/allocation.hpp" #include "runtime/timer.hpp" // Output streams for printing // // Printing guidelines: // Where possible, please use tty->print() and tty->print_cr(). // For product mode VM warnings use warning() which internally uses tty. // In places where tty is not initialized yet or too much overhead, // we may use jio_printf: // jio_fprintf(defaultStream::output_stream(), "Message"); // This allows for redirection via -XX:+DisplayVMOutputToStdout and // -XX:+DisplayVMOutputToStderr class outputStream : public ResourceObj { protected: int _indentation; // current indentation int _width; // width of the page int _position; // position on the current line int _newlines; // number of '\n' output so far julong _precount; // number of chars output, less _position TimeStamp _stamp; // for time stamps void update_position(const char* s, size_t len); static const char* do_vsnprintf(char* buffer, size_t buflen, const char* format, va_list ap, bool add_cr, size_t& result_len); public: // creation outputStream(int width = 80); outputStream(int width, bool has_time_stamps); // indentation outputStream& indent(); void inc() { _indentation++; }; void dec() { _indentation--; }; void inc(int n) { _indentation += n; }; void dec(int n) { _indentation -= n; }; int indentation() const { return _indentation; } void set_indentation(int i) { _indentation = i; } void fill_to(int col); void move_to(int col, int slop = 6, int min_space = 2); // sizing int width() const { return _width; } int position() const { return _position; } int newlines() const { return _newlines; } julong count() const { return _precount + _position; } void set_count(julong count) { _precount = count - _position; } void set_position(int pos) { _position = pos; } // printing void print(const char* format, ...); void print_cr(const char* format, ...); void vprint(const char *format, va_list argptr); void vprint_cr(const char* format, va_list argptr); void print_raw(const char* str) { write(str, strlen(str)); } void print_raw(const char* str, int len) { write(str, len); } void print_raw_cr(const char* str) { write(str, strlen(str)); cr(); } void print_raw_cr(const char* str, int len){ write(str, len); cr(); } void print_data(void* data, size_t len, bool with_ascii); void put(char ch); void sp(int count = 1); void cr(); void bol() { if (_position > 0) cr(); } // Time stamp TimeStamp& time_stamp() { return _stamp; } void stamp(); void stamp(bool guard, const char* prefix, const char* suffix); void stamp(bool guard) { stamp(guard, "", ": "); } // Date stamp void date_stamp(bool guard, const char* prefix, const char* suffix); // A simplified call that includes a suffix of ": " void date_stamp(bool guard) { date_stamp(guard, "", ": "); } // portable printing of 64 bit integers void print_jlong(jlong value); void print_julong(julong value); // flushing virtual void flush() {} virtual void write(const char* str, size_t len) = 0; virtual void rotate_log() {} // GC log rotation virtual ~outputStream() {} // close properly on deletion void dec_cr() { dec(); cr(); } void inc_cr() { inc(); cr(); } }; // standard output // ANSI C++ name collision extern outputStream* tty; // tty output extern outputStream* gclog_or_tty; // stream for gc log if -Xloggc:<f>, or tty class streamIndentor : public StackObj { private: outputStream* _str; int _amount; public: streamIndentor(outputStream* str, int amt = 2) : _str(str), _amount(amt) { _str->inc(_amount); } ~streamIndentor() { _str->dec(_amount); } }; // advisory locking for the shared tty stream: class ttyLocker: StackObj { friend class ttyUnlocker; private: intx _holder; public: static intx hold_tty(); // returns a "holder" token static void release_tty(intx holder); // must witness same token static bool release_tty_if_locked(); // returns true if lock was released static void break_tty_lock_for_safepoint(intx holder); ttyLocker() { _holder = hold_tty(); } ~ttyLocker() { release_tty(_holder); } }; // Release the tty lock if it's held and reacquire it if it was // locked. Used to avoid lock ordering problems. class ttyUnlocker: StackObj { private: bool _was_locked; public: ttyUnlocker() { _was_locked = ttyLocker::release_tty_if_locked(); } ~ttyUnlocker() { if (_was_locked) { ttyLocker::hold_tty(); } } }; // for writing to strings; buffer will expand automatically class stringStream : public outputStream { protected: char* buffer; size_t buffer_pos; size_t buffer_length; bool buffer_fixed; public: stringStream(size_t initial_bufsize = 256); stringStream(char* fixed_buffer, size_t fixed_buffer_size); ~stringStream(); virtual void write(const char* c, size_t len); size_t size() { return buffer_pos; } const char* base() { return buffer; } void reset() { buffer_pos = 0; _precount = 0; _position = 0; } char* as_string(); }; class fileStream : public outputStream { protected: FILE* _file; bool _need_close; public: fileStream() { _file = NULL; _need_close = false; } fileStream(const char* file_name); fileStream(const char* file_name, const char* opentype); fileStream(FILE* file) { _file = file; _need_close = false; } ~fileStream(); bool is_open() const { return _file != NULL; } void set_need_close(bool b) { _need_close = b;} virtual void write(const char* c, size_t len); size_t read(void *data, size_t size, size_t count) { return ::fread(data, size, count, _file); } char* readln(char *data, int count); int eof() { return feof(_file); } long fileSize(); void rewind() { ::rewind(_file); } void flush(); }; // unlike fileStream, fdStream does unbuffered I/O by calling // open() and write() directly. It is async-safe, but output // from multiple thread may be mixed together. Used by fatal // error handler. class fdStream : public outputStream { protected: int _fd; bool _need_close; public: fdStream(const char* file_name); fdStream(int fd = -1) { _fd = fd; _need_close = false; } ~fdStream(); bool is_open() const { return _fd != -1; } void set_fd(int fd) { _fd = fd; _need_close = false; } int fd() const { return _fd; } virtual void write(const char* c, size_t len); void flush() {}; }; class rotatingFileStream : public fileStream { protected: char* _file_name; jlong _bytes_written; uintx _cur_file_num; // current logfile rotation number, from 0 to MaxGCLogFileNumbers-1 public: rotatingFileStream(const char* file_name); rotatingFileStream(const char* file_name, const char* opentype); rotatingFileStream(FILE* file) : fileStream(file) {} ~rotatingFileStream(); virtual void write(const char* c, size_t len); virtual void rotate_log(); }; void ostream_init(); void ostream_init_log(); void ostream_exit(); void ostream_abort(); // staticBufferStream uses a user-supplied buffer for all formatting. // Used for safe formatting during fatal error handling. Not MT safe. // Do not share the stream between multiple threads. class staticBufferStream : public outputStream { private: char* _buffer; size_t _buflen; outputStream* _outer_stream; public: staticBufferStream(char* buffer, size_t buflen, outputStream *outer_stream); ~staticBufferStream() {}; virtual void write(const char* c, size_t len); void flush(); void print(const char* format, ...); void print_cr(const char* format, ...); void vprint(const char *format, va_list argptr); void vprint_cr(const char* format, va_list argptr); }; // In the non-fixed buffer case an underlying buffer will be created and // managed in C heap. Not MT-safe. class bufferedStream : public outputStream { protected: char* buffer; size_t buffer_pos; size_t buffer_max; size_t buffer_length; bool buffer_fixed; public: bufferedStream(size_t initial_bufsize = 256, size_t bufmax = 1024*1024*10); bufferedStream(char* fixed_buffer, size_t fixed_buffer_size, size_t bufmax = 1024*1024*10); ~bufferedStream(); virtual void write(const char* c, size_t len); size_t size() { return buffer_pos; } const char* base() { return buffer; } void reset() { buffer_pos = 0; _precount = 0; _position = 0; } char* as_string(); }; #define O_BUFLEN 2000 // max size of output of individual print() methods #ifndef PRODUCT class networkStream : public bufferedStream { private: int _socket; public: networkStream(); ~networkStream(); bool connect(const char *host, short port); bool is_open() const { return _socket != -1; } int read(char *buf, size_t len); void close(); virtual void flush(); }; #endif #endif // SHARE_VM_UTILITIES_OSTREAM_HPP