tracing: split out ThreadLocalEventBuffer

base/trace_event/trace_log.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_TRACE_LOG_H_
 #define BASE_TRACE_EVENT_TRACE_LOG_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
+#include "base/message_loop/message_loop.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/trace_config.h"
 #include "base/trace_event/trace_event_impl.h"
 #include "build/build_config.h"
 
 namespace base {
 
 template <typename Type>
 struct DefaultSingletonTraits;
 class MessageLoop;
 class RefCountedString;
 
 namespace trace_event {
 
+class ThreadLocalEventBuffer;
 struct TraceCategory;
 class TraceBuffer;
 class TraceBufferChunk;
 class TraceEvent;
 class TraceEventMemoryOverhead;
 
 struct BASE_EXPORT TraceLogStatus {
   TraceLogStatus();
   ~TraceLogStatus();
   uint32_t event_capacity;
   uint32_t event_count;
 };
 
-class BASE_EXPORT TraceLog : public MemoryDumpProvider {
+class BASE_EXPORT TraceLog : public MessageLoop::DestructionObserver,
+                             public MemoryDumpProvider {
  public:
   // Argument passed to TraceLog::SetEnabled.
   enum Mode : uint8_t {
     // Enables normal tracing (recording trace events in the trace buffer).
     RECORDING_MODE = 1 << 0,
 
     // Trace events are enabled just for filtering but not for recording. Only
     // event filters config of |trace_config| argument is used.
     FILTERING_MODE = 1 << 1
   };
 
   static TraceLog* GetInstance();
 
   // Get set of known category groups. This can change as new code paths are
   // reached. The known category groups are inserted into |category_groups|.
   void GetKnownCategoryGroups(std::vector<std::string>* category_groups);
 
   // Retrieves a copy (for thread-safety) of the current TraceConfig.
   TraceConfig GetCurrentTraceConfig() const;
 
   // Initializes the thread-local event buffer, if not already initialized and
   // if the current thread supports that (has a message loop).
   void InitializeThreadLocalEventBufferIfSupported();
+  void DestroyThreadLocalEventBufferIfSupported();
 
   // See TraceConfig comments for details on how to control which categories
   // will be traced. SetDisabled must be called distinctly for each mode that is
   // enabled. If tracing has already been enabled for recording, category filter
   // (enabled and disabled categories) will be merged into the current category
   // filter. Enabling RECORDING_MODE does not enable filters. Trace event
   // filters will be used only if FILTERING_MODE is set on |modes_to_enable|.
   // Conversely to RECORDING_MODE, FILTERING_MODE doesn't support upgrading,
   // i.e. filters can only be enabled if not previously enabled.
   void SetEnabled(const TraceConfig& trace_config, uint8_t modes_to_enable);
@@ skipping 188 matching lines @@
                                 TraceEventHandle handle);
 
   void EndFilteredEvent(const unsigned char* category_group_enabled,
                         const char* name,
                         TraceEventHandle handle);
 
   int process_id() const { return process_id_; }
 
   uint64_t MangleEventId(uint64_t id);
 
+  // Functions to exchange chunks with the ThreadLocalEventBuffer. Ownership of
+  // |logged_events_| chunks is trasnferred to each thread and moved back to
+  // the TraceLog once the thread-local instance has filled the chunk, or upon
+  // flush (end of tracing).
+  std::unique_ptr<TraceBufferChunk> TakeChunk(size_t* chunk_index);
+  void ReturnChunk(std::unique_ptr<TraceBufferChunk>,
+                   int generation,
+                   size_t chunk_index);
+
   // Exposed for unittesting:
 
   // Allows deleting our singleton instance.
   static void DeleteForTesting();
 
   // Allow tests to inspect TraceEvents.
   TraceEvent* GetEventByHandle(TraceEventHandle handle);
 
   void SetProcessID(int process_id);
 
@@ skipping 28 matching lines @@
   void SetCurrentThreadBlocksMessageLoop();
 
 #if defined(OS_WIN)
   // This function is called by the ETW exporting module whenever the ETW
   // keyword (flags) changes. This keyword indicates which categories should be
   // exported, so whenever it changes, we adjust accordingly.
   void UpdateETWCategoryGroupEnabledFlags();
 #endif
 
  private:
+  // Used to report the overhead of each thread-local instance to memory-infra.
+  class MemoryDumpProviderForThreadLocalBuffer : public MemoryDumpProvider {
+   public:
+    explicit MemoryDumpProviderForThreadLocalBuffer(ThreadLocalEventBuffer*);
+    ~MemoryDumpProviderForThreadLocalBuffer() override;
+
+    bool OnMemoryDump(const MemoryDumpArgs&, ProcessMemoryDump*) override;
+
+   private:
+    ThreadLocalEventBuffer* const thread_local_event_buffer_;
+
+    DISALLOW_COPY_AND_ASSIGN(MemoryDumpProviderForThreadLocalBuffer);
+  };
+
   typedef unsigned int InternalTraceOptions;
 
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferGetReturnChunk);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferHalfIteration);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferFullIteration);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture, TraceBufferVectorReportFull);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            ConvertTraceConfigToInternalOptions);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceRecordAsMuchAsPossibleMode);
 
   // This allows constructor and destructor to be private and usable only
   // by the Singleton class.
   friend struct DefaultSingletonTraits<TraceLog>;
 
   // MemoryDumpProvider implementation.
   bool OnMemoryDump(const MemoryDumpArgs& args,
                     ProcessMemoryDump* pmd) override;
 
