#include <pwd.h>
#include <errno.h>
#include <dirent.h>
+#include <inttypes.h>
#include "zlib.h"
#include "util/crc32.h"
} while (0);
struct disk_cache *
-disk_cache_create(const char *gpu_name, const char *timestamp,
+disk_cache_create(const char *gpu_name, const char *driver_id,
uint64_t driver_flags)
{
void *local;
goto path_fail;
cache->index_mmap_size = size;
- close(fd);
-
cache->size = (uint64_t *) cache->index_mmap;
cache->stored_keys = cache->index_mmap + sizeof(uint64_t);
cache->max_size = max_size;
- /* 1 thread was chosen because we don't really care about getting things
- * to disk quickly just that it's not blocking other tasks.
+ /* 4 threads were chosen below because just about all modern CPUs currently
+ * available that run Mesa have *at least* 4 cores. For these CPUs allowing
+ * more threads can result in the queue being processed faster, thus
+ * avoiding excessive memory use due to a backlog of cache entrys building
+ * up in the queue. Since we set the UTIL_QUEUE_INIT_USE_MINIMUM_PRIORITY
+ * flag this should have little negative impact on low core systems.
*
* The queue will resize automatically when it's full, so adding new jobs
* doesn't stall.
*/
- util_queue_init(&cache->cache_queue, "disk$", 32, 1,
+ util_queue_init(&cache->cache_queue, "disk$", 32, 4,
UTIL_QUEUE_INIT_RESIZE_IF_FULL |
- UTIL_QUEUE_INIT_USE_MINIMUM_PRIORITY);
+ UTIL_QUEUE_INIT_USE_MINIMUM_PRIORITY |
+ UTIL_QUEUE_INIT_SET_FULL_THREAD_AFFINITY);
cache->path_init_failed = false;
path_fail:
+ if (fd != -1)
+ close(fd);
+
cache->driver_keys_blob_size = cv_size;
/* Create driver id keys */
- size_t ts_size = strlen(timestamp) + 1;
+ size_t id_size = strlen(driver_id) + 1;
size_t gpu_name_size = strlen(gpu_name) + 1;
- cache->driver_keys_blob_size += ts_size;
+ cache->driver_keys_blob_size += id_size;
cache->driver_keys_blob_size += gpu_name_size;
/* We sometimes store entire structs that contains a pointers in the cache,
uint8_t *drv_key_blob = cache->driver_keys_blob;
DRV_KEY_CPY(drv_key_blob, &cache_version, cv_size)
- DRV_KEY_CPY(drv_key_blob, timestamp, ts_size)
+ DRV_KEY_CPY(drv_key_blob, driver_id, id_size)
DRV_KEY_CPY(drv_key_blob, gpu_name, gpu_name_size)
DRV_KEY_CPY(drv_key_blob, &ptr_size, ptr_size_size)
DRV_KEY_CPY(drv_key_blob, &driver_flags, driver_flags_size)
return cache;
fail:
- if (fd != -1)
- close(fd);
if (cache)
ralloc_free(cache);
ralloc_free(local);
deflate_and_write_to_disk(const void *in_data, size_t in_data_size, int dest,
const char *filename)
{
- unsigned char out[BUFSIZE];
+ unsigned char *out;
/* allocate deflate state */
z_stream strm;
/* compress until end of in_data */
size_t compressed_size = 0;
int flush;
+
+ out = malloc(BUFSIZE * sizeof(unsigned char));
+ if (out == NULL)
+ return 0;
+
do {
int remaining = in_data_size - BUFSIZE;
flush = remaining > 0 ? Z_NO_FLUSH : Z_FINISH;
ssize_t written = write_all(dest, out, have);
if (written == -1) {
(void)deflateEnd(&strm);
+ free(out);
return 0;
}
} while (strm.avail_out == 0);
/* clean up and return */
(void)deflateEnd(&strm);
+ free(out);
return compressed_size;
}
if (dc_job) {
util_queue_fence_init(&dc_job->fence);
util_queue_add_job(&cache->cache_queue, dc_job, &dc_job->fence,
- cache_put, destroy_put_job);
+ cache_put, destroy_put_job, dc_job->size);
}
}