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

gpu/common/gpu_trace_event.cc

 // 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.
 
 #include "gpu/common/gpu_trace_event.h"
 
 #include "base/format_macros.h"
 #include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ skipping 21 matching lines @@
       static_cast<base::subtle::Atomic32>(enabled));
 }
 
 TraceCategory::~TraceCategory() {
   base::subtle::NoBarrier_Store(&enabled_,
       static_cast<base::subtle::Atomic32>(0));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
+// TraceAnyType
+//
+////////////////////////////////////////////////////////////////////////////////
+
+void TraceAnyType::Destroy() {
+  if (type_ == STRING) {
+    free(value_.as_string);
+    value_.as_string = NULL;
+  }
+  type_ = NONE;
+}
+
+TraceAnyType& TraceAnyType::operator=(const TraceAnyType& rhs) {
+  DCHECK(sizeof(value_) == sizeof(uint64));
+  Destroy();
+  type_ = rhs.type_;
+  if (rhs.type_ == STRING) {
+    value_.as_string = strdup(rhs.value_.as_string);
+  } else {
+    // Copy all 64 bits for all other types.
+    value_.as_uint = rhs.value_.as_uint;
+  }
+  return *this;
+}
+
+bool TraceAnyType::operator==(const TraceAnyType& rhs) const {
+  if (type_ != rhs.type())
+    return false;
+  if (rhs.type_ == STRING) {
+    return (strcmp(value_.as_string, rhs.value_.as_string) == 0);
+  } else {
+    // Compare all 64 bits for all other types. Unused bits are set to zero
+    // by the constructors of types that may be less than 64 bits.
+    return (value_.as_uint == rhs.value_.as_uint);
+  }
+}
+
+void TraceAnyType::AppendAsJSON(std::string* out) const {
+  char temp_string[128];
+  switch (type_) {
+  case BOOLEAN:
+    *out += as_bool()? "true" : "false";
+    break;
+  case UINT:
+    snprintf(temp_string, sizeof(temp_string), "%llu",
+             (unsigned long long)as_uint());
+    *out += temp_string;
+    break;
+  case INT:
+    snprintf(temp_string, sizeof(temp_string), "%lld", (long long)as_int());
+    *out += temp_string;
+    break;
+  case DOUBLE:
+    snprintf(temp_string, sizeof(temp_string), "%f", as_double());
+    *out += temp_string;
+    break;
+  case POINTER:
+    snprintf(temp_string, sizeof(temp_string), "%p", as_pointer());
+    *out += temp_string;
+    break;
+  case STRING:
+    *out += "'";

[scheib, 2011/04/21 16:44:35]

Should check for ' characters in the string and escape them or change them.

[jbates, 2011/04/21 21:11:51]

Done.

+    *out += as_string();
+    *out += "'";
+    break;
+  default:
+    *out += "''";
+    break;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
 // TraceEvent
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 const char* GetPhaseStr(TraceEventPhase phase) {
   if (phase == GPU_TRACE_EVENT_PHASE_BEGIN) {
     return "B";
   } else if (phase == GPU_TRACE_EVENT_PHASE_INSTANT) {
     return "I";
@@ skipping 49 matching lines @@
       category->name(),
       static_cast<int>(processId),
       static_cast<int>(threadId),
       time_llui,
       phaseStr,
       name);
   for (int  i = 0; i < nargs; ++i) {
     if (i > 0)
       *out += ",";
     *out += argNames[i];
-    *out += ":'";
-    *out += argValues[i];
-    *out += "'";
+    *out += ":";
+    argValues[i].AppendAsJSON(out);
   }
   *out += "}}";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceLog
 //
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 82 matching lines @@
       output_callback_->Run(json_events);
     }
   }
   logged_events_.erase(logged_events_.begin(), logged_events_.end());
 }
 
 void TraceLog::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) {
   DCHECK(file && name);
 #ifdef USE_UNRELIABLE_NOW
   TimeTicks now = TimeTicks::HighResNow();
 #else
   TimeTicks now = TimeTicks::Now();
 #endif
   //static_cast<unsigned long>(base::GetCurrentProcId()),
   AutoLock lock(lock_);
   if (logged_events_.size() >= TRACE_EVENT_BUFFER_SIZE)
     return;
   logged_events_.push_back(TraceEvent());
   TraceEvent& event = logged_events_.back();
   event.processId = static_cast<unsigned long>(base::GetCurrentProcId());
   event.threadId = PlatformThread::CurrentId();
   event.timestamp = now;
   event.phase = phase;
   event.category = category;
   event.name = name;
   event.argNames[0] = arg1name;
-  event.argValues[0] = arg1name ? arg1val : "";
+  event.argValues[0] = arg1val;
   event.argNames[1] = arg2name;
-  event.argValues[1] = arg2name ? arg2val : "";
+  event.argValues[1] = arg2val;
   COMPILE_ASSERT(TRACE_MAX_NUM_ARGS == 2, TraceEvent_arc_count_out_of_sync);
   if (logged_events_.size() == TRACE_EVENT_BUFFER_SIZE &&
       buffer_full_callback_.get())
     buffer_full_callback_->Run();
 }
 
 }  // namespace gpu