tracing: split out ThreadLocalEventBuffer

base/trace_event/trace_log.cc

 // Copyright 2015 The Chromium 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 "base/trace_event/trace_log.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 #include <utility>
@@ skipping 22 matching lines @@
 #include "base/time/time.h"
 #include "base/trace_event/category_registry.h"
 #include "base/trace_event/event_filter_registry.h"
 #include "base/trace_event/event_name_filter.h"
 #include "base/trace_event/heap_profiler.h"
 #include "base/trace_event/heap_profiler_allocation_context_tracker.h"
 #include "base/trace_event/heap_profiler_event_filter.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/process_memory_dump.h"
+#include "base/trace_event/thread_local_event_buffer.h"
 #include "base/trace_event/trace_buffer.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include "base/trace_event/trace_event_etw_export_win.h"
 #endif
 
 namespace base {
@@ skipping 82 matching lines @@
     DCHECK(!thread_local_boolean_->Get());
     thread_local_boolean_->Set(true);
   }
   ~AutoThreadLocalBoolean() { thread_local_boolean_->Set(false); }
 
  private:
   ThreadLocalBoolean* thread_local_boolean_;
   DISALLOW_COPY_AND_ASSIGN(AutoThreadLocalBoolean);
 };
 
-// Use this function instead of TraceEventHandle constructor to keep the
-// overhead of ScopedTracer (trace_event.h) constructor minimum.
-void MakeHandle(uint32_t chunk_seq,
-                size_t chunk_index,
-                size_t event_index,
-                TraceEventHandle* handle) {
-  DCHECK(chunk_seq);
-  DCHECK(chunk_index <= TraceBufferChunk::kMaxChunkIndex);
-  DCHECK(event_index < TraceBufferChunk::kTraceBufferChunkSize);
-  DCHECK(chunk_index <= std::numeric_limits<uint16_t>::max());
-  handle->chunk_seq = chunk_seq;
-  handle->chunk_index = static_cast<uint16_t>(chunk_index);
-  handle->event_index = static_cast<uint16_t>(event_index);
-}
-
 template <typename Function>
 void ForEachCategoryFilter(const unsigned char* category_group_enabled,
                            Function filter_fn) {
   auto* cat = CategoryRegistry::GetCategoryByStatePtr(category_group_enabled);
   uint32_t filter_bitmap = cat->enabled_filters();
   for (int index = 0; filter_bitmap != 0; filter_bitmap >>= 1, index++) {
     if (filter_bitmap & 1)
       filter_fn(EventFilterRegistry::Get(index));
   }
 }
@@ skipping 17 matching lines @@
       locked_ = true;
     }
   }
 
  private:
   Lock* lock_;
   bool locked_;
   DISALLOW_COPY_AND_ASSIGN(OptionalAutoLock);
 };
 
