Avoid unnecessary indirection when creating CodeEntries

src/cpu-profiler.cc

 // Copyright 2012 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 26 matching lines @@
 #include "../include/v8-profiler.h"
 
 namespace v8 {
 namespace internal {
 
 static const int kTickSamplesBufferChunkSize = 64 * KB;
 static const int kTickSamplesBufferChunksCount = 16;
 static const int kProfilerStackSize = 64 * KB;
 
 
-ProfilerEventsProcessor::ProfilerEventsProcessor(ProfileGenerator* generator)
+ProfilerEventsProcessor::ProfilerEventsProcessor(
+    ProfileGenerator* generator, CpuProfilesCollection* profiles)
     : Thread(Thread::Options("v8:ProfEvntProc", kProfilerStackSize)),
       generator_(generator),
+      profiles_(profiles),
       running_(true),
       ticks_buffer_(sizeof(TickSampleEventRecord),
                     kTickSamplesBufferChunkSize,
                     kTickSamplesBufferChunksCount),
       enqueue_order_(0) {
 }
 
 
 void ProfilerEventsProcessor::CallbackCreateEvent(Logger::LogEventsAndTags tag,
                                                   const char* prefix,
                                                   Name* name,
                                                   Address start) {
   if (FilterOutCodeCreateEvent(tag)) return;
   CodeEventsContainer evt_rec;
   CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
   rec->type = CodeEventRecord::CODE_CREATION;
   rec->order = ++enqueue_order_;
   rec->start = start;
-  rec->entry = generator_->NewCodeEntry(tag, prefix, name);
+  rec->entry = profiles_->NewCodeEntry(tag, prefix, name);
   rec->size = 1;
   rec->shared = NULL;
   events_buffer_.Enqueue(evt_rec);
 }
 
 
 void ProfilerEventsProcessor::CodeCreateEvent(Logger::LogEventsAndTags tag,
                                               Name* name,
                                               String* resource_name,
                                               int line_number,
                                               Address start,
                                               unsigned size,
                                               Address shared) {
   if (FilterOutCodeCreateEvent(tag)) return;
   CodeEventsContainer evt_rec;
   CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
   rec->type = CodeEventRecord::CODE_CREATION;
   rec->order = ++enqueue_order_;
   rec->start = start;
-  rec->entry = generator_->NewCodeEntry(tag, name, resource_name, line_number);
+  rec->entry = profiles_->NewCodeEntry(tag, name, resource_name, line_number);
   rec->size = size;
   rec->shared = shared;
   events_buffer_.Enqueue(evt_rec);
 }
 
 
 void ProfilerEventsProcessor::CodeCreateEvent(Logger::LogEventsAndTags tag,
                                               const char* name,
                                               Address start,
                                               unsigned size) {
   if (FilterOutCodeCreateEvent(tag)) return;
   CodeEventsContainer evt_rec;
   CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
   rec->type = CodeEventRecord::CODE_CREATION;
   rec->order = ++enqueue_order_;
   rec->start = start;
-  rec->entry = generator_->NewCodeEntry(tag, name);
+  rec->entry = profiles_->NewCodeEntry(tag, name);
   rec->size = size;
   rec->shared = NULL;
   events_buffer_.Enqueue(evt_rec);
 }
 
 
 void ProfilerEventsProcessor::CodeCreateEvent(Logger::LogEventsAndTags tag,
                                               int args_count,
                                               Address start,
                                               unsigned size) {
   if (FilterOutCodeCreateEvent(tag)) return;
   CodeEventsContainer evt_rec;
   CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
   rec->type = CodeEventRecord::CODE_CREATION;
   rec->order = ++enqueue_order_;
   rec->start = start;
-  rec->entry = generator_->NewCodeEntry(tag, args_count);
+  rec->entry = profiles_->NewCodeEntry(tag, args_count);
   rec->size = size;
   rec->shared = NULL;
   events_buffer_.Enqueue(evt_rec);
 }
 
 
 void ProfilerEventsProcessor::CodeMoveEvent(Address from, Address to) {
   CodeEventsContainer evt_rec;
   CodeMoveEventRecord* rec = &evt_rec.CodeMoveEventRecord_;
   rec->type = CodeEventRecord::CODE_MOVE;
@@ skipping 22 matching lines @@
     const char* prefix,
     String* name,
     Address start,
     unsigned size) {
   if (FilterOutCodeCreateEvent(tag)) return;
   CodeEventsContainer evt_rec;
   CodeCreateEventRecord* rec = &evt_rec.CodeCreateEventRecord_;
   rec->type = CodeEventRecord::CODE_CREATION;
   rec->order = ++enqueue_order_;
   rec->start = start;
-  rec->entry = generator_->NewCodeEntry(tag, prefix, name);
+  rec->entry = profiles_->NewCodeEntry(tag, prefix, name);
   rec->size = size;
   events_buffer_.Enqueue(evt_rec);
 }
 
 
 void ProfilerEventsProcessor::AddCurrentStack() {
   TickSampleEventRecord record(enqueue_order_);
   TickSample* sample = &record.sample;
   Isolate* isolate = Isolate::Current();
   sample->state = isolate->current_vm_state();
@@ skipping 260 matching lines @@
   StartProfiling(profiles_->GetName(title), record_samples);
 }
 
 
 void CpuProfiler::StartProcessorIfNotStarted() {
   if (processor_ == NULL) {
     // Disable logging when using the new implementation.
     saved_logging_nesting_ = isolate_->logger()->logging_nesting_;
     isolate_->logger()->logging_nesting_ = 0;
     generator_ = new ProfileGenerator(profiles_);
-    processor_ = new ProfilerEventsProcessor(generator_);
+    processor_ = new ProfilerEventsProcessor(generator_, profiles_);
     is_profiling_ = true;
     processor_->StartSynchronously();
     // Enumerate stuff we already have in the heap.
     if (isolate_->heap()->HasBeenSetUp()) {
       if (!FLAG_prof_browser_mode) {
         bool saved_log_code_flag = FLAG_log_code;
         FLAG_log_code = true;
         isolate_->logger()->LogCodeObjects();
         FLAG_log_code = saved_log_code_flag;
       }
       isolate_->logger()->LogCompiledFunctions();
       isolate_->logger()->LogAccessorCallbacks();
     }
     // Enable stack sampling.
-    Sampler* sampler = reinterpret_cast<Sampler*>(isolate_->logger()->ticker_);
+    Sampler* sampler = isolate_->logger()->sampler();
     sampler->IncreaseProfilingDepth();
     if (!sampler->IsActive()) {
       sampler->Start();
       need_to_stop_sampler_ = true;
     }
   }
 }
 
 
 CpuProfile* CpuProfiler::StopProfiling(const char* title) {
@@ skipping 39 matching lines @@
   processor_->Join();
   delete processor_;
   delete generator_;
   processor_ = NULL;
   generator_ = NULL;
   logger->logging_nesting_ = saved_logging_nesting_;
 }
 
 
 } }  // namespace v8::internal