brw_state_cache.c File Reference

Include dependency graph for brw_state_cache.c:

Go to the source code of this file.

Enumerations
enum	pool_type { DW_SURFACE_STATE, DW_GENERAL_STATE }
Functions
static unsigned	hash_key (const void *key, unsigned key_size)
static struct brw_cache_item *	search_cache (struct brw_cache *cache, unsigned hash, const void *key, unsigned key_size)
static void	rehash (struct brw_cache *cache)
boolean	brw_search_cache (struct brw_cache *cache, const void *key, unsigned key_size, void *aux_return, unsigned *offset_return)
unsigned	brw_upload_cache (struct brw_cache *cache, const void *key, unsigned key_size, const void *data, unsigned data_size, const void *aux, void *aux_return)
unsigned	brw_cache_data_sz (struct brw_cache *cache, const void *data, unsigned data_size)
unsigned	brw_cache_data (struct brw_cache *cache, const void *data)
static void	brw_init_cache (struct brw_context *brw, const char *name, unsigned id, unsigned key_size, unsigned aux_size, enum pool_type pool_type)
void	brw_init_caches (struct brw_context *brw)
static void	clear_cache (struct brw_cache *cache)
void	brw_clear_all_caches (struct brw_context *brw)
void	brw_destroy_caches (struct brw_context *brw)

---

Enumeration Type Documentation

enum pool_type

Enumerator:

DW_SURFACE_STATE
DW_GENERAL_STATE

Definition at line 225 of file brw_state_cache.c.

               {
   DW_SURFACE_STATE,
   DW_GENERAL_STATE
};

---

Function Documentation

unsigned brw_cache_data	(	struct brw_cache *	cache,
		const void *	data
	)

Definition at line 219 of file brw_state_cache.c.

References brw_cache_data_sz(), and brw_cache::key_size.

{
   return brw_cache_data_sz(cache, data, cache->key_size);
}

unsigned brw_cache_data_sz	(	struct brw_cache *	cache,
		const void *	data,
		unsigned	data_size
	)

Definition at line 203 of file brw_state_cache.c.

References brw_search_cache(), and brw_upload_cache().

{
   unsigned addr;

   if (!brw_search_cache(cache, data, data_size, NULL, &addr)) {
      addr = brw_upload_cache(cache,
                              data, data_size,
                              data, data_size,
                              NULL, NULL);
   }

   return addr;
}

void brw_clear_all_caches

(

struct brw_context *

brw

)

Definition at line 414 of file brw_state_cache.c.

References brw_state_flags::brw, BRW_DEBUG, BRW_MAX_CACHE, brw_state_flags::cache, brw_context::cache, clear_cache(), brw_context::curbe, debug_printf(), DEBUG_STATE, brw_context::dirty, FREE, brw_context::last_buf, and brw_context::state.

{
   int i;

   if (BRW_DEBUG & DEBUG_STATE)
      debug_printf("%s\n", __FUNCTION__);

   for (i = 0; i < BRW_MAX_CACHE; i++)
      clear_cache(&brw->cache[i]);

   if (brw->curbe.last_buf) {
      FREE(brw->curbe.last_buf);
      brw->curbe.last_buf = NULL;
   }

   brw->state.dirty.brw |= ~0;
   brw->state.dirty.cache |= ~0;
}

void brw_destroy_caches

(

struct brw_context *

brw

)

Definition at line 437 of file brw_state_cache.c.

References BRW_MAX_CACHE, brw_context::cache, and clear_cache().

{
   unsigned i;

   for (i = 0; i < BRW_MAX_CACHE; i++)
      clear_cache(&brw->cache[i]);
}

static void brw_init_cache	(	struct brw_context *	brw,
		const char *	name,
		unsigned	id,
		unsigned	key_size,
		unsigned	aux_size,
		enum pool_type	pool_type
	)			[static]

Definition at line 230 of file brw_state_cache.c.

References assert, brw_cache::aux_size, brw_cache::brw, BRW_GS_POOL, BRW_SS_POOL, brw_context::cache, CALLOC, DW_GENERAL_STATE, DW_SURFACE_STATE, brw_cache::id, brw_cache::items, brw_cache::key_size, brw_cache::n_items, brw_cache::name, brw_context::pool, brw_cache::pool, and brw_cache::size.

{
   struct brw_cache *cache = &brw->cache[id];
   cache->brw = brw;
   cache->id = id;
   cache->name = name;
   cache->items = NULL;

   cache->size = 7;
   cache->n_items = 0;
   cache->items = (struct brw_cache_item **)
      CALLOC(cache->size, sizeof(struct brw_cache_item));


   cache->key_size = key_size;
   cache->aux_size = aux_size;
   switch (pool_type) {
   case DW_GENERAL_STATE: cache->pool = &brw->pool[BRW_GS_POOL]; break;
   case DW_SURFACE_STATE: cache->pool = &brw->pool[BRW_SS_POOL]; break;
   default: assert(0); break;
   }
}

