diff options
| author | dmurph@chromium.org <dmurph@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2012-07-23 20:39:39 +0000 |
|---|---|---|
| committer | dmurph@chromium.org <dmurph@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98> | 2012-07-23 20:39:39 +0000 |
| commit | 65dfc60d7035875767bcddf62b9201f16126222a (patch) | |
| tree | 8de0b9f97b48112b08b544d142ca7a46ca016768 /gpu/command_buffer/service/program_cache.h | |
| parent | 51383d802b69967b462bf2eabd1d7b1ee879d7f7 (diff) | |
| download | chromium_src-65dfc60d7035875767bcddf62b9201f16126222a.zip chromium_src-65dfc60d7035875767bcddf62b9201f16126222a.tar.gz chromium_src-65dfc60d7035875767bcddf62b9201f16126222a.tar.bz2 | |
gpu in-memory program cache implementation with a memory limit + lru eviction.
Wiring:
- Added bindings for glProgramBinary, glGetProgramBinary, glProgramParameteri
- Plumbed the shader cache from gl_channel_manager to program_manager
- Program cache creation after first context is created
Refactoring:
- moved DoCompile to ProgramManager
New:
- added functionality to ShaderInfo to store if we have a possible pending cache compile
- exposed attrib_map and uniform_map in ShaderInfo for the cache
- program_cache base class with in-memory status storage
- Simple memory_program_cache implementation, stores programs with lru eviction
- Added caching logic to DoCompileShader and Link in ProgramMAnager
- MemoryProgramCache, the in-memory cache implementation
- ProgramCacheLruHelper, an O(1) lru implementation
Misc:
- A couple style fixes in modified files
Design doc: https://docs.google.com/document/d/1Vceem-nF4TCICoeGSh7OMXxfGuJEJYblGXRgN9V9hcE/edit
BUG=88572
Review URL: https://chromiumcodereview.appspot.com/10797055
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@147932 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat (limited to 'gpu/command_buffer/service/program_cache.h')
| -rw-r--r-- | gpu/command_buffer/service/program_cache.h | 127 |
1 files changed, 127 insertions, 0 deletions
diff --git a/gpu/command_buffer/service/program_cache.h b/gpu/command_buffer/service/program_cache.h new file mode 100644 index 0000000..310908b --- /dev/null +++ b/gpu/command_buffer/service/program_cache.h @@ -0,0 +1,127 @@ +// 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. + +#ifndef GPU_COMMAND_BUFFER_SERVICE_PROGRAM_CACHE_H_ +#define GPU_COMMAND_BUFFER_SERVICE_PROGRAM_CACHE_H_ + +#include <map> +#include <string> + +#include "base/hash_tables.h" +#include "base/sha1.h" +#include "gpu/command_buffer/common/gles2_cmd_format.h" +#include "gpu/command_buffer/service/shader_manager.h" + +namespace gpu { +namespace gles2 { + +// Program cache base class for caching linked gpu programs +class GPU_EXPORT ProgramCache { + public: + static const size_t kHashLength = base::kSHA1Length; + + typedef std::map<std::string, GLint> LocationMap; + + enum CompiledShaderStatus { + COMPILATION_UNKNOWN, + COMPILATION_SUCCEEDED + }; + + enum LinkedProgramStatus { + LINK_UNKNOWN, + LINK_SUCCEEDED + }; + + enum ProgramLoadResult { + PROGRAM_LOAD_FAILURE, + PROGRAM_LOAD_SUCCESS + }; + + ProgramCache(); + virtual ~ProgramCache(); + + CompiledShaderStatus GetShaderCompilationStatus( + const std::string& shader_src) const; + void ShaderCompilationSucceeded(const std::string& shader_src); + + LinkedProgramStatus GetLinkedProgramStatus( + const std::string& untranslated_a, + const std::string& untranslated_b, + const LocationMap* bind_attrib_location_map) const; + + // Loads the linked program from the cache. If the program is not found or + // there was an error, PROGRAM_LOAD_FAILURE should be returned. + virtual ProgramLoadResult LoadLinkedProgram( + GLuint program, + ShaderManager::ShaderInfo* shader_a, + ShaderManager::ShaderInfo* shader_b, + const LocationMap* bind_attrib_location_map) const = 0; + + // Saves the program into the cache. If successful, the implementation should + // call LinkedProgramCacheSuccess. + virtual void SaveLinkedProgram( + GLuint program, + const ShaderManager::ShaderInfo* shader_a, + const ShaderManager::ShaderInfo* shader_b, + const LocationMap* bind_attrib_location_map) = 0; + + // clears the cache + void Clear(); + + // Only for testing + void LinkedProgramCacheSuccess(const std::string& shader_a, + const std::string& shader_b, + const LocationMap* bind_attrib_location_map); + + protected: + // called by implementing class after a shader was successfully cached + void LinkedProgramCacheSuccess(const std::string& program_hash, + const std::string& shader_a_hash, + const std::string& shader_b_hash); + + // result is not null terminated + void ComputeShaderHash(const std::string& shader, + char* result) const; + + // result is not null terminated. hashed shaders are expected to be + // kHashLength in length + void ComputeProgramHash( + const char* hashed_shader_0, + const char* hashed_shader_1, + const LocationMap* bind_attrib_location_map, + char* result) const; + + void Evict(const std::string& program_hash, + const std::string& shader_0_hash, + const std::string& shader_1_hash); + + private: + struct CompiledShaderInfo { + CompiledShaderInfo() : status(COMPILATION_UNKNOWN), ref_count(0) { } + explicit CompiledShaderInfo(CompiledShaderStatus status_) + : status(status_), + ref_count(0) { } + + CompiledShaderStatus status; + size_t ref_count; + }; + + typedef base::hash_map<std::string, + CompiledShaderInfo> CompileStatusMap; + typedef base::hash_map<std::string, + LinkedProgramStatus> LinkStatusMap; + + // called to clear the backend cache + virtual void ClearBackend() = 0; + + CompileStatusMap shader_status_; + LinkStatusMap link_status_; + + DISALLOW_COPY_AND_ASSIGN(ProgramCache); +}; + +} // namespace gles2 +} // namespace gpu + +#endif // GPU_COMMAND_BUFFER_SERVICE_PROGRAM_CACHE_H_ |