GPU Program Caching

gpu/command_buffer/service/program_manager.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/program_manager.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
+#include "net/base/net_log.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 
 namespace gpu {
 namespace gles2 {
 
 static int ShaderTypeToIndex(GLenum shader_type) {
   switch (shader_type) {
@@ skipping 221 matching lines @@
 void ProgramManager::ProgramInfo::ExecuteBindAttribLocationCalls() {
   for (std::map<std::string, GLint>::const_iterator it =
            bind_attrib_location_map_.begin();
        it != bind_attrib_location_map_.end(); ++it) {
     const std::string* mapped_name = GetAttribMappedName(it->first);
     if (mapped_name && *mapped_name != it->first)
       glBindAttribLocation(service_id_, it->second, mapped_name->c_str());
   }
 }
 
-bool ProgramManager::ProgramInfo::Link() {
+void ProgramManager::DoCompileShader(ShaderManager::ShaderInfo* info,
+                                     ShaderTranslator* translator,
+                                     FeatureInfo::Ref feature_info) {

[greggman, 2012/06/15 08:10:24]

feature_info should just be a raw pointer.

[dmurph, 2012/06/19 01:08:33]

Done.

+    // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
+    // glShaderSource and then glCompileShader.
+    const char* shader_src = info->source() ? info->source()->c_str() : "";
+    if (translator) {
+      if (!translator->Translate(shader_src)) {
+        info->SetStatus(false, translator->info_log(), NULL);
+        if(shader_cache_) {
+          shader_cache_->setShaderCompilationStatus(
+              info->source()->c_str(),
+              SHADER_CACHE_COMPILATION_SUCCEEDED);
+        }
+        return;
+      }
+      shader_src = translator->translated_shader();
+      if (!feature_info->feature_flags().angle_translated_shader_source)
+        info->UpdateTranslatedSource(shader_src);
+    }
+
+    glShaderSource(info->service_id(), 1, &shader_src, NULL);
+    glCompileShader(info->service_id());
+    if (feature_info->feature_flags().angle_translated_shader_source) {
+      GLint max_len = 0;
+      glGetShaderiv(info->service_id(),
+                    GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE,
+                    &max_len);
+      scoped_array<char> temp(new char[max_len]);
+      GLint len = 0;
+      glGetTranslatedShaderSourceANGLE(
+          info->service_id(), max_len, &len, temp.get());
+      DCHECK(max_len == 0 || len < max_len);
+      DCHECK(len == 0 || temp[len] == '\0');
+      info->UpdateTranslatedSource(temp.get());
+    }
+
+    GLint status = GL_FALSE;
+    glGetShaderiv(info->service_id(),  GL_COMPILE_STATUS, &status);
+    if (status) {
+      info->SetStatus(true, "", translator);
+      if(shader_cache_) {
+        shader_cache_->setShaderCompilationStatus(
+            info->source()->c_str(),
+            SHADER_CACHE_COMPILATION_SUCCEEDED);
+      }
+    } else {
+      // We cannot reach here if we are using the shader translator.
+      // All invalid shaders must be rejected by the translator.
+      // All translated shaders must compile.
+      LOG_IF(ERROR, translator)
+          << "Shader translator allowed/produced an invalid shader.";
+      GLint max_len = 0;
+      glGetShaderiv(info->service_id(), GL_INFO_LOG_LENGTH, &max_len);
+      scoped_array<char> temp(new char[max_len]);
+      GLint len = 0;
+      glGetShaderInfoLog(info->service_id(), max_len, &len, temp.get());
+      DCHECK(max_len == 0 || len < max_len);
+      DCHECK(len == 0 || temp[len] == '\0');
+      info->SetStatus(false, std::string(temp.get(), len).c_str(), NULL);
+      if(shader_cache_) {
+        shader_cache_->setShaderCompilationStatus(
+            info->source()->c_str(),
+            SHADER_CACHE_COMPILATION_UNKNOWN);
+      }
+    }
+}
+
+bool ProgramManager::ProgramInfo::Link(ShaderManager* manager,
+                                       ShaderTranslator* vertex_translator,
+                                       ShaderTranslator* fragment_shader,
+                                       FeatureInfo::Ref feature_info) {
   ClearLinkStatus();
   if (!CanLink()) {
     set_log_info("missing shaders");
     return false;
   }
   if (DetectAttribLocationBindingConflicts()) {
     set_log_info("glBindAttribLocation() conflicts");
     return false;
   }
   ExecuteBindAttribLocationCalls();
-  glLinkProgram(service_id());
+
+  bool link = true;
+  ShaderCache* cache = manager_->shader_cache_;
+  const char* shader_a = attached_shaders_[0]->source()->c_str();
+  const char* shader_b = attached_shaders_[1]->source()->c_str();
+  if(cache) {
+    LinkedProgramStatus status = cache->getLinkedProgramStatus(
+                                   shader_a,
+                                   shader_b);
+    switch(status) {
+      case SHADER_CACHE_LINK_UNKNOWN:
+        fprintf(stderr,
+                "program %i not linked yet compiling and linking\n",
+                service_id());
+        // compile our shaders + attach
+        manager_->DoCompileShader(attached_shaders_[0],
+                                  vertex_translator,
+                                  feature_info);
+        manager_->DoCompileShader(attached_shaders_[1],
+                                  fragment_shader,
+                                  feature_info);
+        AttachShader(manager, attached_shaders_[0]);

[greggman, 2012/06/15 08:10:24]

Why do you have to attach here? Shouldn't they already be attached?

[dmurph, 2012/06/19 01:08:33]

Done.

+        glAttachShader(service_id(), attached_shaders_[0]->service_id());
+        AttachShader(manager, attached_shaders_[1]);
+        glAttachShader(service_id(), attached_shaders_[1]->service_id());
+        link = true;
+        break;
+      case SHADER_CACHE_LINK_SUCCEEDED:
+        fprintf(stderr, "program %i linked and cached!\n", service_id());
+        GLsizei length;
+        GLenum format;
+        const GLvoid* binary;
+        cache->getLinkedProgram(shader_a, shader_b,
+                                        &length, &format, &binary);
+        glProgramBinary(service_id(), format, binary, length);
+        link = false;
+        break;
+    }
+  }
+
+  if(link) {
+    glLinkProgram(service_id());
+  }
+
   GLint success = 0;
   glGetProgramiv(service_id(), GL_LINK_STATUS, &success);
   if (success == GL_TRUE) {
     Update();
+    if(cache && link) {
+      fprintf(stderr, "program %i just linked, caching\n", service_id());
+      GLsizei length;
+      GLenum format;
+      glGetProgramBinary(service_id(),

[greggman, 2012/06/15 08:10:24]

This code makes no sense to me. What is cache->cache_buffer for? it just a temp
buffer to store the shader for a moment when you pull it out because you then
copy it a few lines below.

I'd do this

1) You need to call 

GLsize length = 0;
glGetProgramiv(service_id(), GL_PROGRAM_BINARY_LENGTH_OES, &length) 

To find out the size of the buffer you need. As it is now if the program happesn
to be huge it will just trash memory.

Then, I'd do one of the following

Either add std::vector<uint8> binary_program_buffer_ to ShaderCache and then
resize if it's not big enough as in

if (binary_program_buffer_.size() < 
    static_cast<size_t>(length)) {
   binary_program_buffer_.resize(length);
}

That way it will only grow to the size of the largest program but will rarely be
reallocated.

Otherwise I'd find some way of making it get gl to copy the shader directly into
the place you plan to store it. Then the code wouldn't be copying it twice as as
it is now. (once from GL and again from cache_buffer)

[dmurph, 2012/06/15 16:40:23]

Sounds good, I didn't know I could query the size of the binary, that seems like
the best approach.

+                         kShaderCacheBufferSize,
+                         &length,
+                         &format,
+                         cache->cache_buffer());
+      fprintf(stderr, "got length of %i\n", length);
+
+      if(length != 0) {
+        GLvoid* trimedBinary = new char[length];

[greggman, 2012/06/15 08:10:24]

Related to the above comment where does this memory get freed? It seems like
since it's the responsibility of the cache to free this memory it should be the
responsibility of the cache to allocate it. 

Should the caching code be calling glGetProgramIv and glGetProgramBinary as in
maybe the chunk of code after line 388 should be moved into
ShaderCache::CacheProgram(GLuint program_id, ...). CacheProgram can do the
generic thing (making the GL calls) and call some virtual functions in
MemoryShaderCache to actually store them or something. I don't want to back seat
design, just trying to throw out ideas.

[dmurph, 2012/06/15 16:40:23]

I like that, the memory issue was bothering me yesterday evening on the way
home, definitely can be cleaned up a lot by putting all of that in the cache

+        memcpy(trimedBinary, cache->cache_buffer(), length);
+        cache->setLinkedProgram(shader_a,
+                                shader_b,
+                                length,
+                                format,
+                                trimedBinary);
+        cache->setLinkedProgramStatus(shader_a,
+                                      shader_b,
+                                      SHADER_CACHE_LINK_SUCCEEDED);
+        fprintf(stderr, "caching [%s] and [%s]\n", shader_a, shader_b);
+      }
+
+    }
   } else {
     UpdateLogInfo();
+    if(cache) {
+      fprintf(stderr, "program %i not linked correctly\n", service_id());
+      cache->setLinkedProgramStatus(shader_a,
+                                    shader_b,
+                                    SHADER_CACHE_LINK_UNKNOWN);
+    }
   }
   return success == GL_TRUE;
 }
 
 void ProgramManager::ProgramInfo::Validate() {
   if (!IsValid()) {
     set_log_info("program not linked");
     return;
   }
   glValidateProgram(service_id());
@@ skipping 392 matching lines @@
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 // TODO(gman): make this some kind of random number. Base::RandInt is not
 // callable because of the sandbox. What matters is that it's possibly different
 // by at least 1 bit each time chrome is run.
 static int uniform_random_offset_ = 3;
 
-ProgramManager::ProgramManager()
+ProgramManager::ProgramManager(base::WeakPtr<ShaderCache> shader_cache)
     : uniform_swizzle_(uniform_random_offset_++ % 15),
       program_info_count_(0),
       have_context_(true),
       disable_workarounds_(
           CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kDisableGpuDriverBugWorkarounds)) {
-}
+              switches::kDisableGpuDriverBugWorkarounds)),
+      shader_cache_(shader_cache){ }
 
 ProgramManager::~ProgramManager() {
   DCHECK(program_infos_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   have_context_ = have_context;
   program_infos_.clear();
 }
 
@@ skipping 25 matching lines @@
   for (ProgramInfoMap::const_iterator it = program_infos_.begin();
        it != program_infos_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
     }
   }
   return false;
 }
 
+ShaderCache* ProgramManager::GetShaderCache() const {
+  return shader_cache_;
+}
+
 bool ProgramManager::IsOwned(ProgramManager::ProgramInfo* info) {
   for (ProgramInfoMap::iterator it = program_infos_.begin();
        it != program_infos_.end(); ++it) {
     if (it->second.get() == info) {
       return true;
     }
   }
   return false;
 }
 
@@ skipping 65 matching lines @@
 }
 
 GLint ProgramManager::UnswizzleLocation(GLint v) const {
   return v < 0 ? v : Swizzle(v - uniform_swizzle_);
 }
 
 }  // namespace gles2
 }  // namespace gpu