[WIP] A sampler thread in d8 for consuming the new API.

src/log.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdarg.h>
 
 #include "src/v8.h"
 
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 1045 matching lines @@
     ApiEvent("api,check-security,undefined\n");
   } else {
     ApiEvent("api,check-security,['no-name']\n");
   }
 }
 
 
 void Logger::SharedLibraryEvent(const std::string& library_path,
                                 uintptr_t start,
                                 uintptr_t end) {
+  codeEventHandler()->SharedLibrary(library_path,
+                                    (const void*)start,
+                                    (const void*)end);
   if (!log_->IsEnabled() || !FLAG_prof) return;
   Log::MessageBuilder msg(log_);
   msg.Append("shared-library,\"%s\",0x%08" V8PRIxPTR ",0x%08" V8PRIxPTR "\n",
              library_path.c_str(),
              start,
              end);
   msg.WriteToLogFile();
 }
 
 
@@ skipping 270 matching lines @@
                              Code* code,
                              const char* comment) {
   PROFILER_LOG(CodeCreateEvent(tag, code, comment));
 
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(CodeCreateEvent(tag, code, comment));
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   Log::MessageBuilder msg(log_);
   AppendCodeCreateHeader(&msg, tag, code);
+  msg.StartSubstring();
   msg.AppendDoubleQuotedString(comment);
+  msg.EndSubstring();
   msg.Append('\n');
   msg.WriteToLogFile();
+  std::string code_name;
+  msg.GetSubstring(&code_name);
+  codeEventHandler()->Create((const void*)code->address(),

[Jarin, 2014/08/26 08:23:57]

If you are interested in the address of actual code (without header), you might
want to call code->instruction_start().

+                             (const int)code->ExecutableSize(),
+                             code_name);
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              Name* name) {
   PROFILER_LOG(CodeCreateEvent(tag, code, name));
 
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(CodeCreateEvent(tag, code, name));
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   Log::MessageBuilder msg(log_);
   AppendCodeCreateHeader(&msg, tag, code);
+  msg.StartSubstring();
   if (name->IsString()) {
     msg.Append('"');
     msg.AppendDetailed(String::cast(name), false);
     msg.Append('"');
   } else {
     msg.AppendSymbolName(Symbol::cast(name));
   }
+  msg.EndSubstring();
   msg.Append('\n');
   msg.WriteToLogFile();
+  std::string code_name;
+  msg.GetSubstring(&code_name);
+  codeEventHandler()->Create((const void*)code->address(),
+                             (const int)code->ExecutableSize(),
+                             code_name);
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              SharedFunctionInfo* shared,
                              CompilationInfo* info,
                              Name* name) {
   PROFILER_LOG(CodeCreateEvent(tag, code, shared, info, name));
 
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(CodeCreateEvent(tag, code, shared, info, name));
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   if (code == isolate_->builtins()->builtin(Builtins::kCompileUnoptimized))
     return;
 
   Log::MessageBuilder msg(log_);
   AppendCodeCreateHeader(&msg, tag, code);
+  msg.StartSubstring();
   if (name->IsString()) {
     SmartArrayPointer<char> str =
         String::cast(name)->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
     msg.Append("\"%s\"", str.get());
   } else {
     msg.AppendSymbolName(Symbol::cast(name));
   }
+  msg.EndSubstring();
   msg.Append(',');
   msg.AppendAddress(shared->address());
   msg.Append(",%s", ComputeMarker(code));
   msg.Append('\n');
   msg.WriteToLogFile();
+  std::string code_name;
+  msg.GetSubstring(&code_name);
+  codeEventHandler()->Create((const void*)code->address(),
+                             (const int)code->ExecutableSize(),
+                             code_name);
 }
 
 
 // Although, it is possible to extract source and line from
 // the SharedFunctionInfo object, we left it to caller
 // to leave logging functions free from heap allocations.
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              SharedFunctionInfo* shared,
                              CompilationInfo* info,
                              Name* source, int line, int column) {
   PROFILER_LOG(CodeCreateEvent(tag, code, shared, info, source, line, column));
 
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(CodeCreateEvent(tag, code, shared, info, source, line,
                                  column));
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   Log::MessageBuilder msg(log_);
   AppendCodeCreateHeader(&msg, tag, code);
+  msg.StartSubstring();
   SmartArrayPointer<char> name =
       shared->DebugName()->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
   msg.Append("\"%s ", name.get());
   if (source->IsString()) {
     SmartArrayPointer<char> sourcestr =
        String::cast(source)->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
     msg.Append("%s", sourcestr.get());
   } else {
     msg.AppendSymbolName(Symbol::cast(source));
   }
-  msg.Append(":%d:%d\",", line, column);
+  msg.Append(":%d:%d\"", line, column);
+  msg.EndSubstring();
+  msg.Append(",");
   msg.AppendAddress(shared->address());
   msg.Append(",%s", ComputeMarker(code));
   msg.Append('\n');
   msg.WriteToLogFile();
+  std::string code_name;
+  msg.GetSubstring(&code_name);
+  codeEventHandler()->Create((const void*)code->address(),
+                             (const int)code->ExecutableSize(),
+                             code_name);
 }
 
 
 void Logger::CodeCreateEvent(LogEventsAndTags tag,
                              Code* code,
                              int args_count) {
   PROFILER_LOG(CodeCreateEvent(tag, code, args_count));
 
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(CodeCreateEvent(tag, code, args_count));
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   Log::MessageBuilder msg(log_);
   AppendCodeCreateHeader(&msg, tag, code);
+  msg.StartSubstring();
   msg.Append("\"args_count: %d\"", args_count);
+  msg.EndSubstring();
   msg.Append('\n');
   msg.WriteToLogFile();
+  std::string code_name;
+  msg.GetSubstring(&code_name);
+  codeEventHandler()->Create((const void*)code->address(),
+                             (const int)code->ExecutableSize(),
+                             code_name);
 }
 
 
 void Logger::CodeDisableOptEvent(Code* code,
                                  SharedFunctionInfo* shared) {
   PROFILER_LOG(CodeDisableOptEvent(code, shared));
 
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(CodeDisableOptEvent(code, shared));
 
@@ skipping 20 matching lines @@
 
 void Logger::RegExpCodeCreateEvent(Code* code, String* source) {
   PROFILER_LOG(RegExpCodeCreateEvent(code, source));
 
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(RegExpCodeCreateEvent(code, source));
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   Log::MessageBuilder msg(log_);
   AppendCodeCreateHeader(&msg, REG_EXP_TAG, code);
+  msg.StartSubstring();
   msg.Append('"');
   msg.AppendDetailed(source, false);
   msg.Append('"');
+  msg.EndSubstring();
   msg.Append('\n');
   msg.WriteToLogFile();
+  std::string code_name;
+  msg.GetSubstring(&code_name);
+  codeEventHandler()->Create((const void*)code->address(),
+                             (const int)code->ExecutableSize(),
+                             code_name);
 }
 
 
 void Logger::CodeMoveEvent(Address from, Address to) {
   PROFILER_LOG(CodeMoveEvent(from, to));
-
+  codeEventHandler()->Move((const void*)from,
+                           (const void*)to);
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(CodeMoveEvent(from, to));
   MoveEventInternal(CODE_MOVE_EVENT, from, to);
 }
 
 
 void Logger::CodeDeleteEvent(Address from) {
   PROFILER_LOG(CodeDeleteEvent(from));
+  codeEventHandler()->Delete((const void*)from);

[Jarin, 2014/08/26 08:23:57]

I think this is never called.

 
   if (!is_logging_code_events()) return;
   CALL_LISTENERS(CodeDeleteEvent(from));
 
   if (!FLAG_log_code || !log_->IsEnabled()) return;
   Log::MessageBuilder msg(log_);
   msg.Append("%s,", kLogEventsNames[CODE_DELETE_EVENT]);
   msg.AppendAddress(from);
   msg.Append('\n');
   msg.WriteToLogFile();
@@ skipping 545 matching lines @@
     addCodeEventListener(jit_logger_);
     if (options & kJitCodeEventEnumExisting) {
       HandleScope scope(isolate_);
       LogCodeObjects();
       LogCompiledFunctions();
     }
   }
 }
 
 
+void Logger::SetCodeEventHandler(v8::CodeEventHandler* handler) {
+  code_event_handler_ = handler;
+}
+
+
 Sampler* Logger::sampler() {
   return ticker_;
 }
 
 
+CodeEventHandler* Logger::codeEventHandler() {
+  if (code_event_handler_ == NULL)
+    code_event_handler_ = new StubCodeEventHandler();
+  return code_event_handler_;
+}
+
+
 FILE* Logger::TearDown() {
   if (!is_initialized_) return NULL;
   is_initialized_ = false;
 
   // Stop the profiler before closing the file.
   if (profiler_ != NULL) {
     profiler_->Disengage();
     delete profiler_;
     profiler_ = NULL;
   }
@@ skipping 22 matching lines @@
   if (jit_logger_) {
     removeCodeEventListener(jit_logger_);
     delete jit_logger_;
     jit_logger_ = NULL;
   }
 
   return log_->Close();
 }
 
 } }  // namespace v8::internal