command_buffer: Batch command processing to reduce handler overheads.

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 554 matching lines @@
                          public ErrorStateClient {
  public:
   explicit GLES2DecoderImpl(ContextGroup* group);
   virtual ~GLES2DecoderImpl();
 
   // 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;
+
   // 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 1047 matching lines @@
   error::Error WillAccessBoundFramebufferForRead() {
     if (ShouldDeferReads())
       return error::kDeferCommandUntilLater;
     if (!offscreen_target_frame_buffer_.get() &&
         !framebuffer_state_.bound_read_framebuffer.get() &&
         !surface_->SetBackbufferAllocation(true))
       return error::kLostContext;
     return error::kNoError;
   }
 
+  // Set remaining commands to process to 0 to force DoCommands to return
+  // and allow context preemption and GPU watchdog checks in GpuScheduler().
+  void ExitCommandProcessingEarly() { commands_to_process_ = 0; }
+
   void ProcessPendingReadPixels();
   void FinishReadPixels(const cmds::ReadPixels& c, GLuint buffer);
 
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
 #define GLES2_CMD_OP(name) \
   Error Handle##name(uint32 immediate_data_size, const void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
@@ skipping 101 matching lines @@
   scoped_refptr<ShaderTranslator> fragment_translator_;
 
   DisallowedFeatures disallowed_features_;
 
   // Cached from ContextGroup
   const Validators* validators_;
   scoped_refptr<FeatureInfo> feature_info_;
 
   int frame_number_;
 
+  // Number of commands remaining to be processed in DoCommands().
+  int commands_to_process_;
+
   bool has_robustness_extension_;
   GLenum reset_status_;
   bool reset_by_robustness_extension_;
   bool supports_post_sub_buffer_;
 
   // These flags are used to override the state of the shared feature_info_
   // member.  Because the same FeatureInfo instance may be shared among many
   // contexts, the assumptions on the availablity of extensions in WebGL
   // contexts may be broken.  These flags override the shared state to preserve
   // WebGL semantics.
@@ skipping 1968 matching lines @@
   return error::kNoError;
 }
 
 const char* GLES2DecoderImpl::GetCommandName(unsigned int command_id) const {
   if (command_id > kStartPoint && command_id < kNumCommands) {
     return gles2::GetCommandName(static_cast<CommandId>(command_id));
   }
   return GetCommonCommandName(static_cast<cmd::CommandId>(command_id));
 }
 