-class TraceLog::ThreadLocalEventBuffer
-    : public MessageLoop::DestructionObserver,
-      public MemoryDumpProvider {
- public:
-  explicit ThreadLocalEventBuffer(TraceLog* trace_log);
-  ~ThreadLocalEventBuffer() override;
-
-  TraceEvent* AddTraceEvent(TraceEventHandle* handle);
-
-  TraceEvent* GetEventByHandle(TraceEventHandle handle) {
-    if (!chunk_ || handle.chunk_seq != chunk_->seq() ||
-        handle.chunk_index != chunk_index_) {
-      return nullptr;
-    }
-
-    return chunk_->GetEventAt(handle.event_index);
-  }
-
-  int generation() const { return generation_; }
-
- private:
-  // MessageLoop::DestructionObserver
-  void WillDestroyCurrentMessageLoop() override;
-
-  // MemoryDumpProvider implementation.
-  bool OnMemoryDump(const MemoryDumpArgs& args,
-                    ProcessMemoryDump* pmd) override;
-
-  void FlushWhileLocked();
-
-  void CheckThisIsCurrentBuffer() const {
-    DCHECK(trace_log_->thread_local_event_buffer_.Get() == this);
-  }
-
-  // Since TraceLog is a leaky singleton, trace_log_ will always be valid
-  // as long as the thread exists.
-  TraceLog* trace_log_;
-  std::unique_ptr<TraceBufferChunk> chunk_;
-  size_t chunk_index_;
-  int generation_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadLocalEventBuffer);
-};
-
-TraceLog::ThreadLocalEventBuffer::ThreadLocalEventBuffer(TraceLog* trace_log)
-    : trace_log_(trace_log),
-      chunk_index_(0),
-      generation_(trace_log->generation()) {
-  // ThreadLocalEventBuffer is created only if the thread has a message loop, so
-  // the following message_loop won't be NULL.
-  MessageLoop* message_loop = MessageLoop::current();
-  message_loop->AddDestructionObserver(this);
-
-  // This is to report the local memory usage when memory-infra is enabled.
-  MemoryDumpManager::GetInstance()->RegisterDumpProvider(
-      this, "ThreadLocalEventBuffer", ThreadTaskRunnerHandle::Get());
-
-  AutoLock lock(trace_log->lock_);
-  trace_log->thread_message_loops_.insert(message_loop);
-}
-
-TraceLog::ThreadLocalEventBuffer::~ThreadLocalEventBuffer() {
-  CheckThisIsCurrentBuffer();
-  MessageLoop::current()->RemoveDestructionObserver(this);
-  MemoryDumpManager::GetInstance()->UnregisterDumpProvider(this);
-
-  {
-    AutoLock lock(trace_log_->lock_);
-    FlushWhileLocked();
-    trace_log_->thread_message_loops_.erase(MessageLoop::current());
-  }
-  trace_log_->thread_local_event_buffer_.Set(NULL);
-}
-
-TraceEvent* TraceLog::ThreadLocalEventBuffer::AddTraceEvent(
-    TraceEventHandle* handle) {
-  CheckThisIsCurrentBuffer();
-
-  if (chunk_ && chunk_->IsFull()) {
-    AutoLock lock(trace_log_->lock_);
-    FlushWhileLocked();
-    chunk_.reset();
-  }
-  if (!chunk_) {
-    AutoLock lock(trace_log_->lock_);
-    chunk_ = trace_log_->logged_events_->GetChunk(&chunk_index_);
-    trace_log_->CheckIfBufferIsFullWhileLocked();
-  }
-  if (!chunk_)
-    return NULL;
-
-  size_t event_index;
-  TraceEvent* trace_event = chunk_->AddTraceEvent(&event_index);
-  if (trace_event && handle)
-    MakeHandle(chunk_->seq(), chunk_index_, event_index, handle);
-
-  return trace_event;
-}
-
-void TraceLog::ThreadLocalEventBuffer::WillDestroyCurrentMessageLoop() {
-  delete this;
-}
-
-bool TraceLog::ThreadLocalEventBuffer::OnMemoryDump(const MemoryDumpArgs& args,
-                                                    ProcessMemoryDump* pmd) {
-  if (!chunk_)
-    return true;
-  std::string dump_base_name = StringPrintf(
-      "tracing/thread_%d", static_cast<int>(PlatformThread::CurrentId()));
-  TraceEventMemoryOverhead overhead;
-  chunk_->EstimateTraceMemoryOverhead(&overhead);
-  overhead.DumpInto(dump_base_name.c_str(), pmd);
-  return true;
-}
-
-void TraceLog::ThreadLocalEventBuffer::FlushWhileLocked() {
-  if (!chunk_)
-    return;
-
-  trace_log_->lock_.AssertAcquired();
-  if (trace_log_->CheckGeneration(generation_)) {
-    // Return the chunk to the buffer only if the generation matches.
-    trace_log_->logged_events_->ReturnChunk(chunk_index_, std::move(chunk_));
-  }
-  // Otherwise this method may be called from the destructor, or TraceLog will
-  // find the generation mismatch and delete this buffer soon.
-}
-
 struct TraceLog::RegisteredAsyncObserver {
   explicit RegisteredAsyncObserver(WeakPtr<AsyncEnabledStateObserver> observer)
       : observer(observer), task_runner(ThreadTaskRunnerHandle::Get()) {}
   ~RegisteredAsyncObserver() {}
 
   WeakPtr<AsyncEnabledStateObserver> observer;
   scoped_refptr<SequencedTaskRunner> task_runner;
 };
 
+TraceLog::MemoryDumpProviderForThreadLocalBuffer::
+    MemoryDumpProviderForThreadLocalBuffer(
+        ThreadLocalEventBuffer* thread_local_event_buffer)
+    : thread_local_event_buffer_(thread_local_event_buffer) {}
+
+TraceLog::MemoryDumpProviderForThreadLocalBuffer::
+    ~MemoryDumpProviderForThreadLocalBuffer() {}
+
+bool TraceLog::MemoryDumpProviderForThreadLocalBuffer::OnMemoryDump(
+    const MemoryDumpArgs& args,
+    ProcessMemoryDump* pmd) {
+  std::string dump_base_name = StringPrintf(
+      "tracing/thread_%d", static_cast<int>(PlatformThread::CurrentId()));
+  TraceEventMemoryOverhead overhead;
+  TraceBufferChunk* const chunk = thread_local_event_buffer_->chunk();
+  chunk->EstimateTraceMemoryOverhead(&overhead);
+  overhead.DumpInto(dump_base_name.c_str(), pmd);
+  return true;
+}
+
 TraceLogStatus::TraceLogStatus() : event_capacity(0), event_count(0) {}
 
 TraceLogStatus::~TraceLogStatus() {}
 
 // static
 TraceLog* TraceLog::GetInstance() {
   return Singleton<TraceLog, LeakySingletonTraits<TraceLog>>::get();
 }
 
 TraceLog::TraceLog()