void brw_init_caches

(

struct brw_context *

brw

)

Definition at line 258 of file brw_state_cache.c.

References BRW_CC_UNIT, BRW_CC_VP, BRW_CLIP_PROG, BRW_CLIP_UNIT, BRW_GS_PROG, BRW_GS_UNIT, brw_init_cache(), BRW_SAMPLER, BRW_SAMPLER_DEFAULT_COLOR, BRW_SF_PROG, BRW_SF_UNIT, BRW_SF_VP, BRW_SS_SURF_BIND, BRW_SS_SURFACE, BRW_VS_PROG, BRW_VS_UNIT, BRW_WM_PROG, BRW_WM_UNIT, DW_GENERAL_STATE, and DW_SURFACE_STATE.

{

   brw_init_cache(brw,
                  "CC_VP",
                  BRW_CC_VP,
                  sizeof(struct brw_cc_viewport),
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "CC_UNIT",
                  BRW_CC_UNIT,
                  sizeof(struct brw_cc_unit_state),
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "WM_PROG",
                  BRW_WM_PROG,
                  sizeof(struct brw_wm_prog_key),
                  sizeof(struct brw_wm_prog_data),
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "SAMPLER_DEFAULT_COLOR",
                  BRW_SAMPLER_DEFAULT_COLOR,
                  sizeof(struct brw_sampler_default_color),
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "SAMPLER",
                  BRW_SAMPLER,
                  0,            /* variable key/data size */
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "WM_UNIT",
                  BRW_WM_UNIT,
                  sizeof(struct brw_wm_unit_state),
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "SF_PROG",
                  BRW_SF_PROG,
                  sizeof(struct brw_sf_prog_key),
                  sizeof(struct brw_sf_prog_data),
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "SF_VP",
                  BRW_SF_VP,
                  sizeof(struct brw_sf_viewport),
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "SF_UNIT",
                  BRW_SF_UNIT,
                  sizeof(struct brw_sf_unit_state),
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "VS_UNIT",
                  BRW_VS_UNIT,
                  sizeof(struct brw_vs_unit_state),
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "VS_PROG",
                  BRW_VS_PROG,
                  sizeof(struct brw_vs_prog_key),
                  sizeof(struct brw_vs_prog_data),
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "CLIP_UNIT",
                  BRW_CLIP_UNIT,
                  sizeof(struct brw_clip_unit_state),
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "CLIP_PROG",
                  BRW_CLIP_PROG,
                  sizeof(struct brw_clip_prog_key),
                  sizeof(struct brw_clip_prog_data),
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "GS_UNIT",
                  BRW_GS_UNIT,
                  sizeof(struct brw_gs_unit_state),
                  0,
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "GS_PROG",
                  BRW_GS_PROG,
                  sizeof(struct brw_gs_prog_key),
                  sizeof(struct brw_gs_prog_data),
                  DW_GENERAL_STATE);

   brw_init_cache(brw,
                  "SS_SURFACE",
                  BRW_SS_SURFACE,
                  sizeof(struct brw_surface_state),
                  0,
                  DW_SURFACE_STATE);

   brw_init_cache(brw,
                  "SS_SURF_BIND",
                  BRW_SS_SURF_BIND,
                  sizeof(struct brw_surface_binding_table),
                  0,
                  DW_SURFACE_STATE);
}

boolean brw_search_cache	(	struct brw_cache *	cache,
		const void *	key,
		unsigned	key_size,
		void *	aux_return,
		unsigned *	offset_return
	)

Definition at line 109 of file brw_state_cache.c.

References brw_cache::brw, brw_state_flags::cache, brw_context::dirty, brw_cache_item::hash, hash_key(), brw_cache::id, brw_cache_item::key, brw_cache_item::key_size, brw_cache::last_addr, brw_cache_item::offset, search_cache(), and brw_context::state.

{
   struct brw_cache_item *item;
   unsigned addr = 0;
   unsigned hash = hash_key(key, key_size);

   item = search_cache(cache, hash, key, key_size);

   if (item) {
      if (aux_return)
         *(void **)aux_return = (void *)((char *)item->key + item->key_size);

      *offset_return = addr = item->offset;
   }

   if (item == NULL || addr != cache->last_addr) {
      cache->brw->state.dirty.cache |= 1<<cache->id;
      cache->last_addr = addr;
   }

   return item != NULL;
}

unsigned brw_upload_cache	(	struct brw_cache *	cache,
		const void *	key,
		unsigned	key_size,
		const void *	data,
		unsigned	data_size,
		const void *	aux,
		void *	aux_return
	)

Definition at line 136 of file brw_state_cache.c.

