Home | History | Annotate | Download | only in service 
      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 #ifndef GPU_COMMAND_BUFFER_SERVICE_MEMORY_PROGRAM_CACHE_H_
      6 #define GPU_COMMAND_BUFFER_SERVICE_MEMORY_PROGRAM_CACHE_H_
      7 
      8 #include <map>
      9 #include <string>
     10 
     11 #include "base/containers/hash_tables.h"
     12 #include "base/containers/mru_cache.h"
     13 #include "base/memory/ref_counted.h"
     14 #include "base/memory/scoped_ptr.h"
     15 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
     16 #include "gpu/command_buffer/service/program_cache.h"
     17 #include "gpu/command_buffer/service/shader_translator.h"
     18 
     19 namespace gpu {
     20 namespace gles2 {
     21 
     22 // Program cache that stores binaries completely in-memory
     23 class GPU_EXPORT MemoryProgramCache : public ProgramCache {
     24  public:
     25   MemoryProgramCache();
     26   explicit MemoryProgramCache(const size_t max_cache_size_bytes);
     27   virtual ~MemoryProgramCache();
     28 
     29   virtual ProgramLoadResult LoadLinkedProgram(
     30       GLuint program,
     31       Shader* shader_a,
     32       const ShaderTranslatorInterface* translator_a,
     33       Shader* shader_b,
     34       const ShaderTranslatorInterface* translator_b,
     35       const LocationMap* bind_attrib_location_map,
     36       const ShaderCacheCallback& shader_callback) OVERRIDE;
     37   virtual void SaveLinkedProgram(
     38       GLuint program,
     39       const Shader* shader_a,
     40       const ShaderTranslatorInterface* translator_a,
     41       const Shader* shader_b,
     42       const ShaderTranslatorInterface* translator_b,
     43       const LocationMap* bind_attrib_location_map,
     44       const ShaderCacheCallback& shader_callback) OVERRIDE;
     45 
     46   virtual void LoadProgram(const std::string& program) OVERRIDE;
     47 
     48  private:
     49   virtual void ClearBackend() OVERRIDE;
     50 
     51   class ProgramCacheValue : public base::RefCounted<ProgramCacheValue> {
     52    public:
     53     ProgramCacheValue(GLsizei length,
     54                       GLenum format,
     55                       const char* data,
     56                       const std::string& program_hash,
     57                       const char* shader_0_hash,
     58                       const ShaderTranslator::VariableMap& attrib_map_0,
     59                       const ShaderTranslator::VariableMap& uniform_map_0,
     60                       const ShaderTranslator::VariableMap& varying_map_0,
     61                       const char* shader_1_hash,
     62                       const ShaderTranslator::VariableMap& attrib_map_1,
     63                       const ShaderTranslator::VariableMap& uniform_map_1,
     64                       const ShaderTranslator::VariableMap& varying_map_1,
     65                       MemoryProgramCache* program_cache);
     66 
     67     GLsizei length() const {
     68       return length_;
     69     }
     70 
     71     GLenum format() const {
     72       return format_;
     73     }
     74 
     75     const char* data() const {
     76       return data_.get();
     77     }
     78 
     79     const std::string& shader_0_hash() const {
     80       return shader_0_hash_;
     81     }
     82 
     83     const ShaderTranslator::VariableMap& attrib_map_0() const {
     84       return attrib_map_0_;
     85     }
     86 
     87     const ShaderTranslator::VariableMap& uniform_map_0() const {
     88       return uniform_map_0_;
     89     }
     90 
     91     const ShaderTranslator::VariableMap& varying_map_0() const {
     92       return varying_map_0_;
     93     }
     94 
     95     const std::string& shader_1_hash() const {
     96       return shader_1_hash_;
     97     }
     98 
     99     const ShaderTranslator::VariableMap& attrib_map_1() const {
    100       return attrib_map_1_;
    101     }
    102 
    103     const ShaderTranslator::VariableMap& uniform_map_1() const {
    104       return uniform_map_1_;
    105     }
    106 
    107     const ShaderTranslator::VariableMap& varying_map_1() const {
    108       return varying_map_1_;
    109     }
    110 
    111    private:
    112     friend class base::RefCounted<ProgramCacheValue>;
    113 
    114     ~ProgramCacheValue();
    115 
    116     const GLsizei length_;
    117     const GLenum format_;
    118     const scoped_ptr<const char[]> data_;
    119     const std::string program_hash_;
    120     const std::string shader_0_hash_;
    121     const ShaderTranslator::VariableMap attrib_map_0_;
    122     const ShaderTranslator::VariableMap uniform_map_0_;
    123     const ShaderTranslator::VariableMap varying_map_0_;
    124     const std::string shader_1_hash_;
    125     const ShaderTranslator::VariableMap attrib_map_1_;
    126     const ShaderTranslator::VariableMap uniform_map_1_;
    127     const ShaderTranslator::VariableMap varying_map_1_;
    128     MemoryProgramCache* const program_cache_;
    129 
    130     DISALLOW_COPY_AND_ASSIGN(ProgramCacheValue);
    131   };
    132 
    133   friend class ProgramCacheValue;
    134 
    135   typedef base::MRUCache<std::string,
    136                          scoped_refptr<ProgramCacheValue> > ProgramMRUCache;
    137 
    138   const size_t max_size_bytes_;
    139   size_t curr_size_bytes_;
    140   ProgramMRUCache store_;
    141 
    142   DISALLOW_COPY_AND_ASSIGN(MemoryProgramCache);
    143 };
    144 
    145 }  // namespace gles2
    146 }  // namespace gpu
    147 
    148 #endif  // GPU_COMMAND_BUFFER_SERVICE_MEMORY_PROGRAM_CACHE_H_
    149