X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fintel%2Fvulkan%2Fanv_pipeline_cache.c;h=e1d48b879b07effede1be87a0355a76b0e36a120;hb=f118ca20758c85da1aaf1792e61aadb298b32a47;hp=c3a62f538e371a0775648f8bd45c4608927f1063;hpb=dcb6a68bb4f69dd83f65dfbaecd4c8a0be7aec12;p=mesa.git

diff --git a/src/intel/vulkan/anv_pipeline_cache.c b/src/intel/vulkan/anv_pipeline_cache.c
index c3a62f538e3..e1d48b879b0 100644
--- a/src/intel/vulkan/anv_pipeline_cache.c
+++ b/src/intel/vulkan/anv_pipeline_cache.c
@@ -21,81 +21,99 @@
  * IN THE SOFTWARE.
  */
 
+#include "util/blob.h"
 #include "util/hash_table.h"
 #include "util/debug.h"
+#include "util/disk_cache.h"
+#include "util/mesa-sha1.h"
+#include "nir/nir_serialize.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);
-}
+#include "nir/nir_xfb_info.h"
 
 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 void *constant_data, uint32_t constant_data_size,
+                      const struct brw_stage_prog_data *prog_data_in,
+                      uint32_t prog_data_size, const void *prog_data_param_in,
+                      const struct brw_compile_stats *stats, uint32_t num_stats,
+                      const nir_xfb_info *xfb_info_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;
+   struct anv_shader_bin_key *key;
+   struct brw_stage_prog_data *prog_data;
+   uint32_t *prog_data_param;
+   nir_xfb_info *xfb_info;
+   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);
+   if (xfb_info_in) {
+      uint32_t xfb_info_size = nir_xfb_info_size(xfb_info_in->output_count);
+      anv_multialloc_add_size(&ma, &xfb_info, xfb_info_size);
+   }
+   anv_multialloc_add(&ma, &surface_to_descriptor,
+                           bind_map->surface_count);
+   anv_multialloc_add(&ma, &sampler_to_descriptor,
+                           bind_map->sampler_count);
 
-   struct anv_shader_bin *shader =
-      vk_alloc(&device->alloc, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
-   if (!shader)
+   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);
+   if (constant_data_size) {
+      shader->constant_data =
+         anv_state_pool_alloc(&device->dynamic_state_pool,
+                              constant_data_size, 32);
+      memcpy(shader->constant_data.map, constant_data, constant_data_size);
+   } else {
+      shader->constant_data = ANV_STATE_NULL;
+   }
+   shader->constant_data_size = constant_data_size;
 
-   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);
+   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;
 
-   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);
+   assert(num_stats <= ARRAY_SIZE(shader->stats));
+   typed_memcpy(shader->stats, stats, num_stats);
+   shader->num_stats = num_stats;
 
-   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);
+   if (xfb_info_in) {
+      *xfb_info = *xfb_info_in;
+      typed_memcpy(xfb_info->outputs, xfb_info_in->outputs,
+                   xfb_info_in->output_count);
+      shader->xfb_info = xfb_info;
+   } else {
+      shader->xfb_info = NULL;
+   }
 
-   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;
 }
