GPU Program Caching

gpu/command_buffer/service/program_cache_unittest.cc

Index: gpu/command_buffer/service/program_cache_unittest.cc
diff --git a/gpu/command_buffer/service/program_cache_unittest.cc b/gpu/command_buffer/service/program_cache_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b1a909a90674a73e51e30b566a55bd612a394a07
--- /dev/null
+++ b/gpu/command_buffer/service/program_cache_unittest.cc
@@ -0,0 +1,199 @@
+// 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_cache.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+typedef std::map<std::string, GLint> LocationMap;
+} // anonymous namespace
+
+namespace gpu {
+namespace gles2 {
+
+class NoBackendProgramCache : public ProgramCache {
+public:
+  bool LoadLinkedProgram(const GLuint program,
+                         ShaderManager::ShaderInfo* shader_a,
+                         ShaderManager::ShaderInfo* shader_b,
+                         const LocationMap* bind_attrib_location_map) const {
+    return true;
+  }
+  void SaveLinkedProgram(const GLuint program,
+                         const ShaderManager::ShaderInfo* shader_a,
+                         const ShaderManager::ShaderInfo* shader_b,
+                         const LocationMap* bind_attrib_location_map) { }
+
+  void ClearBackend() {}
+
+  void SaySuccessfullyCached(const std::string& shader1,
+                               const std::string& shader2,
+                               std::map<std::string, GLint>* attrib_map) {
+    char a_sha[kHashLength];
+    char b_sha[kHashLength];
+    computeShaderHash(shader1, a_sha);
+    computeShaderHash(shader2, b_sha);
+
+    char sha[kHashLength];
+    computeProgramHash(a_sha,
+                       b_sha,
+                       attrib_map,
+                       sha);
+    const std::string shaString(sha, kHashLength);
+
+    LinkedProgramCacheSuccess(shaString,
+                        std::string(a_sha, kHashLength),
+                        std::string(b_sha, kHashLength));
+  }
+
+  void computeShaderHash(const std::string& shader,
+                         char* result) const {
+    ProgramCache::ComputeShaderHash(shader, result);
+  }
+
+  void computeProgramHash(const char* hashed_shader_0,
+                          const char* hashed_shader_1,
+                          const BindAttribMap* bind_attrib_location_map,
+                          char* result) const {
+    ProgramCache::ComputeProgramHash(hashed_shader_0,
+                                     hashed_shader_1,
+                                     bind_attrib_location_map,
+                                     result);
+  }
+
+  void evict(const std::string& program_hash,
+             const std::string& shader_0_hash,
+             const std::string& shader_1_hash) {
+    ProgramCache::Evict(program_hash, shader_0_hash, shader_1_hash);
+  }
+
+  uint32 getHashLength() {
+    return ProgramCache::kHashLength ;
+  }
+};
+
+class ProgramCacheTest : public testing::Test {
+ public:
+  ProgramCacheTest() :
+    cache_(new NoBackendProgramCache()) { }
+
+ protected:
+
+  scoped_ptr<NoBackendProgramCache> cache_;
+};
+
+TEST_F(ProgramCacheTest, ProgramCacheCompilationStatus) {
+  const std::string shader1 = "abcd1234";
+  {
+    std::string shader = shader1;
+    ASSERT_EQ(ProgramCache::COMPILATION_UNKNOWN,
+              cache_->GetShaderCompilationStatus(shader));
+    cache_->ShaderCompilationSucceeded(shader);
+    shader.clear();
+  }
+  // make sure it was copied
+  ASSERT_EQ(ProgramCache::COMPILATION_SUCCEEDED,
+            cache_->GetShaderCompilationStatus(shader1));
+}
+
+TEST_F(ProgramCacheTest, ProgramCacheProgramLinkStatus) {
+  const std::string shader1 = "abcd1234";
+  const std::string shader2 = "abcda sda b1~#4 bbbbb1234";
+  {
+    std::string shaderA = shader1;
+    std::string shaderB = shader2;
+    ASSERT_EQ(ProgramCache::LINK_UNKNOWN,
+              cache_->GetLinkedProgramStatus(shaderA, shaderB, NULL));
+    cache_->SaySuccessfullyCached(shaderA, shaderB, NULL);
+
+    shaderA.clear();
+    shaderB.clear();
+  }
+  // make sure it was copied
+  ASSERT_EQ(ProgramCache::LINK_SUCCEEDED,
+            cache_->GetLinkedProgramStatus(shader1, shader2, NULL));
+}
+
+TEST_F(ProgramCacheTest, ProgramCacheEviction) {
+  const std::string shader1 = "abcd1234";
+  const std::string shader2 = "abcda sda b1~#4 bbbbb1234";
+  cache_->ShaderCompilationSucceeded(shader1);
+  cache_->ShaderCompilationSucceeded(shader2);
+  cache_->SaySuccessfullyCached(shader1, shader2, NULL);
+  const uint32 hashLength = cache_->getHashLength();
+  char a_sha[hashLength];
+  char b_sha[hashLength];
+  cache_->computeShaderHash(shader1, a_sha);
+  cache_->computeShaderHash(shader2, b_sha);
+
+  char sha[hashLength];
+  cache_->computeProgramHash(a_sha,
+                                     b_sha,
+                                     NULL,
+                                     sha);
+  cache_->evict(std::string(sha, hashLength),
+                        std::string(a_sha, hashLength),
+                        std::string(b_sha, hashLength));
+  ASSERT_EQ(ProgramCache::COMPILATION_UNKNOWN,
+            cache_->GetShaderCompilationStatus(shader1));
+  ASSERT_EQ(ProgramCache::COMPILATION_UNKNOWN,
+            cache_->GetShaderCompilationStatus(shader2));
+  ASSERT_EQ(ProgramCache::LINK_UNKNOWN,
+            cache_->GetLinkedProgramStatus(shader1, shader2, NULL));
+}
+
+TEST_F(ProgramCacheTest, ProgramCacheEvictionWithReusedShader) {
+  const std::string shader1 = "abcd1234";
+  const std::string shader2 = "abcda sda b1~#4 bbbbb1234";
+  const std::string shader3 = "asbjbbjj239a";
+  cache_->ShaderCompilationSucceeded(shader1);
+  cache_->ShaderCompilationSucceeded(shader2);
+  cache_->SaySuccessfullyCached(shader1, shader2, NULL);
+  cache_->ShaderCompilationSucceeded(shader3);
+  cache_->SaySuccessfullyCached(shader1, shader3, NULL);
+
+  const uint32 hashLength = cache_->getHashLength();
+  char a_sha[hashLength];
+  char b_sha[hashLength];
+  char c_sha[hashLength];
+  cache_->computeShaderHash(shader1, a_sha);
+  cache_->computeShaderHash(shader2, b_sha);
+  cache_->computeShaderHash(shader3, c_sha);
+
+  char sha[hashLength];
+  cache_->computeProgramHash(a_sha,
+                             b_sha,
+                             NULL,
+                             sha);
+  cache_->evict(std::string(sha, hashLength),
+                std::string(a_sha, hashLength),
+                std::string(b_sha, hashLength));
+  ASSERT_EQ(ProgramCache::COMPILATION_SUCCEEDED,
+            cache_->GetShaderCompilationStatus(shader1));
+  ASSERT_EQ(ProgramCache::COMPILATION_UNKNOWN,
+            cache_->GetShaderCompilationStatus(shader2));
+  ASSERT_EQ(ProgramCache::COMPILATION_SUCCEEDED,
+            cache_->GetShaderCompilationStatus(shader3));
+  ASSERT_EQ(ProgramCache::LINK_UNKNOWN,
+            cache_->GetLinkedProgramStatus(shader1, shader2, NULL));
+
+  cache_->computeProgramHash(a_sha,
+                             c_sha,
+                             NULL,
+                             sha);
+  cache_->evict(std::string(sha, hashLength),
+                std::string(a_sha, hashLength),
+                std::string(c_sha, hashLength));
+  ASSERT_EQ(ProgramCache::COMPILATION_UNKNOWN,
+            cache_->GetShaderCompilationStatus(shader1));
+  ASSERT_EQ(ProgramCache::COMPILATION_UNKNOWN,
+            cache_->GetShaderCompilationStatus(shader2));
+  ASSERT_EQ(ProgramCache::COMPILATION_UNKNOWN,
+            cache_->GetShaderCompilationStatus(shader3));
+}
+
+} // namespace gles2
+} // namespace gpu