During virtual context switches only restore texture units that have changed from the previous cont…

gpu/command_buffer/service/context_state.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/context_state.h"
 
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
@@ skipping 22 matching lines @@
 }
 
 TextureUnit::~TextureUnit() {
 }
 
 ContextState::ContextState(FeatureInfo* feature_info, Logger* logger)
     : active_texture_unit(0),
       pack_reverse_row_order(false),
       fbo_binding_for_scissor_workaround_dirty_(false),
       feature_info_(feature_info),
+      max_active_texture_unit_(0),
       error_state_(ErrorState::Create(logger)) {
   Initialize();
 }
 
 ContextState::~ContextState() {
 }
 
 void ContextState::RestoreTextureUnitBindings(GLuint unit) const {
   DCHECK_LT(unit, texture_units.size());
   const TextureUnit& texture_unit = texture_units[unit];
@@ skipping 41 matching lines @@
 }
 
 void ContextState::RestoreProgramBindings() const {
   glUseProgram(current_program.get() ? current_program->service_id() : 0);
 }
 
 void ContextState::RestoreActiveTexture() const {
   glActiveTexture(GL_TEXTURE0 + active_texture_unit);
 }
 
-void ContextState::RestoreAllTextureUnitBindings() const {
+void ContextState::RestoreAllTextureUnitBindings(
+    const ContextState* prev_state) const {
+  size_t units_to_restore = texture_units.size();

[boliu, 2013/12/18 19:55:11]

Should this be max_active_texture_unit_?

+  if (prev_state) {
+    // Only restore units that have been modified by both contexts.
+    units_to_restore = std::max(prev_state->max_active_texture_unit_,
+                                max_active_texture_unit_) + 1;

[no sievers, 2013/12/18 19:36:20]

Do we really need |max_active_texture_unit_| which seems to track which units
*might* be set to something else than the default textures? But it doesn't know
when we set textures back to the default texture, and it also doesn't know about
which target was changed. But luckily we have all this information... :)

So.... can't you just compare the old and new service id in
RestoreTextureUnitBindings()? That would actually eliminate even more GL calls
(in fact, all redundant ones).

[kaanb, 2013/12/18 19:43:56]

Having max_active_texture_unit_ is useful as it reduces the number of iterations
of the loop. I was planning to land this patch first and then go into target
specific optimizations in RestoreTextureUnitBindings() after the holidays.

Even with this approach, we go down from 32 * 3 GL calls per switch to 1 * 3 GL
calls so it is still a huge win IMHO.

[boliu, 2013/12/18 19:55:11]

Just diffing against prev_state would be great for android webview. If we could
plug in the app's state as prev_state, then we could save a lot of GL calls when
switching between app and chromium.

[Ken Russell (switch to Gerrit), 2013/12/18 20:09:44]

Reducing the number of loop iterations is a premature optimization that is known
to not be fully correct. Please remove the newly added max_active_texture_unit_
state and just iterate over all texture units. If it's later determined that the
optimization would help, it can be added.

+  }
+
   // Restore Texture state.
-  for (size_t ii = 0; ii < texture_units.size(); ++ii) {
+  for (size_t ii = 0; ii < units_to_restore; ++ii) {
     RestoreTextureUnitBindings(ii);
   }
   RestoreActiveTexture();
 }
 
 void ContextState::RestoreAttribute(GLuint attrib_index) const {
   const VertexAttrib* attrib =
       vertex_attrib_manager->GetVertexAttrib(attrib_index);
   const void* ptr = reinterpret_cast<const void*>(attrib->offset());
   Buffer* buffer = attrib->buffer();
@@ skipping 15 matching lines @@
     }
   }
   glVertexAttrib4fv(attrib_index, attrib_values[attrib_index].v);
 }
 
 void ContextState::RestoreGlobalState() const {
   InitCapabilities();
   InitState();
 }
 
-void ContextState::RestoreState() const {
-  RestoreAllTextureUnitBindings();
+void ContextState::RestoreState(const ContextState* prev_state) const {
+  RestoreAllTextureUnitBindings(prev_state);
 
   // Restore Attrib State
   // TODO: This if should not be needed. RestoreState is getting called
   // before GLES2Decoder::Initialize which is a bug.
   if (vertex_attrib_manager.get()) {
     // TODO(gman): Move this restoration to VertexAttribManager.
     for (size_t attrib = 0; attrib < vertex_attrib_manager->num_attribs();
          ++attrib) {
       RestoreAttribute(attrib);
     }
@@ skipping 11 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/context_state_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu