#include "util/debug.h"
#include "anv_private.h"
-struct shader_bin_key {
- uint32_t size;
- uint8_t data[0];
-};
-
static size_t
anv_shader_bin_size(uint32_t prog_data_size, uint32_t key_size,
uint32_t surface_count, uint32_t sampler_count)
align_u32(binding_data_size, 8);
}
-static inline const struct shader_bin_key *
-anv_shader_bin_get_key(const struct anv_shader_bin *shader)
-{
- const void *data = shader;
- data += align_u32(sizeof(struct anv_shader_bin), 8);
- data += align_u32(shader->prog_data_size, 8);
- return data;
-}
-
struct anv_shader_bin *
anv_shader_bin_create(struct anv_device *device,
const void *key_data, uint32_t key_size,
const void *kernel_data, uint32_t kernel_size,
- const void *prog_data, uint32_t prog_data_size,
+ const struct brw_stage_prog_data *prog_data,
+ uint32_t prog_data_size,
const struct anv_pipeline_bind_map *bind_map)
{
const size_t size =
bind_map->surface_count, bind_map->sampler_count);
struct anv_shader_bin *shader =
- anv_alloc(&device->alloc, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
+ vk_alloc(&device->alloc, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
if (!shader)
return NULL;
void *data = shader;
data += align_u32(sizeof(struct anv_shader_bin), 8);
+ shader->prog_data = data;
memcpy(data, prog_data, prog_data_size);
data += align_u32(prog_data_size, 8);
- struct shader_bin_key *key = data;
+ shader->key = data;
+ struct anv_shader_bin_key *key = data;
key->size = key_size;
memcpy(key->data, key_data, key_size);
data += align_u32(sizeof(*key) + key_size, 8);
{
assert(shader->ref_cnt == 0);
anv_state_pool_free(&device->instruction_state_pool, shader->kernel);
- anv_free(&device->alloc, shader);
+ vk_free(&device->alloc, shader);
}
static size_t
anv_shader_bin_data_size(const struct anv_shader_bin *shader)
{
return anv_shader_bin_size(shader->prog_data_size,
- anv_shader_bin_get_key(shader)->size,
+ shader->key->size,
shader->bind_map.surface_count,
shader->bind_map.sampler_count) +
align_u32(shader->kernel_size, 8);
{
size_t struct_size =
anv_shader_bin_size(shader->prog_data_size,
- anv_shader_bin_get_key(shader)->size,
+ shader->key->size,
shader->bind_map.surface_count,
shader->bind_map.sampler_count);
static uint32_t
shader_bin_key_hash_func(const void *void_key)
{
- const struct shader_bin_key *key = void_key;
+ const struct anv_shader_bin_key *key = void_key;
return _mesa_hash_data(key->data, key->size);
}
static bool
shader_bin_key_compare_func(const void *void_a, const void *void_b)
{
- const struct shader_bin_key *a = void_a, *b = void_b;
+ const struct anv_shader_bin_key *a = void_a, *b = void_b;
if (a->size != b->size)
return false;
const void *key_data, uint32_t key_size)
{
uint32_t vla[1 + DIV_ROUND_UP(key_size, sizeof(uint32_t))];
- struct shader_bin_key *key = (void *)vla;
+ struct anv_shader_bin_key *key = (void *)vla;
key->size = key_size;
memcpy(key->data, key_data, key_size);
if (!bin)
return NULL;
- _mesa_hash_table_insert(cache->cache, anv_shader_bin_get_key(bin), bin);
+ _mesa_hash_table_insert(cache->cache, bin->key, bin);
return bin;
}
anv_pipeline_cache_upload_kernel(struct anv_pipeline_cache *cache,
const void *key_data, uint32_t key_size,
const void *kernel_data, uint32_t kernel_size,
- const void *prog_data, uint32_t prog_data_size,
+ const struct brw_stage_prog_data *prog_data,
+ uint32_t prog_data_size,
const struct anv_pipeline_bind_map *bind_map)
{
if (cache->cache) {
const void *prog_data = p;
p += align_u32(bin.prog_data_size, 8);
- struct shader_bin_key key;
+ struct anv_shader_bin_key key;
if (p + sizeof(key) > end)
break;
memcpy(&key, p, sizeof(key));
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO);
assert(pCreateInfo->flags == 0);
- cache = anv_alloc2(&device->alloc, pAllocator,
+ cache = vk_alloc2(&device->alloc, pAllocator,
sizeof(*cache), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (cache == NULL)
anv_pipeline_cache_finish(cache);
- anv_free2(&device->alloc, pAllocator, cache);
+ vk_free2(&device->alloc, pAllocator, cache);
}
VkResult anv_GetPipelineCacheData(
p += align_u32(sizeof(*count), 8);
*count = 0;
+ VkResult result = VK_SUCCESS;
if (cache->cache) {
struct hash_entry *entry;
hash_table_foreach(cache->cache, entry) {
struct anv_shader_bin *shader = entry->data;
size_t data_size = anv_shader_bin_data_size(entry->data);
- if (p + data_size > end)
+ if (p + data_size > end) {
+ result = VK_INCOMPLETE;
break;
+ }
anv_shader_bin_write_data(shader, p);
p += data_size;
*pDataSize = p - pData;
- return VK_SUCCESS;
+ return result;
}
VkResult anv_MergePipelineCaches(
struct hash_entry *entry;
hash_table_foreach(src->cache, entry) {
struct anv_shader_bin *bin = entry->data;
- if (_mesa_hash_table_search(dst->cache, anv_shader_bin_get_key(bin)))
+ if (_mesa_hash_table_search(dst->cache, bin->key))
continue;
anv_shader_bin_ref(bin);
- _mesa_hash_table_insert(dst->cache, anv_shader_bin_get_key(bin), bin);
+ _mesa_hash_table_insert(dst->cache, bin->key, bin);
}
}
projects / mesa.git / blobdiff