-// Decode command with its arguments, and call the corresponding GL function.
-// Note: args 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.
-error::Error GLES2DecoderImpl::DoCommand(
-    unsigned int command,
-    unsigned int arg_count,
-    const void* cmd_data) {
+// Decode a command, and call the corresponding GL functions.
+// NOTE: DoCommand() is slower than calling DoCommands() on larger batches
+// of commands at once, and is now only used for tests that need to track
+// individual commands.
+error::Error GLES2DecoderImpl::DoCommand(unsigned int command,
+                                         unsigned int arg_count,
+                                         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) {
+  commands_to_process_ = num_commands;
   error::Error result = error::kNoError;
-  if (log_commands()) {
-    // TODO(notme): Change this to a LOG/VLOG that works in release. Tried
-    // VLOG(1), no luck.
-    LOG(ERROR) << "[" << logger_.GetLogPrefix() << "]" << "cmd: "
-               << GetCommandName(command);
+  const CommandBufferEntry* cmd_data =
+      static_cast<const CommandBufferEntry*>(buffer);
+  int process_pos = 0;
+
+  while (process_pos < num_entries && result == error::kNoError &&
+         commands_to_process_--) {
+    CommandHeader header = cmd_data->value_header;
+    if (header.size == 0) {

[piman, 2014/09/09 00:59:01]

nit: It was already before, but it's easier to see now. We're using header.size
many times in this function. It's a bitfield, so each use might involve a mask
and/or shift, unless the compiler's aliasing analysis lets it figure out that it
can't change. It might be worth extracting the size once and for all into a
local variable.

[vmiura, 2014/09/09 01:38:56]

Done.

+      DVLOG(1) << "Error: zero sized command in command buffer";
+      if (entries_processed)
+        *entries_processed = process_pos;
+      return error::kInvalidSize;
+    }
+
+    if (static_cast<int>(header.size) + process_pos > num_entries) {
+      DVLOG(1) << "Error: get offset out of bounds";
+      if (entries_processed)
+        *entries_processed = process_pos;
+      return error::kOutOfBounds;
+    }
+
+    TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cb_command"),
+                 GetCommandName(header.command));
+
+    {

[piman, 2014/09/09 00:59:01]

nit: do you need this scope? I don't think you're using any Scoped thing in
there... It would help readability a bit if it wasn't there.

[vmiura, 2014/09/09 01:38:56]

Done.

+      const unsigned int command = header.command;
+      const unsigned int arg_count = header.size - 1;
+
+      if (log_commands()) {
+        // TODO(notme): Change this to a LOG/VLOG that works in release. Tried
+        // VLOG(1), no luck.
+        LOG(ERROR) << "[" << logger_.GetLogPrefix() << "]"
+                   << "cmd: " << GetCommandName(command);
+      }
+      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 (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)
+            gpu_tracer_->End(kTraceDecoder);
+
+          if (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 (result == error::kNoError &&
+          current_decoder_error_ != error::kNoError) {
+        result = current_decoder_error_;
+        current_decoder_error_ = error::kNoError;
+      }
+    }
+
+    if (result != error::kDeferCommandUntilLater) {
+      process_pos += header.size;
+      cmd_data += header.size;
+    }
   }
-  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 (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
+  if (entries_processed)
+    *entries_processed = process_pos;
 
-      result = (this->*info.cmd_handler)(immediate_data_size, cmd_data);
-
-      if (doing_gpu_trace)
-        gpu_tracer_->End(kTraceDecoder);
-
-      if (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 (result == error::kNoError && current_decoder_error_ != error::kNoError) {
-      result = current_decoder_error_;
-      current_decoder_error_ = error::kNoError;
-  }
   return result;
 }
 
 void GLES2DecoderImpl::RemoveBuffer(GLuint client_id) {
   buffer_manager()->RemoveBuffer(client_id);
 }
 
 bool GLES2DecoderImpl::CreateProgramHelper(GLuint client_id) {
   if (GetProgram(client_id)) {
     return false;
@@ skipping 1874 matching lines @@
                     workarounds().count_all_in_varyings_packing ?
                         Program::kCountAll : Program::kCountOnlyStaticallyUsed,
                     shader_cache_callback_)) {
     if (program == state_.current_program.get()) {
       if (workarounds().use_current_program_after_successful_link)
         glUseProgram(program->service_id());
       if (workarounds().clear_uniforms_before_first_program_use)
         program_manager()->ClearUniforms(program);
     }
   }
+
+  // LinkProgram can be very slow.  Exit command processing to allow for
+  // context preemption and GPU watchdog checks.
+  ExitCommandProcessingEarly();
 };
 
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
   TextureRef* texture = texture_manager()->GetTextureInfoForTarget(
       &state_, target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexParameterf", "unknown texture");
     return;
   }
@@ skipping 1108 matching lines @@
   if (use_shader_translator_) {
     translator = shader->shader_type() == GL_VERTEX_SHADER ?
         vertex_translator_.get() : fragment_translator_.get();
   }
 
   program_manager()->DoCompileShader(
      shader,
      translator,
      feature_info_->feature_flags().angle_translated_shader_source ?
          ProgramManager::kANGLE : ProgramManager::kGL);
-};
+
+  // CompileShader can be very slow.  Exit command processing to allow for
+  // context preemption and GPU watchdog checks.
+  ExitCommandProcessingEarly();
+}
 
 void GLES2DecoderImpl::DoGetShaderiv(
     GLuint shader_id, GLenum pname, GLint* params) {
   Shader* shader = GetShaderInfoNotProgram(shader_id, "glGetShaderiv");
   if (!shader) {
     return;
   }
   switch (pname) {
     case GL_SHADER_SOURCE_LENGTH:
       *params = shader->source() ? shader->source()->size() + 1 : 0;
@@ skipping 1478 matching lines @@
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage2D");
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   GLenum error = LOCAL_PEEK_GL_ERROR("glCompressedTexImage2D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
         texture_ref, target, level, internal_format,
         width, height, 1, border, 0, 0, true);
   }
+
+  // This may be a slow command.  Exit command processing to allow for
+  // context preemption and GPU watchdog checks.
+  ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2D(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::CompressedTexImage2D& c =
       *static_cast<const gles2::cmds::CompressedTexImage2D*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
@@ skipping 127 matching lines @@
     if (!pixels) {
       return error::kOutOfBounds;
     }
   }
 
   TextureManager::DoTextImage2DArguments args = {
     target, level, internal_format, width, height, border, format, type,
     pixels, pixels_size};
   texture_manager()->ValidateAndDoTexImage2D(
       &texture_state_, &state_, &framebuffer_state_, args);
+
+  // This may be a slow command.  Exit command processing to allow for
+  // context preemption and GPU watchdog checks.
+  ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoCompressedTexSubImage2D(
   GLenum target,
   GLint level,
   GLint xoffset,
   GLint yoffset,
   GLsizei width,
   GLsizei height,
@@ skipping 38 matching lines @@
     return;
   }
 
 
   // Note: There is no need to deal with texture cleared tracking here
   // because the validation above means you can only get here if the level
   // is already a matching compressed format and in that case
   // CompressedTexImage2D already cleared the texture.
   glCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, image_size, data);
+
+  // This may be a slow command.  Exit command processing to allow for
+  // context preemption and GPU watchdog checks.
+  ExitCommandProcessingEarly();
 }
 
 static void Clip(
     GLint start, GLint range, GLint sourceRange,
     GLint* out_start, GLint* out_range) {
   DCHECK(out_start);
   DCHECK(out_range);
   if (start < 0) {
     range += start;
     start = 0;
@@ skipping 125 matching lines @@
     ScopedModifyPixels modify(texture_ref);
     glCopyTexImage2D(target, level, internal_format,
                      copyX, copyY, copyWidth, copyHeight, border);
   }
   GLenum error = LOCAL_PEEK_GL_ERROR("glCopyTexImage2D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
         texture_ref, target, level, internal_format, width, height, 1,
         border, internal_format, GL_UNSIGNED_BYTE, true);
   }