References assert, brw_cache::aux_size, brw_cache::brw, BRW_DEBUG, brw_pool_alloc(), brw_mem_pool::buffer, brw_winsys::buffer_subdata_typed, brw_state_flags::cache, CALLOC_STRUCT, brw_cache_item::data_size, debug_printf(), DEBUG_STATE, brw_context::dirty, brw_cache_item::hash, hash_key(), brw_cache::id, brw_cache::items, brw_cache_item::key, brw_cache_item::key_size, brw_cache::last_addr, MALLOC, brw_cache::n_items, brw_cache::name, brw_cache_item::next, brw_cache_item::offset, offset(), brw_cache::pool, rehash(), brw_cache::size, brw_context::state, and brw_context::winsys.

{
   unsigned offset;
   struct brw_cache_item *item = CALLOC_STRUCT(brw_cache_item);
   unsigned hash = hash_key(key, key_size);
   void *tmp = MALLOC(key_size + cache->aux_size);

   if (!brw_pool_alloc(cache->pool, data_size, 1 << 6, &offset)) {
      /* Should not be possible:
       */
      debug_printf("brw_pool_alloc failed\n");
      exit(1);
   }

   memcpy(tmp, key, key_size);

   if (cache->aux_size)
      memcpy(tmp+key_size, aux, cache->aux_size);

   item->key = tmp;
   item->hash = hash;
   item->key_size = key_size;
   item->offset = offset;
   item->data_size = data_size;

   if (++cache->n_items > cache->size * 1.5)
      rehash(cache);

   hash %= cache->size;
   item->next = cache->items[hash];
   cache->items[hash] = item;

   if (aux_return) {
      assert(cache->aux_size);
      *(void **)aux_return = (void *)((char *)item->key + item->key_size);
   }

   if (BRW_DEBUG & DEBUG_STATE)
      debug_printf("upload %s: %d bytes to pool buffer %p offset %x\n",
             cache->name, 
             data_size,
             (void*)cache->pool->buffer,
             offset);

   /* Copy data to the buffer:
    */
   cache->brw->winsys->buffer_subdata_typed(cache->brw->winsys,
                                            cache->pool->buffer, 
                                            offset, 
                                            data_size, 
                                            data,
                                            cache->id);

   cache->brw->state.dirty.cache |= 1<<cache->id;
   cache->last_addr = offset;

   return offset;
}

static void clear_cache

(

struct brw_cache *

cache

)

[static]

Definition at line 397 of file brw_state_cache.c.

References brw_cache::items, brw_cache_item::key, brw_cache::n_items, brw_cache_item::next, and brw_cache::size.

{
   struct brw_cache_item *c, *next;
   unsigned i;

   for (i = 0; i < cache->size; i++) {
      for (c = cache->items[i]; c; c = next) {
         next = c->next;
         free((void *)c->key);
         free(c);
      }
      cache->items[i] = NULL;
   }

   cache->n_items = 0;
}

static unsigned hash_key	(	const void *	key,
		unsigned	key_size
	)			[static]

Definition at line 53 of file brw_state_cache.c.

References assert.

{
   unsigned *ikey = (unsigned *)key;
   unsigned hash = 0, i;

   assert(key_size % 4 == 0);

   /* I'm sure this can be improved on:
    */
   for (i = 0; i < key_size/4; i++)
      hash ^= ikey[i];

   return hash;
}

static void rehash

(

struct brw_cache *

cache

)

[static]

Definition at line 86 of file brw_state_cache.c.

References FREE, brw_cache_item::hash, brw_cache::items, MALLOC, brw_cache_item::next, and brw_cache::size.

{
   struct brw_cache_item **items;
   struct brw_cache_item *c, *next;
   unsigned size, i;

   size = cache->size * 3;
   items = (struct brw_cache_item**) MALLOC(size * sizeof(*items));
   memset(items, 0, size * sizeof(*items));

   for (i = 0; i < cache->size; i++)
      for (c = cache->items[i]; c; c = next) {
         next = c->next;
         c->next = items[c->hash % size];
         items[c->hash % size] = c;
      }

   FREE(cache->items);
   cache->items = items;
   cache->size = size;
}

static struct brw_cache_item* search_cache	(	struct brw_cache *	cache,
		unsigned	hash,
		const void *	key,
		unsigned	key_size
	)			[static, read]

Definition at line 68 of file brw_state_cache.c.

References brw_cache_item::hash, brw_cache::items, brw_cache_item::key, brw_cache_item::key_size, brw_cache_item::next, and brw_cache::size.

{
   struct brw_cache_item *c;

   for (c = cache->items[hash % cache->size]; c; c = c->next) {
      if (c->hash == hash &&
          c->key_size == key_size &&
          memcmp(c->key, key, key_size) == 0)
         return c;
   }

   return NULL;
}

---