@@ skipping 23 matching lines @@
 }
 
 TraceLog::~TraceLog() {}
 
 void TraceLog::InitializeThreadLocalEventBufferIfSupported() {
   // A ThreadLocalEventBuffer needs the message loop
   // - to know when the thread exits;
   // - to handle the final flush.
   // For a thread without a message loop or the message loop may be blocked, the
   // trace events will be added into the main buffer directly.
-  if (thread_blocks_message_loop_.Get() || !MessageLoop::current())
+  MessageLoop* const message_loop = MessageLoop::current();
+  if (thread_blocks_message_loop_.Get() || !message_loop)
     return;
-  HEAP_PROFILER_SCOPED_IGNORE;
+
+  // If the thread-local instance was created during a prior tracing session,
+  // tear it down and re-create it.
   auto* thread_local_event_buffer = thread_local_event_buffer_.Get();
   if (thread_local_event_buffer &&
       !CheckGeneration(thread_local_event_buffer->generation())) {
-    delete thread_local_event_buffer;
-    thread_local_event_buffer = NULL;
+    DestroyThreadLocalEventBufferIfSupported();
+    thread_local_event_buffer = nullptr;
   }
   if (!thread_local_event_buffer) {
-    thread_local_event_buffer = new ThreadLocalEventBuffer(this);
+    HEAP_PROFILER_SCOPED_IGNORE;
+    thread_local_event_buffer = new ThreadLocalEventBuffer(generation());
     thread_local_event_buffer_.Set(thread_local_event_buffer);
+    message_loop->AddDestructionObserver(this);
+    // This is to report the local memory usage when memory-infra is enabled.
+    auto memory_dump_provider =
+        MakeUnique<MemoryDumpProviderForThreadLocalBuffer>(
+            thread_local_event_buffer);
+    MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+        memory_dump_provider.get(), "ThreadLocalEventBuffer",
+        message_loop->task_runner());
+    AutoLock lock(lock_);
+    thread_message_loops_.insert(message_loop);
+    thread_local_mdps_[message_loop] = std::move(memory_dump_provider);
   }
 }
 
