Handle filling up of memory buffer to make log processing in DevTools Profiler easier.

src/log-utils.cc

 // Copyright 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
@@ skipping 16 matching lines @@
 
 #include "v8.h"
 
 #include "log-utils.h"
 
 namespace v8 {
 namespace internal {
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
-LogDynamicBuffer::LogDynamicBuffer(int block_size, int max_size)
+LogDynamicBuffer::LogDynamicBuffer(
+    int block_size, int max_size, const char* seal, int seal_size)
     : block_size_(block_size),
       max_size_(max_size - (max_size % block_size_)),
+      seal_(seal),
+      seal_size_(seal_size),
       blocks_(max_size_ / block_size_ + 1),
-      write_pos_(0), block_index_(0), block_write_pos_(0) {
+      write_pos_(0), block_index_(0), block_write_pos_(0), is_sealed_(false) {
   ASSERT(BlocksCount() > 0);
   AllocateBlock(0);
   for (int i = 1; i < BlocksCount(); ++i) {
     blocks_[i] = NULL;
   }
 }
 
 
 LogDynamicBuffer::~LogDynamicBuffer() {
   for (int i = 0; i < BlocksCount(); ++i) {
@@ skipping 19 matching lines @@
     read_pos += read_size;
     if (block_read_pos == block_size_) {
       block_read_pos = 0;
       ++block_read_index;
     }
   }
   return dest_buf_pos;
 }
 
 
+int LogDynamicBuffer::Seal() {
+  WriteInternal(seal_, seal_size_);
+  is_sealed_ = true;
+  return 0;
+}
+
+
 int LogDynamicBuffer::Write(const char* data, int data_size) {
-  if ((write_pos_ + data_size) > max_size_) return 0;
+  if (is_sealed_) return 0;

[Søren Thygesen Gjesse, 2009/05/28 13:23:35]

Please use {} for one line if's.

[Mikhail Naganov, 2009/05/28 13:52:52]

Done.

+  if ((write_pos_ + data_size) <= (max_size_ - seal_size_)) {
+    return WriteInternal(data, data_size);
+  } else {
+    return Seal();
+  }
+}
+
+
+int LogDynamicBuffer::WriteInternal(const char* data, int data_size) {
   int data_pos = 0;
   while (data_pos < data_size) {
     const int write_size =
         Min(data_size - data_pos, block_size_ - block_write_pos_);
     memcpy(blocks_[block_index_] + block_write_pos_, data + data_pos,
            write_size);
     block_write_pos_ += write_size;
     data_pos += write_size;
     if (block_write_pos_ == block_size_) {
       block_write_pos_ = 0;
       AllocateBlock(++block_index_);
     }
   }
   write_pos_ += data_size;
   return data_size;
 }
 
 
+bool Log::is_stopped_ = false;
 Log::WritePtr Log::Write = NULL;
 FILE* Log::output_handle_ = NULL;
 LogDynamicBuffer* Log::output_buffer_ = NULL;
+// Must be the same message as in Logger::PauseProfiler
+const char* Log::kDynamicBufferSeal = "profiler,\"pause\"\n";
 Mutex* Log::mutex_ = NULL;
 char* Log::message_buffer_ = NULL;
 
 
 void Log::Init() {
   mutex_ = OS::CreateMutex();
   message_buffer_ = NewArray<char>(kMessageBufferSize);
 }
 
 
 void Log::OpenStdout() {
   ASSERT(!IsEnabled());
   output_handle_ = stdout;
   Write = WriteToFile;
   Init();
 }
 
 
 void Log::OpenFile(const char* name) {
   ASSERT(!IsEnabled());
   output_handle_ = OS::FOpen(name, OS::LogFileOpenMode);
   Write = WriteToFile;
   Init();
 }
 
 
 void Log::OpenMemoryBuffer() {
   ASSERT(!IsEnabled());
   output_buffer_ = new LogDynamicBuffer(
-      kDynamicBufferBlockSize, kMaxDynamicBufferSize);
+      kDynamicBufferBlockSize, kMaxDynamicBufferSize,
+      kDynamicBufferSeal, strlen(kDynamicBufferSeal));
   Write = WriteToMemory;
   Init();
 }
 
 
 void Log::Close() {
   if (Write == WriteToFile) {
     fclose(output_handle_);
     output_handle_ = NULL;
   } else if (Write == WriteToMemory) {
     delete output_buffer_;
     output_buffer_ = NULL;
   } else {
     ASSERT(Write == NULL);
   }
   Write = NULL;
 
   delete mutex_;
   mutex_ = NULL;
+
+  is_stopped_ = false;
 }
 
 
 int Log::GetLogLines(int from_pos, char* dest_buf, int max_size) {
   if (Write != WriteToMemory) return 0;
   ASSERT(output_buffer_ != NULL);
   ASSERT(from_pos >= 0);
   ASSERT(max_size >= 0);
   int actual_size = output_buffer_->Read(from_pos, dest_buf, max_size);
   ASSERT(actual_size <= max_size);
   if (actual_size == 0) return 0;
 
   // Find previous log line boundary.
   char* end_pos = dest_buf + actual_size - 1;
   while (end_pos >= dest_buf && *end_pos != '\n') --end_pos;
   actual_size = end_pos - dest_buf + 1;
   ASSERT(actual_size <= max_size);
   return actual_size;
 }
 
 
+LogMessageBuilder::WriteFailureHandler
+    LogMessageBuilder::write_failure_handler = NULL;
+
+
 LogMessageBuilder::LogMessageBuilder(): sl(Log::mutex_), pos_(0) {
   ASSERT(Log::message_buffer_ != NULL);
 }
 
 
 void LogMessageBuilder::Append(const char* format, ...) {
   Vector<char> buf(Log::message_buffer_ + pos_,
                    Log::kMessageBufferSize - pos_);
   va_list args;
   va_start(args, format);
@@ skipping 60 matching lines @@
       Append("\\\\");
     } else {
       Append("%lc", c);
     }
   }
 }
 
 
 void LogMessageBuilder::WriteToLogFile() {
   ASSERT(pos_ <= Log::kMessageBufferSize);
-  Log::Write(Log::message_buffer_, pos_);
+  if (pos_ != Log::Write(Log::message_buffer_, pos_)) {

[Søren Thygesen Gjesse, 2009/05/28 13:23:35]

I would suggest the following:

int written = Log::Write(Log::message_buffer_, pos_);
if (written != pos_ && write_failure_handler != NULL) {
  write_failure_handler();
}

[Mikhail Naganov, 2009/05/28 13:52:52]

Done. Thanks for noticing.

+    if (write_failure_handler != NULL) write_failure_handler();
+  }
 }
 
 
 void LogMessageBuilder::WriteCStringToLogFile(const char* str) {
   int len = strlen(str);
-  Log::Write(str, len);
+  if (len != Log::Write(str, len)) {

[Søren Thygesen Gjesse, 2009/05/28 13:23:35]

Ditto.

[Mikhail Naganov, 2009/05/28 13:52:52]

Done.

+    if (write_failure_handler != NULL) write_failure_handler();
+  }
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal