gpu/command_buffer/service/program_cache.h

   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_PROGRAM_CACHE_H_
   6 #define GPU_COMMAND_BUFFER_SERVICE_PROGRAM_CACHE_H_
   7
   8 #include <map>
   9 #include <string>
  10
  11 #include "base/containers/hash_tables.h"
  12 #include "base/sha1.h"
  13 #include "gpu/command_buffer/common/gles2_cmd_format.h"
  14 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
  15 #include "gpu/command_buffer/service/shader_manager.h"
  16
  17 namespace gpu {
  18 namespace gles2 {
  19
  20 class Shader;
  21 class ShaderTranslator;
  22
  23 // Program cache base class for caching linked gpu programs
  24 class GPU_EXPORT ProgramCache {
  25  public:
  26   static const size_t kHashLength = base::kSHA1Length;
  27
  28   typedef std::map<std::string, GLint> LocationMap;
  29
  30   enum LinkedProgramStatus {
  31     LINK_UNKNOWN,
  32     LINK_SUCCEEDED
  33   };
  34
  35   enum ProgramLoadResult {
  36     PROGRAM_LOAD_FAILURE,
  37     PROGRAM_LOAD_SUCCESS
  38   };
  39
  40   ProgramCache();
  41   virtual ~ProgramCache();
  42
  43   LinkedProgramStatus GetLinkedProgramStatus(
  44       const std::string& untranslated_shader_a,
  45       const ShaderTranslatorInterface* translator_a,
  46       const std::string& untranslated_shader_b,
  47       const ShaderTranslatorInterface* translator_b,
  48       const LocationMap* bind_attrib_location_map) const;
  49
  50   // Loads the linked program from the cache.  If the program is not found or
  51   // there was an error, PROGRAM_LOAD_FAILURE should be returned.
  52   virtual ProgramLoadResult LoadLinkedProgram(
  53       GLuint program,
  54       Shader* shader_a,
  55       const ShaderTranslatorInterface* translator_a,
  56       Shader* shader_b,
  57       const ShaderTranslatorInterface* translator_b,
  58       const LocationMap* bind_attrib_location_map,
  59       const ShaderCacheCallback& shader_callback) = 0;
  60
  61   // Saves the program into the cache.  If successful, the implementation should
  62   // call LinkedProgramCacheSuccess.
  63   virtual void SaveLinkedProgram(
  64       GLuint program,
  65       const Shader* shader_a,
  66       const ShaderTranslatorInterface* translator_a,
  67       const Shader* shader_b,
  68       const ShaderTranslatorInterface* translator_b,
  69       const LocationMap* bind_attrib_location_map,
  70       const ShaderCacheCallback& shader_callback) = 0;
  71
  72   virtual void LoadProgram(const std::string& program) = 0;
  73
  74   // clears the cache
  75   void Clear();
  76
  77   // Only for testing
  78   void LinkedProgramCacheSuccess(const std::string& shader_a,
  79                                  const ShaderTranslatorInterface* translator_a,
  80                                  const std::string& shader_b,
  81                                  const ShaderTranslatorInterface* translator_b,
  82                                  const LocationMap* bind_attrib_location_map);
  83
  84  protected:
  85   // called by implementing class after a shader was successfully cached
  86   void LinkedProgramCacheSuccess(const std::string& program_hash);
  87
  88   // result is not null terminated
  89   void ComputeShaderHash(const std::string& shader,
  90                          const ShaderTranslatorInterface* translator,
  91                          char* result) const;
  92
  93   // result is not null terminated.  hashed shaders are expected to be
  94   // kHashLength in length
  95   void ComputeProgramHash(
  96       const char* hashed_shader_0,
  97       const char* hashed_shader_1,
  98       const LocationMap* bind_attrib_location_map,
  99       char* result) const;
 100
 101   void Evict(const std::string& program_hash);
 102
 103  private:
 104   typedef base::hash_map<std::string,
 105                          LinkedProgramStatus> LinkStatusMap;
 106
 107   // called to clear the backend cache
 108   virtual void ClearBackend() = 0;
 109
 110   LinkStatusMap link_status_;
 111
 112   DISALLOW_COPY_AND_ASSIGN(ProgramCache);
 113 };
 114
 115 }  // namespace gles2
 116 }  // namespace gpu
 117
 118 #endif  // GPU_COMMAND_BUFFER_SERVICE_PROGRAM_CACHE_H_