Add subscribeUniform extension pipeline

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 38 matching lines @@
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/texture_manager.h"
+#include "gpu/command_buffer/service/uniform_subscription_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "third_party/smhasher/src/City.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_MACOSX)
 #include <IOSurface/IOSurfaceAPI.h>
@@ skipping 720 matching lines @@
   TextureManager* texture_manager() {
     return group_->texture_manager();
   }
 
   MailboxManager* mailbox_manager() {
     return group_->mailbox_manager();
   }
 
   ImageManager* image_manager() { return image_manager_.get(); }
 
+  UniformSubscriptionManager* uniform_subscription_manager() {
+    return uniform_subscription_manager_.get();
+  }
+
+  // Populate uniforms the program is currently subscribed too
+  void PopulateUniformSubscriptions();

[piman, 2014/10/16 02:39:18]

When is this called?

[orglofch, 2014/10/21 04:19:38]

It wasn't it was meant as a placeholder. Updated it to reflect actual
implementation.

+
   VertexArrayManager* vertex_array_manager() {
     return vertex_array_manager_.get();
   }
 
   MemoryTracker* memory_tracker() {
     return group_->memory_tracker();
   }
 
   bool EnsureGPUMemoryAvailable(size_t estimated_size) {
     MemoryTracker* tracker = memory_tracker();
@@ skipping 142 matching lines @@
   void DoProduceTextureCHROMIUM(GLenum target, const GLbyte* key);
   void DoProduceTextureDirectCHROMIUM(GLuint texture, GLenum target,
       const GLbyte* key);
   void ProduceTextureRef(std::string func_name, TextureRef* texture_ref,
       GLenum target, const GLbyte* data);
 
   void DoConsumeTextureCHROMIUM(GLenum target, const GLbyte* key);
   void DoCreateAndConsumeTextureCHROMIUM(GLenum target, const GLbyte* key,
     GLuint client_id);
 
+  void DoSubscribeUniformCHROMIUM(GLenum target, const GLchar* name);
+
   void DoBindTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
   void DoReleaseTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
 
   void DoTraceEndCHROMIUM(void);
 
   void DoDrawBuffersEXT(GLsizei count, const GLenum* bufs);
@@ skipping 749 matching lines @@
   scoped_ptr<BackFramebuffer> offscreen_resolved_frame_buffer_;
   scoped_ptr<BackTexture> offscreen_resolved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
   scoped_ptr<QueryManager> query_manager_;
 
   scoped_ptr<VertexArrayManager> vertex_array_manager_;
 
   scoped_ptr<ImageManager> image_manager_;
 
+  scoped_ptr<UniformSubscriptionManager> uniform_subscription_manager_;
+
   base::Callback<void(gfx::Size, float)> resize_callback_;
 
   WaitSyncPointCallback wait_sync_point_callback_;
 
   ShaderCacheCallback shader_cache_callback_;
 
   scoped_ptr<AsyncPixelTransferManager> async_pixel_transfer_manager_;
 
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
@@ skipping 693 matching lines @@
       group_->max_vertex_attribs(),
       feature_info_->workarounds().init_vertex_attributes);
 
   // vertex_attrib_manager is set to default_vertex_attrib_manager by this call
   DoBindVertexArrayOES(0);
 
   query_manager_.reset(new QueryManager(this, feature_info_.get()));
 
   image_manager_.reset(new ImageManager);
 
+  uniform_subscription_manager_.reset(new UniformSubscriptionManager);
+
   util_.set_num_compressed_texture_formats(
       validators_->compressed_texture_format.GetValues().size());
 
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     // We have to enable vertex array 0 on OpenGL or it won't render. Note that
     // OpenGL ES 2.0 does not have this issue.
     glEnableVertexAttribArray(0);
   }
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
@@ skipping 1073 matching lines @@
   if (vertex_array_manager_ .get()) {
     vertex_array_manager_->Destroy(have_context);
     vertex_array_manager_.reset();
   }
 
   if (image_manager_.get()) {
     image_manager_->Destroy(have_context);
     image_manager_.reset();
   }
 
+  if (uniform_subscription_manager_.get()) {
+    uniform_subscription_manager_->Destroy(have_context);
+    uniform_subscription_manager_.reset();
+  }
+
   offscreen_target_frame_buffer_.reset();
   offscreen_target_color_texture_.reset();
   offscreen_target_color_render_buffer_.reset();
   offscreen_target_depth_render_buffer_.reset();
   offscreen_target_stencil_render_buffer_.reset();
   offscreen_saved_frame_buffer_.reset();
   offscreen_saved_color_texture_.reset();
   offscreen_resolved_frame_buffer_.reset();
   offscreen_resolved_color_texture_.reset();
 
