X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fauxiliary%2Fcso_cache%2Fcso_cache.c;h=6cae21ca871957d2ca185705e73efd484252fc84;hb=9ed33383a5b1399315cd62f119234ee2332ee76f;hp=900c64df4b93279ac951a780a63bfb15a0b1b045;hpb=1318848f782cce716d6376ca13aebf68b728e24c;p=mesa.git diff --git a/src/gallium/auxiliary/cso_cache/cso_cache.c b/src/gallium/auxiliary/cso_cache/cso_cache.c index 900c64df4b9..6cae21ca871 100644 --- a/src/gallium/auxiliary/cso_cache/cso_cache.c +++ b/src/gallium/auxiliary/cso_cache/cso_cache.c @@ -1,6 +1,6 @@ /************************************************************************** * - * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * Copyright 2007 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a @@ -18,14 +18,14 @@ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * **************************************************************************/ -/* Authors: Zack Rusin +/* Authors: Zack Rusin */ #include "util/u_debug.h" @@ -37,13 +37,7 @@ 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_hash *velements_hash; + struct cso_hash hashes[CSO_CACHE_MAX]; int max_size; cso_sanitize_callback sanitize_cb; @@ -86,38 +80,12 @@ unsigned cso_construct_key(void *item, int item_size) return hash_key((item), item_size); } -static struct cso_hash *_cso_hash_for_type(struct cso_cache *sc, enum cso_cache_type type) +static inline struct cso_hash *_cso_hash_for_type(struct cso_cache *sc, enum cso_cache_type type) { - struct cso_hash *hash = 0; - - switch(type) { - case CSO_BLEND: - hash = sc->blend_hash; - break; - case CSO_SAMPLER: - hash = sc->sampler_hash; - break; - case CSO_DEPTH_STENCIL_ALPHA: - hash = sc->depth_stencil_hash; - break; - case CSO_RASTERIZER: - hash = sc->rasterizer_hash; - break; - case CSO_FRAGMENT_SHADER: - hash = sc->fs_hash; - break; - case CSO_VERTEX_SHADER: - hash = sc->vs_hash; - break; - case CSO_VELEMENTS: - hash = sc->velements_hash; - break; - } - - return hash; + return &sc->hashes[type]; } -static void delete_blend_state(void *state, void *data) +static void delete_blend_state(void *state, UNUSED void *data) { struct cso_blend *cso = (struct cso_blend *)state; if (cso->delete_state) @@ -125,7 +93,7 @@ static void delete_blend_state(void *state, void *data) FREE(state); } -static void delete_depth_stencil_state(void *state, void *data) +static void delete_depth_stencil_state(void *state, UNUSED void *data) { struct cso_depth_stencil_alpha *cso = (struct cso_depth_stencil_alpha *)state; if (cso->delete_state) @@ -133,7 +101,7 @@ static void delete_depth_stencil_state(void *state, void *data) FREE(state); } -static void delete_sampler_state(void *state, void *data) +static void delete_sampler_state(void *state, UNUSED void *data) { struct cso_sampler *cso = (struct cso_sampler *)state; if (cso->delete_state) @@ -141,7 +109,7 @@ static void delete_sampler_state(void *state, void *data) FREE(state); } -static void delete_rasterizer_state(void *state, void *data) +static void delete_rasterizer_state(void *state, UNUSED void *data) { struct cso_rasterizer *cso = (struct cso_rasterizer *)state; if (cso->delete_state) @@ -149,23 +117,7 @@ static void delete_rasterizer_state(void *state, void *data) FREE(state); } -static void delete_fs_state(void *state, void *data) -{ - struct cso_fragment_shader *cso = (struct cso_fragment_shader *)state; - if (cso->delete_state) - cso->delete_state(cso->context, cso->data); - FREE(state); -} - -static void delete_vs_state(void *state, void *data) -{ - struct cso_vertex_shader *cso = (struct cso_vertex_shader *)state; - if (cso->delete_state) - cso->delete_state(cso->context, cso->data); - FREE(state); -} - -static void delete_velements(void *state, void *data) +static void delete_velements(void *state, UNUSED void *data) { struct cso_velements *cso = (struct cso_velements *)state; if (cso->delete_state) @@ -173,7 +125,7 @@ static void delete_velements(void *state, void *data) FREE(state); } -static INLINE void delete_cso(void *state, enum cso_cache_type type) +static inline void delete_cso(void *state, enum cso_cache_type type) { switch (type) { case CSO_BLEND: @@ -188,12 +140,6 @@ static INLINE void delete_cso(void *state, enum cso_cache_type type) case CSO_RASTERIZER: delete_rasterizer_state(state, 0); break; - case CSO_FRAGMENT_SHADER: - delete_fs_state(state, 0); - break; - case CSO_VERTEX_SHADER: - delete_vs_state(state, 0); - break; case CSO_VELEMENTS: delete_velements(state, 0); break; @@ -204,7 +150,7 @@ static INLINE void delete_cso(void *state, enum cso_cache_type type) } -static INLINE void sanitize_hash(struct cso_cache *sc, +static inline void sanitize_hash(struct cso_cache *sc, struct cso_hash *hash, enum cso_cache_type type, int max_size) @@ -214,8 +160,8 @@ static INLINE void sanitize_hash(struct cso_cache *sc, } -static INLINE void sanitize_cb(struct cso_hash *hash, enum cso_cache_type type, - int max_size, void *user_data) +static inline void sanitize_cb(struct cso_hash *hash, enum cso_cache_type type, + int max_size, UNUSED void *user_data) { /* if we're approach the maximum size, remove fourth of the entries * otherwise every subsequent call will go through the same */ @@ -298,17 +244,14 @@ void * cso_take_state(struct cso_cache *sc, struct cso_cache *cso_cache_create(void) { struct cso_cache *sc = MALLOC_STRUCT(cso_cache); - if (sc == NULL) + int i; + if (!sc) return NULL; sc->max_size = 4096; - sc->blend_hash = cso_hash_create(); - sc->sampler_hash = cso_hash_create(); - sc->depth_stencil_hash = cso_hash_create(); - sc->rasterizer_hash = cso_hash_create(); - sc->fs_hash = cso_hash_create(); - sc->vs_hash = cso_hash_create(); - sc->velements_hash = cso_hash_create(); + for (i = 0; i < CSO_CACHE_MAX; i++) + cso_hash_init(&sc->hashes[i]); + sc->sanitize_cb = sanitize_cb; sc->sanitize_data = 0; @@ -318,33 +261,9 @@ struct cso_cache *cso_cache_create(void) void cso_for_each_state(struct cso_cache *sc, enum cso_cache_type type, cso_state_callback func, void *user_data) { - struct cso_hash *hash = 0; + struct cso_hash *hash = _cso_hash_for_type(sc, type); struct cso_hash_iter iter; - switch (type) { - case CSO_BLEND: - hash = sc->blend_hash; - break; - case CSO_SAMPLER: - hash = sc->sampler_hash; - break; - case CSO_DEPTH_STENCIL_ALPHA: - hash = sc->depth_stencil_hash; - break; - case CSO_RASTERIZER: - hash = sc->rasterizer_hash; - break; - case CSO_FRAGMENT_SHADER: - hash = sc->fs_hash; - break; - case CSO_VERTEX_SHADER: - hash = sc->vs_hash; - break; - case CSO_VELEMENTS: - hash = sc->velements_hash; - break; - } - iter = cso_hash_first_node(hash); while (!cso_hash_iter_is_null(iter)) { void *state = cso_hash_iter_data(iter); @@ -357,6 +276,7 @@ void cso_for_each_state(struct cso_cache *sc, enum cso_cache_type type, void cso_cache_delete(struct cso_cache *sc) { + int i; assert(sc); if (!sc) @@ -365,34 +285,24 @@ void cso_cache_delete(struct cso_cache *sc) /* delete driver data */ cso_for_each_state(sc, CSO_BLEND, delete_blend_state, 0); cso_for_each_state(sc, CSO_DEPTH_STENCIL_ALPHA, delete_depth_stencil_state, 0); - cso_for_each_state(sc, CSO_FRAGMENT_SHADER, delete_fs_state, 0); - cso_for_each_state(sc, CSO_VERTEX_SHADER, delete_vs_state, 0); cso_for_each_state(sc, CSO_RASTERIZER, delete_rasterizer_state, 0); cso_for_each_state(sc, CSO_SAMPLER, delete_sampler_state, 0); cso_for_each_state(sc, CSO_VELEMENTS, delete_velements, 0); - cso_hash_delete(sc->blend_hash); - cso_hash_delete(sc->sampler_hash); - cso_hash_delete(sc->depth_stencil_hash); - cso_hash_delete(sc->rasterizer_hash); - cso_hash_delete(sc->fs_hash); - cso_hash_delete(sc->vs_hash); - cso_hash_delete(sc->velements_hash); + for (i = 0; i < CSO_CACHE_MAX; i++) + cso_hash_deinit(&sc->hashes[i]); + FREE(sc); } void cso_set_maximum_cache_size(struct cso_cache *sc, int number) { + int i; + sc->max_size = number; - sanitize_hash(sc, sc->blend_hash, CSO_BLEND, sc->max_size); - sanitize_hash(sc, sc->depth_stencil_hash, CSO_DEPTH_STENCIL_ALPHA, - sc->max_size); - sanitize_hash(sc, sc->fs_hash, CSO_FRAGMENT_SHADER, sc->max_size); - sanitize_hash(sc, sc->vs_hash, CSO_VERTEX_SHADER, sc->max_size); - sanitize_hash(sc, sc->rasterizer_hash, CSO_RASTERIZER, sc->max_size); - sanitize_hash(sc, sc->sampler_hash, CSO_SAMPLER, sc->max_size); - sanitize_hash(sc, sc->velements_hash, CSO_VELEMENTS, sc->max_size); + for (i = 0; i < CSO_CACHE_MAX; i++) + sanitize_hash(sc, &sc->hashes[i], i, sc->max_size); } int cso_maximum_cache_size(const struct cso_cache *sc)