@@ -106,32 +124,104 @@ anv_shader_bin_destroy(struct anv_device *device,
 {
    assert(shader->ref_cnt == 0);
    anv_state_pool_free(&device->instruction_state_pool, shader->kernel);
+   anv_state_pool_free(&device->dynamic_state_pool, shader->constant_data);
    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);
+   blob_write_uint32(blob, shader->key->size);
+   blob_write_bytes(blob, shader->key->data, shader->key->size);
+
+   blob_write_uint32(blob, shader->kernel_size);
+   blob_write_bytes(blob, shader->kernel.map, shader->kernel_size);
+
+   blob_write_uint32(blob, shader->constant_data_size);
+   blob_write_bytes(blob, shader->constant_data.map,
+                    shader->constant_data_size);
+
+   blob_write_uint32(blob, shader->prog_data_size);
+   blob_write_bytes(blob, shader->prog_data, shader->prog_data_size);
+   blob_write_bytes(blob, shader->prog_data->param,
+                    shader->prog_data->nr_params *
+                    sizeof(*shader->prog_data->param));
+
+   blob_write_uint32(blob, shader->num_stats);
+   blob_write_bytes(blob, shader->stats,
+                    shader->num_stats * sizeof(shader->stats[0]));
+
+   if (shader->xfb_info) {
+      uint32_t xfb_info_size =
+         nir_xfb_info_size(shader->xfb_info->output_count);
+      blob_write_uint32(blob, xfb_info_size);
+      blob_write_bytes(blob, shader->xfb_info, xfb_info_size);
+   } else {
+      blob_write_uint32(blob, 0);
+   }
+
+   blob_write_uint32(blob, shader->bind_map.surface_count);
+   blob_write_uint32(blob, shader->bind_map.sampler_count);
+   blob_write_bytes(blob, shader->bind_map.surface_to_descriptor,
+                    shader->bind_map.surface_count *
+                    sizeof(*shader->bind_map.surface_to_descriptor));
+   blob_write_bytes(blob, shader->bind_map.sampler_to_descriptor,
+                    shader->bind_map.sampler_count *
+                    sizeof(*shader->bind_map.sampler_to_descriptor));
+
+   return !blob->out_of_memory;
 }
 
-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);
+
+   uint32_t kernel_size = blob_read_uint32(blob);
+   const void *kernel_data = blob_read_bytes(blob, kernel_size);
+
+   uint32_t constant_data_size = blob_read_uint32(blob);
+   const void *constant_data = blob_read_bytes(blob, constant_data_size);
 
-   memcpy(data, shader, struct_size);
-   data += struct_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));
+
+   uint32_t num_stats = blob_read_uint32(blob);
+   const struct brw_compile_stats *stats =
+      blob_read_bytes(blob, num_stats * sizeof(stats[0]));
+
+   const nir_xfb_info *xfb_info = NULL;
+   uint32_t xfb_size = blob_read_uint32(blob);
+   if (xfb_size)
+      xfb_info = blob_read_bytes(blob, xfb_size);
+
+   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.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;
 
-   memcpy(data, shader->kernel.map, shader->kernel_size);
+   return anv_shader_bin_create(device,
+                                key_data, key_size,
+                                kernel_data, kernel_size,
+                                constant_data, constant_data_size,
+                                prog_data, prog_data_size, prog_data_param,
+                                stats, num_stats, xfb_info, &bind_map);
 }
 
 /* Remaining work:
@@ -141,9 +231,7 @@ anv_shader_bin_write_data(const struct anv_shader_bin *shader, void *data)
  *
  * - Review prog_data struct for size and cacheability: struct
  *   brw_stage_prog_data has binding_table which uses a lot of uint32_t for 8
- *   bit quantities etc; param, pull_param, and image_params are pointers, we
- *   just need the compation map. use bit fields for all bools, eg
- *   dual_src_blend.
+ *   bit quantities etc; use bit fields for all bools, eg dual_src_blend.
  */
 
 static uint32_t
@@ -163,6 +251,18 @@ shader_bin_key_compare_func(const void *void_a, const void *void_b)
    return memcmp(a->data, b->data, a->size) == 0;
 }
 
+static uint32_t
+sha1_hash_func(const void *sha1)
+{
+   return _mesa_hash_data(sha1, 20);
+}
+
+static bool
+sha1_compare_func(const void *sha1_a, const void *sha1_b)
+{
+   return memcmp(sha1_a, sha1_b, 20) == 0;
+}
+
 void
 anv_pipeline_cache_init(struct anv_pipeline_cache *cache,
                         struct anv_device *device,
@@ -174,8 +274,11 @@ anv_pipeline_cache_init(struct anv_pipeline_cache *cache,
    if (cache_enabled) {
       cache->cache = _mesa_hash_table_create(NULL, shader_bin_key_hash_func,
                                              shader_bin_key_compare_func);
+      cache->nir_cache = _mesa_hash_table_create(NULL, sha1_hash_func,
+                                                 sha1_compare_func);
    } else {
       cache->cache = NULL;
+      cache->nir_cache = NULL;
    }
 }
 
@@ -189,12 +292,18 @@ anv_pipeline_cache_finish(struct anv_pipeline_cache *cache)
        * going away, the shader cache has to hold a reference to all shader
        * binaries it contains.  We unref them when we destroy the cache.
        */
-      struct hash_entry *entry;
       hash_table_foreach(cache->cache, entry)
          anv_shader_bin_unref(cache->device, entry->data);
 
       _mesa_hash_table_destroy(cache->cache, NULL);
    }
+
+   if (cache->nir_cache) {
+      hash_table_foreach(cache->nir_cache, entry)
+         ralloc_free(entry->data);
+
+      _mesa_hash_table_destroy(cache->nir_cache, NULL);
+   }
 }
 
 static struct anv_shader_bin *
@@ -234,14 +343,39 @@ anv_pipeline_cache_search(struct anv_pipeline_cache *cache,
    return shader;
 }
 
+static void
+anv_pipeline_cache_add_shader_bin(struct anv_pipeline_cache *cache,
+                                  struct anv_shader_bin *bin)
+{
+   if (!cache->cache)
+      return;
+
+   pthread_mutex_lock(&cache->mutex);
+
+   struct hash_entry *entry = _mesa_hash_table_search(cache->cache, bin->key);
+   if (entry == NULL) {
+      /* Take a reference for the cache */
+      anv_shader_bin_ref(bin);
+      _mesa_hash_table_insert(cache->cache, bin->key, bin);
+   }
+
+   pthread_mutex_unlock(&cache->mutex);
+}
+
 static struct anv_shader_bin *
-anv_pipeline_cache_add_shader(struct anv_pipeline_cache *cache,
-                              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 anv_pipeline_bind_map *bind_map)
+anv_pipeline_cache_add_shader_locked(struct anv_pipeline_cache *cache,
+                                     const void *key_data, uint32_t key_size,
+                                     const void *kernel_data,
+                                     uint32_t kernel_size,
+                                     const void *constant_data,
+                                     uint32_t constant_data_size,
+                                     const struct brw_stage_prog_data *prog_data,
+                                     uint32_t prog_data_size,
+                                     const void *prog_data_param,
+                                     const struct brw_compile_stats *stats,
+                                     uint32_t num_stats,
+                                     const nir_xfb_info *xfb_info,
+                                     const struct anv_pipeline_bind_map *bind_map)
 {
    struct anv_shader_bin *shader =
       anv_pipeline_cache_search_locked(cache, key_data, key_size);
@@ -251,8 +385,9 @@ anv_pipeline_cache_add_shader(struct anv_pipeline_cache *cache,
    struct anv_shader_bin *bin =
       anv_shader_bin_create(cache->device, key_data, key_size,
                             kernel_data, kernel_size,
+                            constant_data, constant_data_size,
                             prog_data, prog_data_size, prog_data_param,
-                            bind_map);
+                            stats, num_stats, xfb_info, bind_map);
    if (!bin)
       return NULL;
 
@@ -265,18 +400,26 @@ struct anv_shader_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 *constant_data,
+                                 uint32_t constant_data_size,
                                  const struct brw_stage_prog_data *prog_data,
                                  uint32_t prog_data_size,
+                                 const struct brw_compile_stats *stats,
+                                 uint32_t num_stats,
+                                 const nir_xfb_info *xfb_info,
                                  const struct anv_pipeline_bind_map *bind_map)
 {
    if (cache->cache) {
       pthread_mutex_lock(&cache->mutex);
 
       struct anv_shader_bin *bin =
-         anv_pipeline_cache_add_shader(cache, key_data, key_size,
-                                       kernel_data, kernel_size,
-                                       prog_data, prog_data_size,
-                                       prog_data->param, bind_map);
+         anv_pipeline_cache_add_shader_locked(cache, key_data, key_size,
+                                              kernel_data, kernel_size,
+                                              constant_data, constant_data_size,
+                                              prog_data, prog_data_size,
+                                              prog_data->param,
+                                              stats, num_stats,
+                                              xfb_info, bind_map);
 
       pthread_mutex_unlock(&cache->mutex);
 
@@ -289,8 +432,11 @@ anv_pipeline_cache_upload_kernel(struct anv_pipeline_cache *cache,
       /* In this case, we're not caching it so the caller owns it entirely */
       return anv_shader_bin_create(cache->device, key_data, key_size,
                                    kernel_data, kernel_size,
+                                   constant_data, constant_data_size,
                                    prog_data, prog_data_size,
-                                   prog_data->param, bind_map);
+                                   prog_data->param,
+                                   stats, num_stats,
+                                   xfb_info, bind_map);
    }
 }
 
@@ -308,14 +454,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,68 +478,15 @@ 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);
    }
 }
 
-static bool
-pipeline_cache_enabled()
-{
-   static int enabled = -1;
-   if (enabled < 0)
-      enabled = env_var_as_boolean("ANV_ENABLE_PIPELINE_CACHE", true);
-   return enabled;
-}
-
 VkResult anv_CreatePipelineCache(
     VkDevice                                    _device,
     const VkPipelineCacheCreateInfo*            pCreateInfo,
@@ -407,7 +505,8 @@ VkResult anv_CreatePipelineCache(
    if (cache == NULL)
       return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
 
-   anv_pipeline_cache_init(cache, device, pipeline_cache_enabled());
+   anv_pipeline_cache_init(cache, device,
+                           device->instance->pipeline_cache_enabled);
 
    if (pCreateInfo->initialDataSize > 0)
       anv_pipeline_cache_load(cache,
@@ -444,59 +543,53 @@ 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;
+   intptr_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;
 }
@@ -517,7 +610,6 @@ VkResult anv_MergePipelineCaches(
       if (!src->cache)
          continue;
 
-      struct hash_entry *entry;
       hash_table_foreach(src->cache, entry) {
          struct anv_shader_bin *bin = entry->data;
          assert(bin);
@@ -532,3 +624,189 @@ VkResult anv_MergePipelineCaches(
 
    return VK_SUCCESS;
 }
+
+struct anv_shader_bin *
+anv_device_search_for_kernel(struct anv_device *device,
+                             struct anv_pipeline_cache *cache,
+                             const void *key_data, uint32_t key_size,
+                             bool *user_cache_hit)
+{
+   struct anv_shader_bin *bin;
+
+   *user_cache_hit = false;
+
+   if (cache) {
+      bin = anv_pipeline_cache_search(cache, key_data, key_size);
+      if (bin) {
+         *user_cache_hit = cache != &device->default_pipeline_cache;
+         return bin;
+      }
+   }
+
+#ifdef ENABLE_SHADER_CACHE
+   struct disk_cache *disk_cache = device->instance->physicalDevice.disk_cache;
+   if (disk_cache && device->instance->pipeline_cache_enabled) {
+      cache_key cache_key;
+      disk_cache_compute_key(disk_cache, key_data, key_size, cache_key);
+
+      size_t buffer_size;
+      uint8_t *buffer = disk_cache_get(disk_cache, cache_key, &buffer_size);
+      if (buffer) {
+         struct blob_reader blob;
+         blob_reader_init(&blob, buffer, buffer_size);
+         bin = anv_shader_bin_create_from_blob(device, &blob);
+         free(buffer);
+
+         if (bin) {
+            if (cache)
+               anv_pipeline_cache_add_shader_bin(cache, bin);
+            return bin;
+         }
+      }
+   }
+#endif
+
+   return NULL;
+}
+
+struct anv_shader_bin *
+anv_device_upload_kernel(struct anv_device *device,
+                         struct anv_pipeline_cache *cache,
+                         const void *key_data, uint32_t key_size,
+                         const void *kernel_data, uint32_t kernel_size,
+                         const void *constant_data,
+                         uint32_t constant_data_size,
+                         const struct brw_stage_prog_data *prog_data,
+                         uint32_t prog_data_size,
+                         const struct brw_compile_stats *stats,
+                         uint32_t num_stats,
+                         const nir_xfb_info *xfb_info,
+                         const struct anv_pipeline_bind_map *bind_map)
+{
+   struct anv_shader_bin *bin;
+   if (cache) {
+      bin = anv_pipeline_cache_upload_kernel(cache, key_data, key_size,
+                                             kernel_data, kernel_size,
+                                             constant_data, constant_data_size,
+                                             prog_data, prog_data_size,
+                                             stats, num_stats,
+                                             xfb_info, bind_map);
+   } else {
+      bin = anv_shader_bin_create(device, key_data, key_size,
+                                  kernel_data, kernel_size,
+                                  constant_data, constant_data_size,
+                                  prog_data, prog_data_size,
+                                  prog_data->param,
+                                  stats, num_stats,
+                                  xfb_info, bind_map);
+   }
+
+   if (bin == NULL)
+      return NULL;
+
+#ifdef ENABLE_SHADER_CACHE
+   struct disk_cache *disk_cache = device->instance->physicalDevice.disk_cache;
+   if (disk_cache) {
+      struct blob binary;
+      blob_init(&binary);
+      if (anv_shader_bin_write_to_blob(bin, &binary)) {
+         cache_key cache_key;
+         disk_cache_compute_key(disk_cache, key_data, key_size, cache_key);
+
+         disk_cache_put(disk_cache, cache_key, binary.data, binary.size, NULL);
+      }
+
+      blob_finish(&binary);
+   }
+#endif
+
+   return bin;
+}
+
+struct serialized_nir {
+   unsigned char sha1_key[20];
+   size_t size;
+   char data[0];
+};
+
+struct nir_shader *
+anv_device_search_for_nir(struct anv_device *device,
+                          struct anv_pipeline_cache *cache,
+                          const nir_shader_compiler_options *nir_options,
+                          unsigned char sha1_key[20],
+                          void *mem_ctx)
+{
+   if (cache && cache->nir_cache) {
+      const struct serialized_nir *snir = NULL;
+
+      pthread_mutex_lock(&cache->mutex);
+      struct hash_entry *entry =
+         _mesa_hash_table_search(cache->nir_cache, sha1_key);
+      if (entry)
+         snir = entry->data;
+      pthread_mutex_unlock(&cache->mutex);
+
+      if (snir) {
+         struct blob_reader blob;
+         blob_reader_init(&blob, snir->data, snir->size);
+
+         nir_shader *nir = nir_deserialize(mem_ctx, nir_options, &blob);
+         if (blob.overrun) {
+            ralloc_free(nir);
+         } else {
+            return nir;
+         }
+      }
+   }
+
+   return NULL;
+}
+
+void
+anv_device_upload_nir(struct anv_device *device,
+                      struct anv_pipeline_cache *cache,
+                      const struct nir_shader *nir,
+                      unsigned char sha1_key[20])
+{
+   if (cache && cache->nir_cache) {
+      pthread_mutex_lock(&cache->mutex);
+      struct hash_entry *entry =
+         _mesa_hash_table_search(cache->nir_cache, sha1_key);
+      pthread_mutex_unlock(&cache->mutex);
+      if (entry)
+         return;
+
+      struct blob blob;
+      blob_init(&blob);
+
+      nir_serialize(&blob, nir, false);
+      if (blob.out_of_memory) {
+         blob_finish(&blob);
+         return;
+      }
+
+      pthread_mutex_lock(&cache->mutex);
+      /* Because ralloc isn't thread-safe, we have to do all this inside the
+       * lock.  We could unlock for the big memcpy but it's probably not worth
+       * the hassle.
+       */
+      entry = _mesa_hash_table_search(cache->nir_cache, sha1_key);
+      if (entry) {
+         blob_finish(&blob);
+         pthread_mutex_unlock(&cache->mutex);
+         return;
+      }
+
+      struct serialized_nir *snir =
+         ralloc_size(cache->nir_cache, sizeof(*snir) + blob.size);
+      memcpy(snir->sha1_key, sha1_key, 20);
+      snir->size = blob.size;
+      memcpy(snir->data, blob.data, blob.size);
+
+      blob_finish(&blob);
+
+      _mesa_hash_table_insert(cache->nir_cache, snir->sha1_key, snir);
+
+      pthread_mutex_unlock(&cache->mutex);
+   }
+}