Add a sampling tracing to RenderWidget::DoDeferredUpdate

base/debug/trace_event.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.
 
 // This header file defines the set of trace_event macros without specifying
 // how the events actually get collected and stored. If you need to expose trace
 // events to some other universe, you can copy-and-paste this file as well as
 // trace_event.h, modifying the macros contained there as necessary for the
 // target platform. The end result is that multiple libraries can funnel events
 // through to a shared trace event collector.
@@ skipping 281 matching lines @@
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, \
         category_group, name, TRACE_EVENT_FLAG_COPY | scope, \
         arg1_name, arg1_val, arg2_name, arg2_val)
 
 // Sets the current sample state to the given category and name (both must be
 // constant strings). These states are intended for a sampling profiler.
 // Implementation note: we store category and name together because we don't
 // want the inconsistency/expense of storing two pointers.
 // |thread_bucket| is [0..2] and is used to statically isolate samples in one
 // thread from others.
-#define TRACE_EVENT_SAMPLE_STATE(thread_bucket, category, name)                \
-  TRACE_EVENT_API_ATOMIC_STORE(                                                \
-      TRACE_EVENT_API_THREAD_BUCKET(thread_bucket),                            \
-      reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(category "\0" name));
+#define TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(    \
+    bucket_number, category, name)                    \
+    TRACE_EVENT_API_ATOMIC_STORE(                     \
+        TRACE_EVENT_API_THREAD_BUCKET(bucket_number), \
+        reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(category "\0" name));
+
+// Creates a scope of a sampling state of the given bucket.
+//
+// {  // The sampling state is set within this scope.
+//    TRACE_EVENT_SAMPLING_STATE_SCOPE_FOR_BUCKET(0, "category", "name");

[nduca, 2013/07/03 09:54:34]

bikeshed: how about TRACE_EVENT_SCOPED_SET_SAMPLING_STATE_FOR_BUCKET(...).

[haraken, 2013/07/04 02:03:16]

Done.

+//    ...;
+// }
+#define TRACE_EVENT_SAMPLING_STATE_SCOPE_FOR_BUCKET(                    \
+    bucket_number, category, name)                                      \
+    trace_event_internal::TraceEventSamplingStateScope<bucket_number>   \
+        traceEventSamplingScope(category "\0" name);
+
+// Returns a current sampling state of the current scope of the given bucket.
+#define TRACE_EVENT_SAMPLING_STATE_SCOPE_CURRENT_FOR_BUCKET(bucket_number) \
+    trace_event_internal::TraceEventSamplingStateScope<bucket_number>::Current()
+
+// Updates a sampling state of the current scope of the given bucket.
+// You should use this macro only when the overhead of
+// TRACE_EVENT_SAMPLING_STATE_SCOPE_FOR_BUCKET is not acceptable.
+#define TRACE_EVENT_SAMPLING_STATE_SCOPE_SET_CURRENT_FOR_BUCKET( \
+    bucket_number, category, name)                               \
+      trace_event_internal::                                     \
+      TraceEventSamplingStateScope<bucket_number>::Set(category "\0" name)
+
+// Syntactic sugars for the sampling tracing in the main thread.
+#define TRACE_EVENT_SAMPLING_STATE_SCOPE(category, name) \
+    TRACE_EVENT_SAMPLING_STATE_SCOPE_FOR_BUCKET(0, category, name)
+#define TRACE_EVENT_SAMPLING_STATE_SCOPE_CURRENT() \
+    TRACE_EVENT_SAMPLING_STATE_SCOPE_CURRENT_FOR_BUCKET(0)
+#define TRACE_EVENT_SAMPLING_STATE_SCOPE_SET_CURRENT(category, name) \
+    TRACE_EVENT_SAMPLING_STATE_SCOPE_SET_CURRENT_FOR_BUCKET(0, category, name)
+
 
 // Records a single BEGIN event called "name" immediately, with 0, 1 or 2
 // associated arguments. If the category is not enabled, then this
 // does nothing.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
 #define TRACE_EVENT_BEGIN0(category_group, name) \
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, \
         category_group, name, TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_BEGIN1(category_group, name, arg1_name, arg1_val) \
