2 Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
4 develop this 3D driver.
6 Permission is hereby granted, free of charge, to any person obtaining
7 a 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, sublicense, 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:
14 The above copyright notice and this permission notice (including the
15 next paragraph) shall be included in all copies or substantial
16 portions of the Software.
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **********************************************************************/
29 * Keith Whitwell <keith@tungstengraphics.com>
32 /** @file brw_state_cache.c
34 * This file implements a simple static state cache for 965. The consumers
35 * can query the hash table of state using a cache_id, opaque key data,
36 * and list of buffers that will be used in relocations, and receive the
37 * corresponding state buffer object of state (plus associated auxiliary
40 * The inner workings are a simple hash table based on a CRC of the key data.
41 * The cache_id and relocation target buffers associated with the state
42 * buffer are included as auxiliary key data, but are not part of the hash
43 * value (this should be fixed, but will likely be fixed instead by making
44 * consumers use structured keys).
46 * Replacement is not implemented. Instead, when the cache gets too big, at
47 * a safe point (unlock) we throw out all of the cache data and let it
48 * regenerate for the next rendering operation.
50 * The reloc_buf pointers need to be included as key data, otherwise the
51 * non-unique values stuffed in the offset in key data through
52 * brw_cache_data() may result in successful probe for state buffers
53 * even when the buffer being referenced doesn't match. The result would be
54 * that the same state cache entry is used twice for different buffers,
55 * only one of the two buffers referenced gets put into the offset, and the
56 * incorrect program is run for the other instance.
59 #include "brw_state.h"
60 #include "intel_batchbuffer.h"
61 #include "main/imports.h"
63 /* XXX: Fixme - have to include these to get the sizes of the prog_key
72 static GLuint
hash_key( const void *key
, GLuint key_size
,
73 dri_bo
**reloc_bufs
, GLuint nr_reloc_bufs
)
75 GLuint
*ikey
= (GLuint
*)key
;
78 assert(key_size
% 4 == 0);
80 /* I'm sure this can be improved on:
82 for (i
= 0; i
< key_size
/4; i
++) {
84 hash
= (hash
<< 5) | (hash
>> 27);
87 /* Include the BO pointers as key data as well */
88 ikey
= (GLuint
*)reloc_bufs
;
89 key_size
= nr_reloc_bufs
* sizeof(dri_bo
*);
90 for (i
= 0; i
< key_size
/4; i
++) {
92 hash
= (hash
<< 5) | (hash
>> 27);
99 * Marks a new buffer as being chosen for the given cache id.
102 update_cache_last(struct brw_cache
*cache
, enum brw_cache_id cache_id
,
105 if (bo
== cache
->last_bo
[cache_id
])
106 return; /* no change */
108 dri_bo_unreference(cache
->last_bo
[cache_id
]);
109 cache
->last_bo
[cache_id
] = bo
;
110 dri_bo_reference(cache
->last_bo
[cache_id
]);
111 cache
->brw
->state
.dirty
.cache
|= 1 << cache_id
;
114 static struct brw_cache_item
*
115 search_cache(struct brw_cache
*cache
, enum brw_cache_id cache_id
,
116 GLuint hash
, const void *key
, GLuint key_size
,
117 dri_bo
**reloc_bufs
, GLuint nr_reloc_bufs
)
119 struct brw_cache_item
*c
;
124 for (c
= cache
->items
[hash
% cache
->size
]; c
; c
= c
->next
)
127 fprintf(stderr
, "bucket %d/%d = %d/%d items\n", hash
% cache
->size
,
128 cache
->size
, bucketcount
, cache
->n_items
);
131 for (c
= cache
->items
[hash
% cache
->size
]; c
; c
= c
->next
) {
132 if (c
->cache_id
== cache_id
&&
134 c
->key_size
== key_size
&&
135 memcmp(c
->key
, key
, key_size
) == 0 &&
136 c
->nr_reloc_bufs
== nr_reloc_bufs
&&
137 memcmp(c
->reloc_bufs
, reloc_bufs
,
138 nr_reloc_bufs
* sizeof(dri_bo
*)) == 0)
146 static void rehash( struct brw_cache
*cache
)
148 struct brw_cache_item
**items
;
149 struct brw_cache_item
*c
, *next
;
152 size
= cache
->size
* 3;
153 items
= (struct brw_cache_item
**) _mesa_calloc(size
* sizeof(*items
));
155 for (i
= 0; i
< cache
->size
; i
++)
156 for (c
= cache
->items
[i
]; c
; c
= next
) {
158 c
->next
= items
[c
->hash
% size
];
159 items
[c
->hash
% size
] = c
;
163 cache
->items
= items
;
168 * Returns the buffer object matching cache_id and key, or NULL.
170 dri_bo
*brw_search_cache( struct brw_cache
*cache
,
171 enum brw_cache_id cache_id
,
174 dri_bo
**reloc_bufs
, GLuint nr_reloc_bufs
,
177 struct brw_cache_item
*item
;
178 GLuint hash
= hash_key(key
, key_size
, reloc_bufs
, nr_reloc_bufs
);
180 item
= search_cache(cache
, cache_id
, hash
, key
, key_size
,
181 reloc_bufs
, nr_reloc_bufs
);
187 *(void **)aux_return
= (void *)((char *)item
->key
+ item
->key_size
);
189 update_cache_last(cache
, cache_id
, item
->bo
);
191 dri_bo_reference(item
->bo
);
196 brw_upload_cache( struct brw_cache
*cache
,
197 enum brw_cache_id cache_id
,
201 GLuint nr_reloc_bufs
,
207 struct brw_cache_item
*item
= CALLOC_STRUCT(brw_cache_item
);
208 GLuint hash
= hash_key(key
, key_size
, reloc_bufs
, nr_reloc_bufs
);
209 GLuint relocs_size
= nr_reloc_bufs
* sizeof(dri_bo
*);
210 GLuint aux_size
= cache
->aux_size
[cache_id
];
215 /* Create the buffer object to contain the data */
216 bo
= dri_bo_alloc(cache
->brw
->intel
.bufmgr
,
217 cache
->name
[cache_id
], data_size
, 1 << 6);
220 /* Set up the memory containing the key, aux_data, and reloc_bufs */
221 tmp
= _mesa_malloc(key_size
+ aux_size
+ relocs_size
);
223 memcpy(tmp
, key
, key_size
);
224 memcpy(tmp
+ key_size
, aux
, cache
->aux_size
[cache_id
]);
225 memcpy(tmp
+ key_size
+ aux_size
, reloc_bufs
, relocs_size
);
226 for (i
= 0; i
< nr_reloc_bufs
; i
++) {
227 if (reloc_bufs
[i
] != NULL
)
228 dri_bo_reference(reloc_bufs
[i
]);
231 item
->cache_id
= cache_id
;
234 item
->key_size
= key_size
;
235 item
->reloc_bufs
= tmp
+ key_size
+ aux_size
;
236 item
->nr_reloc_bufs
= nr_reloc_bufs
;
239 dri_bo_reference(bo
);
240 item
->data_size
= data_size
;
242 if (cache
->n_items
> cache
->size
* 1.5)
246 item
->next
= cache
->items
[hash
];
247 cache
->items
[hash
] = item
;
251 assert(cache
->aux_size
[cache_id
]);
252 *(void **)aux_return
= (void *)((char *)item
->key
+ item
->key_size
);
255 if (INTEL_DEBUG
& DEBUG_STATE
)
256 _mesa_printf("upload %s: %d bytes to cache id %d\n",
257 cache
->name
[cache_id
],
258 data_size
, cache_id
);
260 /* Copy data to the buffer */
261 dri_bo_subdata(bo
, 0, data_size
, data
);
263 update_cache_last(cache
, cache_id
, bo
);
268 /* This doesn't really work with aux data. Use search/upload instead
271 brw_cache_data_sz(struct brw_cache
*cache
,
272 enum brw_cache_id cache_id
,
276 GLuint nr_reloc_bufs
)
279 struct brw_cache_item
*item
;
280 GLuint hash
= hash_key(data
, data_size
, reloc_bufs
, nr_reloc_bufs
);
282 item
= search_cache(cache
, cache_id
, hash
, data
, data_size
,
283 reloc_bufs
, nr_reloc_bufs
);
285 update_cache_last(cache
, cache_id
, item
->bo
);
286 dri_bo_reference(item
->bo
);
290 bo
= brw_upload_cache(cache
, cache_id
,
292 reloc_bufs
, nr_reloc_bufs
,
300 * Wrapper around brw_cache_data_sz using the cache_id's canonical key size.
302 * If nr_reloc_bufs is nonzero, brw_search_cache()/brw_upload_cache() would be
303 * better to use, as the potentially changing offsets in the data-used-as-key
304 * will result in excessive cache misses.
307 brw_cache_data(struct brw_cache
*cache
,
308 enum brw_cache_id cache_id
,
311 GLuint nr_reloc_bufs
)
313 return brw_cache_data_sz(cache
, cache_id
, data
, cache
->key_size
[cache_id
],
314 reloc_bufs
, nr_reloc_bufs
);
323 brw_init_cache_id( struct brw_context
*brw
,
325 enum brw_cache_id id
,
329 struct brw_cache
*cache
= &brw
->cache
;
331 cache
->name
[id
] = strdup(name
);
332 cache
->key_size
[id
] = key_size
;
333 cache
->aux_size
[id
] = aux_size
;
336 void brw_init_cache( struct brw_context
*brw
)
338 struct brw_cache
*cache
= &brw
->cache
;
344 cache
->items
= (struct brw_cache_item
**)
345 _mesa_calloc(cache
->size
*
346 sizeof(struct brw_cache_item
));
348 brw_init_cache_id(brw
,
351 sizeof(struct brw_cc_viewport
),
354 brw_init_cache_id(brw
,
357 sizeof(struct brw_cc_unit_state
),
360 brw_init_cache_id(brw
,
363 sizeof(struct brw_wm_prog_key
),
364 sizeof(struct brw_wm_prog_data
));
366 brw_init_cache_id(brw
,
367 "SAMPLER_DEFAULT_COLOR",
368 BRW_SAMPLER_DEFAULT_COLOR
,
369 sizeof(struct brw_sampler_default_color
),
372 brw_init_cache_id(brw
,
375 0, /* variable key/data size */
378 brw_init_cache_id(brw
,
381 sizeof(struct brw_wm_unit_state
),
384 brw_init_cache_id(brw
,
387 sizeof(struct brw_sf_prog_key
),
388 sizeof(struct brw_sf_prog_data
));
390 brw_init_cache_id(brw
,
393 sizeof(struct brw_sf_viewport
),
396 brw_init_cache_id(brw
,
399 sizeof(struct brw_sf_unit_state
),
402 brw_init_cache_id(brw
,
405 sizeof(struct brw_vs_unit_state
),
408 brw_init_cache_id(brw
,
411 sizeof(struct brw_vs_prog_key
),
412 sizeof(struct brw_vs_prog_data
));
414 brw_init_cache_id(brw
,
417 sizeof(struct brw_clip_unit_state
),
420 brw_init_cache_id(brw
,
423 sizeof(struct brw_clip_prog_key
),
424 sizeof(struct brw_clip_prog_data
));
426 brw_init_cache_id(brw
,
429 sizeof(struct brw_gs_unit_state
),
432 brw_init_cache_id(brw
,
435 sizeof(struct brw_gs_prog_key
),
436 sizeof(struct brw_gs_prog_data
));
438 brw_init_cache_id(brw
,
441 sizeof(struct brw_surface_state
),
444 brw_init_cache_id(brw
,
452 brw_clear_cache( struct brw_context
*brw
)
454 struct brw_cache_item
*c
, *next
;
457 if (INTEL_DEBUG
& DEBUG_STATE
)
458 _mesa_printf("%s\n", __FUNCTION__
);
460 for (i
= 0; i
< brw
->cache
.size
; i
++) {
461 for (c
= brw
->cache
.items
[i
]; c
; c
= next
) {
465 for (j
= 0; j
< c
->nr_reloc_bufs
; j
++)
466 dri_bo_unreference(c
->reloc_bufs
[j
]);
467 dri_bo_unreference(c
->bo
);
468 free((void *)c
->key
);
471 brw
->cache
.items
[i
] = NULL
;
474 brw
->cache
.n_items
= 0;
476 if (brw
->curbe
.last_buf
) {
477 _mesa_free(brw
->curbe
.last_buf
);
478 brw
->curbe
.last_buf
= NULL
;
481 brw
->state
.dirty
.mesa
|= ~0;
482 brw
->state
.dirty
.brw
|= ~0;
483 brw
->state
.dirty
.cache
|= ~0;
486 void brw_state_cache_check_size( struct brw_context
*brw
)
488 /* un-tuned guess. We've got around 20 state objects for a total of around
489 * 32k, so 1000 of them is around 1.5MB.
491 if (brw
->cache
.n_items
> 1000)
492 brw_clear_cache(brw
);
495 void brw_destroy_cache( struct brw_context
*brw
)
499 brw_clear_cache(brw
);
500 for (i
= 0; i
< BRW_MAX_CACHE
; i
++) {
501 dri_bo_unreference(brw
->cache
.last_bo
[i
]);
502 free(brw
->cache
.name
[i
]);
504 free(brw
->cache
.items
);
505 brw
->cache
.items
= NULL
;