2 * Copyright © 2014 Intel Corporation
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:
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
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
24 #ifdef ENABLE_SHADER_CACHE
32 #include <sys/types.h>
34 #include <sys/statvfs.h>
43 #include "util/crc32.h"
44 #include "util/rand_xor.h"
45 #include "util/u_atomic.h"
46 #include "util/u_queue.h"
47 #include "util/mesa-sha1.h"
48 #include "util/ralloc.h"
49 #include "main/errors.h"
50 #include "util/macros.h"
52 #include "disk_cache.h"
54 /* Number of bits to mask off from a cache key to get an index. */
55 #define CACHE_INDEX_KEY_BITS 16
57 /* Mask for computing an index from a key. */
58 #define CACHE_INDEX_KEY_MASK ((1 << CACHE_INDEX_KEY_BITS) - 1)
60 /* The number of keys that can be stored in the index. */
61 #define CACHE_INDEX_MAX_KEYS (1 << CACHE_INDEX_KEY_BITS)
64 /* The path to the cache directory. */
67 /* Thread queue for compressing and writing cache entries to disk */
68 struct util_queue cache_queue
;
70 /* Seed for rand, which is used to pick a random directory */
71 uint64_t seed_xorshift128plus
[2];
73 /* A pointer to the mmapped index file within the cache directory. */
75 size_t index_mmap_size
;
77 /* Pointer to total size of all objects in cache (within index_mmap) */
80 /* Pointer to stored keys, (within index_mmap). */
83 /* Maximum size of all cached objects (in bytes). */
86 /* Driver cache keys. */
87 uint8_t *driver_keys_blob
;
88 size_t driver_keys_blob_size
;
91 struct disk_cache_put_job
{
92 struct util_queue_fence fence
;
94 struct disk_cache
*cache
;
98 /* Copy of cache data to be compressed and written. */
101 /* Size of data to be compressed and written. */
105 /* Create a directory named 'path' if it does not already exist.
107 * Returns: 0 if path already exists as a directory or if created.
108 * -1 in all other cases.
111 mkdir_if_needed(const char *path
)
115 /* If the path exists already, then our work is done if it's a
116 * directory, but it's an error if it is not.
118 if (stat(path
, &sb
) == 0) {
119 if (S_ISDIR(sb
.st_mode
)) {
122 fprintf(stderr
, "Cannot use %s for shader cache (not a directory)"
123 "---disabling.\n", path
);
128 int ret
= mkdir(path
, 0755);
129 if (ret
== 0 || (ret
== -1 && errno
== EEXIST
))
132 fprintf(stderr
, "Failed to create %s for shader cache (%s)---disabling.\n",
133 path
, strerror(errno
));
138 /* Concatenate an existing path and a new name to form a new path. If the new
139 * path does not exist as a directory, create it then return the resulting
140 * name of the new path (ralloc'ed off of 'ctx').
142 * Returns NULL on any error, such as:
144 * <path> does not exist or is not a directory
145 * <path>/<name> exists but is not a directory
146 * <path>/<name> cannot be created as a directory
149 concatenate_and_mkdir(void *ctx
, const char *path
, const char *name
)
154 if (stat(path
, &sb
) != 0 || ! S_ISDIR(sb
.st_mode
))
157 new_path
= ralloc_asprintf(ctx
, "%s/%s", path
, name
);
159 if (mkdir_if_needed(new_path
) == 0)
166 create_mesa_cache_dir(void *mem_ctx
, const char *path
, const char *gpu_name
)
168 char *new_path
= concatenate_and_mkdir(mem_ctx
, path
, "mesa");
169 if (new_path
== NULL
)
172 /* Create a parent architecture directory so that we don't remove cache
173 * files for other architectures. In theory we could share the cache
174 * between architectures but we have no way of knowing if they were created
175 * by a compatible Mesa version.
177 new_path
= concatenate_and_mkdir(mem_ctx
, new_path
, get_arch_bitness_str());
178 if (new_path
== NULL
)
181 new_path
= concatenate_and_mkdir(mem_ctx
, new_path
, gpu_name
);
182 if (new_path
== NULL
)
189 disk_cache_create(const char *gpu_name
, const char *timestamp
)
192 struct disk_cache
*cache
= NULL
;
193 char *path
, *max_size_str
;
197 struct statvfs vfs
= { 0 };
200 /* If running as a users other than the real user disable cache */
201 if (geteuid() != getuid())
204 /* A ralloc context for transient data during this invocation. */
205 local
= ralloc_context(NULL
);
209 /* At user request, disable shader cache entirely. */
210 if (getenv("MESA_GLSL_CACHE_DISABLE"))
213 /* Determine path for cache based on the first defined name as follows:
215 * $MESA_GLSL_CACHE_DIR
216 * $XDG_CACHE_HOME/mesa
217 * <pwd.pw_dir>/.cache/mesa
219 path
= getenv("MESA_GLSL_CACHE_DIR");
221 if (mkdir_if_needed(path
) == -1)
224 path
= create_mesa_cache_dir(local
, path
, gpu_name
);
230 char *xdg_cache_home
= getenv("XDG_CACHE_HOME");
232 if (xdg_cache_home
) {
233 if (mkdir_if_needed(xdg_cache_home
) == -1)
236 path
= create_mesa_cache_dir(local
, xdg_cache_home
, gpu_name
);
245 struct passwd pwd
, *result
;
247 buf_size
= sysconf(_SC_GETPW_R_SIZE_MAX
);
251 /* Loop until buf_size is large enough to query the directory */
253 buf
= ralloc_size(local
, buf_size
);
255 getpwuid_r(getuid(), &pwd
, buf
, buf_size
, &result
);
259 if (errno
== ERANGE
) {
268 path
= concatenate_and_mkdir(local
, pwd
.pw_dir
, ".cache");
272 path
= create_mesa_cache_dir(local
, path
, gpu_name
);
277 cache
= ralloc(NULL
, struct disk_cache
);
281 cache
->path
= ralloc_strdup(cache
, path
);
282 if (cache
->path
== NULL
)
285 path
= ralloc_asprintf(local
, "%s/index", cache
->path
);
289 fd
= open(path
, O_RDWR
| O_CREAT
| O_CLOEXEC
, 0644);
293 if (fstat(fd
, &sb
) == -1)
296 /* Force the index file to be the expected size. */
297 size
= sizeof(*cache
->size
) + CACHE_INDEX_MAX_KEYS
* CACHE_KEY_SIZE
;
298 if (sb
.st_size
!= size
) {
299 if (ftruncate(fd
, size
) == -1)
303 /* We map this shared so that other processes see updates that we
306 * Note: We do use atomic addition to ensure that multiple
307 * processes don't scramble the cache size recorded in the
308 * index. But we don't use any locking to prevent multiple
309 * processes from updating the same entry simultaneously. The idea
310 * is that if either result lands entirely in the index, then
311 * that's equivalent to a well-ordered write followed by an
312 * eviction and a write. On the other hand, if the simultaneous
313 * writes result in a corrupt entry, that's not really any
314 * different than both entries being evicted, (since within the
315 * guarantees of the cryptographic hash, a corrupt entry is
316 * unlikely to ever match a real cache key).
318 cache
->index_mmap
= mmap(NULL
, size
, PROT_READ
| PROT_WRITE
,
320 if (cache
->index_mmap
== MAP_FAILED
)
322 cache
->index_mmap_size
= size
;
326 cache
->size
= (uint64_t *) cache
->index_mmap
;
327 cache
->stored_keys
= cache
->index_mmap
+ sizeof(uint64_t);
331 max_size_str
= getenv("MESA_GLSL_CACHE_MAX_SIZE");
334 max_size
= strtoul(max_size_str
, &end
, 10);
335 if (end
== max_size_str
) {
345 max_size
*= 1024*1024;
351 max_size
*= 1024*1024*1024;
357 /* Default to 1GB or 10% of filesystem for maximum cache size. */
360 max_size
= MAX2(1024*1024*1024, vfs
.f_blocks
* vfs
.f_bsize
/ 10);
363 cache
->max_size
= max_size
;
365 /* A limit of 32 jobs was choosen as observations of Deus Ex start-up times
366 * showed that we reached at most 11 jobs on an Intel i5-6400 CPU@2.70GHz
367 * (a fairly modest desktop CPU). 1 thread was chosen because we don't
368 * really care about getting things to disk quickly just that it's not
369 * blocking other tasks.
371 util_queue_init(&cache
->cache_queue
, "disk_cache", 32, 1);
373 /* Create driver id keys */
374 size_t ts_size
= strlen(timestamp
) + 1;
375 cache
->driver_keys_blob_size
= ts_size
;
377 cache
->driver_keys_blob
=
378 ralloc_size(cache
, cache
->driver_keys_blob_size
);
379 if (!cache
->driver_keys_blob
)
382 memcpy(cache
->driver_keys_blob
, timestamp
, ts_size
);
384 /* Seed our rand function */
385 s_rand_xorshift128plus(cache
->seed_xorshift128plus
, true);
402 disk_cache_destroy(struct disk_cache
*cache
)
405 util_queue_destroy(&cache
->cache_queue
);
406 munmap(cache
->index_mmap
, cache
->index_mmap_size
);
412 /* Return a filename within the cache's directory corresponding to 'key'. The
413 * returned filename is ralloced with 'cache' as the parent context.
415 * Returns NULL if out of memory.
418 get_cache_file(struct disk_cache
*cache
, const cache_key key
)
423 _mesa_sha1_format(buf
, key
);
424 if (asprintf(&filename
, "%s/%c%c/%s", cache
->path
, buf
[0],
425 buf
[1], buf
+ 2) == -1)
431 /* Create the directory that will be needed for the cache file for \key.
433 * Obviously, the implementation here must closely match
434 * _get_cache_file above.
437 make_cache_file_directory(struct disk_cache
*cache
, const cache_key key
)
442 _mesa_sha1_format(buf
, key
);
443 if (asprintf(&dir
, "%s/%c%c", cache
->path
, buf
[0], buf
[1]) == -1)
446 mkdir_if_needed(dir
);
450 /* Given a directory path and predicate function, find the entry with
451 * the oldest access time in that directory for which the predicate
454 * Returns: A malloc'ed string for the path to the chosen file, (or
455 * NULL on any error). The caller should free the string when
459 choose_lru_file_matching(const char *dir_path
,
460 bool (*predicate
)(const char *dir_path
,
462 const char *, const size_t))
465 struct dirent
*entry
;
467 char *lru_name
= NULL
;
468 time_t lru_atime
= 0;
470 dir
= opendir(dir_path
);
475 entry
= readdir(dir
);
480 if (fstatat(dirfd(dir
), entry
->d_name
, &sb
, 0) == 0) {
481 if (!lru_atime
|| (sb
.st_atime
< lru_atime
)) {
482 size_t len
= strlen(entry
->d_name
);
484 if (!predicate(dir_path
, &sb
, entry
->d_name
, len
))
487 char *tmp
= realloc(lru_name
, len
+ 1);
490 memcpy(lru_name
, entry
->d_name
, len
+ 1);
491 lru_atime
= sb
.st_atime
;
497 if (lru_name
== NULL
) {
502 if (asprintf(&filename
, "%s/%s", dir_path
, lru_name
) < 0)
511 /* Is entry a regular file, and not having a name with a trailing
515 is_regular_non_tmp_file(const char *path
, const struct stat
*sb
,
516 const char *d_name
, const size_t len
)
518 if (!S_ISREG(sb
->st_mode
))
521 if (len
>= 4 && strcmp(&d_name
[len
-4], ".tmp") == 0)
527 /* Returns the size of the deleted file, (or 0 on any error). */
529 unlink_lru_file_from_directory(const char *path
)
534 filename
= choose_lru_file_matching(path
, is_regular_non_tmp_file
);
535 if (filename
== NULL
)
538 if (stat(filename
, &sb
) == -1) {
549 /* Is entry a directory with a two-character name, (and not the
550 * special name of ".."). We also return false if the dir is empty.
553 is_two_character_sub_directory(const char *path
, const struct stat
*sb
,
554 const char *d_name
, const size_t len
)
556 if (!S_ISDIR(sb
->st_mode
))
562 if (strcmp(d_name
, "..") == 0)
566 if (asprintf(&subdir
, "%s/%s", path
, d_name
) == -1)
568 DIR *dir
= opendir(subdir
);
574 unsigned subdir_entries
= 0;
576 while ((d
= readdir(dir
)) != NULL
) {
577 if(++subdir_entries
> 2)
582 /* If dir only contains '.' and '..' it must be empty */
583 if (subdir_entries
<= 2)
590 evict_lru_item(struct disk_cache
*cache
)
594 /* With a reasonably-sized, full cache, (and with keys generated
595 * from a cryptographic hash), we can choose two random hex digits
596 * and reasonably expect the directory to exist with a file in it.
597 * Provides pseudo-LRU eviction to reduce checking all cache files.
599 uint64_t rand64
= rand_xorshift128plus(cache
->seed_xorshift128plus
);
600 if (asprintf(&dir_path
, "%s/%02" PRIx64
, cache
->path
, rand64
& 0xff) < 0)
603 size_t size
= unlink_lru_file_from_directory(dir_path
);
608 p_atomic_add(cache
->size
, - (uint64_t)size
);
612 /* In the case where the random choice of directory didn't find
613 * something, we choose the least recently accessed from the
614 * existing directories.
616 * Really, the only reason this code exists is to allow the unit
617 * tests to work, (which use an artificially-small cache to be able
618 * to force a single cached item to be evicted).
620 dir_path
= choose_lru_file_matching(cache
->path
,
621 is_two_character_sub_directory
);
622 if (dir_path
== NULL
)
625 size
= unlink_lru_file_from_directory(dir_path
);
630 p_atomic_add(cache
->size
, - (uint64_t)size
);
634 disk_cache_remove(struct disk_cache
*cache
, const cache_key key
)
638 char *filename
= get_cache_file(cache
, key
);
639 if (filename
== NULL
) {
643 if (stat(filename
, &sb
) == -1) {
652 p_atomic_add(cache
->size
, - (uint64_t)sb
.st_size
);
656 write_all(int fd
, const void *buf
, size_t count
)
658 const char *out
= buf
;
662 for (done
= 0; done
< count
; done
+= written
) {
663 written
= write(fd
, out
+ done
, count
- done
);
670 /* From the zlib docs:
671 * "If the memory is available, buffers sizes on the order of 128K or 256K
672 * bytes should be used."
674 #define BUFSIZE 256 * 1024
677 * Compresses cache entry in memory and writes it to disk. Returns the size
678 * of the data written to disk.
681 deflate_and_write_to_disk(const void *in_data
, size_t in_data_size
, int dest
,
682 const char *filename
)
684 unsigned char out
[BUFSIZE
];
686 /* allocate deflate state */
688 strm
.zalloc
= Z_NULL
;
690 strm
.opaque
= Z_NULL
;
691 strm
.next_in
= (uint8_t *) in_data
;
692 strm
.avail_in
= in_data_size
;
694 int ret
= deflateInit(&strm
, Z_BEST_COMPRESSION
);
698 /* compress until end of in_data */
699 size_t compressed_size
= 0;
702 int remaining
= in_data_size
- BUFSIZE
;
703 flush
= remaining
> 0 ? Z_NO_FLUSH
: Z_FINISH
;
704 in_data_size
-= BUFSIZE
;
706 /* Run deflate() on input until the output buffer is not full (which
707 * means there is no more data to deflate).
710 strm
.avail_out
= BUFSIZE
;
713 ret
= deflate(&strm
, flush
); /* no bad return value */
714 assert(ret
!= Z_STREAM_ERROR
); /* state not clobbered */
716 size_t have
= BUFSIZE
- strm
.avail_out
;
717 compressed_size
+= have
;
719 ssize_t written
= write_all(dest
, out
, have
);
721 (void)deflateEnd(&strm
);
724 } while (strm
.avail_out
== 0);
726 /* all input should be used */
727 assert(strm
.avail_in
== 0);
729 } while (flush
!= Z_FINISH
);
731 /* stream should be complete */
732 assert(ret
== Z_STREAM_END
);
734 /* clean up and return */
735 (void)deflateEnd(&strm
);
736 return compressed_size
;
739 static struct disk_cache_put_job
*
740 create_put_job(struct disk_cache
*cache
, const cache_key key
,
741 const void *data
, size_t size
)
743 struct disk_cache_put_job
*dc_job
= (struct disk_cache_put_job
*)
744 malloc(sizeof(struct disk_cache_put_job
) + size
);
747 dc_job
->cache
= cache
;
748 memcpy(dc_job
->key
, key
, sizeof(cache_key
));
749 dc_job
->data
= dc_job
+ 1;
750 memcpy(dc_job
->data
, data
, size
);
758 destroy_put_job(void *job
, int thread_index
)
765 struct cache_entry_file_data
{
767 uint32_t uncompressed_size
;
771 cache_put(void *job
, int thread_index
)
775 int fd
= -1, fd_final
= -1, err
, ret
;
777 char *filename
= NULL
, *filename_tmp
= NULL
;
778 struct disk_cache_put_job
*dc_job
= (struct disk_cache_put_job
*) job
;
780 filename
= get_cache_file(dc_job
->cache
, dc_job
->key
);
781 if (filename
== NULL
)
784 /* If the cache is too large, evict something else first. */
785 while (*dc_job
->cache
->size
+ dc_job
->size
> dc_job
->cache
->max_size
&&
787 evict_lru_item(dc_job
->cache
);
791 /* Write to a temporary file to allow for an atomic rename to the
792 * final destination filename, (to prevent any readers from seeing
793 * a partially written file).
795 if (asprintf(&filename_tmp
, "%s.tmp", filename
) == -1)
798 fd
= open(filename_tmp
, O_WRONLY
| O_CLOEXEC
| O_CREAT
, 0644);
800 /* Make the two-character subdirectory within the cache as needed. */
805 make_cache_file_directory(dc_job
->cache
, dc_job
->key
);
807 fd
= open(filename_tmp
, O_WRONLY
| O_CLOEXEC
| O_CREAT
, 0644);
812 /* With the temporary file open, we take an exclusive flock on
813 * it. If the flock fails, then another process still has the file
814 * open with the flock held. So just let that file be responsible
815 * for writing the file.
817 err
= flock(fd
, LOCK_EX
| LOCK_NB
);
821 /* Now that we have the lock on the open temporary file, we can
822 * check to see if the destination file already exists. If so,
823 * another process won the race between when we saw that the file
824 * didn't exist and now. In this case, we don't do anything more,
825 * (to ensure the size accounting of the cache doesn't get off).
827 fd_final
= open(filename
, O_RDONLY
| O_CLOEXEC
);
828 if (fd_final
!= -1) {
829 unlink(filename_tmp
);
833 /* OK, we're now on the hook to write out a file that we know is
834 * not in the cache, and is also not being written out to the cache
835 * by some other process.
837 * Create CRC of the data and store at the start of the file. We will
838 * read this when restoring the cache and use it to check for corruption.
840 struct cache_entry_file_data cf_data
;
841 cf_data
.crc32
= util_hash_crc32(dc_job
->data
, dc_job
->size
);
842 cf_data
.uncompressed_size
= dc_job
->size
;
844 size_t cf_data_size
= sizeof(cf_data
);
845 ret
= write_all(fd
, &cf_data
, cf_data_size
);
847 unlink(filename_tmp
);
851 /* Now, finally, write out the contents to the temporary file, then
852 * rename them atomically to the destination filename, and also
853 * perform an atomic increment of the total cache size.
855 size_t file_size
= deflate_and_write_to_disk(dc_job
->data
, dc_job
->size
,
857 if (file_size
== 0) {
858 unlink(filename_tmp
);
861 ret
= rename(filename_tmp
, filename
);
863 unlink(filename_tmp
);
867 file_size
+= cf_data_size
;
868 p_atomic_add(dc_job
->cache
->size
, file_size
);
873 /* This close finally releases the flock, (now that the final file
874 * has been renamed into place and the size has been added).
885 disk_cache_put(struct disk_cache
*cache
, const cache_key key
,
886 const void *data
, size_t size
)
888 struct disk_cache_put_job
*dc_job
=
889 create_put_job(cache
, key
, data
, size
);
892 util_queue_fence_init(&dc_job
->fence
);
893 util_queue_add_job(&cache
->cache_queue
, dc_job
, &dc_job
->fence
,
894 cache_put
, destroy_put_job
);
899 * Decompresses cache entry, returns true if successful.
902 inflate_cache_data(uint8_t *in_data
, size_t in_data_size
,
903 uint8_t *out_data
, size_t out_data_size
)
907 /* allocate inflate state */
908 strm
.zalloc
= Z_NULL
;
910 strm
.opaque
= Z_NULL
;
911 strm
.next_in
= in_data
;
912 strm
.avail_in
= in_data_size
;
913 strm
.next_out
= out_data
;
914 strm
.avail_out
= out_data_size
;
916 int ret
= inflateInit(&strm
);
920 ret
= inflate(&strm
, Z_NO_FLUSH
);
921 assert(ret
!= Z_STREAM_ERROR
); /* state not clobbered */
923 /* Unless there was an error we should have decompressed everything in one
924 * go as we know the uncompressed file size.
926 if (ret
!= Z_STREAM_END
) {
927 (void)inflateEnd(&strm
);
930 assert(strm
.avail_out
== 0);
932 /* clean up and return */
933 (void)inflateEnd(&strm
);
938 disk_cache_get(struct disk_cache
*cache
, const cache_key key
, size_t *size
)
940 int fd
= -1, ret
, len
;
942 char *filename
= NULL
;
943 uint8_t *data
= NULL
;
944 uint8_t *uncompressed_data
= NULL
;
949 filename
= get_cache_file(cache
, key
);
950 if (filename
== NULL
)
953 fd
= open(filename
, O_RDONLY
| O_CLOEXEC
);
957 if (fstat(fd
, &sb
) == -1)
960 data
= malloc(sb
.st_size
);
964 /* Load the CRC that was created when the file was written. */
965 struct cache_entry_file_data cf_data
;
966 size_t cf_data_size
= sizeof(cf_data
);
967 assert(sb
.st_size
> cf_data_size
);
968 for (len
= 0; len
< cf_data_size
; len
+= ret
) {
969 ret
= read(fd
, ((uint8_t *) &cf_data
) + len
, cf_data_size
- len
);
974 /* Load the actual cache data. */
975 size_t cache_data_size
= sb
.st_size
- cf_data_size
;
976 for (len
= 0; len
< cache_data_size
; len
+= ret
) {
977 ret
= read(fd
, data
+ len
, cache_data_size
- len
);
982 /* Uncompress the cache data */
983 uncompressed_data
= malloc(cf_data
.uncompressed_size
);
984 if (!inflate_cache_data(data
, cache_data_size
, uncompressed_data
,
985 cf_data
.uncompressed_size
))
988 /* Check the data for corruption */
989 if (cf_data
.crc32
!= util_hash_crc32(uncompressed_data
,
990 cf_data
.uncompressed_size
))
998 *size
= cf_data
.uncompressed_size
;
1000 return uncompressed_data
;
1005 if (uncompressed_data
)
1006 free(uncompressed_data
);
1016 disk_cache_put_key(struct disk_cache
*cache
, const cache_key key
)
1018 const uint32_t *key_chunk
= (const uint32_t *) key
;
1019 int i
= *key_chunk
& CACHE_INDEX_KEY_MASK
;
1020 unsigned char *entry
;
1022 entry
= &cache
->stored_keys
[i
* CACHE_KEY_SIZE
];
1024 memcpy(entry
, key
, CACHE_KEY_SIZE
);
1027 /* This function lets us test whether a given key was previously
1028 * stored in the cache with disk_cache_put_key(). The implement is
1029 * efficient by not using syscalls or hitting the disk. It's not
1030 * race-free, but the races are benign. If we race with someone else
1031 * calling disk_cache_put_key, then that's just an extra cache miss and an
1035 disk_cache_has_key(struct disk_cache
*cache
, const cache_key key
)
1037 const uint32_t *key_chunk
= (const uint32_t *) key
;
1038 int i
= *key_chunk
& CACHE_INDEX_KEY_MASK
;
1039 unsigned char *entry
;
1041 entry
= &cache
->stored_keys
[i
* CACHE_KEY_SIZE
];
1043 return memcmp(entry
, key
, CACHE_KEY_SIZE
) == 0;
1047 disk_cache_compute_key(struct disk_cache
*cache
, const void *data
, size_t size
,
1050 struct mesa_sha1 ctx
;
1052 _mesa_sha1_init(&ctx
);
1053 _mesa_sha1_update(&ctx
, cache
->driver_keys_blob
,
1054 cache
->driver_keys_blob_size
);
1055 _mesa_sha1_update(&ctx
, data
, size
);
1056 _mesa_sha1_final(&ctx
, key
);
1059 #endif /* ENABLE_SHADER_CACHE */