@@ skipping 432 matching lines @@
 
 // Defines atomic operations used internally by the tracing system.
 #define TRACE_EVENT_API_ATOMIC_WORD base::subtle::AtomicWord
 #define TRACE_EVENT_API_ATOMIC_LOAD(var) base::subtle::NoBarrier_Load(&(var))
 #define TRACE_EVENT_API_ATOMIC_STORE(var, value) \
     base::subtle::NoBarrier_Store(&(var), (value))
 
 // Defines visibility for classes in trace_event.h
 #define TRACE_EVENT_API_CLASS_EXPORT BASE_EXPORT
 
-// Not supported in split-dll build. http://crbug.com/237249
+// Not supported in split-dll build. http://crbug.com/256965
 #if !defined(CHROME_SPLIT_DLL)
 // The thread buckets for the sampling profiler.
-TRACE_EVENT_API_CLASS_EXPORT extern TRACE_EVENT_API_ATOMIC_WORD g_trace_state0;
-TRACE_EVENT_API_CLASS_EXPORT extern TRACE_EVENT_API_ATOMIC_WORD g_trace_state1;
-TRACE_EVENT_API_CLASS_EXPORT extern TRACE_EVENT_API_ATOMIC_WORD g_trace_state2;
+TRACE_EVENT_API_CLASS_EXPORT extern \
+    TRACE_EVENT_API_ATOMIC_WORD g_trace_state[3];
+
 #define TRACE_EVENT_API_THREAD_BUCKET(thread_bucket)                           \
-  g_trace_state##thread_bucket
+    g_trace_state[thread_bucket]
+
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Implementation detail: trace event macros create temporary variables
 // to keep instrumentation overhead low. These macros give each temporary
 // variable a unique name based on the line number to prevent name collissions.
 #define INTERNAL_TRACE_EVENT_UID3(a,b) \
     trace_event_unique_##a##b
 #define INTERNAL_TRACE_EVENT_UID2(a,b) \
@@ skipping 656 matching lines @@
         INTERNAL_TRACE_EVENT_UID(profileScope)( \
             &INTERNAL_TRACE_EVENT_UID(atomic), name); \
 
 // This macro generates less code then TRACE_EVENT0 but is also
 // slower to execute when tracing is off. It should generally only be
 // used with code that is seldom executed or conditionally executed
 // when debugging.
 #define TRACE_EVENT_BINARY_EFFICIENT0(category_group, name) \
     INTERNAL_TRACE_EVENT_BINARY_EFFICIENT_ADD_SCOPED(category_group, name)
 
+// TraceEventSamplingStateScope records the current sampling state
+// and sets a new sampling state. When the scope exists, it restores
+// the sampling state having recorded.
+template<size_t BucketNumber>
+class TraceEventSamplingStateScope {
+ public:
+  TraceEventSamplingStateScope(const char* category_and_name) {
+    previous_state_ = TraceEventSamplingStateScope<BucketNumber>::Current();
+    TraceEventSamplingStateScope<BucketNumber>::Set(category_and_name);
+  }
+
+  ~TraceEventSamplingStateScope() {
+    TraceEventSamplingStateScope<BucketNumber>::Set(previous_state_);
+  }
+
+  static inline const char* Current() {
+    return reinterpret_cast<const char*>(TRACE_EVENT_API_ATOMIC_LOAD(
+      g_trace_state[BucketNumber]));
+  }
+
+  static inline void Set(const char* category_and_name) {
+    TRACE_EVENT_API_ATOMIC_STORE(
+      g_trace_state[BucketNumber],
+      reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(
+        const_cast<char*>(category_and_name)));
+  }
+
+ private:
+  const char* previous_state_;
+};
+
 }  // namespace trace_event_internal
 
 namespace base {
 namespace debug {
 
 template<typename IDType> class TraceScopedTrackableObject {
  public:
   TraceScopedTrackableObject(const char* category_group, const char* name,
       IDType id)
     : category_group_(category_group),
@@ skipping 15 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 } // namespace debug
 } // namespace base
 
 #endif /* BASE_DEBUG_TRACE_EVENT_H_ */