+void TraceLog::DestroyThreadLocalEventBufferIfSupported() {
+  auto* thread_local_event_buffer = thread_local_event_buffer_.Get();
+  if (!thread_local_event_buffer)
+    return;
+  HEAP_PROFILER_SCOPED_IGNORE;
+  thread_local_event_buffer->Flush();
+  thread_local_event_buffer_.Set(nullptr);
+  MessageLoop* const message_loop = MessageLoop::current();
+  delete thread_local_event_buffer;
+  message_loop->RemoveDestructionObserver(this);
+
+  AutoLock lock(lock_);
+  thread_message_loops_.erase(message_loop);
+  auto memory_dump_provider_it = thread_local_mdps_.find(message_loop);
+  DCHECK(memory_dump_provider_it != thread_local_mdps_.end());
+  MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      memory_dump_provider_it->second.get());
+  memory_dump_provider_it->second.reset();
+  thread_local_mdps_.erase(memory_dump_provider_it);
+  // TODO order of this !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+}
+
+void TraceLog::WillDestroyCurrentMessageLoop() {
+  DestroyThreadLocalEventBufferIfSupported();
+}
+
 bool TraceLog::OnMemoryDump(const MemoryDumpArgs& args,
                             ProcessMemoryDump* pmd) {
   // TODO(ssid): Use MemoryDumpArgs to create light dumps when requested
   // (crbug.com/499731).
   TraceEventMemoryOverhead overhead;
   overhead.Add("TraceLog", sizeof(*this));
   {
     AutoLock lock(lock_);
     if (logged_events_)
       logged_events_->EstimateTraceMemoryOverhead(&overhead);
@@ skipping 395 matching lines @@
     thread_shared_chunk_ =
         logged_events_->GetChunk(&thread_shared_chunk_index_);
     if (check_buffer_is_full)
       CheckIfBufferIsFullWhileLocked();
   }
   if (!thread_shared_chunk_)
     return NULL;
 
   size_t event_index;
   TraceEvent* trace_event = thread_shared_chunk_->AddTraceEvent(&event_index);
-  if (trace_event && handle) {
-    MakeHandle(thread_shared_chunk_->seq(), thread_shared_chunk_index_,
-               event_index, handle);
+  DCHECK(trace_event);
+  if (handle) {
+    thread_shared_chunk_->MakeHandle(thread_shared_chunk_index_, event_index,
+                                     handle);
   }
   return trace_event;
 }
 
 void TraceLog::CheckIfBufferIsFullWhileLocked() {
   lock_.AssertAcquired();
   if (logged_events_->IsFull()) {
     if (buffer_limit_reached_timestamp_.is_null()) {
       buffer_limit_reached_timestamp_ = OffsetNow();
     }
@@ skipping 153 matching lines @@
 // Run in each thread holding a local event buffer.
 void TraceLog::FlushCurrentThread(int generation, bool discard_events) {
   {
     AutoLock lock(lock_);
     if (!CheckGeneration(generation) || !flush_task_runner_) {
       // This is late. The corresponding flush has finished.
       return;
     }
   }
 
-  // This will flush the thread local buffer.
-  delete thread_local_event_buffer_.Get();
+  DestroyThreadLocalEventBufferIfSupported();
 
   AutoLock lock(lock_);
   if (!CheckGeneration(generation) || !flush_task_runner_ ||
       !thread_message_loops_.empty())
     return;
 
   flush_task_runner_->PostTask(
       FROM_HERE, Bind(&TraceLog::FinishFlush, Unretained(this), generation,
                       discard_events));
 }
@@ skipping 329 matching lines @@
   trace_event->Initialize(
       thread_id, now, thread_now, TRACE_EVENT_PHASE_METADATA,
       category_group_enabled, name,
       trace_event_internal::kGlobalScope,  // scope
       trace_event_internal::kNoId,         // id
       trace_event_internal::kNoId,         // bind_id
       num_args, arg_names, arg_types, arg_values, convertable_values, flags);
   metadata_events_.push_back(std::move(trace_event));
 }
 
+std::unique_ptr<TraceBufferChunk> TraceLog::TakeChunk(size_t* chunk_index) {
+  AutoLock lock(lock_);
+  auto chunk = logged_events_->GetChunk(chunk_index);
+  CheckIfBufferIsFullWhileLocked();
+  return chunk;
+}
+
+void TraceLog::ReturnChunk(std::unique_ptr<TraceBufferChunk> chunk,
+                           int generation,
+                           size_t chunk_index) {
+  AutoLock lock(lock_);
+  // Return the chunk to the buffer only if the generation matches.
+  if (CheckGeneration(generation))
+    logged_events_->ReturnChunk(chunk_index, std::move(chunk));
+}
+
 // May be called when a COMPELETE event ends and the unfinished event has been
 // recycled (phase == TRACE_EVENT_PHASE_END and trace_event == NULL).
 std::string TraceLog::EventToConsoleMessage(unsigned char phase,
                                             const TimeTicks& timestamp,
                                             TraceEvent* trace_event) {
   HEAP_PROFILER_SCOPED_IGNORE;
   AutoLock thread_info_lock(thread_info_lock_);
 
   // The caller should translate TRACE_EVENT_PHASE_COMPLETE to
   // TRACE_EVENT_PHASE_BEGIN or TRACE_EVENT_END.
@@ skipping 261 matching lines @@
 void TraceLog::SetTimeOffset(TimeDelta offset) {
   time_offset_ = offset;
 }
 
 size_t TraceLog::GetObserverCountForTest() const {
   return enabled_state_observer_list_.size();
 }
 
 void TraceLog::SetCurrentThreadBlocksMessageLoop() {
   thread_blocks_message_loop_.Set(true);
-  // This will flush the thread local buffer.
-  delete thread_local_event_buffer_.Get();
+  DestroyThreadLocalEventBufferIfSupported();
 }
 
 TraceBuffer* TraceLog::CreateTraceBuffer() {
   HEAP_PROFILER_SCOPED_IGNORE;
   InternalTraceOptions options = trace_options();
   if (options & kInternalRecordContinuously) {
     return TraceBuffer::CreateTraceBufferRingBuffer(
         kTraceEventRingBufferChunks);
   }
   if (options & kInternalEchoToConsole) {
@@ skipping 81 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
                                                 event_handle_);
   }
 }
 
 }  // namespace trace_event_internal