+  // MessageLoop::DestructionObserver implementation.
+  void WillDestroyCurrentMessageLoop() override;
+
   // Enable/disable each category group based on the current mode_,
   // category_filter_ and event_filters_enabled_.
   // Enable the category group in the recording mode if category_filter_ matches
   // the category group, is not null. Enable category for filtering if any
   // filter in event_filters_enabled_ enables it.
   void UpdateCategoryRegistry();
   void UpdateCategoryState(TraceCategory* category);
 
   void CreateFiltersForTraceConfig();
 
   // Configure synthetic delays based on the values set in the current
   // trace config.
   void UpdateSyntheticDelaysFromTraceConfig();
 
   InternalTraceOptions GetInternalOptionsFromTraceConfig(
       const TraceConfig& config);
 
-  class ThreadLocalEventBuffer;
   class OptionalAutoLock;
   struct RegisteredAsyncObserver;
 
   TraceLog();
   ~TraceLog() override;
   void AddMetadataEventsWhileLocked();
 
   InternalTraceOptions trace_options() const {
     return static_cast<InternalTraceOptions>(
         subtle::NoBarrier_Load(&trace_options_));
@@ skipping 92 matching lines @@
 
   ThreadLocalPointer<ThreadLocalEventBuffer> thread_local_event_buffer_;
   ThreadLocalBoolean thread_blocks_message_loop_;
   ThreadLocalBoolean thread_is_in_trace_event_;
 
   // Contains the message loops of threads that have had at least one event
   // added into the local event buffer. Not using SingleThreadTaskRunner
   // because we need to know the life time of the message loops.
   hash_set<MessageLoop*> thread_message_loops_;
 
+  // Maps each MessageLoop to the corresponding MDP that is used to report the
+  // overhead of the ThreadLocalEventBuffer.
+  std::unordered_map<MessageLoop*,
+                     std::unique_ptr<MemoryDumpProviderForThreadLocalBuffer>>
+      thread_local_mdps_;
+
+  // TODO get rid of this and use a locked writer. ////////////////////////////////////
   // For events which can't be added into the thread local buffer, e.g. events
   // from threads without a message loop.
   std::unique_ptr<TraceBufferChunk> thread_shared_chunk_;
   size_t thread_shared_chunk_index_;
 
   // Set when asynchronous Flush is in progress.
   OutputCallback flush_output_callback_;
   scoped_refptr<SingleThreadTaskRunner> flush_task_runner_;
   ArgumentFilterPredicate argument_filter_predicate_;
   subtle::AtomicWord generation_;
   bool use_worker_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_LOG_H_