2 Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 Intel funded Tungsten Graphics 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 <keithw@vmware.com>
32 /** @file brw_program_cache.c
34 * This file implements a simple program cache for 965. The consumers can
35 * query the hash table of programs using a cache_id and program key, and
36 * receive the corresponding program buffer object (plus associated auxiliary
37 * data) in return. Objects in the cache may not have relocations
38 * (pointers to other BOs) in them.
40 * The inner workings are a simple hash table based on a CRC of the
43 * Replacement is not implemented. Instead, when the cache gets too
44 * big we throw out all of the cache data and let it get regenerated.
47 #include "main/imports.h"
48 #include "intel_batchbuffer.h"
49 #include "brw_state.h"
53 #include "brw_program.h"
54 #include "compiler/brw_eu.h"
56 #define FILE_DEBUG_FLAG DEBUG_STATE
58 struct brw_cache_item
{
60 * Effectively part of the key, cache_id identifies what kind of state
61 * buffer is involved, and also which dirty flag should set.
63 enum brw_cache_id cache_id
;
65 /** 32-bit hash of the key data */
68 /** for variable-sized keys */
76 struct brw_cache_item
*next
;
80 get_program_string_id(enum brw_cache_id cache_id
, const void *key
)
83 case BRW_CACHE_VS_PROG
:
84 return ((struct brw_vs_prog_key
*) key
)->program_string_id
;
85 case BRW_CACHE_TCS_PROG
:
86 return ((struct brw_tcs_prog_key
*) key
)->program_string_id
;
87 case BRW_CACHE_TES_PROG
:
88 return ((struct brw_tes_prog_key
*) key
)->program_string_id
;
89 case BRW_CACHE_GS_PROG
:
90 return ((struct brw_gs_prog_key
*) key
)->program_string_id
;
91 case BRW_CACHE_CS_PROG
:
92 return ((struct brw_cs_prog_key
*) key
)->program_string_id
;
93 case BRW_CACHE_FS_PROG
:
94 return ((struct brw_wm_prog_key
*) key
)->program_string_id
;
96 unreachable("no program string id for this kind of program");
101 hash_key(struct brw_cache_item
*item
)
103 GLuint
*ikey
= (GLuint
*)item
->key
;
104 GLuint hash
= item
->cache_id
, i
;
106 assert(item
->key_size
% 4 == 0);
108 /* I'm sure this can be improved on:
110 for (i
= 0; i
< item
->key_size
/4; i
++) {
112 hash
= (hash
<< 5) | (hash
>> 27);
119 brw_cache_item_equals(const struct brw_cache_item
*a
,
120 const struct brw_cache_item
*b
)
122 return a
->cache_id
== b
->cache_id
&&
123 a
->hash
== b
->hash
&&
124 a
->key_size
== b
->key_size
&&
125 (memcmp(a
->key
, b
->key
, a
->key_size
) == 0);
128 static struct brw_cache_item
*
129 search_cache(struct brw_cache
*cache
, GLuint hash
,
130 struct brw_cache_item
*lookup
)
132 struct brw_cache_item
*c
;
137 for (c
= cache
->items
[hash
% cache
->size
]; c
; c
= c
->next
)
140 fprintf(stderr
, "bucket %d/%d = %d/%d items\n", hash
% cache
->size
,
141 cache
->size
, bucketcount
, cache
->n_items
);
144 for (c
= cache
->items
[hash
% cache
->size
]; c
; c
= c
->next
) {
145 if (brw_cache_item_equals(lookup
, c
))
154 rehash(struct brw_cache
*cache
)
156 struct brw_cache_item
**items
;
157 struct brw_cache_item
*c
, *next
;
160 size
= cache
->size
* 3;
161 items
= calloc(size
, sizeof(*items
));
163 for (i
= 0; i
< cache
->size
; i
++)
164 for (c
= cache
->items
[i
]; c
; c
= next
) {
166 c
->next
= items
[c
->hash
% size
];
167 items
[c
->hash
% size
] = c
;
171 cache
->items
= items
;
177 * Returns the buffer object matching cache_id and key, or NULL.
180 brw_search_cache(struct brw_cache
*cache
,
181 enum brw_cache_id cache_id
,
182 const void *key
, GLuint key_size
,
183 uint32_t *inout_offset
, void *inout_aux
)
185 struct brw_context
*brw
= cache
->brw
;
186 struct brw_cache_item
*item
;
187 struct brw_cache_item lookup
;
190 lookup
.cache_id
= cache_id
;
192 lookup
.key_size
= key_size
;
193 hash
= hash_key(&lookup
);
196 item
= search_cache(cache
, hash
, &lookup
);
201 void *aux
= ((char *) item
->key
) + item
->key_size
;
203 if (item
->offset
!= *inout_offset
|| aux
!= *((void **) inout_aux
)) {
204 brw
->ctx
.NewDriverState
|= (1 << cache_id
);
205 *inout_offset
= item
->offset
;
206 *((void **) inout_aux
) = aux
;
213 brw_cache_new_bo(struct brw_cache
*cache
, uint32_t new_size
)
215 struct brw_context
*brw
= cache
->brw
;
216 struct brw_bo
*new_bo
;
219 new_bo
= brw_bo_alloc(brw
->bufmgr
, "program cache", new_size
, 64);
220 if (can_do_exec_capture(brw
->screen
))
221 new_bo
->kflags
= EXEC_OBJECT_CAPTURE
;
223 llc_map
= brw_bo_map_unsynchronized(brw
, new_bo
);
225 /* Copy any existing data that needs to be saved. */
226 if (cache
->next_offset
!= 0) {
228 memcpy(llc_map
, cache
->map
, cache
->next_offset
);
230 void *map
= brw_bo_map(brw
, cache
->bo
, MAP_READ
);
231 brw_bo_subdata(new_bo
, 0, cache
->next_offset
, map
);
232 brw_bo_unmap(cache
->bo
);
237 brw_bo_unmap(cache
->bo
);
238 brw_bo_unreference(cache
->bo
);
240 cache
->map
= brw
->has_llc
? llc_map
: NULL
;
241 cache
->bo_used_by_gpu
= false;
243 /* Since we have a new BO in place, we need to signal the units
244 * that depend on it (state base address on gen5+, or unit state before).
246 brw
->ctx
.NewDriverState
|= BRW_NEW_PROGRAM_CACHE
;
247 brw
->batch
.state_base_address_emitted
= false;
251 * Attempts to find an item in the cache with identical data.
253 static const struct brw_cache_item
*
254 brw_lookup_prog(const struct brw_cache
*cache
,
255 enum brw_cache_id cache_id
,
256 const void *data
, unsigned data_size
)
258 struct brw_context
*brw
= cache
->brw
;
260 const struct brw_cache_item
*item
;
262 for (i
= 0; i
< cache
->size
; i
++) {
263 for (item
= cache
->items
[i
]; item
; item
= item
->next
) {
266 if (item
->cache_id
!= cache_id
|| item
->size
!= data_size
)
271 map
= brw_bo_map(brw
, cache
->bo
, MAP_READ
);
275 ret
= memcmp(map
+ item
->offset
, data
, item
->size
);
277 brw_bo_unmap(cache
->bo
);
289 brw_alloc_item_data(struct brw_cache
*cache
, uint32_t size
)
292 struct brw_context
*brw
= cache
->brw
;
294 /* Allocate space in the cache BO for our new program. */
295 if (cache
->next_offset
+ size
> cache
->bo
->size
) {
296 uint32_t new_size
= cache
->bo
->size
* 2;
298 while (cache
->next_offset
+ size
> new_size
)
301 brw_cache_new_bo(cache
, new_size
);
304 /* If we would block on writing to an in-use program BO, just
307 if (!brw
->has_llc
&& cache
->bo_used_by_gpu
) {
308 perf_debug("Copying busy program cache buffer.\n");
309 brw_cache_new_bo(cache
, cache
->bo
->size
);
312 offset
= cache
->next_offset
;
314 /* Programs are always 64-byte aligned, so set up the next one now */
315 cache
->next_offset
= ALIGN(offset
+ size
, 64);
321 brw_find_previous_compile(struct brw_cache
*cache
,
322 enum brw_cache_id cache_id
,
323 unsigned program_string_id
)
325 for (unsigned i
= 0; i
< cache
->size
; i
++) {
326 for (struct brw_cache_item
*c
= cache
->items
[i
]; c
; c
= c
->next
) {
327 if (c
->cache_id
== cache_id
&&
328 get_program_string_id(cache_id
, c
->key
) == program_string_id
) {
338 brw_upload_cache(struct brw_cache
*cache
,
339 enum brw_cache_id cache_id
,
346 uint32_t *out_offset
,
349 struct brw_context
*brw
= cache
->brw
;
350 struct brw_cache_item
*item
= CALLOC_STRUCT(brw_cache_item
);
351 const struct brw_cache_item
*matching_data
=
352 brw_lookup_prog(cache
, cache_id
, data
, data_size
);
356 item
->cache_id
= cache_id
;
357 item
->size
= data_size
;
359 item
->key_size
= key_size
;
360 item
->aux_size
= aux_size
;
361 hash
= hash_key(item
);
364 /* If we can find a matching prog in the cache already, then reuse the
365 * existing stuff without creating new copy into the underlying buffer
366 * object. This is notably useful for programs generating shaders at
367 * runtime, where multiple shaders may compile to the same thing in our
371 item
->offset
= matching_data
->offset
;
373 item
->offset
= brw_alloc_item_data(cache
, data_size
);
375 /* Copy data to the buffer */
377 memcpy(cache
->map
+ item
->offset
, data
, data_size
);
379 brw_bo_subdata(cache
->bo
, item
->offset
, data_size
, data
);
383 /* Set up the memory containing the key and aux_data */
384 tmp
= malloc(key_size
+ aux_size
);
386 memcpy(tmp
, key
, key_size
);
387 memcpy(tmp
+ key_size
, aux
, aux_size
);
391 if (cache
->n_items
> cache
->size
* 1.5f
)
395 item
->next
= cache
->items
[hash
];
396 cache
->items
[hash
] = item
;
399 *out_offset
= item
->offset
;
400 *(void **)out_aux
= (void *)((char *)item
->key
+ item
->key_size
);
401 cache
->brw
->ctx
.NewDriverState
|= 1 << cache_id
;
405 brw_init_caches(struct brw_context
*brw
)
407 struct brw_cache
*cache
= &brw
->cache
;
414 calloc(cache
->size
, sizeof(struct brw_cache_item
*));
416 cache
->bo
= brw_bo_alloc(brw
->bufmgr
, "program cache", 4096, 64);
417 if (can_do_exec_capture(brw
->screen
))
418 cache
->bo
->kflags
= EXEC_OBJECT_CAPTURE
;
420 cache
->map
= brw_bo_map_unsynchronized(brw
, cache
->bo
);
424 brw_clear_cache(struct brw_context
*brw
, struct brw_cache
*cache
)
426 struct brw_cache_item
*c
, *next
;
429 DBG("%s\n", __func__
);
431 for (i
= 0; i
< cache
->size
; i
++) {
432 for (c
= cache
->items
[i
]; c
; c
= next
) {
434 if (c
->cache_id
== BRW_CACHE_VS_PROG
||
435 c
->cache_id
== BRW_CACHE_TCS_PROG
||
436 c
->cache_id
== BRW_CACHE_TES_PROG
||
437 c
->cache_id
== BRW_CACHE_GS_PROG
||
438 c
->cache_id
== BRW_CACHE_FS_PROG
||
439 c
->cache_id
== BRW_CACHE_CS_PROG
) {
440 const void *item_aux
= c
->key
+ c
->key_size
;
441 brw_stage_prog_data_free(item_aux
);
443 free((void *)c
->key
);
446 cache
->items
[i
] = NULL
;
451 /* Start putting programs into the start of the BO again, since
452 * we'll never find the old results.
454 cache
->next_offset
= 0;
456 /* We need to make sure that the programs get regenerated, since
457 * any offsets leftover in brw_context will no longer be valid.
459 brw
->NewGLState
= ~0;
460 brw
->ctx
.NewDriverState
= ~0ull;
461 brw
->state
.pipelines
[BRW_RENDER_PIPELINE
].mesa
= ~0;
462 brw
->state
.pipelines
[BRW_RENDER_PIPELINE
].brw
= ~0ull;
463 brw
->state
.pipelines
[BRW_COMPUTE_PIPELINE
].mesa
= ~0;
464 brw
->state
.pipelines
[BRW_COMPUTE_PIPELINE
].brw
= ~0ull;
466 /* Also, NULL out any stale program pointers. */
467 brw
->vs
.base
.prog_data
= NULL
;
468 brw
->tcs
.base
.prog_data
= NULL
;
469 brw
->tes
.base
.prog_data
= NULL
;
470 brw
->gs
.base
.prog_data
= NULL
;
471 brw
->wm
.base
.prog_data
= NULL
;
472 brw
->cs
.base
.prog_data
= NULL
;
474 intel_batchbuffer_flush(brw
);
478 brw_program_cache_check_size(struct brw_context
*brw
)
480 /* un-tuned guess. Each object is generally a page, so 2000 of them is 8 MB of
483 if (brw
->cache
.n_items
> 2000) {
484 perf_debug("Exceeded state cache size limit. Clearing the set "
485 "of compiled programs, which will trigger recompiles\n");
486 brw_clear_cache(brw
, &brw
->cache
);
492 brw_destroy_cache(struct brw_context
*brw
, struct brw_cache
*cache
)
495 DBG("%s\n", __func__
);
497 /* This can be NULL if context creation failed early on */
500 brw_bo_unmap(cache
->bo
);
501 brw_bo_unreference(cache
->bo
);
505 brw_clear_cache(brw
, cache
);
513 brw_destroy_caches(struct brw_context
*brw
)
515 brw_destroy_cache(brw
, &brw
->cache
);
519 cache_name(enum brw_cache_id cache_id
)
522 case BRW_CACHE_VS_PROG
:
524 case BRW_CACHE_TCS_PROG
:
526 case BRW_CACHE_TES_PROG
:
528 case BRW_CACHE_FF_GS_PROG
:
529 return "Fixed-function GS kernel";
530 case BRW_CACHE_GS_PROG
:
532 case BRW_CACHE_CLIP_PROG
:
533 return "CLIP kernel";
534 case BRW_CACHE_SF_PROG
:
536 case BRW_CACHE_FS_PROG
:
538 case BRW_CACHE_CS_PROG
:
546 brw_print_program_cache(struct brw_context
*brw
)
548 const struct brw_cache
*cache
= &brw
->cache
;
549 struct brw_cache_item
*item
;
553 map
= brw_bo_map(brw
, cache
->bo
, MAP_READ
);
557 for (unsigned i
= 0; i
< cache
->size
; i
++) {
558 for (item
= cache
->items
[i
]; item
; item
= item
->next
) {
559 fprintf(stderr
, "%s:\n", cache_name(i
));
560 brw_disassemble(&brw
->screen
->devinfo
, map
,
561 item
->offset
, item
->size
, stderr
);
566 brw_bo_unmap(cache
->bo
);