util/disk_cache: actually enforce cache size

Currently only a one in one out eviction so if at max_size and
cache files were to constantly increase in size then so would the
cache. Restrict to limit of 8 evictions per new cache entry.

V2: (Timothy Arceri) fix make check tests

Reviewed-by: Grazvydas Ignotas <notasas@gmail.com>

diff --git a/src/compiler/glsl/tests/cache_test.c b/src/compiler/glsl/tests/cache_test.c
index 61ee630395ae45b5263c0f21bcc8f61aebea3c1a..832693e10395c3f42f319a5051046fa618049ee0 100644 (file)
--- a/src/compiler/glsl/tests/cache_test.c
+++ b/src/compiler/glsl/tests/cache_test.c
@@ -350,9 +350,10 @@ test_put_and_get(void)
 
    free(result);
 
-   /* Ensure eviction happened by checking that only one of the two
-    * previously-added items can still be fetched.
+   /* Ensure eviction happened by checking that both of the previous
+    * cache itesm were evicted.
     */
+   bool contains_1KB_file = false;
    count = 0;
    if (does_cache_contain(cache, blob_key))
        count++;
@@ -360,6 +361,13 @@ test_put_and_get(void)
    if (does_cache_contain(cache, string_key))
        count++;
 
+   if (does_cache_contain(cache, one_KB_key)) {
+      count++;
+      contains_1KB_file = true;
+   }
+
+   expect_true(contains_1KB_file,
+               "disk_cache_put eviction last file == MAX_SIZE (1KB)");
    expect_equal(count, 1, "disk_cache_put eviction with MAX_SIZE=1K");
 
    /* Now increase the size to 1M, add back both items, and ensure all
@@ -406,6 +414,7 @@ test_put_and_get(void)
     */
    wait_until_file_written(cache, one_MB_key);
 
+   bool contains_1MB_file = false;
    count = 0;
    if (does_cache_contain(cache, blob_key))
        count++;
@@ -416,7 +425,14 @@ test_put_and_get(void)
    if (does_cache_contain(cache, one_KB_key))
        count++;
 
-   expect_equal(count, 2, "eviction after overflow with MAX_SIZE=1M");
+   if (does_cache_contain(cache, one_MB_key)) {
+      count++;
+      contains_1MB_file = true;
+   }
+
+   expect_true(contains_1MB_file,
+               "disk_cache_put eviction last file == MAX_SIZE (1MB)");
+   expect_equal(count, 1, "eviction after overflow with MAX_SIZE=1M");
 
    disk_cache_destroy(cache);
 }

diff --git a/src/util/disk_cache.c b/src/util/disk_cache.c
index 931e308cd53f1fa181026a520bf8181bee638924..54134441bdacdab09f5ce35c05cf0667c28d4efe 100644 (file)
--- a/src/util/disk_cache.c
+++ b/src/util/disk_cache.c
@@ -798,6 +798,7 @@ cache_put(void *job, int thread_index)
    assert(job);
 
    int fd = -1, fd_final = -1, err, ret;
+   unsigned i = 0;
    size_t len;
    char *filename = NULL, *filename_tmp = NULL;
    struct disk_cache_put_job *dc_job = (struct disk_cache_put_job *) job;
@@ -853,8 +854,11 @@ cache_put(void *job, int thread_index)
     * Before we do that, if the cache is too large, evict something
     * else first.
     */
-   if (*dc_job->cache->size + dc_job->size > dc_job->cache->max_size)
+   while ((*dc_job->cache->size + dc_job->size > dc_job->cache->max_size) &&
+          i < 8) {
       evict_lru_item(dc_job->cache);
+      i++;
+   }
 
    /* Create CRC of the data and store at the start of the file. We will
     * read this when restoring the cache and use it to check for corruption.