2009-05-28 07:08:09 +00:00
|
|
|
// Copyright 2006-2009 the V8 project authors. All rights reserved.
|
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
// modification, are permitted provided that the following conditions are
|
|
|
|
// met:
|
|
|
|
//
|
|
|
|
// * Redistributions of source code must retain the above copyright
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
// * Redistributions in binary form must reproduce the above
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
// with the distribution.
|
|
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
#ifndef V8_LOG_UTILS_H_
|
|
|
|
#define V8_LOG_UTILS_H_
|
|
|
|
|
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
|
|
|
|
|
|
|
#ifdef ENABLE_LOGGING_AND_PROFILING
|
|
|
|
|
|
|
|
// A memory buffer that increments its size as you write in it. Size
|
|
|
|
// is incremented with 'block_size' steps, never exceeding 'max_size'.
|
2009-05-28 13:56:32 +00:00
|
|
|
// During growth, memory contents are never copied. At the end of the
|
|
|
|
// buffer an amount of memory specified in 'seal_size' is reserved.
|
|
|
|
// When writing position reaches max_size - seal_size, buffer auto-seals
|
|
|
|
// itself with 'seal' and allows no further writes. Data pointed by
|
|
|
|
// 'seal' must be available during entire LogDynamicBuffer lifetime.
|
2009-05-28 07:08:09 +00:00
|
|
|
//
|
|
|
|
// An instance of this class is created dynamically by Log.
|
|
|
|
class LogDynamicBuffer {
|
|
|
|
public:
|
2009-05-28 13:56:32 +00:00
|
|
|
LogDynamicBuffer(
|
|
|
|
int block_size, int max_size, const char* seal, int seal_size);
|
2009-05-28 07:08:09 +00:00
|
|
|
|
|
|
|
~LogDynamicBuffer();
|
|
|
|
|
|
|
|
// Reads contents of the buffer starting from 'from_pos'. Upon
|
|
|
|
// return, 'dest_buf' is filled with the data. Actual amount of data
|
|
|
|
// filled is returned, it is <= 'buf_size'.
|
|
|
|
int Read(int from_pos, char* dest_buf, int buf_size);
|
|
|
|
|
|
|
|
// Writes 'data' to the buffer, making it larger if necessary. If
|
|
|
|
// data is too big to fit in the buffer, it doesn't get written at
|
2009-05-28 13:56:32 +00:00
|
|
|
// all. In that case, buffer auto-seals itself and stops to accept
|
|
|
|
// any incoming writes. Returns amount of data written (it is either
|
|
|
|
// 'data_size', or 0, if 'data' is too big).
|
2009-05-28 07:08:09 +00:00
|
|
|
int Write(const char* data, int data_size);
|
|
|
|
|
|
|
|
private:
|
|
|
|
void AllocateBlock(int index) {
|
|
|
|
blocks_[index] = NewArray<char>(block_size_);
|
|
|
|
}
|
|
|
|
|
|
|
|
int BlockIndex(int pos) const { return pos / block_size_; }
|
|
|
|
|
|
|
|
int BlocksCount() const { return BlockIndex(max_size_) + 1; }
|
|
|
|
|
|
|
|
int PosInBlock(int pos) const { return pos % block_size_; }
|
|
|
|
|
2009-05-28 13:56:32 +00:00
|
|
|
int Seal();
|
|
|
|
|
|
|
|
int WriteInternal(const char* data, int data_size);
|
|
|
|
|
2009-05-28 07:08:09 +00:00
|
|
|
const int block_size_;
|
|
|
|
const int max_size_;
|
2009-05-28 13:56:32 +00:00
|
|
|
const char* seal_;
|
|
|
|
const int seal_size_;
|
2009-05-28 07:08:09 +00:00
|
|
|
ScopedVector<char*> blocks_;
|
|
|
|
int write_pos_;
|
|
|
|
int block_index_;
|
|
|
|
int block_write_pos_;
|
2009-05-28 13:56:32 +00:00
|
|
|
bool is_sealed_;
|
2009-05-28 07:08:09 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// Functions and data for performing output of log messages.
|
|
|
|
class Log : public AllStatic {
|
|
|
|
public:
|
|
|
|
// Opens stdout for logging.
|
|
|
|
static void OpenStdout();
|
|
|
|
|
|
|
|
// Opens file for logging.
|
|
|
|
static void OpenFile(const char* name);
|
|
|
|
|
|
|
|
// Opens memory buffer for logging.
|
|
|
|
static void OpenMemoryBuffer();
|
|
|
|
|
2009-05-28 13:56:32 +00:00
|
|
|
// Disables logging, but preserves acquired resources.
|
|
|
|
static void stop() { is_stopped_ = true; }
|
|
|
|
|
2009-05-28 07:08:09 +00:00
|
|
|
// Frees all resources acquired in Open... functions.
|
|
|
|
static void Close();
|
|
|
|
|
|
|
|
// See description in include/v8.h.
|
|
|
|
static int GetLogLines(int from_pos, char* dest_buf, int max_size);
|
|
|
|
|
|
|
|
// Returns whether logging is enabled.
|
|
|
|
static bool IsEnabled() {
|
2009-05-28 13:56:32 +00:00
|
|
|
return !is_stopped_ && (output_handle_ != NULL || output_buffer_ != NULL);
|
2009-05-28 07:08:09 +00:00
|
|
|
}
|
|
|
|
|
2009-09-18 12:05:18 +00:00
|
|
|
// Size of buffer used for formatting log messages.
|
2010-03-11 09:48:01 +00:00
|
|
|
static const int kMessageBufferSize = v8::V8::kMinimumSizeForLogLinesBuffer;
|
2009-09-18 12:05:18 +00:00
|
|
|
|
2009-05-28 07:08:09 +00:00
|
|
|
private:
|
|
|
|
typedef int (*WritePtr)(const char* msg, int length);
|
|
|
|
|
|
|
|
// Initialization function called from Open... functions.
|
|
|
|
static void Init();
|
|
|
|
|
|
|
|
// Write functions assume that mutex_ is acquired by the caller.
|
|
|
|
static WritePtr Write;
|
|
|
|
|
|
|
|
// Implementation of writing to a log file.
|
|
|
|
static int WriteToFile(const char* msg, int length) {
|
|
|
|
ASSERT(output_handle_ != NULL);
|
2009-11-11 09:50:06 +00:00
|
|
|
size_t rv = fwrite(msg, 1, length, output_handle_);
|
|
|
|
ASSERT(static_cast<size_t>(length) == rv);
|
|
|
|
USE(rv);
|
2010-09-30 10:50:39 +00:00
|
|
|
fflush(output_handle_);
|
2009-11-11 09:50:06 +00:00
|
|
|
return length;
|
2009-05-28 07:08:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Implementation of writing to a memory buffer.
|
|
|
|
static int WriteToMemory(const char* msg, int length) {
|
|
|
|
ASSERT(output_buffer_ != NULL);
|
|
|
|
return output_buffer_->Write(msg, length);
|
|
|
|
}
|
|
|
|
|
2009-05-28 13:56:32 +00:00
|
|
|
// Whether logging is stopped (e.g. due to insufficient resources).
|
|
|
|
static bool is_stopped_;
|
|
|
|
|
2009-05-28 07:08:09 +00:00
|
|
|
// When logging is active, either output_handle_ or output_buffer_ is used
|
|
|
|
// to store a pointer to log destination. If logging was opened via OpenStdout
|
|
|
|
// or OpenFile, then output_handle_ is used. If logging was opened
|
|
|
|
// via OpenMemoryBuffer, then output_buffer_ is used.
|
|
|
|
// mutex_ should be acquired before using output_handle_ or output_buffer_.
|
|
|
|
static FILE* output_handle_;
|
|
|
|
|
|
|
|
static LogDynamicBuffer* output_buffer_;
|
|
|
|
|
|
|
|
// Size of dynamic buffer block (and dynamic buffer initial size).
|
|
|
|
static const int kDynamicBufferBlockSize = 65536;
|
|
|
|
|
|
|
|
// Maximum size of dynamic buffer.
|
|
|
|
static const int kMaxDynamicBufferSize = 50 * 1024 * 1024;
|
|
|
|
|
2009-05-28 13:56:32 +00:00
|
|
|
// Message to "seal" dynamic buffer with.
|
|
|
|
static const char* kDynamicBufferSeal;
|
|
|
|
|
2009-05-28 07:08:09 +00:00
|
|
|
// mutex_ is a Mutex used for enforcing exclusive
|
|
|
|
// access to the formatting buffer and the log file or log memory buffer.
|
|
|
|
static Mutex* mutex_;
|
|
|
|
|
|
|
|
// Buffer used for formatting log messages. This is a singleton buffer and
|
|
|
|
// mutex_ should be acquired before using it.
|
|
|
|
static char* message_buffer_;
|
|
|
|
|
2009-06-15 09:37:50 +00:00
|
|
|
friend class LogMessageBuilder;
|
|
|
|
friend class LogRecordCompressor;
|
|
|
|
};
|
|
|
|
|
2009-06-11 14:08:34 +00:00
|
|
|
|
2009-06-15 09:37:50 +00:00
|
|
|
// An utility class for performing backward reference compression
|
|
|
|
// of string ends. It operates using a window of previous strings.
|
|
|
|
class LogRecordCompressor {
|
|
|
|
public:
|
|
|
|
// 'window_size' is the size of backward lookup window.
|
|
|
|
explicit LogRecordCompressor(int window_size)
|
|
|
|
: buffer_(window_size + kNoCompressionWindowSize),
|
|
|
|
kMaxBackwardReferenceSize(
|
|
|
|
GetBackwardReferenceSize(window_size, Log::kMessageBufferSize)),
|
|
|
|
curr_(-1), prev_(-1) {
|
|
|
|
}
|
2009-06-11 14:08:34 +00:00
|
|
|
|
2009-06-15 09:37:50 +00:00
|
|
|
~LogRecordCompressor();
|
|
|
|
|
|
|
|
// Fills vector with a compressed version of the previous record.
|
|
|
|
// Returns false if there is no previous record.
|
|
|
|
bool RetrievePreviousCompressed(Vector<char>* prev_record);
|
|
|
|
|
|
|
|
// Stores a record if it differs from a previous one (or there's no previous).
|
|
|
|
// Returns true, if the record has been stored.
|
|
|
|
bool Store(const Vector<const char>& record);
|
|
|
|
|
|
|
|
private:
|
|
|
|
// The minimum size of a buffer: a place needed for the current and
|
|
|
|
// the previous record. Since there is no place for precedessors of a previous
|
|
|
|
// record, it can't be compressed at all.
|
|
|
|
static const int kNoCompressionWindowSize = 2;
|
|
|
|
|
|
|
|
// Formatting strings for back references.
|
|
|
|
static const char* kLineBackwardReferenceFormat;
|
|
|
|
static const char* kBackwardReferenceFormat;
|
|
|
|
|
|
|
|
static int GetBackwardReferenceSize(int distance, int pos);
|
|
|
|
|
|
|
|
static void PrintBackwardReference(Vector<char> dest, int distance, int pos);
|
|
|
|
|
|
|
|
ScopedVector< Vector<const char> > buffer_;
|
|
|
|
const int kMaxBackwardReferenceSize;
|
|
|
|
int curr_;
|
|
|
|
int prev_;
|
2009-05-28 07:08:09 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
// Utility class for formatting log messages. It fills the message into the
|
|
|
|
// static buffer in Log.
|
|
|
|
class LogMessageBuilder BASE_EMBEDDED {
|
|
|
|
public:
|
|
|
|
// Create a message builder starting from position 0. This acquires the mutex
|
|
|
|
// in the log as well.
|
|
|
|
explicit LogMessageBuilder();
|
|
|
|
~LogMessageBuilder() { }
|
|
|
|
|
|
|
|
// Append string data to the log message.
|
|
|
|
void Append(const char* format, ...);
|
|
|
|
|
|
|
|
// Append string data to the log message.
|
2009-06-15 15:49:03 +00:00
|
|
|
void AppendVA(const char* format, va_list args);
|
2009-05-28 07:08:09 +00:00
|
|
|
|
|
|
|
// Append a character to the log message.
|
|
|
|
void Append(const char c);
|
|
|
|
|
|
|
|
// Append a heap string.
|
|
|
|
void Append(String* str);
|
|
|
|
|
2009-06-15 09:37:50 +00:00
|
|
|
// Appends an address, compressing it if needed by offsetting
|
|
|
|
// from Logger::last_address_.
|
|
|
|
void AppendAddress(Address addr);
|
|
|
|
|
|
|
|
// Appends an address, compressing it if needed.
|
|
|
|
void AppendAddress(Address addr, Address bias);
|
|
|
|
|
2009-05-28 07:08:09 +00:00
|
|
|
void AppendDetailed(String* str, bool show_impl_info);
|
|
|
|
|
2009-09-18 12:05:18 +00:00
|
|
|
// Append a portion of a string.
|
|
|
|
void AppendStringPart(const char* str, int len);
|
|
|
|
|
2009-06-11 14:08:34 +00:00
|
|
|
// Stores log message into compressor, returns true if the message
|
2009-06-15 09:37:50 +00:00
|
|
|
// was stored (i.e. doesn't repeat the previous one).
|
|
|
|
bool StoreInCompressor(LogRecordCompressor* compressor);
|
2009-06-11 14:08:34 +00:00
|
|
|
|
|
|
|
// Sets log message to a previous version of compressed message.
|
2009-06-15 09:37:50 +00:00
|
|
|
// Returns false, if there is no previous message.
|
|
|
|
bool RetrieveCompressedPrevious(LogRecordCompressor* compressor) {
|
|
|
|
return RetrieveCompressedPrevious(compressor, "");
|
|
|
|
}
|
2009-06-11 14:08:34 +00:00
|
|
|
|
|
|
|
// Does the same at the version without arguments, and sets a prefix.
|
2009-06-15 09:37:50 +00:00
|
|
|
bool RetrieveCompressedPrevious(LogRecordCompressor* compressor,
|
|
|
|
const char* prefix);
|
2009-06-11 14:08:34 +00:00
|
|
|
|
2009-05-28 07:08:09 +00:00
|
|
|
// Write the log message to the log file currently opened.
|
|
|
|
void WriteToLogFile();
|
|
|
|
|
2009-05-28 13:56:32 +00:00
|
|
|
// A handler that is called when Log::Write fails.
|
|
|
|
typedef void (*WriteFailureHandler)();
|
|
|
|
|
|
|
|
static void set_write_failure_handler(WriteFailureHandler handler) {
|
|
|
|
write_failure_handler = handler;
|
|
|
|
}
|
|
|
|
|
2009-05-28 07:08:09 +00:00
|
|
|
private:
|
2009-05-28 13:56:32 +00:00
|
|
|
static WriteFailureHandler write_failure_handler;
|
|
|
|
|
2009-05-28 07:08:09 +00:00
|
|
|
ScopedLock sl;
|
|
|
|
int pos_;
|
|
|
|
};
|
|
|
|
|
|
|
|
#endif // ENABLE_LOGGING_AND_PROFILING
|
|
|
|
|
|
|
|
} } // namespace v8::internal
|
|
|
|
|
|
|
|
#endif // V8_LOG_UTILS_H_
|