Replaced std::string argument storage in gpu_trace_event with faster TraceAnyType

gpu/common/gpu_trace_event.h

 // Copyright (c) 2011 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.
 
 // Trace events are for tracking application performance.
 //
 // Events are issued against categories. Whereas LOG's
 // categories are statically defined, TRACE categories are created
 // implicitly with a string. For example:
 //   GPU_TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent")
@@ skipping 54 matching lines @@
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/atomicops.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/singleton.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/callback.h"
+#include "base/string_util.h"
 #include <vector>
 
 
 // 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 GPU_TRACE_EVENT_UNIQUE_IDENTIFIER3(a,b) a##b
 #define GPU_TRACE_EVENT_UNIQUE_IDENTIFIER2(a,b) \
   GPU_TRACE_EVENT_UNIQUE_IDENTIFIER3(a,b)
 #define GPU_TRACE_EVENT_UNIQUE_IDENTIFIER(name_prefix) \
@@ skipping 107 matching lines @@
 };
 
 #define TRACE_MAX_NUM_ARGS 2
 
 enum TraceEventPhase {
   GPU_TRACE_EVENT_PHASE_BEGIN,
   GPU_TRACE_EVENT_PHASE_END,
   GPU_TRACE_EVENT_PHASE_INSTANT
 };
 
+// Simple union of values. This is much lighter weight than base::Value, which
+// requires dynamic allocation and a vtable. To keep the trace runtime overhead
+// low, we want constant size storage here.
+class TraceValue {
+ public:
+  enum Type {
+    TRACE_TYPE_UNDEFINED,
+    TRACE_TYPE_BOOL,
+    TRACE_TYPE_UINT,
+    TRACE_TYPE_INT,
+    TRACE_TYPE_DOUBLE,
+    TRACE_TYPE_POINTER,
+    TRACE_TYPE_STRING
+  };
+
+  TraceValue() : type_(TRACE_TYPE_UNDEFINED) {
+    value_.as_uint = 0ull;
+  }
+  TraceValue(bool rhs) : type_(TRACE_TYPE_BOOL) {
+    value_.as_uint = 0ull; // zero all bits
+    value_.as_bool = rhs;
+  }
+  TraceValue(uint64 rhs) : type_(TRACE_TYPE_UINT) {
+    value_.as_uint = rhs;
+  }
+  TraceValue(uint32 rhs) : type_(TRACE_TYPE_UINT) {
+    value_.as_uint = rhs;
+  }
+  TraceValue(uint16 rhs) : type_(TRACE_TYPE_UINT) {
+    value_.as_uint = rhs;
+  }
+  TraceValue(uint8 rhs) : type_(TRACE_TYPE_UINT) {
+    value_.as_uint = rhs;
+  }
+  TraceValue(int64 rhs) : type_(TRACE_TYPE_INT) {
+    value_.as_int = rhs;
+  }
+  TraceValue(int32 rhs) : type_(TRACE_TYPE_INT) {
+    value_.as_int = rhs;
+  }
+  TraceValue(int16 rhs) : type_(TRACE_TYPE_INT) {
+    value_.as_int = rhs;
+  }
+  TraceValue(int8 rhs) : type_(TRACE_TYPE_INT) {
+    value_.as_int = rhs;
+  }
+  TraceValue(double rhs) : type_(TRACE_TYPE_DOUBLE) {
+    value_.as_double = rhs;
+  }
+  TraceValue(const void* rhs) : type_(TRACE_TYPE_POINTER) {
+    value_.as_uint = 0ull; // zero all bits
+    value_.as_pointer = rhs;
+  }
+  explicit TraceValue(const char* rhs) : type_(TRACE_TYPE_STRING) {
+    value_.as_uint = 0ull; // zero all bits
+    value_.as_string = base::strdup(rhs);
+  }
+  TraceValue(const TraceValue& rhs) : type_(TRACE_TYPE_UNDEFINED) {
+    operator=(rhs);
+  }
+  ~TraceValue() {
+    Destroy();
+  }
+
+  TraceValue& operator=(const TraceValue& rhs);
+  bool operator==(const TraceValue& rhs) const;
+  bool operator!=(const TraceValue& rhs) const {
+    return !operator==(rhs);
+  }
+
+  void Destroy();
+
+  void AppendAsJSON(std::string* out) const;
+
+  Type type() const {
+    return type_;
+  }
+  uint64 as_uint() const {
+    return value_.as_uint;
+  }
+  bool as_bool() const {
+    return value_.as_bool;
+  }
+  int64 as_int() const {
+    return value_.as_int;
+  }
+  double as_double() const {
+    return value_.as_double;
+  }
+  const void* as_pointer() const {
+    return value_.as_pointer;
+  }
+  const char* as_string() const {
+    return value_.as_string;
+  }
+
+ private:
+  union Value {
+    bool as_bool;
+    uint64 as_uint;
+    int64 as_int;
+    double as_double;
+    const void* as_pointer;
+    char* as_string;
+  };
+
+  Type type_;
+  Value value_;
+};
+
 // Output records are "Events" and can be obtained via the
 // OutputCallback whenever the logging system decides to flush. This
 // can happen at any time, on any thread, or you can programatically
 // force it to happen.
 struct TraceEvent {
   static void AppendAsJSON(std::string* out,
       const std::vector<TraceEvent>& events,
       size_t start,
       size_t count);
   TraceEvent();
   ~TraceEvent();
   void AppendAsJSON(std::string* out) const;
 
 
   unsigned long processId;
   unsigned long threadId;
   base::TimeTicks timestamp;
   TraceEventPhase phase;
   TraceCategory* category;
   const char* name;
   const char* argNames[TRACE_MAX_NUM_ARGS];
-  std::string argValues[TRACE_MAX_NUM_ARGS];
+  TraceValue argValues[TRACE_MAX_NUM_ARGS];
 };
 
 
 class TraceLog {
  public:
   static TraceLog* GetInstance();
 
   // Global enable of tracing. Currently enables all categories or not.
   // TODO(nduca) Replaced with an Enable/DisableCategory() that
   // implicitly controls the global logging state.
@@ skipping 21 matching lines @@
   void Flush();
 
   // Called by GPU_TRACE_EVENT* macros, don't call this directly.
   TraceCategory* GetCategory(const char* name);
 
   // Called by GPU_TRACE_EVENT* macros, don't call this directly.
   void AddTraceEvent(TraceEventPhase phase,
       const char* file, int line,
       TraceCategory* category,
       const char* name,
-      const char* arg1name, const char* arg1val,
-      const char* arg2name, const char* arg2val);
+      const char* arg1name, TraceValue arg1val,
+      const char* arg2name, TraceValue arg2val);
 
  private:
   // This allows constructor and destructor to be private and usable only
   // by the Singleton class.
   friend struct StaticMemorySingletonTraits<TraceLog>;
 
   TraceLog();
   ~TraceLog();
   void FlushWithLockAlreadyHeld();
 
@@ skipping 37 matching lines @@
   int line_;
   TraceCategory* category_;
   const char* name_;
 };
 
 }  // namespace internal
 
 }  // namespace gpu
 #endif  // __native_client__
 #endif  // GPU_TRACE_EVENT_H_