GPU Program Caching

gpu/command_buffer/service/shader_cache.h

Index: gpu/command_buffer/service/shader_cache.h
diff --git a/gpu/command_buffer/service/shader_cache.h b/gpu/command_buffer/service/shader_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..b1a561e079fde1904d19f1d086689764714c2645
--- /dev/null
+++ b/gpu/command_buffer/service/shader_cache.h
@@ -0,0 +1,184 @@
+// 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_SHADER_CACHE_H_
+#define GPU_COMMAND_BUFFER_SERVICE_SHADER_CACHE_H_
+#pragma once
+
+#include "base/memory/weak_ptr.h"
+#include "gpu/command_buffer/common/gles2_cmd_format.h"
+
+namespace gpu {
+
+const uint32 kShaderCacheBufferSize = 4*1024*1024;
+
+enum CompiledShaderStatus {

[greggman, 2012/06/15 08:10:24]

move these inside ShaderCache so they aren't in the public namespace?

[dmurph, 2012/06/19 01:08:33]

Done.

+  SHADER_CACHE_COMPILATION_UNKNOWN,
+  SHADER_CACHE_COMPILATION_SUCCEEDED
+};
+
+enum LinkedProgramStatus {
+  SHADER_CACHE_LINK_UNKNOWN,
+  SHADER_CACHE_LINK_SUCCEEDED
+};
+
+class ShaderCache : public base::SupportsWeakPtr<ShaderCache>{
+public:
+  ShaderCache() : cache_buffer_(new char[kShaderCacheBufferSize]) { };

[greggman, 2012/06/15 08:10:24]

how does this work???

[dmurph, 2012/06/15 16:40:23]

Trying to find a good place for the buffer for returning the cached program,
didn't realize you could query the size.

+  virtual ~ShaderCache() { delete[] cache_buffer_; }
+
+  virtual bool isShaderCacheEnabled() = 0;
+
+  virtual CompiledShaderStatus getShaderCompilationStatus(
+      const char* shader_src) = 0;
+  virtual void setShaderCompilationStatus(const char* shader_src,
+                                          CompiledShaderStatus status) = 0;
+
+  virtual LinkedProgramStatus getLinkedProgramStatus(
+      const char* untranslated_a,
+      const char* untranslated_b) = 0;
+  virtual void setLinkedProgramStatus(const char* untranslated_a,
+                                      const char* untranslated_b,
+                                      LinkedProgramStatus status) = 0;
+
+  virtual void getLinkedProgram(const char* untranslated_a,
+                                const char* untranslated_b,
+                                GLsizei* length,
+                                GLenum* binaryFormat,
+                                const GLvoid** binary) = 0;
+  virtual void setLinkedProgram(const char* untranslated_a,
+                                const char* untranslated_b,
+                                GLsizei length,
+                                GLenum binaryFormat,
+                                GLvoid* binary) = 0;
+
+  char* cache_buffer() { return cache_buffer_; }
+private:
+  char* cache_buffer_;
+};
+
+struct CachedShaderKey {

[greggman, 2012/06/15 08:10:24]

These keys probably need a version number or the chrome link number or
something. Otherwise if you change one of these structures they'll be invalid
when loaded from the cache

On the other hand, maybe these keys should be specific to the type of cache. You
don't need gl_vendor, gl_render, vendor_id_ or driver_id in the
MemoryShaderCache

[dmurph, 2012/06/15 16:40:23]

Yeah, so I'm thinking the shader_cache could be non-virtual and handle all the
in-memory caching (with memory limits, etc), and leave handles for the
disk-based portion.  I would have separate keys for the hash_maps that don't
include information that can't change during the lifespan of the cache
(basically the lifespan of the gpu process)

+  CachedShaderKey()
+    : untranslated_src(0),
+      gl_vendor(0),
+      gl_renderer(0),
+      vendor_id(0),
+      driver_id(0) { };
+  CachedShaderKey(const char* _untranslated_src,

[greggman, 2012/06/15 08:10:24]

given the use this seems like it should be 'const& std::string' ?

[dmurph, 2012/06/19 01:08:33]

Done.

+                  const char* _gl_vendor,
+                  const char* _gl_renderer,
+                  const uint32 _vendor_id,
+                  const uint32 _driver_id) :
+                    untranslated_src(_untranslated_src),
+                    gl_vendor(_gl_vendor),
+                    gl_renderer(_gl_renderer),
+                    vendor_id(_vendor_id),
+                    driver_id(_driver_id) { };
+  const char* untranslated_src;

[greggman, 2012/06/15 08:10:24]

these strings need to be std::string or something that actually stores the
string. The strings you're passing in all the way from ShaderInfo.source are not
guaranteed to stick around.

[dmurph, 2012/06/15 16:40:23]

Yeah

+  const char* gl_vendor;
+  const char* gl_renderer;
+  uint32 vendor_id;
+  uint32 driver_id;
+};
+
+struct CachedShaderKeyHash {
+  inline size_t operator()(const CachedShaderKey& key) const;
+};
+
+struct CachedShaderKeyEquals {
+  inline bool operator()(const CachedShaderKey& a,
+                         const CachedShaderKey& b) const;
+};
+
+struct CachedProgramKey {
+  CachedProgramKey()
+    : untranslated_src_0(0),
+      untranslated_src_1(0),
+      gl_vendor(0),
+      gl_renderer(0),
+      vendor_id(0),
+      driver_id(0) { };
+  CachedProgramKey(const char* _untranslated_src_0,

[greggman, 2012/06/15 08:10:24]

same here? should it be 'const& std::string' ?

[dmurph, 2012/06/19 01:08:33]

Done.

+                   const char* _untranslated_src_1,
+                   const char* _gl_vendor,
+                   const char* _gl_renderer,
+                   const uint32 _vendor_id,
+                   const uint32 _driver_id) :
+                     untranslated_src_0(_untranslated_src_0),
+                     untranslated_src_1(_untranslated_src_1),
+                     gl_vendor(_gl_vendor),
+                     gl_renderer(_gl_renderer),
+                     vendor_id(_vendor_id),
+                     driver_id(_driver_id) {};
+  const char* untranslated_src_0;

[greggman, 2012/06/15 08:10:24]

same here. these need to be something that stores the string. 

[dmurph, 2012/06/19 01:08:33]

Done.

+  const char* untranslated_src_1;
+  const char* gl_vendor;
+  const char* gl_renderer;
+  uint32 vendor_id;
+  uint32 driver_id;
+};
+
+struct CachedProgramKeyHash {
+  inline size_t operator()(const CachedProgramKey& key) const;
+};
+
+struct CachedProgramKeyEquals {
+  inline bool operator()(const CachedProgramKey& a,
+                         const CachedProgramKey& b) const;
+};
+
+// sbdm hash function
+inline unsigned int sbdm(const char *str) {
+  unsigned int hash = 0;
+  int c;
+  while ((c = *str++))
+    hash = c + (hash << 6) + (hash << 16) - hash;
+  return hash;
+}
+
+inline size_t CachedShaderKeyHash::operator()(
+    const CachedShaderKey& key) const {
+  unsigned int hash = sbdm(key.untranslated_src);
+  hash = (hash << 6) + (hash << 16) - hash + sbdm(key.gl_vendor);
+  hash = (hash << 6) + (hash << 16) - hash + sbdm(key.gl_renderer);
+  hash = (hash << 6) + (hash << 16) - hash + key.vendor_id;
+  hash = (hash << 6) + (hash << 16) - hash + key.driver_id;
+  return hash;
+}
+
+inline bool CachedShaderKeyEquals::operator()(const CachedShaderKey& a,
+                                              const CachedShaderKey& b) const {
+  return strcmp(a.untranslated_src, b.untranslated_src) == 0
+      && strcmp(a.gl_vendor, b.gl_vendor) == 0
+      && strcmp(a.gl_renderer, b.gl_renderer) == 0 && a.vendor_id == b.vendor_id
+      && a.driver_id == b.driver_id;
+}
+
+inline size_t CachedProgramKeyHash::operator()(
+    const CachedProgramKey& key) const {
+  unsigned int hash = sbdm(key.untranslated_src_0)
+                    + sbdm(key.untranslated_src_1);
+  hash = (hash << 6) + (hash << 16) - hash + sbdm(key.gl_vendor);
+  hash = (hash << 6) + (hash << 16) - hash + sbdm(key.gl_renderer);
+  hash = (hash << 6) + (hash << 16) - hash + key.vendor_id;
+  hash = (hash << 6) + (hash << 16) - hash + key.driver_id;
+  return hash;
+}
+
+inline bool CachedProgramKeyEquals::operator()(
+    const CachedProgramKey& a,
+    const CachedProgramKey& b) const {
+  return strcmp(a.untranslated_src_0, b.untranslated_src_0) == 0 &&
+         strcmp(a.untranslated_src_1, b.untranslated_src_1) == 0 &&
+         strcmp(a.gl_vendor, b.gl_vendor) == 0 &&
+         strcmp(a.gl_renderer, b.gl_renderer) == 0 &&
+         a.vendor_id == b.vendor_id &&
+         a.driver_id == b.driver_id;
+}
+
+} // namespace gpu
+
+

[greggman, 2012/06/15 08:10:24]

style: remove extra blank lines

[dmurph, 2012/06/19 01:08:33]

Done.

+
+#endif // GPU_COMMAND_BUFFER_SERVICE_SHADER_CACHE_H_