src/vulkan/anv_pipeline_cache.c

   1 /*
   2  * Copyright © 2015 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include "util/mesa-sha1.h"
  25 #include "util/debug.h"
  26 #include "anv_private.h"
  27
  28 /* Remaining work:
  29  *
  30  * - Compact binding table layout so it's tight and not dependent on
  31  *   descriptor set layout.
  32  *
  33  * - Review prog_data struct for size and cacheability: struct
  34  *   brw_stage_prog_data has binding_table which uses a lot of uint32_t for 8
  35  *   bit quantities etc; param, pull_param, and image_params are pointers, we
  36  *   just need the compation map. use bit fields for all bools, eg
  37  *   dual_src_blend.
  38  */
  39
  40 void
  41 anv_pipeline_cache_init(struct anv_pipeline_cache *cache,
  42                         struct anv_device *device)
  43 {
  44    cache->device = device;
  45    anv_state_stream_init(&cache->program_stream,
  46                          &device->instruction_block_pool);
  47    pthread_mutex_init(&cache->mutex, NULL);
  48
  49    cache->kernel_count = 0;
  50    cache->total_size = 0;
  51    cache->table_size = 1024;
  52    const size_t byte_size = cache->table_size * sizeof(cache->table[0]);
  53    cache->table = malloc(byte_size);
  54
  55    /* We don't consider allocation failure fatal, we just start with a 0-sized
  56     * cache. */
  57    if (cache->table == NULL)
  58       cache->table_size = 0;
  59    else
  60       memset(cache->table, 0xff, byte_size);
  61 }
  62
  63 void
  64 anv_pipeline_cache_finish(struct anv_pipeline_cache *cache)
  65 {
  66    anv_state_stream_finish(&cache->program_stream);
  67    pthread_mutex_destroy(&cache->mutex);
  68    free(cache->table);
  69 }
  70
  71 struct cache_entry {
  72    unsigned char sha1[20];
  73    uint32_t prog_data_size;
  74    uint32_t kernel_size;
  75    char prog_data[0];
  76
  77    /* kernel follows prog_data at next 64 byte aligned address */
  78 };
  79
  80 void
  81 anv_hash_shader(unsigned char *hash, const void *key, size_t key_size,
  82                 struct anv_shader_module *module,
  83                 const char *entrypoint,
  84                 const VkSpecializationInfo *spec_info)
  85 {
  86    struct mesa_sha1 *ctx;
  87
  88    ctx = _mesa_sha1_init();
  89    _mesa_sha1_update(ctx, &key, sizeof(key));
  90    _mesa_sha1_update(ctx, module->sha1, sizeof(module->sha1));
  91    _mesa_sha1_update(ctx, entrypoint, strlen(entrypoint));
  92    /* hash in shader stage, pipeline layout? */
  93    if (spec_info) {
  94       _mesa_sha1_update(ctx, spec_info->pMapEntries,
  95                         spec_info->mapEntryCount * sizeof spec_info->pMapEntries[0]);
  96       _mesa_sha1_update(ctx, spec_info->pData, spec_info->dataSize);
  97    }
  98    _mesa_sha1_final(ctx, hash);
  99 }
 100
 101 uint32_t
 102 anv_pipeline_cache_search(struct anv_pipeline_cache *cache,
 103                           const unsigned char *sha1, void *prog_data)
 104 {
 105    const uint32_t mask = cache->table_size - 1;
 106    const uint32_t start = (*(uint32_t *) sha1);
 107
 108    for (uint32_t i = 0; i < cache->table_size; i++) {
 109       const uint32_t index = (start + i) & mask;
 110       const uint32_t offset = cache->table[index];
 111
 112       if (offset == ~0)
 113          return NO_KERNEL;
 114
 115       struct cache_entry *entry =
 116          cache->program_stream.block_pool->map + offset;
 117       if (memcmp(entry->sha1, sha1, sizeof(entry->sha1)) == 0) {
 118          if (prog_data)
 119             memcpy(prog_data, entry->prog_data, entry->prog_data_size);
 120
 121          const uint32_t preamble_size =
 122             align_u32(sizeof(*entry) + entry->prog_data_size, 64);
 123
 124          return offset + preamble_size;
 125       }
 126    }
 127
 128    return NO_KERNEL;
 129 }
 130
 131 static void
 132 anv_pipeline_cache_add_entry(struct anv_pipeline_cache *cache,
 133                              struct cache_entry *entry, uint32_t entry_offset)
 134 {
 135    const uint32_t mask = cache->table_size - 1;
 136    const uint32_t start = (*(uint32_t *) entry->sha1);
 137
 138    /* We'll always be able to insert when we get here. */
 139    assert(cache->kernel_count < cache->table_size / 2);
 140
 141    for (uint32_t i = 0; i < cache->table_size; i++) {
 142       const uint32_t index = (start + i) & mask;
 143       if (cache->table[index] == ~0) {
 144          cache->table[index] = entry_offset;
 145          break;
 146       }
 147    }
 148
 149    /* We don't include the alignment padding bytes when we serialize, so
 150     * don't include taht in the the total size. */
 151    cache->total_size +=
 152       sizeof(*entry) + entry->prog_data_size + entry->kernel_size;
 153    cache->kernel_count++;
 154 }
 155
 156 static VkResult
 157 anv_pipeline_cache_grow(struct anv_pipeline_cache *cache)
 158 {
 159    const uint32_t table_size = cache->table_size * 2;
 160    const uint32_t old_table_size = cache->table_size;
 161    const size_t byte_size = table_size * sizeof(cache->table[0]);
 162    uint32_t *table;
 163    uint32_t *old_table = cache->table;
 164
 165    table = malloc(byte_size);
 166    if (table == NULL)
 167       return VK_ERROR_OUT_OF_HOST_MEMORY;
 168
 169    cache->table = table;
 170    cache->table_size = table_size;
 171    cache->kernel_count = 0;
 172    cache->total_size = 0;
 173
 174    memset(cache->table, 0xff, byte_size);
 175    for (uint32_t i = 0; i < old_table_size; i++) {
 176       const uint32_t offset = old_table[i];
 177       if (offset == ~0)
 178          continue;
 179
 180       struct cache_entry *entry =
 181          cache->program_stream.block_pool->map + offset;
 182       anv_pipeline_cache_add_entry(cache, entry, offset);
 183    }
 184
 185    free(old_table);
 186
 187    return VK_SUCCESS;
 188 }
 189
 190 uint32_t
 191 anv_pipeline_cache_upload_kernel(struct anv_pipeline_cache *cache,
 192                                  const unsigned char *sha1,
 193                                  const void *kernel, size_t kernel_size,
 194                                  const void *prog_data, size_t prog_data_size)
 195 {
 196    pthread_mutex_lock(&cache->mutex);
 197    struct cache_entry *entry;
 198
 199    /* Meta pipelines don't have SPIR-V, so we can't hash them.
 200     * Consequentally, they just don't get cached.
 201     */
 202    const uint32_t preamble_size = sha1 ?
 203       align_u32(sizeof(*entry) + prog_data_size, 64) :
 204       0;
 205
 206    const uint32_t size = preamble_size + kernel_size;
 207
 208    assert(size < cache->program_stream.block_pool->block_size);
 209    const struct anv_state state =
 210       anv_state_stream_alloc(&cache->program_stream, size, 64);
 211
 212    if (sha1 && env_var_as_boolean("ANV_ENABLE_PIPELINE_CACHE", false)) {
 213       assert(anv_pipeline_cache_search(cache, sha1, NULL) == NO_KERNEL);
 214       entry = state.map;
 215       memcpy(entry->sha1, sha1, sizeof(entry->sha1));
 216       entry->prog_data_size = prog_data_size;
 217       memcpy(entry->prog_data, prog_data, prog_data_size);
 218       entry->kernel_size = kernel_size;
 219
 220       if (cache->kernel_count == cache->table_size / 2)
 221          anv_pipeline_cache_grow(cache);
 222
 223       /* Failing to grow that hash table isn't fatal, but may mean we don't
 224        * have enough space to add this new kernel. Only add it if there's room.
 225        */
 226       if (cache->kernel_count < cache->table_size / 2)
 227          anv_pipeline_cache_add_entry(cache, entry, state.offset);
 228    }
 229
 230    pthread_mutex_unlock(&cache->mutex);
 231
 232    memcpy(state.map + preamble_size, kernel, kernel_size);
 233
 234    if (!cache->device->info.has_llc)
 235       anv_state_clflush(state);
 236
 237    return state.offset + preamble_size;
 238 }
 239
 240 static void
 241 anv_pipeline_cache_load(struct anv_pipeline_cache *cache,
 242                         const void *data, size_t size)
 243 {
 244    struct anv_device *device = cache->device;
 245    uint8_t uuid[VK_UUID_SIZE];
 246    struct {
 247       uint32_t device_id;
 248       uint8_t uuid[VK_UUID_SIZE];
 249    } header;
 250
 251    if (size < sizeof(header))
 252       return;
 253    memcpy(&header, data, sizeof(header));
 254    if (header.device_id != device->chipset_id)
 255       return;
 256    anv_device_get_cache_uuid(uuid);
 257    if (memcmp(header.uuid, uuid, VK_UUID_SIZE) != 0)
 258       return;
 259
 260    const void *end = data + size;
 261    const void *p = data + sizeof(header);
 262
 263    while (p < end) {
 264       /* The kernels aren't 64 byte aligned in the serialized format so
 265        * they're always right after the prog_data.
 266        */
 267       const struct cache_entry *entry = p;
 268       const void *kernel = &entry->prog_data[entry->prog_data_size];
 269
 270       anv_pipeline_cache_upload_kernel(cache, entry->sha1,
 271                                        kernel, entry->kernel_size,
 272                                        entry->prog_data, entry->prog_data_size);
 273       p = kernel + entry->kernel_size;
 274    }
 275 }
 276
 277 VkResult anv_CreatePipelineCache(
 278     VkDevice                                    _device,
 279     const VkPipelineCacheCreateInfo*            pCreateInfo,
 280     const VkAllocationCallbacks*                pAllocator,
 281     VkPipelineCache*                            pPipelineCache)
 282 {
 283    ANV_FROM_HANDLE(anv_device, device, _device);
 284    struct anv_pipeline_cache *cache;
 285
 286    assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO);
 287    assert(pCreateInfo->flags == 0);
 288
 289    cache = anv_alloc2(&device->alloc, pAllocator,
 290                        sizeof(*cache), 8,
 291                        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
 292    if (cache == NULL)
 293       return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
 294
 295    anv_pipeline_cache_init(cache, device);
 296
 297    if (pCreateInfo->initialDataSize > 0)
 298       anv_pipeline_cache_load(cache,
 299                               pCreateInfo->pInitialData,
 300                               pCreateInfo->initialDataSize);
 301
 302    *pPipelineCache = anv_pipeline_cache_to_handle(cache);
 303
 304    return VK_SUCCESS;
 305 }
 306
 307 void anv_DestroyPipelineCache(
 308     VkDevice                                    _device,
 309     VkPipelineCache                             _cache,
 310     const VkAllocationCallbacks*                pAllocator)
 311 {
 312    ANV_FROM_HANDLE(anv_device, device, _device);
 313    ANV_FROM_HANDLE(anv_pipeline_cache, cache, _cache);
 314
 315    anv_pipeline_cache_finish(cache);
 316
 317    anv_free2(&device->alloc, pAllocator, cache);
 318 }
 319
 320 VkResult anv_GetPipelineCacheData(
 321     VkDevice                                    _device,
 322     VkPipelineCache                             _cache,
 323     size_t*                                     pDataSize,
 324     void*                                       pData)
 325 {
 326    ANV_FROM_HANDLE(anv_device, device, _device);
 327    ANV_FROM_HANDLE(anv_pipeline_cache, cache, _cache);
 328
 329    const size_t size = 4 + VK_UUID_SIZE + cache->total_size;
 330
 331    if (pData == NULL) {
 332       *pDataSize = size;
 333       return VK_SUCCESS;
 334    }
 335
 336    if (*pDataSize < size) {
 337       *pDataSize = 0;
 338       return VK_INCOMPLETE;
 339    }
 340
 341    void *p = pData;
 342    memcpy(p, &device->chipset_id, sizeof(device->chipset_id));
 343    p += sizeof(device->chipset_id);
 344
 345    anv_device_get_cache_uuid(p);
 346    p += VK_UUID_SIZE;
 347
 348    struct cache_entry *entry;
 349    for (uint32_t i = 0; i < cache->table_size; i++) {
 350       if (cache->table[i] == ~0)
 351          continue;
 352
 353       entry = cache->program_stream.block_pool->map + cache->table[i];
 354
 355       memcpy(p, entry, sizeof(*entry) + entry->prog_data_size);
 356       p += sizeof(*entry) + entry->prog_data_size;
 357
 358       void *kernel = (void *) entry +
 359          align_u32(sizeof(*entry) + entry->prog_data_size, 64);
 360
 361       memcpy(p, kernel, entry->kernel_size);
 362       p += entry->kernel_size;
 363    }
 364
 365    return VK_SUCCESS;
 366 }
 367
 368 static void
 369 anv_pipeline_cache_merge(struct anv_pipeline_cache *dst,
 370                          struct anv_pipeline_cache *src)
 371 {
 372    for (uint32_t i = 0; i < src->table_size; i++) {
 373       if (src->table[i] == ~0)
 374          continue;
 375
 376       struct cache_entry *entry =
 377          src->program_stream.block_pool->map + src->table[i];
 378
 379       if (anv_pipeline_cache_search(dst, entry->sha1, NULL) != NO_KERNEL)
 380          continue;
 381
 382       const void *kernel = (void *) entry +
 383          align_u32(sizeof(*entry) + entry->prog_data_size, 64);
 384       anv_pipeline_cache_upload_kernel(dst, entry->sha1,
 385                                        kernel, entry->kernel_size,
 386                                        entry->prog_data, entry->prog_data_size);
 387    }
 388 }
 389
 390 VkResult anv_MergePipelineCaches(
 391     VkDevice                                    _device,
 392     VkPipelineCache                             destCache,
 393     uint32_t                                    srcCacheCount,
 394     const VkPipelineCache*                      pSrcCaches)
 395 {
 396    ANV_FROM_HANDLE(anv_pipeline_cache, dst, destCache);
 397
 398    for (uint32_t i = 0; i < srcCacheCount; i++) {
 399       ANV_FROM_HANDLE(anv_pipeline_cache, src, pSrcCaches[i]);
 400
 401       anv_pipeline_cache_merge(dst, src);
 402    }
 403
 404    return VK_SUCCESS;
 405 }