command_buffer: Optimize non-debug path of GLES2DecoderImpl::DoCommands().

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // 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.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 552 matching lines @@
   // Overridden from AsyncAPIInterface.
   virtual Error DoCommand(unsigned int command,
                           unsigned int arg_count,
                           const void* args) OVERRIDE;
 
   virtual error::Error DoCommands(unsigned int num_commands,
                                   const void* buffer,
                                   int num_entries,
                                   int* entries_processed) OVERRIDE;
 
+  template <bool DebugImpl>
+  error::Error DoCommandsImpl(unsigned int num_commands,
+                              const void* buffer,
+                              int num_entries,
+                              int* entries_processed);
+
   // Overridden from AsyncAPIInterface.
   virtual const char* GetCommandName(unsigned int command_id) const OVERRIDE;
 
   // Overridden from GLES2Decoder.
   virtual bool Initialize(const scoped_refptr<gfx::GLSurface>& surface,
                           const scoped_refptr<gfx::GLContext>& context,
                           bool offscreen,
                           const gfx::Size& size,
                           const DisallowedFeatures& disallowed_features,
                           const std::vector<int32>& attribs) OVERRIDE;
@@ skipping 1219 matching lines @@
 
   // Command buffer stats.
   base::TimeDelta total_processing_commands_time_;
 
   // States related to each manager.
   DecoderTextureState texture_state_;
   DecoderFramebufferState framebuffer_state_;
 
   scoped_ptr<GPUTracer> gpu_tracer_;
   scoped_ptr<GPUStateTracer> gpu_state_tracer_;
+  const unsigned char* cb_command_trace_category_;
   int gpu_trace_level_;
   bool gpu_trace_commands_;
+  bool gpu_debug_commands_;
 
   std::queue<linked_ptr<FenceCallback> > pending_readpixel_fences_;
 
   // Used to validate multisample renderbuffers if needed
   GLuint validation_texture_;
   GLuint validation_fbo_multisample_;
   GLuint validation_fbo_;
 
   typedef gpu::gles2::GLES2Decoder::Error (GLES2DecoderImpl::*CmdHandler)(
       uint32 immediate_data_size,
@@ skipping 489 matching lines @@
       shader_texture_lod_explicitly_enabled_(false),
       compile_shader_always_succeeds_(false),
       lose_context_when_out_of_memory_(false),
       service_logging_(CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGPUServiceLoggingGPU)),
       viewport_max_width_(0),
       viewport_max_height_(0),
       texture_state_(group_->feature_info()
                          ->workarounds()
                          .texsubimage2d_faster_than_teximage2d),
+      cb_command_trace_category_(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
+          TRACE_DISABLED_BY_DEFAULT("cb_command"))),
+      gpu_trace_level_(2),
+      gpu_trace_commands_(false),
+      gpu_debug_commands_(false),
       validation_texture_(0),
       validation_fbo_multisample_(0),
       validation_fbo_(0) {
   DCHECK(group);
 
   attrib_0_value_.v[0] = 0.0f;
   attrib_0_value_.v[1] = 0.0f;
   attrib_0_value_.v[2] = 0.0f;
   attrib_0_value_.v[3] = 1.0f;
 
@@ skipping 19 matching lines @@
     const gfx::Size& size,
     const DisallowedFeatures& disallowed_features,
     const std::vector<int32>& attribs) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::Initialize");
   DCHECK(context->IsCurrent(surface.get()));
   DCHECK(!context_.get());
 
   set_initialized();
   gpu_tracer_.reset(new GPUTracer(this));
   gpu_state_tracer_ = GPUStateTracer::Create(&state_);
-  // TODO(vmiura): Enable changing gpu_trace_level_ at runtime
-  gpu_trace_level_ = 2;
-  gpu_trace_commands_ = false;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUDebugging)) {
     set_debug(true);
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUCommandLogging)) {
     set_log_commands(true);
   }
@@ skipping 947 matching lines @@
   resize_callback_ = callback;
 }
 
 Logger* GLES2DecoderImpl::GetLogger() {
   return &logger_;
 }
 
 void GLES2DecoderImpl::BeginDecoding() {
   gpu_tracer_->BeginDecoding();
   gpu_trace_commands_ = gpu_tracer_->IsTracing();
+  gpu_debug_commands_ = log_commands() || debug() || gpu_trace_commands_ ||
+                        (*cb_command_trace_category_ != 0);
 }
 
 void GLES2DecoderImpl::EndDecoding() {
   gpu_tracer_->EndDecoding();
 }
 
 ErrorState* GLES2DecoderImpl::GetErrorState() {
   return state_.GetErrorState();
 }
 
@@ skipping 402 matching lines @@
                                          const void* cmd_data) {
   return DoCommands(1, cmd_data, arg_count + 1, 0);
 }
 
 // Decode multiple commands, and call the corresponding GL functions.
 // NOTE: 'buffer' is a pointer to the command buffer. As such, it could be
 // changed by a (malicious) client at any time, so if validation has to happen,
 // it should operate on a copy of them.
 // NOTE: This is duplicating code from AsyncAPIInterface::DoCommands() in the
 // interest of performance in this critical execution loop.