@@ skipping 5760 matching lines @@
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glShaderBinary", "unknown shader");
       return error::kNoError;
     }
     service_ids[ii] = shader->service_id();
   }
   // TODO(gman): call glShaderBinary
   return error::kNoError;
 #endif
 }
 
+void GLES2DecoderImpl::PopulateUniformSubscriptions() {
+  const UniformSubscriptionManager::SubscriptionMap& subscriptions =
+      uniform_subscription_manager()->subscriptions();
+  for (UniformSubscriptionManager::SubscriptionMap::const_iterator it =
+           subscriptions.begin();
+       it != subscriptions.end();
+       ++it) {
+    if (state_.current_program.get()) {

[piman, 2014/10/16 02:39:18]

This is a loop invariant. Early out instead?

[orglofch, 2014/10/21 04:19:38]

Acknowledged. No longer in the API.

+      GLint location =
+          state_.current_program.get()->GetUniformFakeLocation(it->second);

[piman, 2014/10/16 02:39:18]

This seems pretty costly to do string parsing and linear searches. How often
will this happen?

[orglofch, 2014/10/21 04:19:38]

Acknowledged. No longer in the API.

+      if (location != -1) {
+        // TODO(orglofch): Populate uniform based on it->first type
+      }
+    }
+  }
+}
+
 void GLES2DecoderImpl::DoSwapBuffers() {
   bool is_offscreen = !!offscreen_target_frame_buffer_.get();
 
   int this_frame_number = frame_number_++;
   // TRACE_EVENT for gpu tests:
   TRACE_EVENT_INSTANT2("test_gpu", "SwapBuffersLatency",
                        TRACE_EVENT_SCOPE_THREAD,
                        "GLImpl", static_cast<int>(gfx::GetGLImplementation()),
                        "width", (is_offscreen ? offscreen_size_.width() :
                                  surface_->GetSize().width()));
@@ skipping 1301 matching lines @@
   if (texture->target() != target) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCreateAndConsumeTextureCHROMIUM", "invalid target");
     return;
   }
 
   texture_ref = texture_manager()->Consume(client_id, texture);
 }
 
+error::Error GLES2DecoderImpl::HandleSubscribeUniformCHROMIUM(
+    uint32_t immediate_data_size,
+    const void* cmd_data) {
+  const gles2::cmds::SubscribeUniformCHROMIUM& c =
+      *static_cast<const gles2::cmds::SubscribeUniformCHROMIUM*>(cmd_data);
+  GLenum target = static_cast<GLenum>(c.target);

[piman, 2014/10/16 02:39:18]

Where do we validate target against valid values?

[orglofch, 2014/10/21 04:19:38]

Done. Added to build_gles2_cmd_buffer.py.

+  Bucket* bucket = GetBucket(c.bucket_id);
+  if (!bucket || bucket->size() == 0) {
+    return error::kInvalidArguments;
+  }
+  std::string name_str;
+  if (!bucket->GetAsString(&name_str)) {
+    return error::kInvalidArguments;
+  }
+  DoSubscribeUniformCHROMIUM(target, name_str.c_str());
+  return error::kNoError;
+}
+
+void GLES2DecoderImpl::DoSubscribeUniformCHROMIUM(GLenum target,
+                                                  const GLchar* name) {
+  TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoSubscribeUniformCHROMIUM");
+  uniform_subscription_manager()->AddSubscription(target, name);

[piman, 2014/10/16 02:39:18]

How do you remove entries?

[orglofch, 2014/10/21 04:19:38]

There is no method for removing entries, is there a use case for removing
entries? A clients shaders aren't going to change mid execution.

[piman, 2014/10/21 20:00:40]

In the previous API, the entries were not linked to programs, so once you
subscribe there was no way to unsubscribe.

Now I suppose you could delete the program, but I think there's legitimate use
cases for dynamically switching - e.g. windowed vs fullscreen - and you wouldn't
want to recompile shaders just for that.

[orglofch, 2014/10/22 23:10:21]

Done. I've added an unsubscribe call to API.

+}
+
 void GLES2DecoderImpl::DoInsertEventMarkerEXT(
     GLsizei length, const GLchar* marker) {
   if (!marker) {
     marker = "";
   }
   debug_marker_manager_.SetMarker(
       length ? std::string(marker, length) : std::string(marker));
 }
 
 void GLES2DecoderImpl::DoPushGroupMarkerEXT(
@@ skipping 542 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