Patch for allowing several V8 instances in process:...

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 100 matching lines @@
     data_pos += write_size;
     if (block_write_pos_ == block_size_) {
       block_write_pos_ = 0;
       AllocateBlock(++block_index_);
     }
   }
   write_pos_ += data_size;
   return data_size;
 }
 
+LogData::LogData()
+  :is_stopped_(false),
+  Write(NULL),
+  output_handle_(NULL),
+  mutex_(NULL),
+  message_buffer_(NULL),
+  write_failure_handler(NULL),
+  output_buffer_(NULL) {
+}
 
-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;
-
+const char Log::kDynamicBufferSeal[] = "profiler,\"pause\"\n";
 
 void Log::Init() {
-  mutex_ = OS::CreateMutex();
-  message_buffer_ = NewArray<char>(kMessageBufferSize);
+  LogData& log_data = v8_context()->log_data_;
+  log_data.mutex_ = OS::CreateMutex();
+  log_data.message_buffer_ = NewArray<char>(kMessageBufferSize);
 }
 
 
 void Log::OpenStdout() {
   ASSERT(!IsEnabled());
-  output_handle_ = stdout;
-  Write = WriteToFile;
+  LogData& log_data = v8_context()->log_data_;
+  log_data.output_handle_ = stdout;
+  log_data.Write = WriteToFile;
   Init();
 }
 
 
 void Log::OpenFile(const char* name) {
   ASSERT(!IsEnabled());
-  output_handle_ = OS::FOpen(name, OS::LogFileOpenMode);
-  Write = WriteToFile;
+  LogData& log_data = v8_context()->log_data_;
+  log_data.output_handle_ = OS::FOpen(name, OS::LogFileOpenMode);
+  log_data.Write = WriteToFile;
   Init();
 }
 
 
 void Log::OpenMemoryBuffer() {
   ASSERT(!IsEnabled());
-  output_buffer_ = new LogDynamicBuffer(
+  LogData& log_data = v8_context()->log_data_;
+  log_data.output_buffer_ = new LogDynamicBuffer(
       kDynamicBufferBlockSize, kMaxDynamicBufferSize,
       kDynamicBufferSeal, StrLength(kDynamicBufferSeal));
-  Write = WriteToMemory;
+  log_data.Write = WriteToMemory;
   Init();
 }
 
 
 void Log::Close() {
-  if (Write == WriteToFile) {
-    if (output_handle_ != NULL) fclose(output_handle_);
-    output_handle_ = NULL;
-  } else if (Write == WriteToMemory) {
-    delete output_buffer_;
-    output_buffer_ = NULL;
+  LogData& log_data = v8_context()->log_data_;
+  if (log_data.Write == WriteToFile) {
+    if (log_data.output_handle_ != NULL) fclose(log_data.output_handle_);
+    log_data.output_handle_ = NULL;
+  } else if (log_data.Write == WriteToMemory) {
+    delete log_data.output_buffer_;
+    log_data.output_buffer_ = NULL;
   } else {
-    ASSERT(Write == NULL);
+    ASSERT(log_data.Write == NULL);
   }
-  Write = NULL;
+  log_data.Write = NULL;
 
-  DeleteArray(message_buffer_);
-  message_buffer_ = NULL;
+  DeleteArray(log_data.message_buffer_);
+  log_data.message_buffer_ = NULL;
 
-  delete mutex_;
-  mutex_ = NULL;
+  delete log_data.mutex_;
+  log_data.mutex_ = NULL;
 
-  is_stopped_ = false;
+  log_data.is_stopped_ = false;
 }
 
 
 int Log::GetLogLines(int from_pos, char* dest_buf, int max_size) {
-  if (Write != WriteToMemory) return 0;
-  ASSERT(output_buffer_ != NULL);
+  LogData& log_data = v8_context()->log_data_;
+  if (log_data.Write != WriteToMemory) return 0;
+  ASSERT(log_data.output_buffer_ != NULL);
   ASSERT(from_pos >= 0);
   ASSERT(max_size >= 0);
-  int actual_size = output_buffer_->Read(from_pos, dest_buf, max_size);
+  int actual_size = log_data.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 = static_cast<int>(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);
+LogMessageBuilder::LogMessageBuilder()
+  :log_data_(v8_context()->log_data_),
+  sl(log_data_.mutex_),
+  pos_(0) {
+  ASSERT(log_data_.message_buffer_ != NULL);
 }
 
 
 void LogMessageBuilder::Append(const char* format, ...) {
-  Vector<char> buf(Log::message_buffer_ + pos_,
+  Vector<char> buf(log_data_.message_buffer_ + pos_,
                    Log::kMessageBufferSize - pos_);
   va_list args;
   va_start(args, format);
   AppendVA(format, args);
   va_end(args);
   ASSERT(pos_ <= Log::kMessageBufferSize);
 }
 
 
 void LogMessageBuilder::AppendVA(const char* format, va_list args) {
-  Vector<char> buf(Log::message_buffer_ + pos_,
+  Vector<char> buf(log_data_.message_buffer_ + pos_,
                    Log::kMessageBufferSize - pos_);
   int result = v8::internal::OS::VSNPrintF(buf, format, args);
 
   // Result is -1 if output was truncated.
   if (result >= 0) {
     pos_ += result;
   } else {
     pos_ = Log::kMessageBufferSize;
   }
   ASSERT(pos_ <= Log::kMessageBufferSize);
 }
 
 
 void LogMessageBuilder::Append(const char c) {
   if (pos_ < Log::kMessageBufferSize) {
-    Log::message_buffer_[pos_++] = c;
+    log_data_.message_buffer_[pos_++] = c;
   }
   ASSERT(pos_ <= Log::kMessageBufferSize);
 }
 
 
 void LogMessageBuilder::Append(String* str) {
   AssertNoAllocation no_heap_allocation;  // Ensure string stay valid.
   int length = str->length();
   for (int i = 0; i < length; i++) {
     Append(static_cast<char>(str->Get(i)));
@@ skipping 57 matching lines @@
   }
 }
 
 
 void LogMessageBuilder::AppendStringPart(const char* str, int len) {
   if (pos_ + len > Log::kMessageBufferSize) {
     len = Log::kMessageBufferSize - pos_;
     ASSERT(len >= 0);
     if (len == 0) return;
   }
-  Vector<char> buf(Log::message_buffer_ + pos_,
+  Vector<char> buf(log_data_.message_buffer_ + pos_,
                    Log::kMessageBufferSize - pos_);
   OS::StrNCpy(buf, str, len);
   pos_ += len;
   ASSERT(pos_ <= Log::kMessageBufferSize);
 }
 
 
 bool LogMessageBuilder::StoreInCompressor(LogRecordCompressor* compressor) {
-  return compressor->Store(Vector<const char>(Log::message_buffer_, pos_));
+  return compressor->Store(Vector<const char>(log_data_.message_buffer_, pos_));
 }
 
 
 bool LogMessageBuilder::RetrieveCompressedPrevious(
     LogRecordCompressor* compressor, const char* prefix) {
   pos_ = 0;
   if (prefix[0] != '\0') Append(prefix);
-  Vector<char> prev_record(Log::message_buffer_ + pos_,
+  Vector<char> prev_record(log_data_.message_buffer_ + pos_,
                            Log::kMessageBufferSize - pos_);
   const bool has_prev = compressor->RetrievePreviousCompressed(&prev_record);
   if (!has_prev) return false;
   pos_ += prev_record.length();
   return true;
 }
 
 
 void LogMessageBuilder::WriteToLogFile() {
   ASSERT(pos_ <= Log::kMessageBufferSize);
-  const int written = Log::Write(Log::message_buffer_, pos_);
-  if (written != pos_ && write_failure_handler != NULL) {
-    write_failure_handler();
+  const int written = log_data_.Write(log_data_.message_buffer_, pos_);
+  if (written != pos_ && log_data_.write_failure_handler != NULL) {
+    log_data_.write_failure_handler();
   }
 }
 
 
 void LogMessageBuilder::WriteCStringToLogFile(const char* str) {
   const int len = StrLength(str);
-  const int written = Log::Write(str, len);
-  if (written != len && write_failure_handler != NULL) {
-    write_failure_handler();
+  const int written = log_data_.Write(str, len);
+  if (written != len && log_data_.write_failure_handler != NULL) {
+    log_data_.write_failure_handler();
   }
 }
 
 
 // Formatting string for back references to the whole line. E.g. "#2" means
 // "the second line above".
 const char* LogRecordCompressor::kLineBackwardReferenceFormat = "#%d";
 
 // Formatting string for back references. E.g. "#2:10" means
 // "the second line above, start from char 10 (0-based)".
@@ skipping 125 matching lines @@
     PrintBackwardReference(backref, best.distance, best.copy_from_pos);
     ASSERT(strlen(backref.start()) - best.backref_size == 0);
     prev_record->Truncate(static_cast<int>(unchanged_len + best.backref_size));
   }
   return true;
 }
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal