hide cso cache definition and add some initial code for size limiting

the caches

diff --git a/src/gallium/auxiliary/cso_cache/cso_cache.c b/src/gallium/auxiliary/cso_cache/cso_cache.c
index 9aa1a6427235bb8ef8d631ad202efb5466ca772b..1b870c8e419b94c453053b0dee37a64640fa3fa5 100644 (file)
--- a/src/gallium/auxiliary/cso_cache/cso_cache.c
+++ b/src/gallium/auxiliary/cso_cache/cso_cache.c
@@ -33,6 +33,17 @@
 #include "cso_cache.h"
 #include "cso_hash.h"
 
+
+struct cso_cache {
+   struct cso_hash *blend_hash;
+   struct cso_hash *depth_stencil_hash;
+   struct cso_hash *fs_hash;
+   struct cso_hash *vs_hash;
+   struct cso_hash *rasterizer_hash;
+   struct cso_hash *sampler_hash;
+   int    max_size;
+};
+
 #if 1
 static unsigned hash_key(const void *key, unsigned key_size)
 {
@@ -180,6 +191,7 @@ struct cso_cache *cso_cache_create(void)
 {
    struct cso_cache *sc = MALLOC_STRUCT(cso_cache);
 
+   sc->max_size           = 4096;
    sc->blend_hash         = cso_hash_create();
    sc->sampler_hash       = cso_hash_create();
    sc->depth_stencil_hash = cso_hash_create();
@@ -289,3 +301,13 @@ void cso_cache_delete(struct cso_cache *sc)
    FREE(sc);
 }
 
+void cso_set_maximum_cache_size(struct cso_cache *sc, int number)
+{
+   sc->max_size = number;
+}
+
+int cso_maximum_cache_size(const struct cso_cache *sc)
+{
+   return sc->max_size;
+}
+

diff --git a/src/gallium/auxiliary/cso_cache/cso_cache.h b/src/gallium/auxiliary/cso_cache/cso_cache.h
index f3bd4623c9390f71f4cabe45c766355ceeaad9f2..72a6b9d488f3285ac5f321e6e48f5cec3d1fa6fa 100644 (file)
--- a/src/gallium/auxiliary/cso_cache/cso_cache.h
+++ b/src/gallium/auxiliary/cso_cache/cso_cache.h
@@ -28,7 +28,7 @@
  /**
   * @file
   * Constant State Object (CSO) cache.
-  * 
+  *
   * The basic idea is that the states are created via the
   * create_state/bind_state/delete_state semantics. The driver is expected to
   * perform as much of the Gallium state translation to whatever its internal
@@ -36,15 +36,15 @@
   * mechanism where it stores the created states. When the pipeline needs an
   * actual state change, a bind call is issued. In the bind call the driver
   * gets its already translated representation.
-  * 
+  *
   * Those semantics mean that the driver doesn't do the repeated translations
   * of states on every frame, but only once, when a new state is actually
   * created.
-  * 
+  *
   * Even on hardware that doesn't do any kind of state cache, it makes the
   * driver look a lot neater, plus it avoids all the redundant state
   * translations on every frame.
-  * 
+  *
   * Currently our constant state objects are:
   * - alpha test
   * - blend
@@ -53,7 +53,7 @@
   * - rasterizer (old setup)
   * - sampler
   * - vertex shader
-  * 
+  *
   * Things that are not constant state objects include:
   * - blend_color
   * - clip_state
@@ -65,7 +65,7 @@
   * - scissor_state
   * - texture_state
   * - viewport_state
-  * 
+  *
   * @author Zack Rusin <zack@tungstengraphics.com>
   */
 
@@ -75,24 +75,16 @@
 #include "pipe/p_context.h"
 #include "pipe/p_state.h"
 
-/* cso_hash.h is necessary for cso_hash_iter, as MSVC requires structures 
+/* cso_hash.h is necessary for cso_hash_iter, as MSVC requires structures
  * returned by value to be fully defined */
-#include "cso_hash.h" 
+#include "cso_hash.h"
 
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-  
-struct cso_cache {
-   struct cso_hash *blend_hash;
-   struct cso_hash *depth_stencil_hash;
-   struct cso_hash *fs_hash;
-   struct cso_hash *vs_hash;
-   struct cso_hash *rasterizer_hash;
-   struct cso_hash *sampler_hash;
-};
+struct cso_cache;
 
 struct cso_blend {
    struct pipe_blend_state state;
@@ -164,6 +156,8 @@ void cso_for_each_state(struct cso_cache *sc, enum cso_cache_type type,
 void * cso_take_state(struct cso_cache *sc, unsigned hash_key,
                       enum cso_cache_type type);
 
+void cso_set_maximum_cache_size(struct cso_cache *sc, int number);
+int cso_maximum_cache_size(const struct cso_cache *sc);
 
 #ifdef __cplusplus
 }