1 /**************************************************************************
2 *
3 * Copyright 2003 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28
29 #include "main/glheader.h"
30 #include "main/mtypes.h"
31 #include "main/imports.h"
32 #include "main/shaderobj.h"
33 #include "program/prog_cache.h"
34 #include "program/program.h"
35
36
37 struct cache_item
38 {
39 GLuint hash;
40 unsigned keysize;
41 void *key;
42 struct gl_program *program;
43 struct cache_item *next;
44 };
45
46 struct gl_program_cache
47 {
48 struct cache_item **items;
49 struct cache_item *last;
50 GLuint size, n_items;
51 };
52
53
54
55 /**
56 * Compute hash index from state key.
57 */
58 static GLuint
hash_key(const void * key,GLuint key_size)59 hash_key(const void *key, GLuint key_size)
60 {
61 const GLuint *ikey = (const GLuint *) key;
62 GLuint hash = 0, i;
63
64 assert(key_size >= 4);
65
66 /* Make a slightly better attempt at a hash function:
67 */
68 for (i = 0; i < key_size / sizeof(*ikey); i++)
69 {
70 hash += ikey[i];
71 hash += (hash << 10);
72 hash ^= (hash >> 6);
73 }
74
75 return hash;
76 }
77
78
79 /**
80 * Rebuild/expand the hash table to accommodate more entries
81 */
82 static void
rehash(struct gl_program_cache * cache)83 rehash(struct gl_program_cache *cache)
84 {
85 struct cache_item **items;
86 struct cache_item *c, *next;
87 GLuint size, i;
88
89 cache->last = NULL;
90
91 size = cache->size * 3;
92 items = malloc(size * sizeof(*items));
93 memset(items, 0, size * sizeof(*items));
94
95 for (i = 0; i < cache->size; i++)
96 for (c = cache->items[i]; c; c = next) {
97 next = c->next;
98 c->next = items[c->hash % size];
99 items[c->hash % size] = c;
100 }
101
102 free(cache->items);
103 cache->items = items;
104 cache->size = size;
105 }
106
107
108 static void
clear_cache(struct gl_context * ctx,struct gl_program_cache * cache,GLboolean shader)109 clear_cache(struct gl_context *ctx, struct gl_program_cache *cache,
110 GLboolean shader)
111 {
112 struct cache_item *c, *next;
113 GLuint i;
114
115 cache->last = NULL;
116
117 for (i = 0; i < cache->size; i++) {
118 for (c = cache->items[i]; c; c = next) {
119 next = c->next;
120 free(c->key);
121 if (shader) {
122 _mesa_reference_shader_program(ctx,
123 (struct gl_shader_program **)&c->program,
124 NULL);
125 } else {
126 _mesa_reference_program(ctx, &c->program, NULL);
127 }
128 free(c);
129 }
130 cache->items[i] = NULL;
131 }
132
133
134 cache->n_items = 0;
135 }
136
137
138
139 struct gl_program_cache *
_mesa_new_program_cache(void)140 _mesa_new_program_cache(void)
141 {
142 struct gl_program_cache *cache = CALLOC_STRUCT(gl_program_cache);
143 if (cache) {
144 cache->size = 17;
145 cache->items =
146 calloc(cache->size, sizeof(struct cache_item *));
147 if (!cache->items) {
148 free(cache);
149 return NULL;
150 }
151 }
152 return cache;
153 }
154
155
156 void
_mesa_delete_program_cache(struct gl_context * ctx,struct gl_program_cache * cache)157 _mesa_delete_program_cache(struct gl_context *ctx, struct gl_program_cache *cache)
158 {
159 clear_cache(ctx, cache, GL_FALSE);
160 free(cache->items);
161 free(cache);
162 }
163
164 void
_mesa_delete_shader_cache(struct gl_context * ctx,struct gl_program_cache * cache)165 _mesa_delete_shader_cache(struct gl_context *ctx,
166 struct gl_program_cache *cache)
167 {
168 clear_cache(ctx, cache, GL_TRUE);
169 free(cache->items);
170 free(cache);
171 }
172
173
174 struct gl_program *
_mesa_search_program_cache(struct gl_program_cache * cache,const void * key,GLuint keysize)175 _mesa_search_program_cache(struct gl_program_cache *cache,
176 const void *key, GLuint keysize)
177 {
178 if (cache->last &&
179 cache->last->keysize == keysize &&
180 memcmp(cache->last->key, key, keysize) == 0) {
181 return cache->last->program;
182 }
183 else {
184 const GLuint hash = hash_key(key, keysize);
185 struct cache_item *c;
186
187 for (c = cache->items[hash % cache->size]; c; c = c->next) {
188 if (c->hash == hash &&
189 c->keysize == keysize &&
190 memcmp(c->key, key, keysize) == 0) {
191
192 cache->last = c;
193 return c->program;
194 }
195 }
196
197 return NULL;
198 }
199 }
200
201
202 void
_mesa_program_cache_insert(struct gl_context * ctx,struct gl_program_cache * cache,const void * key,GLuint keysize,struct gl_program * program)203 _mesa_program_cache_insert(struct gl_context *ctx,
204 struct gl_program_cache *cache,
205 const void *key, GLuint keysize,
206 struct gl_program *program)
207 {
208 const GLuint hash = hash_key(key, keysize);
209 struct cache_item *c = CALLOC_STRUCT(cache_item);
210
211 c->hash = hash;
212
213 c->key = malloc(keysize);
214 memcpy(c->key, key, keysize);
215 c->keysize = keysize;
216
217 c->program = program; /* no refcount change */
218
219 if (cache->n_items > cache->size * 1.5) {
220 if (cache->size < 1000)
221 rehash(cache);
222 else
223 clear_cache(ctx, cache, GL_FALSE);
224 }
225
226 cache->n_items++;
227 c->next = cache->items[hash % cache->size];
228 cache->items[hash % cache->size] = c;
229 }
230
231 void
_mesa_shader_cache_insert(struct gl_context * ctx,struct gl_program_cache * cache,const void * key,GLuint keysize,struct gl_shader_program * program)232 _mesa_shader_cache_insert(struct gl_context *ctx,
233 struct gl_program_cache *cache,
234 const void *key, GLuint keysize,
235 struct gl_shader_program *program)
236 {
237 const GLuint hash = hash_key(key, keysize);
238 struct cache_item *c = CALLOC_STRUCT(cache_item);
239
240 c->hash = hash;
241
242 c->key = malloc(keysize);
243 memcpy(c->key, key, keysize);
244 c->keysize = keysize;
245
246 c->program = (struct gl_program *)program; /* no refcount change */
247
248 if (cache->n_items > cache->size * 1.5) {
249 if (cache->size < 1000)
250 rehash(cache);
251 else
252 clear_cache(ctx, cache, GL_TRUE);
253 }
254
255 cache->n_items++;
256 c->next = cache->items[hash % cache->size];
257 cache->items[hash % cache->size] = c;
258 }
259