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 <vector>
 
 #include "base/basictypes.h"
+#include "base/bind.h"

[greggman, 2012/06/26 23:00:27]

is this include needed?

 #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"

[greggman, 2012/06/26 23:00:27]

is this include needed?

 #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 250 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* 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)

[greggman, 2012/06/26 23:00:27]

ugh: please add a new issue. We need to either cache the translated shader
source or call compile lazily 
so that calling glGetTranslatedShaderSourceANGLE works for programs loaded from
the cache. We can probably do that in another CL though.

[dmurph, 2012/07/04 00:01:29]

Hm, okay then I'll leave this alone?  Should the issue say "cache the translated
shader source or call compile lazily"?

+        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);

[greggman, 2012/06/26 23:00:27]

style: I'm sure this was just copied and passed but only 1 space before
GL_COMPILE_STATUS

[dmurph, 2012/07/04 00:01:29]

Done.

+    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_shader,
+                                       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,

[greggman, 2012/06/26 23:00:27]

style: indenting

[dmurph, 2012/07/04 00:01:29]

Done.

+                                   *shader_b,
+                                   &bind_attrib_location_map_);
+    switch (status) {
+      case ProgramCache::LINK_SUCCEEDED: {
+        bool success = cache->LoadLinkedProgram(service_id(),
+                                                attached_shaders_[0],
+                                                attached_shaders_[1],
+                                                &bind_attrib_location_map_);
+        if (success) {
+          link = false;
+          break;
+        }
+      }  // fall through
+      case ProgramCache::LINK_UNKNOWN:
+        // compile our shaders + attach
+        if (attached_shaders_[0]->IsPendingCacheMissCompilation()) {
+          manager_->DoCompileShader(attached_shaders_[0],

[greggman, 2012/06/26 23:00:27]

this code is repeated pretty much repeated twice. It seems like it should be a
function or a loop.

Also, a CHECK() for success would be good because we are assuming it here.

[dmurph, 2012/07/04 00:01:29]

Done.

+                                    vertex_translator,
+                                    feature_info);
+          AttachShader(manager, attached_shaders_[0]);
+          glAttachShader(service_id(), attached_shaders_[0]->service_id());
+          attached_shaders_[0]->SetPendingCompilation(false);
+        }
+        if (attached_shaders_[1]->IsPendingCacheMissCompilation()) {
+          manager_->DoCompileShader(attached_shaders_[1],
+                                    fragment_shader,
+                                    feature_info);
+          AttachShader(manager, attached_shaders_[1]);
+          glAttachShader(service_id(), attached_shaders_[1]->service_id());
+          attached_shaders_[1]->SetPendingCompilation(false);
+        }
+        link = true;
+        break;
+    }
+  }
+
+  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 390 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 46 matching lines @@
   DCHECK(info);
   if (!disable_workarounds_) {
     info->ClearUniforms(&zero_);
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu