| 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/memory_program_cache.h" | |
| 6 | |
| 7 #include "gpu/command_buffer/common/gl_mock.h" | |
| 8 #include "gpu/command_buffer/common/gles2_cmd_format.h" | |
| 9 #include "gpu/command_buffer/service/gl_utils.h" | |
| 10 #include "gpu/command_buffer/service/shader_translator.h" | |
| 11 #include "testing/gtest/include/gtest/gtest.h" | |
| 12 #include "ui/gl/gl_bindings.h" | |
| 13 | |
| 14 using ::testing::_; | |
| 15 using ::testing::ElementsAreArray; | |
| 16 using ::testing::Invoke; | |
| 17 using ::testing::SetArgPointee; | |
| 18 using ::testing::SetArrayArgument; | |
| 19 | |
| 20 namespace { | |
| 21 typedef gpu::gles2::ShaderTranslator::VariableMap VariableMap; | |
| 22 } // anonymous namespace | |
| 23 | |
| 24 namespace gpu { | |
| 25 namespace gles2 { | |
| 26 | |
| 27 class ProgramBinaryEmulator { | |
| 28 public: | |
| 29 ProgramBinaryEmulator(GLsizei length, | |
| 30 GLenum format, | |
| 31 const char* binary) | |
| 32 : length_(length), | |
| 33 format_(format), | |
| 34 binary_(binary) { } | |
| 35 | |
| 36 void GetProgramBinary(GLuint program, | |
| 37 GLsizei buffer_size, | |
| 38 GLsizei* length, | |
| 39 GLenum* format, | |
| 40 GLvoid* binary) { | |
| 41 *length = length_; | |
| 42 *format = format_; | |
| 43 memcpy(binary, binary_, length_); | |
| 44 } | |
| 45 | |
| 46 void ProgramBinary(GLuint program, | |
| 47 GLenum format, | |
| 48 const GLvoid* binary, | |
| 49 GLsizei length) { | |
| 50 // format and length are verified by matcher | |
| 51 EXPECT_EQ(0, memcmp(binary_, binary, length)); | |
| 52 } | |
| 53 | |
| 54 GLsizei length() const { return length_; } | |
| 55 GLenum format() const { return format_; } | |
| 56 const char* binary() const { return binary_; } | |
| 57 | |
| 58 private: | |
| 59 GLsizei length_; | |
| 60 GLenum format_; | |
| 61 const char* binary_; | |
| 62 }; | |
| 63 | |
| 64 class MemoryProgramCacheTest : public testing::Test { | |
| 65 public: | |
| 66 static const size_t kCacheSizeBytes = 1024; | |
| 67 static const GLuint kVertexShaderClientId = 90; | |
| 68 static const GLuint kVertexShaderServiceId = 100; | |
| 69 static const GLuint kFragmentShaderClientId = 91; | |
| 70 static const GLuint kFragmentShaderServiceId = 100; | |
| 71 | |
| 72 MemoryProgramCacheTest() | |
| 73 : cache_(new MemoryProgramCache(kCacheSizeBytes)), | |
| 74 vertex_shader_(NULL), | |
| 75 fragment_shader_(NULL) { } | |
| 76 ~MemoryProgramCacheTest() { | |
| 77 shader_manager_.Destroy(false); | |
| 78 } | |
| 79 | |
| 80 protected: | |
| 81 virtual void SetUp() { | |
| 82 gl_.reset(new ::testing::StrictMock<gfx::MockGLInterface>()); | |
| 83 ::gfx::GLInterface::SetGLInterface(gl_.get()); | |
| 84 | |
| 85 vertex_shader_ = shader_manager_.CreateShaderInfo(kVertexShaderClientId, | |
| 86 kVertexShaderServiceId, | |
| 87 GL_VERTEX_SHADER); | |
| 88 fragment_shader_ = shader_manager_.CreateShaderInfo( | |
| 89 kFragmentShaderClientId, | |
| 90 kFragmentShaderServiceId, | |
| 91 GL_FRAGMENT_SHADER); | |
| 92 ASSERT_TRUE(vertex_shader_ != NULL); | |
| 93 ASSERT_TRUE(fragment_shader_ != NULL); | |
| 94 typedef ShaderTranslatorInterface::VariableInfo VariableInfo; | |
| 95 typedef ShaderTranslator::VariableMap VariableMap; | |
| 96 VariableMap vertex_attrib_map; | |
| 97 VariableMap vertex_uniform_map; | |
| 98 VariableMap fragment_attrib_map; | |
| 99 VariableMap fragment_uniform_map; | |
| 100 | |
| 101 vertex_attrib_map["a"] = VariableInfo(1, 34, "a"); | |
| 102 vertex_uniform_map["a"] = VariableInfo(0, 10, "a"); | |
| 103 vertex_uniform_map["b"] = VariableInfo(2, 3114, "b"); | |
| 104 fragment_attrib_map["jjjbb"] = VariableInfo(463, 1114, "jjjbb"); | |
| 105 fragment_uniform_map["k"] = VariableInfo(10, 34413, "k"); | |
| 106 | |
| 107 vertex_shader_->set_attrib_map(vertex_attrib_map); | |
| 108 vertex_shader_->set_uniform_map(vertex_uniform_map); | |
| 109 fragment_shader_->set_attrib_map(vertex_attrib_map); | |
| 110 fragment_shader_->set_uniform_map(vertex_uniform_map); | |
| 111 | |
| 112 vertex_shader_->UpdateSource("bbbalsldkdkdkd"); | |
| 113 fragment_shader_->UpdateSource("bbbal sldkdkdkas 134 ad"); | |
| 114 vertex_shader_->FlagSourceAsCompiled(true); | |
| 115 fragment_shader_->FlagSourceAsCompiled(true); | |
| 116 | |
| 117 vertex_shader_->SetStatus(true, NULL, NULL); | |
| 118 fragment_shader_->SetStatus(true, NULL, NULL); | |
| 119 } | |
| 120 | |
| 121 virtual void TearDown() { | |
| 122 ::gfx::GLInterface::SetGLInterface(NULL); | |
| 123 gl_.reset(); | |
| 124 } | |
| 125 | |
| 126 void SetExpectationsForSaveLinkedProgram( | |
| 127 const GLint program_id, | |
| 128 ProgramBinaryEmulator* emulator) const { | |
| 129 EXPECT_CALL(*gl_.get(), | |
| 130 GetProgramiv(program_id, GL_PROGRAM_BINARY_LENGTH_OES, _)) | |
| 131 .WillOnce(SetArgPointee<2>(emulator->length())); | |
| 132 EXPECT_CALL(*gl_.get(), | |
| 133 GetProgramBinary(program_id, emulator->length(), _, _, _)) | |
| 134 .WillOnce(Invoke(emulator, &ProgramBinaryEmulator::GetProgramBinary)); | |
| 135 } | |
| 136 | |
| 137 void SetExpectationsForLoadLinkedProgram( | |
| 138 const GLint program_id, | |
| 139 ProgramBinaryEmulator* emulator) const { | |
| 140 EXPECT_CALL(*gl_.get(), | |
| 141 ProgramBinary(program_id, | |
| 142 emulator->format(), | |
| 143 _, | |
| 144 emulator->length())) | |
| 145 .WillOnce(Invoke(emulator, &ProgramBinaryEmulator::ProgramBinary)); | |
| 146 } | |
| 147 | |
| 148 // Use StrictMock to make 100% sure we know how GL will be called. | |
| 149 scoped_ptr< ::testing::StrictMock<gfx::MockGLInterface> > gl_; | |
| 150 scoped_ptr<MemoryProgramCache> cache_; | |
| 151 ShaderManager shader_manager_; | |
| 152 ShaderManager::ShaderInfo* vertex_shader_; | |
| 153 ShaderManager::ShaderInfo* fragment_shader_; | |
| 154 }; | |
| 155 | |
| 156 TEST_F(MemoryProgramCacheTest, CacheSave) { | |
| 157 const GLenum kFormat = 1; | |
| 158 const int kProgramId = 10; | |
| 159 const int kBinaryLength = 20; | |
| 160 char testBinary[kBinaryLength]; | |
| 161 for (int i = 0; i < kBinaryLength; ++i) { | |
| 162 testBinary[i] = i; | |
| 163 } | |
| 164 ProgramBinaryEmulator emulator(kBinaryLength, kFormat, testBinary); | |
| 165 | |
| 166 SetExpectationsForSaveLinkedProgram(kProgramId, &emulator); | |
| 167 cache_->SaveLinkedProgram(kProgramId, vertex_shader_, fragment_shader_, NULL); | |
| 168 | |
| 169 EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus( | |
| 170 *vertex_shader_->deferred_compilation_source(), | |
| 171 *fragment_shader_->deferred_compilation_source(), | |
| 172 NULL)); | |
| 173 } | |
| 174 | |
| 175 TEST_F(MemoryProgramCacheTest, CacheLoadMatchesSave) { | |
| 176 const GLenum kFormat = 1; | |
| 177 const int kProgramId = 10; | |
| 178 const int kBinaryLength = 20; | |
| 179 char testBinary[kBinaryLength]; | |
| 180 for (int i = 0; i < kBinaryLength; ++i) { | |
| 181 testBinary[i] = i; | |
| 182 } | |
| 183 ProgramBinaryEmulator emulator(kBinaryLength, kFormat, testBinary); | |
| 184 | |
| 185 SetExpectationsForSaveLinkedProgram(kProgramId, &emulator); | |
| 186 cache_->SaveLinkedProgram(kProgramId, vertex_shader_, fragment_shader_, NULL); | |
| 187 | |
| 188 VariableMap vertex_attrib_map = vertex_shader_->attrib_map(); | |
| 189 VariableMap vertex_uniform_map = vertex_shader_->uniform_map(); | |
| 190 VariableMap fragment_attrib_map = fragment_shader_->attrib_map(); | |
| 191 VariableMap fragment_uniform_map = fragment_shader_->uniform_map(); | |
| 192 | |
| 193 vertex_shader_->set_attrib_map(VariableMap()); | |
| 194 vertex_shader_->set_uniform_map(VariableMap()); | |
| 195 fragment_shader_->set_attrib_map(VariableMap()); | |
| 196 fragment_shader_->set_uniform_map(VariableMap()); | |
| 197 | |
| 198 SetExpectationsForLoadLinkedProgram(kProgramId, &emulator); | |
| 199 | |
| 200 EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram( | |
| 201 kProgramId, | |
| 202 vertex_shader_, | |
| 203 fragment_shader_, | |
| 204 NULL)); | |
| 205 | |
| 206 // apparently the hash_map implementation on android doesn't have the | |
| 207 // equality operator | |
| 208 #if !defined(OS_ANDROID) | |
| 209 EXPECT_EQ(vertex_attrib_map, vertex_shader_->attrib_map()); | |
| 210 EXPECT_EQ(vertex_attrib_map, vertex_shader_->uniform_map()); | |
| 211 EXPECT_EQ(vertex_attrib_map, fragment_shader_->attrib_map()); | |
| 212 EXPECT_EQ(vertex_attrib_map, fragment_shader_->uniform_map()); | |
| 213 #endif | |
| 214 } | |
| 215 | |
| 216 TEST_F(MemoryProgramCacheTest, LoadFailOnDifferentSource) { | |
| 217 const GLenum kFormat = 1; | |
| 218 const int kProgramId = 10; | |
| 219 const int kBinaryLength = 20; | |
| 220 char testBinary[kBinaryLength]; | |
| 221 for (int i = 0; i < kBinaryLength; ++i) { | |
| 222 testBinary[i] = i; | |
| 223 } | |
| 224 ProgramBinaryEmulator emulator(kBinaryLength, kFormat, testBinary); | |
| 225 | |
| 226 SetExpectationsForSaveLinkedProgram(kProgramId, &emulator); | |
| 227 cache_->SaveLinkedProgram(kProgramId, vertex_shader_, fragment_shader_, NULL); | |
| 228 | |
| 229 const std::string vertex_orig_source = | |
| 230 *vertex_shader_->deferred_compilation_source(); | |
| 231 vertex_shader_->UpdateSource("different!"); | |
| 232 vertex_shader_->FlagSourceAsCompiled(true); | |
| 233 EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram( | |
| 234 kProgramId, | |
| 235 vertex_shader_, | |
| 236 fragment_shader_, | |
| 237 NULL)); | |
| 238 | |
| 239 vertex_shader_->UpdateSource(vertex_orig_source.c_str()); | |
| 240 vertex_shader_->FlagSourceAsCompiled(true); | |
| 241 fragment_shader_->UpdateSource("different!"); | |
| 242 fragment_shader_->FlagSourceAsCompiled(true); | |
| 243 EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram( | |
| 244 kProgramId, | |
| 245 vertex_shader_, | |
| 246 fragment_shader_, | |
| 247 NULL)); | |
| 248 } | |
| 249 | |
| 250 TEST_F(MemoryProgramCacheTest, LoadFailOnDifferentMap) { | |
| 251 const GLenum kFormat = 1; | |
| 252 const int kProgramId = 10; | |
| 253 const int kBinaryLength = 20; | |
| 254 char testBinary[kBinaryLength]; | |
| 255 for (int i = 0; i < kBinaryLength; ++i) { | |
| 256 testBinary[i] = i; | |
| 257 } | |
| 258 ProgramBinaryEmulator emulator(kBinaryLength, kFormat, testBinary); | |
| 259 | |
| 260 SetExpectationsForSaveLinkedProgram(kProgramId, &emulator); | |
| 261 ProgramCache::LocationMap binding_map; | |
| 262 binding_map["test"] = 512; | |
| 263 cache_->SaveLinkedProgram(kProgramId, | |
| 264 vertex_shader_, | |
| 265 fragment_shader_, | |
| 266 &binding_map); | |
| 267 | |
| 268 binding_map["different!"] = 59; | |
| 269 EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram( | |
| 270 kProgramId, | |
| 271 vertex_shader_, | |
| 272 fragment_shader_, | |
| 273 &binding_map)); | |
| 274 EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram( | |
| 275 kProgramId, | |
| 276 vertex_shader_, | |
| 277 fragment_shader_, | |
| 278 NULL)); | |
| 279 } | |
| 280 | |
| 281 TEST_F(MemoryProgramCacheTest, MemoryProgramCacheEviction) { | |
| 282 typedef ShaderTranslator::VariableMap VariableMap; | |
| 283 const GLenum kFormat = 1; | |
| 284 const int kProgramId = 10; | |
| 285 const int kBinaryLength = 20; | |
| 286 char testBinary[kBinaryLength]; | |
| 287 for (int i = 0; i < kBinaryLength; ++i) { | |
| 288 testBinary[i] = i; | |
| 289 } | |
| 290 ProgramBinaryEmulator emulator1(kBinaryLength, kFormat, testBinary); | |
| 291 | |
| 292 | |
| 293 SetExpectationsForSaveLinkedProgram(kProgramId, &emulator1); | |
| 294 cache_->SaveLinkedProgram(kProgramId, vertex_shader_, fragment_shader_, NULL); | |
| 295 | |
| 296 const int kEvictingProgramId = 11; | |
| 297 const GLuint kEvictingBinaryLength = kCacheSizeBytes - kBinaryLength + 1; | |
| 298 | |
| 299 // save old source and modify for new program | |
| 300 const std::string old_source = | |
| 301 *fragment_shader_->deferred_compilation_source(); | |
| 302 fragment_shader_->UpdateSource("al sdfkjdk"); | |
| 303 fragment_shader_->FlagSourceAsCompiled(true); | |
| 304 | |
| 305 scoped_array<char> bigTestBinary = | |
| 306 scoped_array<char>(new char[kEvictingBinaryLength]); | |
| 307 for (size_t i = 0; i < kEvictingBinaryLength; ++i) { | |
| 308 bigTestBinary[i] = i % 250; | |
| 309 } | |
| 310 ProgramBinaryEmulator emulator2(kEvictingBinaryLength, | |
| 311 kFormat, | |
| 312 bigTestBinary.get()); | |
| 313 | |
| 314 SetExpectationsForSaveLinkedProgram(kEvictingProgramId, &emulator2); | |
| 315 cache_->SaveLinkedProgram(kEvictingProgramId, | |
| 316 vertex_shader_, | |
| 317 fragment_shader_, | |
| 318 NULL); | |
| 319 | |
| 320 EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus( | |
| 321 *vertex_shader_->deferred_compilation_source(), | |
| 322 *fragment_shader_->deferred_compilation_source(), | |
| 323 NULL)); | |
| 324 EXPECT_EQ(ProgramCache::LINK_UNKNOWN, cache_->GetLinkedProgramStatus( | |
| 325 old_source, | |
| 326 *fragment_shader_->deferred_compilation_source(), | |
| 327 NULL)); | |
| 328 } | |
| 329 | |
| 330 TEST_F(MemoryProgramCacheTest, SaveCorrectProgram) { | |
| 331 const GLenum kFormat = 1; | |
| 332 const int kProgramId = 10; | |
| 333 const int kBinaryLength = 20; | |
| 334 char testBinary[kBinaryLength]; | |
| 335 for (int i = 0; i < kBinaryLength; ++i) { | |
| 336 testBinary[i] = i; | |
| 337 } | |
| 338 ProgramBinaryEmulator emulator1(kBinaryLength, kFormat, testBinary); | |
| 339 | |
| 340 vertex_shader_->UpdateSource("different!"); | |
| 341 SetExpectationsForSaveLinkedProgram(kProgramId, &emulator1); | |
| 342 cache_->SaveLinkedProgram(kProgramId, vertex_shader_, fragment_shader_, NULL); | |
| 343 | |
| 344 EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus( | |
| 345 *vertex_shader_->deferred_compilation_source(), | |
| 346 *fragment_shader_->deferred_compilation_source(), | |
| 347 NULL)); | |
| 348 } | |
| 349 | |
| 350 TEST_F(MemoryProgramCacheTest, LoadCorrectProgram) { | |
| 351 const GLenum kFormat = 1; | |
| 352 const int kProgramId = 10; | |
| 353 const int kBinaryLength = 20; | |
| 354 char testBinary[kBinaryLength]; | |
| 355 for (int i = 0; i < kBinaryLength; ++i) { | |
| 356 testBinary[i] = i; | |
| 357 } | |
| 358 ProgramBinaryEmulator emulator(kBinaryLength, kFormat, testBinary); | |
| 359 | |
| 360 SetExpectationsForSaveLinkedProgram(kProgramId, &emulator); | |
| 361 cache_->SaveLinkedProgram(kProgramId, vertex_shader_, fragment_shader_, NULL); | |
| 362 | |
| 363 EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus( | |
| 364 *vertex_shader_->deferred_compilation_source(), | |
| 365 *fragment_shader_->deferred_compilation_source(), | |
| 366 NULL)); | |
| 367 | |
| 368 SetExpectationsForLoadLinkedProgram(kProgramId, &emulator); | |
| 369 | |
| 370 fragment_shader_->UpdateSource("different!"); | |
| 371 EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram( | |
| 372 kProgramId, | |
| 373 vertex_shader_, | |
| 374 fragment_shader_, | |
| 375 NULL)); | |
| 376 } | |
| 377 | |
| 378 } // namespace gles2 | |
| 379 } // 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/