+
+  // This may be a slow command.  Exit command processing to allow for
+  // context preemption and GPU watchdog checks.
+  ExitCommandProcessingEarly();
 }
 
 void GLES2DecoderImpl::DoCopyTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
@@ skipping 90 matching lines @@
   if (copyHeight > 0 && copyWidth > 0) {
     GLint dx = copyX - x;
     GLint dy = copyY - y;
     GLint destX = xoffset + dx;
     GLint destY = yoffset + dy;
     ScopedModifyPixels modify(texture_ref);
     glCopyTexSubImage2D(target, level,
                         destX, destY, copyX, copyY,
                         copyWidth, copyHeight);
   }
+
+  // This may be a slow command.  Exit command processing to allow for
+  // context preemption and GPU watchdog checks.
+  ExitCommandProcessingEarly();
 }
 
 bool GLES2DecoderImpl::ValidateTexSubImage2D(
     error::Error* error,
     const char* function_name,
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
@@ skipping 110 matching lines @@
     // NOTE: In OpenGL ES 2.0 border is always zero. If that changes we'll need
     // to look it up.
     glTexImage2D(
         target, level, internal_format, width, height, 0, format, type, data);
   } else {
     ScopedTextureUploadTimer timer(&texture_state_);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
   }
   texture_manager()->SetLevelCleared(texture_ref, target, level, true);
+
+  // This may be a slow command.  Exit command processing to allow for
+  // context preemption and GPU watchdog checks.
+  ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(uint32 immediate_data_size,
                                                    const void* cmd_data) {
   const gles2::cmds::TexSubImage2D& c =
       *static_cast<const gles2::cmds::TexSubImage2D*>(cmd_data);
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexSubImage2D",
       "width", c.width, "height", c.height);
   GLboolean internal = static_cast<GLboolean>(c.internal);
@@ skipping 466 matching lines @@
       // single D3D device for all contexts.
       if (!feature_info_->feature_flags().is_angle)
         glFlush();
     }
   } else {
     if (!surface_->SwapBuffers()) {
       LOG(ERROR) << "Context lost because SwapBuffers failed.";
       LoseContext(GL_UNKNOWN_CONTEXT_RESET_ARB);
     }
   }
+
+  // This may be a slow command.  Exit command processing to allow for
+  // context preemption and GPU watchdog checks.
+  ExitCommandProcessingEarly();
 }
 
 error::Error GLES2DecoderImpl::HandleEnableFeatureCHROMIUM(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::EnableFeatureCHROMIUM& c =
       *static_cast<const gles2::cmds::EnableFeatureCHROMIUM*>(cmd_data);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
@@ skipping 1749 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