radv: skip draw calls with 0-sized index buffers

[mesa.git] / src / amd / vulkan / radv_pipeline_cache.c

diff --git a/src/amd/vulkan/radv_pipeline_cache.c b/src/amd/vulkan/radv_pipeline_cache.c
index 9f01191a2f67024d5a64d7cf9e82fa06c5e8640a..b773de30c326b73003520dda79fbe4ab075ebe3a 100644 (file)
--- a/src/amd/vulkan/radv_pipeline_cache.c
+++ b/src/amd/vulkan/radv_pipeline_cache.c
@@ -31,18 +31,12 @@
 
 #include "ac_nir_to_llvm.h"
 
-struct cache_entry_variant_info {
-       struct radv_shader_variant_info variant_info;
-       struct ac_shader_config config;
-       uint32_t rsrc1, rsrc2;
-};
-
 struct cache_entry {
        union {
                unsigned char sha1[20];
                uint32_t sha1_dw[5];
        };
-       uint32_t code_sizes[MESA_SHADER_STAGES];
+       uint32_t binary_sizes[MESA_SHADER_STAGES];
        struct radv_shader_variant *variants[MESA_SHADER_STAGES];
        char code[0];
 };
@@ -93,8 +87,8 @@ entry_size(struct cache_entry *entry)
 {
        size_t ret = sizeof(*entry);
        for (int i = 0; i < MESA_SHADER_STAGES; ++i)
-               if (entry->code_sizes[i])
-                       ret += sizeof(struct cache_entry_variant_info) + entry->code_sizes[i];
+               if (entry->binary_sizes[i])
+                       ret += entry->binary_sizes[i];
        return ret;
 }
 
@@ -255,18 +249,23 @@ bool
 radv_create_shader_variants_from_pipeline_cache(struct radv_device *device,
                                                struct radv_pipeline_cache *cache,
                                                const unsigned char *sha1,
-                                               struct radv_shader_variant **variants)
+                                               struct radv_shader_variant **variants,
+                                               bool *found_in_application_cache)
 {
        struct cache_entry *entry;
 
-       if (!cache)
+       if (!cache) {
                cache = device->mem_cache;
+               *found_in_application_cache = false;
+       }
 
        pthread_mutex_lock(&cache->mutex);
 
        entry = radv_pipeline_cache_search_unlocked(cache, sha1);
 
        if (!entry) {
+               *found_in_application_cache = false;
+
                /* Don't cache when we want debug info, since this isn't
                 * present in the cache.
                 */
@@ -304,33 +303,15 @@ radv_create_shader_variants_from_pipeline_cache(struct radv_device *device,
 
        char *p = entry->code;
        for(int i = 0; i < MESA_SHADER_STAGES; ++i) {
-               if (!entry->variants[i] && entry->code_sizes[i]) {
-                       struct radv_shader_variant *variant;
-                       struct cache_entry_variant_info info;
-
-                       variant = calloc(1, sizeof(struct radv_shader_variant));
-                       if (!variant) {
-                               pthread_mutex_unlock(&cache->mutex);
-                               return false;
-                       }
-
-                       memcpy(&info, p, sizeof(struct cache_entry_variant_info));
-                       p += sizeof(struct cache_entry_variant_info);
-
-                       variant->config = info.config;
-                       variant->info = info.variant_info;
-                       variant->rsrc1 = info.rsrc1;
-                       variant->rsrc2 = info.rsrc2;
-                       variant->code_size = entry->code_sizes[i];
-                       variant->ref_count = 1;
-
-                       void *ptr = radv_alloc_shader_memory(device, variant);
-                       memcpy(ptr, p, entry->code_sizes[i]);
-                       p += entry->code_sizes[i];
-
-                       entry->variants[i] = variant;
-               } else if (entry->code_sizes[i]) {
-                       p += sizeof(struct cache_entry_variant_info) + entry->code_sizes[i];
+               if (!entry->variants[i] && entry->binary_sizes[i]) {
+                       struct radv_shader_binary *binary = calloc(1, entry->binary_sizes[i]);
+                       memcpy(binary, p, entry->binary_sizes[i]);
+                       p += entry->binary_sizes[i];
+
+                       entry->variants[i] = radv_shader_variant_create(device, binary);
+                       free(binary);
+               } else if (entry->binary_sizes[i]) {
+                       p += entry->binary_sizes[i];
                }
 
        }
@@ -349,8 +330,7 @@ radv_pipeline_cache_insert_shaders(struct radv_device *device,
                                   struct radv_pipeline_cache *cache,
                                   const unsigned char *sha1,
                                   struct radv_shader_variant **variants,
-                                  const void *const *codes,
-                                  const unsigned *code_sizes)
+                                  struct radv_shader_binary *const *binaries)
 {
        if (!cache)
                cache = device->mem_cache;
@@ -383,7 +363,7 @@ radv_pipeline_cache_insert_shaders(struct radv_device *device,
        size_t size = sizeof(*entry);
        for (int i = 0; i < MESA_SHADER_STAGES; ++i)
                if (variants[i])
-                       size += sizeof(struct cache_entry_variant_info) + code_sizes[i];
+                       size += binaries[i]->total_size;
 
 
        entry = vk_alloc(&cache->alloc, size, 8,
@@ -397,24 +377,15 @@ radv_pipeline_cache_insert_shaders(struct radv_device *device,
        memcpy(entry->sha1, sha1, 20);
 
        char* p = entry->code;
-       struct cache_entry_variant_info info;
-       memset(&info, 0, sizeof(info));
 
        for (int i = 0; i < MESA_SHADER_STAGES; ++i) {
                if (!variants[i])
                        continue;
 
-               entry->code_sizes[i] = code_sizes[i];
-
-               info.config = variants[i]->config;
-               info.variant_info = variants[i]->info;
-               info.rsrc1 = variants[i]->rsrc1;
-               info.rsrc2 = variants[i]->rsrc2;
-               memcpy(p, &info, sizeof(struct cache_entry_variant_info));
-               p += sizeof(struct cache_entry_variant_info);
+               entry->binary_sizes[i] = binaries[i]->total_size;
 
-               memcpy(p, codes[i], code_sizes[i]);
-               p += code_sizes[i];
+               memcpy(p, binaries[i], binaries[i]->total_size);
+               p += binaries[i]->total_size;
        }
 
        /* Always add cache items to disk. This will allow collection of