GPU Program Caching

gpu/command_buffer/service/program_cache.cc

Index: gpu/command_buffer/service/program_cache.cc
diff --git a/gpu/command_buffer/service/program_cache.cc b/gpu/command_buffer/service/program_cache.cc
new file mode 100644
index 0000000000000000000000000000000000000000..055e896e119f6686e661d1fad924461965452a72
--- /dev/null
+++ b/gpu/command_buffer/service/program_cache.cc
@@ -0,0 +1,156 @@
+// 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 "program_cache.h"
+
+#include "base/sha1.h"
+#include "base/memory/scoped_ptr.h"
+
+namespace gpu {
+namespace gles2 {
+
+namespace {
+typedef std::map<std::string, GLint> BindAttribMap;
+} // anonymous namespace
+
+
+ProgramCache::~ProgramCache() {}
+
+void ProgramCache::Clear() {
+  shader_status_.clear();
+  link_status_.clear();
+  ClearBackend();
+}
+
+ProgramCache::CompiledShaderStatus ProgramCache::GetShaderCompilationStatus(
+    const std::string& shader_src) const {
+
+  char sha[kHashLength];
+  ComputeShaderHash(shader_src, sha);
+  const std::string shaString(sha, kHashLength);
+
+  CompileStatusMap::const_iterator found = shader_status_.find(shaString);
+
+  if (found == shader_status_.end()) {
+    return ProgramCache::COMPILATION_UNKNOWN;
+  } else {
+    return found->second.status;
+  }
+}
+
+void ProgramCache::ShaderCompilationSucceeded(
+    const std::string& shader_src) {
+  char sha[kHashLength];
+  ComputeShaderHash(shader_src, sha);
+  const std::string shaString(sha, kHashLength);
+
+  shader_status_[shaString] = CompiledShaderInfo(COMPILATION_SUCCEEDED);
+}
+
+ProgramCache::LinkedProgramStatus ProgramCache::GetLinkedProgramStatus(
+    const std::string& untranslated_a,
+    const std::string& untranslated_b,
+    const BindAttribMap* bind_attrib_location_map) const {
+  char a_sha[kHashLength];
+  char b_sha[kHashLength];
+  ComputeShaderHash(untranslated_a, a_sha);
+  ComputeShaderHash(untranslated_b, b_sha);
+
+  char sha[kHashLength];
+  ComputeProgramHash(a_sha,
+                     b_sha,
+                     bind_attrib_location_map,
+                     sha);
+  const std::string shaString(sha, kHashLength);
+
+  LinkStatusMap::const_iterator found = link_status_.find(shaString);
+  if (found == link_status_.end()) {
+    return ProgramCache::LINK_UNKNOWN;
+  } else {
+    return found->second;
+  }
+}
+
+void ProgramCache::LinkedProgramCacheSuccess(const std::string& program_hash,
+                                       const std::string& shader_a_hash,
+                                       const std::string& shader_b_hash) {
+  link_status_[program_hash] = LINK_SUCCEEDED;
+  shader_status_[shader_a_hash].usedInCachedProgram();
+  shader_status_[shader_b_hash].usedInCachedProgram();
+}
+
+void ProgramCache::ComputeShaderHash(const std::string& str,
+                                            char* result) const {
+  base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(str.c_str()),
+                      str.length(), reinterpret_cast<unsigned char*>(result));
+}
+
+void ProgramCache::Evict(const std::string& program_hash,
+                         const std::string& shader_0_hash,
+                         const std::string& shader_1_hash) {
+  CompiledShaderInfo info0 = shader_status_[shader_0_hash];
+  CompiledShaderInfo info1 = shader_status_[shader_1_hash];
+  if(--info0.ref_count <= 0) {
+    shader_status_.erase(shader_0_hash);
+  } else {
+    shader_status_[shader_0_hash] = info0;
+  }
+  if(--info1.ref_count <= 0) {
+    shader_status_.erase(shader_1_hash);
+  } else {
+    shader_status_[shader_1_hash] = info1;
+  }
+  link_status_.erase(program_hash);
+}
+
+namespace {
+uint32 calculateMapSize(const BindAttribMap* map) {
+  if (!map) {
+    return 0;
+  }
+  BindAttribMap::const_iterator it;
+  uint32 total = 0;
+  for(it = map->begin(); it != map->end(); ++it) {
+    total += 4 + it->first.length();
+  }
+  return total;
+}
+} // anonymous namespace
+
+void ProgramCache::ComputeProgramHash(
+    const char* hashed_shader_0,
+    const char* hashed_shader_1,
+    const BindAttribMap* bind_attrib_location_map,
+    char* result) const {
+  const uint32 shader0Size = kHashLength;
+  const uint32 shader1Size = kHashLength;
+  const uint32 mapSize = calculateMapSize(bind_attrib_location_map);
+  const uint32 totalSize = shader0Size + shader1Size + mapSize;
+
+  scoped_array<char> buffer(new char[totalSize]);
+  memcpy(buffer.get(), hashed_shader_0, shader0Size);
+  memcpy(&buffer.get()[shader0Size], hashed_shader_1, shader1Size);
+  if(mapSize != 0) {
+    // copy our map
+    uint32 currPos = shader0Size + shader1Size;
+    BindAttribMap::const_iterator it;
+    for(it = bind_attrib_location_map->begin();
+        it != bind_attrib_location_map->end();
+        ++it) {
+      const uint32 nameSize = it->first.length();
+      memcpy(&buffer.get()[currPos], it->first.c_str(), nameSize);
+      currPos += nameSize;
+      const GLint value = it->second;
+      buffer.get()[currPos++] = (char) (value >> 12);

[greggman, 2012/06/25 18:53:03]

Is there a reason you're doing 4 bits at a time instead of 8?

[dmurph, 2012/06/26 02:32:56]

whoops

+      buffer.get()[currPos++] = (char) (value >> 8);
+      buffer.get()[currPos++] = (char) (value >> 4);
+      buffer.get()[currPos++] = (char) value;
+    }
+  }
+  base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(buffer.get()),
+                      totalSize, reinterpret_cast<unsigned char*>(result));
+}
+
+} // namespace gles2
+} // namespace gpu