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 <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
+#include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
+#include "gpu/command_buffer/service/program_cache.h"
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 
 int ShaderTypeToIndex(GLenum shader_type) {
   switch (shader_type) {
     case GL_VERTEX_SHADER:
       return 0;
     case GL_FRAGMENT_SHADER:
       return 1;
     default:
       NOTREACHED();
       return 0;
   }
 }
 
+ShaderTranslator* ShaderIndexToTranslator(
+    int index,
+    ShaderTranslator* vertex_translator,
+    ShaderTranslator* fragment_translator) {
+  switch (index) {
+    case 0:
+      return vertex_translator;
+    case 1:
+      return fragment_translator;
+    default:
+      NOTREACHED();
+      return NULL;
+  }
+}
+
 // Given a name like "foo.bar[123].moo[456]" sets new_name to "foo.bar[123].moo"
 // and sets element_index to 456. returns false if element expression was not a
 // whole decimal number. For example: "foo[1b2]"
 bool GetUniformNameSansElement(
     const std::string name, int* element_index, std::string* new_name) {
   DCHECK(element_index);
   DCHECK(new_name);
   if (name.size() < 3 || name[name.size() - 1] != ']') {
     *element_index = 0;
     *new_name = name;
@@ skipping 306 matching lines @@
 
 void ProgramManager::ProgramInfo::ExecuteBindAttribLocationCalls() {
   for (LocationMap::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* feature_info) {
+  if (program_cache_ &&
+      program_cache_->GetShaderCompilationStatus(*info->source())
+          == ProgramCache::COMPILATION_SUCCEEDED) {

[greggman, 2012/07/10 21:43:30]

style: operators go at end of previous line

[dmurph, 2012/07/11 23:32:52]

Done.

+    info->SetStatus(true, "", translator);
+    info->set_pending_compilation(true);
+    return;
+  }
+  ForceCompileShader(info, translator, feature_info);
+}
+
+void ProgramManager::ForceCompileShader(ShaderManager::ShaderInfo* info,
+                                        ShaderTranslator* translator,
+                                        FeatureInfo* feature_info) {
+  // 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);
+      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 (program_cache_) {
+      program_cache_->ShaderCompilationSucceeded(*info->source());
+    }
+  } 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);
+  }
+}
+
+bool ProgramManager::ProgramInfo::Link(ShaderManager* manager,
+                                       ShaderTranslator* vertex_translator,
+                                       ShaderTranslator* fragment_translator,
+                                       FeatureInfo* 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;
+  ProgramCache* cache = manager_->program_cache_;
+  const std::string* shader_a = attached_shaders_[0]->source();
+  const std::string* shader_b = attached_shaders_[1]->source();
+  if (cache) {
+    ProgramCache::LinkedProgramStatus status = cache->GetLinkedProgramStatus(
+        *shader_a,
+        *shader_b,
+        &bind_attrib_location_map_);
+    switch (status) {
+      case ProgramCache::LINK_SUCCEEDED: {
+        ProgramCache::ProgramLoadResult success = cache->LoadLinkedProgram(
+            service_id(),
+            attached_shaders_[0],
+            attached_shaders_[1],
+            &bind_attrib_location_map_);
+        if (success == ProgramCache::PROGRAM_LOAD_SUCCESS) {
+          link = false;
+          break;
+        }
+      }
+      // no break
+      case ProgramCache::LINK_UNKNOWN: {
+        // compile our shaders + attach
+        const int kShaders = ProgramManager::ProgramInfo::kMaxAttachedShaders;
+        for (int i = 0; i < kShaders; ++i) {
+          ShaderManager::ShaderInfo* info = attached_shaders_[i].get();
+          if (info->IsPendingCacheMissCompilation()) {
+            ShaderTranslator* translator = ShaderIndexToTranslator(
+                i,
+                vertex_translator,
+                fragment_translator);
+            manager_->ForceCompileShader(attached_shaders_[i],
+                                         translator,
+                                         feature_info);
+            AttachShader(manager, info);

[greggman, 2012/07/10 21:43:30]

You shouldn't need go call AttachShader nor glAttachShader here. The user
already attached the shaders.

[dmurph, 2012/07/11 23:32:52]

Done.

+            glAttachShader(service_id(), info->service_id());
+            info->set_pending_compilation(false);

[greggman, 2012/07/10 21:43:30]

Should ForceCompileShader set set_pending_compilation to false?

Seems like there's a chance for double compilation

[dmurph, 2012/07/11 23:32:52]

Hm.... What if we just moved it right after the if statement, because that's
where we check for it?  I feel like it's better for ForceCompileShader to have
no knowledge of cache stuff.

[greggman, 2012/07/12 00:48:29]

Maybe I'm mis-understanding. It seems like there's a way I can get
ForceCompileShader to be called from GLES2DecoderImpl::DoCompileShader and then
again in Link

Create program AB1 with shaders with src A and src B. 
Create new shader with src A. Shader is marked as pending since it's the same
source.
Change src of shader (glShaderSource) and call glCompileShader.
ForceComipleShader will be called by GLES2DecoderImpl::DoCompileShader but
shader is still marked as pending.
 
Am I right? If so maybe you could add a test for that case?

+            CHECK(info->IsValid());
+          }
+        }
+        link = true;
+        break;
+      }
+      default:
+        NOTREACHED();
+    }
+  }
+
+  if (link) {
+    glLinkProgram(service_id());
+  }
+
   GLint success = 0;
   glGetProgramiv(service_id(), GL_LINK_STATUS, &success);
   if (success == GL_TRUE) {
     Update();
+    if (cache && link) {
+      cache->SaveLinkedProgram(service_id(),
+                               attached_shaders_[0],
+                               attached_shaders_[1],
+                               &bind_attrib_location_map_);
+    }
   } else {
     UpdateLogInfo();
   }
   return success == GL_TRUE;
 }
 
 void ProgramManager::ProgramInfo::Validate() {
   if (!IsValid()) {
     set_log_info("program not linked");
     return;
@@ skipping 452 matching lines @@
 ProgramManager::ProgramInfo::~ProgramInfo() {
   if (manager_) {
     if (manager_->have_context_) {
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
-ProgramManager::ProgramManager()
+
+ProgramManager::ProgramManager(ProgramCache* program_cache)
     : program_info_count_(0),
       have_context_(true),
       disable_workarounds_(
           CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kDisableGpuDriverBugWorkarounds)) {
-}
+              switches::kDisableGpuDriverBugWorkarounds)),
+      program_cache_(program_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;
 }
 
+ProgramCache* ProgramManager::program_cache() const {
+  return program_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 50 matching lines @@
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu