anv: Drop the instance pointer from anv_device

[mesa.git] / src / intel / vulkan / anv_pipeline_cache.c

diff --git a/src/intel/vulkan/anv_pipeline_cache.c b/src/intel/vulkan/anv_pipeline_cache.c
index bc7dd100e2baa8fccaf2872842790e6dafc9678e..1684198a2e0e183fecfec45ebd6a0412374c62ab 100644 (file)
--- a/src/intel/vulkan/anv_pipeline_cache.c
+++ b/src/intel/vulkan/anv_pipeline_cache.c
@@ -21,7 +21,7 @@
  * IN THE SOFTWARE.
  */
 
-#include "compiler/blob.h"
+#include "util/blob.h"
 #include "util/hash_table.h"
 #include "util/debug.h"
 #include "util/disk_cache.h"
@@ -37,6 +37,7 @@ anv_shader_bin_create(struct anv_device *device,
                       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)
 {
@@ -93,6 +94,10 @@ anv_shader_bin_create(struct anv_device *device,
    shader->prog_data = prog_data;
    shader->prog_data_size = prog_data_size;
 
+   assert(num_stats <= ARRAY_SIZE(shader->stats));
+   typed_memcpy(shader->stats, stats, num_stats);
+   shader->num_stats = num_stats;
+
    if (xfb_info_in) {
       *xfb_info = *xfb_info_in;
       typed_memcpy(xfb_info->outputs, xfb_info_in->outputs,
@@ -143,6 +148,10 @@ anv_shader_bin_write_to_blob(const struct anv_shader_bin *shader,
                     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);
@@ -152,15 +161,22 @@ anv_shader_bin_write_to_blob(const struct anv_shader_bin *shader,
       blob_write_uint32(blob, 0);
    }
 
+   blob_write_bytes(blob, shader->bind_map.surface_sha1,
+                    sizeof(shader->bind_map.surface_sha1));
+   blob_write_bytes(blob, shader->bind_map.sampler_sha1,
+                    sizeof(shader->bind_map.sampler_sha1));
+   blob_write_bytes(blob, shader->bind_map.push_sha1,
+                    sizeof(shader->bind_map.push_sha1));
    blob_write_uint32(blob, shader->bind_map.surface_count);
    blob_write_uint32(blob, shader->bind_map.sampler_count);
-   blob_write_uint32(blob, shader->bind_map.image_param_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));
+   blob_write_bytes(blob, shader->bind_map.push_ranges,
+                    sizeof(shader->bind_map.push_ranges));
 
    return !blob->out_of_memory;
 }
@@ -186,21 +202,28 @@ anv_shader_bin_create_from_blob(struct anv_device *device,
    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;
+   blob_copy_bytes(blob, bind_map.surface_sha1, sizeof(bind_map.surface_sha1));
+   blob_copy_bytes(blob, bind_map.sampler_sha1, sizeof(bind_map.sampler_sha1));
+   blob_copy_bytes(blob, bind_map.push_sha1, sizeof(bind_map.push_sha1));
    bind_map.surface_count = blob_read_uint32(blob);
    bind_map.sampler_count = blob_read_uint32(blob);
-   bind_map.image_param_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));
+   blob_copy_bytes(blob, bind_map.push_ranges, sizeof(bind_map.push_ranges));
 
    if (blob->overrun)
       return NULL;
@@ -210,7 +233,7 @@ anv_shader_bin_create_from_blob(struct anv_device *device,
                                 kernel_data, kernel_size,
                                 constant_data, constant_data_size,
                                 prog_data, prog_data_size, prog_data_param,
-                                xfb_info, &bind_map);
+                                stats, num_stats, xfb_info, &bind_map);
 }
 
 /* Remaining work:
@@ -361,6 +384,8 @@ anv_pipeline_cache_add_shader_locked(struct anv_pipeline_cache *cache,
                                      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)
 {
@@ -374,7 +399,7 @@ anv_pipeline_cache_add_shader_locked(struct anv_pipeline_cache *cache,
                             kernel_data, kernel_size,
                             constant_data, constant_data_size,
                             prog_data, prog_data_size, prog_data_param,
-                            xfb_info, bind_map);
+                            stats, num_stats, xfb_info, bind_map);
    if (!bin)
       return NULL;
 
@@ -391,6 +416,8 @@ anv_pipeline_cache_upload_kernel(struct anv_pipeline_cache *cache,
                                  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)
 {
@@ -403,6 +430,7 @@ anv_pipeline_cache_upload_kernel(struct anv_pipeline_cache *cache,
                                               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);
@@ -419,6 +447,7 @@ anv_pipeline_cache_upload_kernel(struct anv_pipeline_cache *cache,
                                    constant_data, constant_data_size,
                                    prog_data, prog_data_size,
                                    prog_data->param,
+                                   stats, num_stats,
                                    xfb_info, bind_map);
    }
 }
@@ -436,7 +465,7 @@ anv_pipeline_cache_load(struct anv_pipeline_cache *cache,
                         const void *data, size_t size)
 {
    struct anv_device *device = cache->device;
-   struct anv_physical_device *pdevice = &device->instance->physicalDevice;
+   struct anv_physical_device *pdevice = device->physical;
 
    if (cache->cache == NULL)
       return;
@@ -489,7 +518,7 @@ VkResult anv_CreatePipelineCache(
       return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
 
    anv_pipeline_cache_init(cache, device,
-                           device->instance->pipeline_cache_enabled);
+                           device->physical->instance->pipeline_cache_enabled);
 
    if (pCreateInfo->initialDataSize > 0)
       anv_pipeline_cache_load(cache,
@@ -525,7 +554,6 @@ 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 blob blob;
    if (pData) {
@@ -540,7 +568,7 @@ VkResult anv_GetPipelineCacheData(
       .vendor_id = 0x8086,
       .device_id = device->chipset_id,
    };
-   memcpy(header.uuid, pdevice->pipeline_cache_uuid, VK_UUID_SIZE);
+   memcpy(header.uuid, device->physical->pipeline_cache_uuid, VK_UUID_SIZE);
    blob_write_bytes(&blob, &header, sizeof(header));
 
    uint32_t count = 0;
@@ -627,8 +655,8 @@ anv_device_search_for_kernel(struct anv_device *device,
    }
 
 #ifdef ENABLE_SHADER_CACHE
-   struct disk_cache *disk_cache = device->instance->physicalDevice.disk_cache;
-   if (disk_cache && device->instance->pipeline_cache_enabled) {
+   struct disk_cache *disk_cache = device->physical->disk_cache;
+   if (disk_cache && device->physical->instance->pipeline_cache_enabled) {
       cache_key cache_key;
       disk_cache_compute_key(disk_cache, key_data, key_size, cache_key);
 
@@ -661,6 +689,8 @@ anv_device_upload_kernel(struct anv_device *device,
                          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)
 {
@@ -670,6 +700,7 @@ anv_device_upload_kernel(struct anv_device *device,
                                              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,
@@ -677,6 +708,7 @@ anv_device_upload_kernel(struct anv_device *device,
                                   constant_data, constant_data_size,
                                   prog_data, prog_data_size,
                                   prog_data->param,
+                                  stats, num_stats,
                                   xfb_info, bind_map);
    }
 
@@ -684,7 +716,7 @@ anv_device_upload_kernel(struct anv_device *device,
       return NULL;
 
 #ifdef ENABLE_SHADER_CACHE
-   struct disk_cache *disk_cache = device->instance->physicalDevice.disk_cache;
+   struct disk_cache *disk_cache = device->physical->disk_cache;
    if (disk_cache) {
       struct blob binary;
       blob_init(&binary);
@@ -758,7 +790,7 @@ anv_device_upload_nir(struct anv_device *device,
       struct blob blob;
       blob_init(&blob);
 
-      nir_serialize(&blob, nir);
+      nir_serialize(&blob, nir, false);
       if (blob.out_of_memory) {
          blob_finish(&blob);
          return;