From: Jason Ekstrand Date: Wed, 11 Oct 2017 19:13:35 +0000 (-0700) Subject: anv/pipeline_cache: Rework to use multialloc and blob X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=b8ab78d1afd50cd10bf9be7046f27e4aa22d57ac;p=mesa.git anv/pipeline_cache: Rework to use multialloc and blob This gets rid of all of our hand-rolled size calculation and serialization code and replaces it with safe "standards" that are used elsewhere in anv and mesa. This should be significantly safer than rolling our own. Reviewed-by: Jordan Justen --- diff --git a/src/intel/vulkan/anv_pipeline_cache.c b/src/intel/vulkan/anv_pipeline_cache.c index c3a62f538e3..f782d04fbe6 100644 --- a/src/intel/vulkan/anv_pipeline_cache.c +++ b/src/intel/vulkan/anv_pipeline_cache.c @@ -21,81 +21,64 @@ * IN THE SOFTWARE. */ +#include "compiler/blob.h" #include "util/hash_table.h" #include "util/debug.h" #include "anv_private.h" -static size_t -anv_shader_bin_size(uint32_t prog_data_size, uint32_t nr_params, - uint32_t key_size, - uint32_t surface_count, uint32_t sampler_count) -{ - const uint32_t binding_data_size = - (surface_count + sampler_count) * sizeof(struct anv_pipeline_binding); - - return align_u32(sizeof(struct anv_shader_bin), 8) + - align_u32(prog_data_size, 8) + - align_u32(nr_params * sizeof(void *), 8) + - align_u32(sizeof(uint32_t) + key_size, 8) + - align_u32(binding_data_size, 8); -} - 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 struct brw_stage_prog_data *prog_data, - uint32_t prog_data_size, const void *prog_data_param, + const struct brw_stage_prog_data *prog_data_in, + uint32_t prog_data_size, const void *prog_data_param_in, const struct anv_pipeline_bind_map *bind_map) { - const size_t size = - anv_shader_bin_size(prog_data_size, prog_data->nr_params, key_size, - bind_map->surface_count, bind_map->sampler_count); - - struct anv_shader_bin *shader = - vk_alloc(&device->alloc, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); - if (!shader) + struct anv_shader_bin *shader; + struct anv_shader_bin_key *key; + struct brw_stage_prog_data *prog_data; + const union gl_constant_value **prog_data_param; + struct anv_pipeline_binding *surface_to_descriptor, *sampler_to_descriptor; + + ANV_MULTIALLOC(ma); + anv_multialloc_add(&ma, &shader, 1); + anv_multialloc_add_size(&ma, &key, sizeof(*key) + key_size); + anv_multialloc_add_size(&ma, &prog_data, prog_data_size); + anv_multialloc_add(&ma, &prog_data_param, prog_data_in->nr_params); + anv_multialloc_add(&ma, &surface_to_descriptor, + bind_map->surface_count); + anv_multialloc_add(&ma, &sampler_to_descriptor, + bind_map->sampler_count); + + if (!anv_multialloc_alloc(&ma, &device->alloc, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE)) return NULL; shader->ref_cnt = 1; + key->size = key_size; + memcpy(key->data, key_data, key_size); + shader->key = key; + shader->kernel = anv_state_pool_alloc(&device->instruction_state_pool, kernel_size, 64); memcpy(shader->kernel.map, kernel_data, kernel_size); shader->kernel_size = kernel_size; - shader->bind_map = *bind_map; - shader->prog_data_size = prog_data_size; - - /* Now we fill out the floating data at the end */ - void *data = shader; - data += align_u32(sizeof(struct anv_shader_bin), 8); - shader->prog_data = data; - struct brw_stage_prog_data *new_prog_data = data; - memcpy(data, prog_data, prog_data_size); - data += align_u32(prog_data_size, 8); - - assert(prog_data->nr_pull_params == 0); - assert(prog_data->nr_image_params == 0); - new_prog_data->param = data; - uint32_t param_size = prog_data->nr_params * sizeof(void *); - memcpy(data, prog_data_param, param_size); - data += align_u32(param_size, 8); - - 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); - - shader->bind_map.surface_to_descriptor = data; - memcpy(data, bind_map->surface_to_descriptor, - bind_map->surface_count * sizeof(struct anv_pipeline_binding)); - data += bind_map->surface_count * sizeof(struct anv_pipeline_binding); + memcpy(prog_data, prog_data_in, prog_data_size); + memcpy(prog_data_param, prog_data_param_in, + prog_data->nr_params * sizeof(*prog_data_param)); + prog_data->param = prog_data_param; + shader->prog_data = prog_data; + shader->prog_data_size = prog_data_size; - shader->bind_map.sampler_to_descriptor = data; - memcpy(data, bind_map->sampler_to_descriptor, - bind_map->sampler_count * sizeof(struct anv_pipeline_binding)); + shader->bind_map = *bind_map; + typed_memcpy(surface_to_descriptor, bind_map->surface_to_descriptor, + bind_map->surface_count); + shader->bind_map.surface_to_descriptor = surface_to_descriptor; + typed_memcpy(sampler_to_descriptor, bind_map->sampler_to_descriptor, + bind_map->sampler_count); + shader->bind_map.sampler_to_descriptor = sampler_to_descriptor; return shader; } @@ -109,29 +92,74 @@ anv_shader_bin_destroy(struct anv_device *device, vk_free(&device->alloc, shader); } -static size_t -anv_shader_bin_data_size(const struct anv_shader_bin *shader) +static bool +anv_shader_bin_write_to_blob(const struct anv_shader_bin *shader, + struct blob *blob) { - return anv_shader_bin_size(shader->prog_data_size, - shader->prog_data->nr_params, shader->key->size, - shader->bind_map.surface_count, - shader->bind_map.sampler_count) + - align_u32(shader->kernel_size, 8); + bool ok; + + ok = blob_write_uint32(blob, shader->key->size); + ok = blob_write_bytes(blob, shader->key->data, shader->key->size); + + ok = blob_write_uint32(blob, shader->kernel_size); + ok = blob_write_bytes(blob, shader->kernel.map, shader->kernel_size); + + ok = blob_write_uint32(blob, shader->prog_data_size); + ok = blob_write_bytes(blob, shader->prog_data, shader->prog_data_size); + ok = blob_write_bytes(blob, shader->prog_data->param, + shader->prog_data->nr_params * + sizeof(*shader->prog_data->param)); + + ok = blob_write_uint32(blob, shader->bind_map.surface_count); + ok = blob_write_uint32(blob, shader->bind_map.sampler_count); + ok = blob_write_uint32(blob, shader->bind_map.image_count); + ok = blob_write_bytes(blob, shader->bind_map.surface_to_descriptor, + shader->bind_map.surface_count * + sizeof(*shader->bind_map.surface_to_descriptor)); + ok = blob_write_bytes(blob, shader->bind_map.sampler_to_descriptor, + shader->bind_map.sampler_count * + sizeof(*shader->bind_map.sampler_to_descriptor)); + + return ok; } -static void -anv_shader_bin_write_data(const struct anv_shader_bin *shader, void *data) +static struct anv_shader_bin * +anv_shader_bin_create_from_blob(struct anv_device *device, + struct blob_reader *blob) { - size_t struct_size = - anv_shader_bin_size(shader->prog_data_size, - shader->prog_data->nr_params, shader->key->size, - shader->bind_map.surface_count, - shader->bind_map.sampler_count); + uint32_t key_size = blob_read_uint32(blob); + const void *key_data = blob_read_bytes(blob, key_size); - memcpy(data, shader, struct_size); - data += struct_size; + uint32_t kernel_size = blob_read_uint32(blob); + const void *kernel_data = blob_read_bytes(blob, kernel_size); - memcpy(data, shader->kernel.map, shader->kernel_size); + uint32_t prog_data_size = blob_read_uint32(blob); + const struct brw_stage_prog_data *prog_data = + blob_read_bytes(blob, prog_data_size); + if (blob->overrun) + return NULL; + const void *prog_data_param = + blob_read_bytes(blob, prog_data->nr_params * sizeof(*prog_data->param)); + + struct anv_pipeline_bind_map bind_map; + bind_map.surface_count = blob_read_uint32(blob); + bind_map.sampler_count = blob_read_uint32(blob); + bind_map.image_count = blob_read_uint32(blob); + bind_map.surface_to_descriptor = (void *) + blob_read_bytes(blob, bind_map.surface_count * + sizeof(*bind_map.surface_to_descriptor)); + bind_map.sampler_to_descriptor = (void *) + blob_read_bytes(blob, bind_map.sampler_count * + sizeof(*bind_map.sampler_to_descriptor)); + + if (blob->overrun) + return NULL; + + return anv_shader_bin_create(device, + key_data, key_size, + kernel_data, kernel_size, + prog_data, prog_data_size, prog_data_param, + &bind_map); } /* Remaining work: @@ -308,14 +336,19 @@ anv_pipeline_cache_load(struct anv_pipeline_cache *cache, { struct anv_device *device = cache->device; struct anv_physical_device *pdevice = &device->instance->physicalDevice; - struct cache_header header; if (cache->cache == NULL) return; - if (size < sizeof(header)) + struct blob_reader blob; + blob_reader_init(&blob, data, size); + + struct cache_header header; + blob_copy_bytes(&blob, &header, sizeof(header)); + uint32_t count = blob_read_uint32(&blob); + if (blob.overrun) return; - memcpy(&header, data, sizeof(header)); + if (header.header_size < sizeof(header)) return; if (header.header_version != VK_PIPELINE_CACHE_HEADER_VERSION_ONE) @@ -327,56 +360,12 @@ anv_pipeline_cache_load(struct anv_pipeline_cache *cache, if (memcmp(header.uuid, pdevice->pipeline_cache_uuid, VK_UUID_SIZE) != 0) return; - const void *end = data + size; - const void *p = data + header.header_size; - - /* Count is the total number of valid entries */ - uint32_t count; - if (p + sizeof(count) >= end) - return; - memcpy(&count, p, sizeof(count)); - p += align_u32(sizeof(count), 8); - for (uint32_t i = 0; i < count; i++) { - struct anv_shader_bin bin; - if (p + sizeof(bin) > end) - break; - memcpy(&bin, p, sizeof(bin)); - p += align_u32(sizeof(struct anv_shader_bin), 8); - - const struct brw_stage_prog_data *prog_data = p; - p += align_u32(bin.prog_data_size, 8); - if (p > end) - break; - - uint32_t param_size = prog_data->nr_params * sizeof(void *); - const void *prog_data_param = p; - p += align_u32(param_size, 8); - - struct anv_shader_bin_key key; - if (p + sizeof(key) > end) - break; - memcpy(&key, p, sizeof(key)); - const void *key_data = p + sizeof(key); - p += align_u32(sizeof(key) + key.size, 8); - - /* We're going to memcpy this so getting rid of const is fine */ - struct anv_pipeline_binding *bindings = (void *)p; - p += align_u32((bin.bind_map.surface_count + bin.bind_map.sampler_count) * - sizeof(struct anv_pipeline_binding), 8); - bin.bind_map.surface_to_descriptor = bindings; - bin.bind_map.sampler_to_descriptor = bindings + bin.bind_map.surface_count; - - const void *kernel_data = p; - p += align_u32(bin.kernel_size, 8); - - if (p > end) + struct anv_shader_bin *bin = + anv_shader_bin_create_from_blob(device, &blob); + if (!bin) break; - - anv_pipeline_cache_add_shader(cache, key_data, key.size, - kernel_data, bin.kernel_size, - prog_data, bin.prog_data_size, - prog_data_param, &bin.bind_map); + _mesa_hash_table_insert(cache->cache, bin->key, bin); } } @@ -444,59 +433,54 @@ VkResult anv_GetPipelineCacheData( ANV_FROM_HANDLE(anv_device, device, _device); ANV_FROM_HANDLE(anv_pipeline_cache, cache, _cache); struct anv_physical_device *pdevice = &device->instance->physicalDevice; - struct cache_header *header; - if (pData == NULL) { - size_t size = align_u32(sizeof(*header), 8) + - align_u32(sizeof(uint32_t), 8); - - if (cache->cache) { - struct hash_entry *entry; - hash_table_foreach(cache->cache, entry) - size += anv_shader_bin_data_size(entry->data); - } - - *pDataSize = size; - return VK_SUCCESS; + struct blob blob; + if (pData) { + blob_init_fixed(&blob, pData, *pDataSize); + } else { + blob_init_fixed(&blob, NULL, SIZE_MAX); } - if (*pDataSize < sizeof(*header)) { + struct cache_header header = { + .header_size = sizeof(struct cache_header), + .header_version = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + .vendor_id = 0x8086, + .device_id = device->chipset_id, + }; + memcpy(header.uuid, pdevice->pipeline_cache_uuid, VK_UUID_SIZE); + blob_write_bytes(&blob, &header, sizeof(header)); + + uint32_t count = 0; + ssize_t count_offset = blob_reserve_uint32(&blob); + if (count_offset < 0) { *pDataSize = 0; + blob_finish(&blob); return VK_INCOMPLETE; } - void *p = pData, *end = pData + *pDataSize; - header = p; - header->header_size = sizeof(*header); - header->header_version = VK_PIPELINE_CACHE_HEADER_VERSION_ONE; - header->vendor_id = 0x8086; - header->device_id = device->chipset_id; - memcpy(header->uuid, pdevice->pipeline_cache_uuid, VK_UUID_SIZE); - p += align_u32(header->header_size, 8); - - uint32_t *count = p; - 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) { + + size_t save_size = blob.size; + if (!anv_shader_bin_write_to_blob(shader, &blob)) { + /* If it fails reset to the previous size and bail */ + blob.size = save_size; result = VK_INCOMPLETE; break; } - anv_shader_bin_write_data(shader, p); - p += data_size; - - (*count)++; + count++; } } - *pDataSize = p - pData; + blob_overwrite_uint32(&blob, count_offset, count); + + *pDataSize = blob.size; + + blob_finish(&blob); return result; } diff --git a/src/intel/vulkan/anv_private.h b/src/intel/vulkan/anv_private.h index e8a845f7229..b33370c3da1 100644 --- a/src/intel/vulkan/anv_private.h +++ b/src/intel/vulkan/anv_private.h @@ -2048,8 +2048,6 @@ struct anv_shader_bin { uint32_t prog_data_size; struct anv_pipeline_bind_map bind_map; - - /* Prog data follows, then params, then the key, all aligned to 8-bytes */ }; struct anv_shader_bin *