-error::Error GLES2DecoderImpl::DoCommands(unsigned int num_commands,
-                                          const void* buffer,
-                                          int num_entries,
-                                          int* entries_processed) {
+template <bool DebugImpl>
+error::Error GLES2DecoderImpl::DoCommandsImpl(unsigned int num_commands,
+                                              const void* buffer,
+                                              int num_entries,
+                                              int* entries_processed) {
   commands_to_process_ = num_commands;
   error::Error result = error::kNoError;
   const CommandBufferEntry* cmd_data =
       static_cast<const CommandBufferEntry*>(buffer);
   int process_pos = 0;
   unsigned int command = 0;
 
   while (process_pos < num_entries && result == error::kNoError &&
          commands_to_process_--) {
     const unsigned int size = cmd_data->value_header.size;
     command = cmd_data->value_header.command;
 
     if (size == 0) {
       result = error::kInvalidSize;
       break;
     }
 
     if (static_cast<int>(size) + process_pos > num_entries) {
       result = error::kOutOfBounds;
       break;
     }
 
-    TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cb_command"),
-                 GetCommandName(command));
+    if (DebugImpl) {
+      TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("cb_command"),
+                         GetCommandName(command));

[vmiura, 2014/09/10 17:09:31]

Scoped TRACE_EVENT was wrong here, so changed to BEGIN/END form.

 
-    if (log_commands()) {
-      LOG(ERROR) << "[" << logger_.GetLogPrefix() << "]"
-                 << "cmd: " << GetCommandName(command);
+      if (log_commands()) {
+        LOG(ERROR) << "[" << logger_.GetLogPrefix() << "]"
+                   << "cmd: " << GetCommandName(command);
+      }
     }
 
     const unsigned int arg_count = size - 1;
     unsigned int command_index = command - kStartPoint - 1;
     if (command_index < arraysize(command_info)) {
       const CommandInfo& info = command_info[command_index];
       unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count);
       if ((info.arg_flags == cmd::kFixed && arg_count == info_arg_count) ||
           (info.arg_flags == cmd::kAtLeastN && arg_count >= info_arg_count)) {
         bool doing_gpu_trace = false;
-        if (gpu_trace_commands_) {
+        if (DebugImpl && gpu_trace_commands_) {
           if (CMD_FLAG_GET_TRACE_LEVEL(info.cmd_flags) <= gpu_trace_level_) {
             doing_gpu_trace = true;
             gpu_tracer_->Begin(GetCommandName(command), kTraceDecoder);
           }
         }
 
         uint32 immediate_data_size = (arg_count - info_arg_count) *
                                      sizeof(CommandBufferEntry);  // NOLINT
 
         result = (this->*info.cmd_handler)(immediate_data_size, cmd_data);
 
-        if (doing_gpu_trace)
+        if (DebugImpl && doing_gpu_trace)
           gpu_tracer_->End(kTraceDecoder);
 
-        if (debug()) {
+        if (DebugImpl && debug()) {
           GLenum error;
           while ((error = glGetError()) != GL_NO_ERROR) {
             LOG(ERROR) << "[" << logger_.GetLogPrefix() << "] "
                        << "GL ERROR: " << GLES2Util::GetStringEnum(error)
                        << " : " << GetCommandName(command);
             LOCAL_SET_GL_ERROR(error, "DoCommand", "GL error from driver");
           }
         }
       } else {
         result = error::kInvalidArguments;
       }
     } else {
       result = DoCommonCommand(command, arg_count, cmd_data);
     }
+
+    if (DebugImpl) {
+      TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("cb_command"),
+                       GetCommandName(command));
+    }
+
     if (result == error::kNoError &&
         current_decoder_error_ != error::kNoError) {
       result = current_decoder_error_;
       current_decoder_error_ = error::kNoError;
     }
 
     if (result != error::kDeferCommandUntilLater) {
       process_pos += size;
       cmd_data += size;
     }
   }
 
   if (entries_processed)
     *entries_processed = process_pos;
 
   if (error::IsError(result)) {
     LOG(ERROR) << "Error: " << result << " for Command "
                << GetCommandName(command);
   }
 
   return result;
 }
 
+error::Error GLES2DecoderImpl::DoCommands(unsigned int num_commands,
+                                          const void* buffer,
+                                          int num_entries,
+                                          int* entries_processed) {
+  if (gpu_debug_commands_) {
+    return DoCommandsImpl<true>(
+        num_commands, buffer, num_entries, entries_processed);
+  } else {
+    return DoCommandsImpl<false>(
+        num_commands, buffer, num_entries, entries_processed);
+  }
+}
+
 void GLES2DecoderImpl::RemoveBuffer(GLuint client_id) {
   buffer_manager()->RemoveBuffer(client_id);
 }
 
 bool GLES2DecoderImpl::CreateProgramHelper(GLuint client_id) {
   if (GetProgram(client_id)) {
     return false;
   }
   GLuint service_id = glCreateProgram();
   if (service_id != 0) {
@@ skipping 7379 matching lines @@
   }
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu