Thread-local trace-event buffers

base/debug/trace_event_impl.h

 // Copyright (c) 2012 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_DEBUG_TRACE_EVENT_IMPL_H_
 #define BASE_DEBUG_TRACE_EVENT_IMPL_H_
 
 #include <stack>
 #include <string>
 #include <vector>
 
+#include "base/atomicops.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
+#include "base/threading/thread_local.h"
 #include "base/timer/timer.h"
 
 // Older style trace macros with explicit id and extra data
 // Only these macros result in publishing data to ETW as currently implemented.
 #define TRACE_EVENT_BEGIN_ETW(name, id, extra) \
     base::debug::TraceLog::AddTraceEventEtw( \
         TRACE_EVENT_PHASE_BEGIN, \
         name, reinterpret_cast<const void*>(id), extra)
 
 #define TRACE_EVENT_END_ETW(name, id, extra) \
     base::debug::TraceLog::AddTraceEventEtw( \
         TRACE_EVENT_PHASE_END, \
         name, reinterpret_cast<const void*>(id), extra)
 
 #define TRACE_EVENT_INSTANT_ETW(name, id, extra) \
     base::debug::TraceLog::AddTraceEventEtw( \
         TRACE_EVENT_PHASE_INSTANT, \
         name, reinterpret_cast<const void*>(id), extra)
 
 template <typename Type>
 struct DefaultSingletonTraits;
 
+#if defined(COMPILER_GCC)
+namespace BASE_HASH_NAMESPACE {
+template <>
+struct hash<base::MessageLoop*> {
+  std::size_t operator()(base::MessageLoop* value) const {
+    return reinterpret_cast<std::size_t>(value);
+  }
+};
+}
+#endif
+
 namespace base {
 
 class WaitableEvent;
+class MessageLoop;
 
 namespace debug {
 
 // For any argument of type TRACE_VALUE_TYPE_CONVERTABLE the provided
 // class must implement this interface.
 class ConvertableToTraceFormat {
  public:
   virtual ~ConvertableToTraceFormat() {}
 
   // Append the class info to the provided |out| string. The appended
@@ skipping 43 matching lines @@
                                  size_t count,
                                  std::string* out);
   void AppendAsJSON(std::string* out) const;
   void AppendPrettyPrinted(std::ostringstream* out) const;
 
   static void AppendValueAsJSON(unsigned char type,
                                 TraceValue value,
                                 std::string* out);
 
   TimeTicks timestamp() const { return timestamp_; }
+  char phase() const { return phase_; }
+  int thread_id() const { return thread_id_; }
 
   // Exposed for unittesting:
 
   const base::RefCountedString* parameter_copy_storage() const {
     return parameter_copy_storage_.get();
   }
 
   const unsigned char* category_group_enabled() const {
     return category_group_enabled_;
   }
@@ skipping 397 matching lines @@
     // notifications from previous calls to AddNotificationWhileLocked, this
     // will call the NotificationCallback.
     inline void SendNotificationIfAny();
 
    private:
     TraceLog* trace_log_;
     NotificationCallback callback_copy_;
     int notification_;
   };
 
+  class ThreadLocalEventBuffer;
+
   TraceLog();
   ~TraceLog();
   const unsigned char* GetCategoryGroupEnabledInternal(const char* name);
   void AddMetadataEvents();
 
+  void EnableEchoToConsole(bool enable);
+
 #if defined(OS_ANDROID)
   void SendToATrace(char phase,
                     const char* category_group,
                     const char* name,
                     unsigned long long id,
                     int num_args,
                     const char** arg_names,
                     const unsigned char* arg_types,
                     const unsigned long long* arg_values,
                     scoped_ptr<ConvertableToTraceFormat> convertable_values[],
                     unsigned char flags);
   static void ApplyATraceEnabledFlag(unsigned char* category_group_enabled);
 #endif
 
   TraceBuffer* GetTraceBuffer();
 
-  // TODO(nduca): switch to per-thread trace buffers to reduce thread
-  // synchronization.
+  bool AddEventToMainBufferWhileLocked(const TraceEvent& trace_event,
+                                       NotificationHelper* notifier);
+  void FlushNextThreadOrFinish();
+  void FlushCurrentThreadAndContinue();
+
   // This lock protects TraceLog member accesses from arbitrary threads.
   Lock lock_;
   int enable_count_;
   int num_traces_recorded_;
+  subtle::AtomicWord /* bool */ buffer_is_full_;
   NotificationCallback notification_callback_;
   scoped_ptr<TraceBuffer> logged_events_;
-  EventCallback event_callback_;
+  subtle::AtomicWord /* EventCallback */ event_callback_;
   bool dispatching_to_observer_list_;
   std::vector<EnabledStateObserver*> enabled_state_observer_list_;
 
   std::string process_name_;
   base::hash_map<int, std::string> process_labels_;
   int process_sort_index_;
   base::hash_map<int, int> thread_sort_indices_;
 
   base::hash_map<int, std::string> thread_names_;
-  base::hash_map<int, std::stack<TimeTicks> > thread_event_start_times_;
-  base::hash_map<std::string, int> thread_colors_;
+
+  subtle::AtomicWord /* EchoToConsoleContext* */ echo_to_console_context_;
 
   // XORed with TraceID to make it unlikely to collide with other processes.
   unsigned long long process_id_hash_;
 
   int process_id_;
 
   TimeDelta time_offset_;
 
   // Allow tests to wake up when certain events occur.
-  const unsigned char* watch_category_;
+  subtle::AtomicWord /* const unsigned char* */ watch_category_;
   std::string watch_event_name_;
 
   Options trace_options_;
 
   // Sampling thread handles.
   scoped_ptr<TraceSamplingThread> sampling_thread_;
   PlatformThreadHandle sampling_thread_handle_;
 
   CategoryFilter category_filter_;
 
+  ThreadLocalPointer<ThreadLocalEventBuffer> thread_local_event_buffer_;
+
+  // Contains the message loops of threads that have had at least one event
+  // is added into the local event buffer.

[dsinclair, 2013/08/16 14:38:32]

s/is//

[Xianzhu, 2013/08/16 19:41:03]

Done.

+  base::hash_set<MessageLoop*> thread_message_loops_;
+
+  // Set when asynchronous Flush is in progress.
+  OutputCallback flush_output_callback_;
+  MessageLoop* flush_message_loop_;
+
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_