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 162 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 TraceAnyType {

[nduca, 2011/04/21 22:15:44]

TraceVar or TraceVariadic?

Very similar to PP_Var (chrome/ppapi)

[jbates, 2011/04/21 23:57:53]

Done.

+ public:
+  enum Type {
+    NONE,
+    BOOLEAN,

[nduca, 2011/04/21 22:15:44]

/me wonders if we usually prefix with TYPE_? pp_var and base/values.h might be
good reference points. And, sorry if you've already normalized to a convention..
:)

[jbates, 2011/04/21 23:57:53]

Done.

+    UINT,
+    INT,
+    DOUBLE,
+    POINTER,
+    STRING
+  };
+
+  TraceAnyType() : type_(NONE) {
+    value_.as_uint = 0ull;
+  }
+  TraceAnyType(bool rhs) : type_(BOOLEAN) {
+    value_.as_uint = 0ull; // zero all bits
+    value_.as_bool = rhs;
+  }
+  TraceAnyType(uint64 rhs) : type_(UINT) {
+    value_.as_uint = rhs;
+  }
+  TraceAnyType(uint32 rhs) : type_(UINT) {
+    value_.as_uint = rhs;
+  }
+  TraceAnyType(uint16 rhs) : type_(UINT) {
+    value_.as_uint = rhs;
+  }
+  TraceAnyType(uint8 rhs) : type_(UINT) {
+    value_.as_uint = rhs;
+  }
+  TraceAnyType(int64 rhs) : type_(INT) {
+    value_.as_int = rhs;
+  }
+  TraceAnyType(int32 rhs) : type_(INT) {
+    value_.as_int = rhs;
+  }
+  TraceAnyType(int16 rhs) : type_(INT) {
+    value_.as_int = rhs;
+  }
+  TraceAnyType(int8 rhs) : type_(INT) {
+    value_.as_int = rhs;
+  }
+  TraceAnyType(double rhs) : type_(DOUBLE) {
+    value_.as_double = rhs;
+  }
+  TraceAnyType(void* rhs) : type_(POINTER) {
+    value_.as_uint = 0ull; // zero all bits
+    value_.as_pointer = rhs;
+  }
+  TraceAnyType(const char* rhs) : type_(STRING) {
+    value_.as_uint = 0ull; // zero all bits
+    value_.as_string = strdup(rhs);
+  }
+  TraceAnyType(const TraceAnyType& rhs) : type_(NONE) {
+    operator=(rhs);
+  }
+  ~TraceAnyType() {
+    Destroy();
+  }
+
+  TraceAnyType& operator=(const TraceAnyType& rhs);
+  bool operator==(const TraceAnyType& rhs) const;
+  bool operator!=(const TraceAnyType& 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;
+  }
+  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;
+    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];
+  TraceAnyType 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, TraceAnyType arg1val,
+      const char* arg2name, TraceAnyType 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  // GPU_TRACE_EVENT_H_