| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "gpu/command_buffer/service/program_cache.h" | |
| 6 | |
| 7 #include "base/memory/scoped_ptr.h" | |
| 8 #include "testing/gtest/include/gtest/gtest.h" | |
| 9 | |
| 10 namespace gpu { | |
| 11 namespace gles2 { | |
| 12 | |
| 13 class NoBackendProgramCache : public ProgramCache { | |
| 14 public: | |
| 15 virtual ProgramLoadResult LoadLinkedProgram( | |
| 16 GLuint /* program */, | |
| 17 ShaderManager::ShaderInfo* /* shader_a */, | |
| 18 ShaderManager::ShaderInfo* /* shader_b */, | |
| 19 const LocationMap* /* bind_attrib_location_map */) const OVERRIDE { | |
| 20 return PROGRAM_LOAD_SUCCESS; | |
| 21 } | |
| 22 virtual void SaveLinkedProgram( | |
| 23 GLuint /* program */, | |
| 24 const ShaderManager::ShaderInfo* /* shader_a */, | |
| 25 const ShaderManager::ShaderInfo* /* shader_b */, | |
| 26 const LocationMap* /* bind_attrib_location_map */) OVERRIDE { } | |
| 27 | |
| 28 virtual void ClearBackend() OVERRIDE {} | |
| 29 | |
| 30 void SaySuccessfullyCached(const std::string& shader1, | |
| 31 const std::string& shader2, | |
| 32 std::map<std::string, GLint>* attrib_map) { | |
| 33 char a_sha[kHashLength]; | |
| 34 char b_sha[kHashLength]; | |
| 35 ComputeShaderHash(shader1, a_sha); | |
| 36 ComputeShaderHash(shader2, b_sha); | |
| 37 | |
| 38 char sha[kHashLength]; | |
| 39 ComputeProgramHash(a_sha, | |
| 40 b_sha, | |
| 41 attrib_map, | |
| 42 sha); | |
| 43 const std::string shaString(sha, kHashLength); | |
| 44 | |
| 45 LinkedProgramCacheSuccess(shaString, | |
| 46 std::string(a_sha, kHashLength), | |
| 47 std::string(b_sha, kHashLength)); | |
| 48 } | |
| 49 | |
| 50 void ComputeShaderHash(const std::string& shader, | |
| 51 char* result) const { | |
| 52 ProgramCache::ComputeShaderHash(shader, result); | |
| 53 } | |
| 54 | |
| 55 void ComputeProgramHash(const char* hashed_shader_0, | |
| 56 const char* hashed_shader_1, | |
| 57 const LocationMap* bind_attrib_location_map, | |
| 58 char* result) const { | |
| 59 ProgramCache::ComputeProgramHash(hashed_shader_0, | |
| 60 hashed_shader_1, | |
| 61 bind_attrib_location_map, | |
| 62 result); | |
| 63 } | |
| 64 | |
| 65 void Evict(const std::string& program_hash, | |
| 66 const std::string& shader_0_hash, | |
| 67 const std::string& shader_1_hash) { | |
| 68 ProgramCache::Evict(program_hash, shader_0_hash, shader_1_hash); | |
| 69 } | |
| 70 }; | |
| 71 | |
| 72 class ProgramCacheTest : public testing::Test { | |
| 73 public: | |
| 74 ProgramCacheTest() : | |
| 75 cache_(new NoBackendProgramCache()) { } | |
| 76 | |
| 77 protected: | |
| 78 scoped_ptr<NoBackendProgramCache> cache_; | |
| 79 }; | |
| 80 | |
| 81 TEST_F(ProgramCacheTest, CompilationStatusSave) { | |
| 82 const std::string shader1 = "abcd1234"; | |
| 83 { | |
| 84 std::string shader = shader1; | |
| 85 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 86 cache_->GetShaderCompilationStatus(shader)); | |
| 87 cache_->ShaderCompilationSucceeded(shader); | |
| 88 shader.clear(); | |
| 89 } | |
| 90 // make sure it was copied | |
| 91 EXPECT_EQ(ProgramCache::COMPILATION_SUCCEEDED, | |
| 92 cache_->GetShaderCompilationStatus(shader1)); | |
| 93 } | |
| 94 | |
| 95 TEST_F(ProgramCacheTest, CompilationUnknownOnSourceChange) { | |
| 96 std::string shader1 = "abcd1234"; | |
| 97 cache_->ShaderCompilationSucceeded(shader1); | |
| 98 | |
| 99 shader1 = "different!"; | |
| 100 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 101 cache_->GetShaderCompilationStatus(shader1)); | |
| 102 } | |
| 103 | |
| 104 TEST_F(ProgramCacheTest, LinkStatusSave) { | |
| 105 const std::string shader1 = "abcd1234"; | |
| 106 const std::string shader2 = "abcda sda b1~#4 bbbbb1234"; | |
| 107 { | |
| 108 std::string shader_a = shader1; | |
| 109 std::string shader_b = shader2; | |
| 110 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, | |
| 111 cache_->GetLinkedProgramStatus(shader_a, shader_b, NULL)); | |
| 112 cache_->SaySuccessfullyCached(shader_a, shader_b, NULL); | |
| 113 | |
| 114 shader_a.clear(); | |
| 115 shader_b.clear(); | |
| 116 } | |
| 117 // make sure it was copied | |
| 118 EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, | |
| 119 cache_->GetLinkedProgramStatus(shader1, shader2, NULL)); | |
| 120 } | |
| 121 | |
| 122 TEST_F(ProgramCacheTest, LinkUnknownOnFragmentSourceChange) { | |
| 123 const std::string shader1 = "abcd1234"; | |
| 124 std::string shader2 = "abcda sda b1~#4 bbbbb1234"; | |
| 125 cache_->SaySuccessfullyCached(shader1, shader2, NULL); | |
| 126 | |
| 127 shader2 = "different!"; | |
| 128 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, | |
| 129 cache_->GetLinkedProgramStatus(shader1, shader2, NULL)); | |
| 130 } | |
| 131 | |
| 132 TEST_F(ProgramCacheTest, LinkUnknownOnVertexSourceChange) { | |
| 133 std::string shader1 = "abcd1234"; | |
| 134 const std::string shader2 = "abcda sda b1~#4 bbbbb1234"; | |
| 135 cache_->SaySuccessfullyCached(shader1, shader2, NULL); | |
| 136 | |
| 137 shader1 = "different!"; | |
| 138 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, | |
| 139 cache_->GetLinkedProgramStatus(shader1, shader2, NULL)); | |
| 140 } | |
| 141 | |
| 142 TEST_F(ProgramCacheTest, StatusEviction) { | |
| 143 const std::string shader1 = "abcd1234"; | |
| 144 const std::string shader2 = "abcda sda b1~#4 bbbbb1234"; | |
| 145 cache_->ShaderCompilationSucceeded(shader1); | |
| 146 cache_->ShaderCompilationSucceeded(shader2); | |
| 147 cache_->SaySuccessfullyCached(shader1, shader2, NULL); | |
| 148 char a_sha[ProgramCache::kHashLength]; | |
| 149 char b_sha[ProgramCache::kHashLength]; | |
| 150 cache_->ComputeShaderHash(shader1, a_sha); | |
| 151 cache_->ComputeShaderHash(shader2, b_sha); | |
| 152 | |
| 153 char sha[ProgramCache::kHashLength]; | |
| 154 cache_->ComputeProgramHash(a_sha, | |
| 155 b_sha, | |
| 156 NULL, | |
| 157 sha); | |
| 158 cache_->Evict(std::string(sha, ProgramCache::kHashLength), | |
| 159 std::string(a_sha, ProgramCache::kHashLength), | |
| 160 std::string(b_sha, ProgramCache::kHashLength)); | |
| 161 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 162 cache_->GetShaderCompilationStatus(shader1)); | |
| 163 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 164 cache_->GetShaderCompilationStatus(shader2)); | |
| 165 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, | |
| 166 cache_->GetLinkedProgramStatus(shader1, shader2, NULL)); | |
| 167 } | |
| 168 | |
| 169 TEST_F(ProgramCacheTest, EvictionWithReusedShader) { | |
| 170 const std::string shader1 = "abcd1234"; | |
| 171 const std::string shader2 = "abcda sda b1~#4 bbbbb1234"; | |
| 172 const std::string shader3 = "asbjbbjj239a"; | |
| 173 cache_->ShaderCompilationSucceeded(shader1); | |
| 174 cache_->ShaderCompilationSucceeded(shader2); | |
| 175 cache_->SaySuccessfullyCached(shader1, shader2, NULL); | |
| 176 cache_->ShaderCompilationSucceeded(shader1); | |
| 177 cache_->ShaderCompilationSucceeded(shader3); | |
| 178 cache_->SaySuccessfullyCached(shader1, shader3, NULL); | |
| 179 | |
| 180 char a_sha[ProgramCache::kHashLength]; | |
| 181 char b_sha[ProgramCache::kHashLength]; | |
| 182 char c_sha[ProgramCache::kHashLength]; | |
| 183 cache_->ComputeShaderHash(shader1, a_sha); | |
| 184 cache_->ComputeShaderHash(shader2, b_sha); | |
| 185 cache_->ComputeShaderHash(shader3, c_sha); | |
| 186 | |
| 187 char sha[ProgramCache::kHashLength]; | |
| 188 cache_->ComputeProgramHash(a_sha, | |
| 189 b_sha, | |
| 190 NULL, | |
| 191 sha); | |
| 192 cache_->Evict(std::string(sha, ProgramCache::kHashLength), | |
| 193 std::string(a_sha, ProgramCache::kHashLength), | |
| 194 std::string(b_sha, ProgramCache::kHashLength)); | |
| 195 EXPECT_EQ(ProgramCache::COMPILATION_SUCCEEDED, | |
| 196 cache_->GetShaderCompilationStatus(shader1)); | |
| 197 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 198 cache_->GetShaderCompilationStatus(shader2)); | |
| 199 EXPECT_EQ(ProgramCache::COMPILATION_SUCCEEDED, | |
| 200 cache_->GetShaderCompilationStatus(shader3)); | |
| 201 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, | |
| 202 cache_->GetLinkedProgramStatus(shader1, shader2, NULL)); | |
| 203 EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, | |
| 204 cache_->GetLinkedProgramStatus(shader1, shader3, NULL)); | |
| 205 | |
| 206 | |
| 207 cache_->ComputeProgramHash(a_sha, | |
| 208 c_sha, | |
| 209 NULL, | |
| 210 sha); | |
| 211 cache_->Evict(std::string(sha, ProgramCache::kHashLength), | |
| 212 std::string(a_sha, ProgramCache::kHashLength), | |
| 213 std::string(c_sha, ProgramCache::kHashLength)); | |
| 214 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 215 cache_->GetShaderCompilationStatus(shader1)); | |
| 216 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 217 cache_->GetShaderCompilationStatus(shader2)); | |
| 218 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 219 cache_->GetShaderCompilationStatus(shader3)); | |
| 220 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, | |
| 221 cache_->GetLinkedProgramStatus(shader1, shader2, NULL)); | |
| 222 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, | |
| 223 cache_->GetLinkedProgramStatus(shader1, shader3, NULL)); | |
| 224 } | |
| 225 | |
| 226 TEST_F(ProgramCacheTest, StatusClear) { | |
| 227 const std::string shader1 = "abcd1234"; | |
| 228 const std::string shader2 = "abcda sda b1~#4 bbbbb1234"; | |
| 229 const std::string shader3 = "asbjbbjj239a"; | |
| 230 cache_->ShaderCompilationSucceeded(shader1); | |
| 231 cache_->ShaderCompilationSucceeded(shader2); | |
| 232 cache_->SaySuccessfullyCached(shader1, shader2, NULL); | |
| 233 cache_->ShaderCompilationSucceeded(shader3); | |
| 234 cache_->SaySuccessfullyCached(shader1, shader3, NULL); | |
| 235 cache_->Clear(); | |
| 236 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 237 cache_->GetShaderCompilationStatus(shader1)); | |
| 238 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 239 cache_->GetShaderCompilationStatus(shader2)); | |
| 240 EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN, | |
| 241 cache_->GetShaderCompilationStatus(shader3)); | |
| 242 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, | |
| 243 cache_->GetLinkedProgramStatus(shader1, shader2, NULL)); | |
| 244 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, | |
| 245 cache_->GetLinkedProgramStatus(shader1, shader3, NULL)); | |
| 246 } | |
| 247 | |
| 248 } // namespace gles2 | |
| 249 } // namespace gpu | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10795037:
Revert 147328 - Current status of patch: (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/