#include <inttypes.h>
#include "zlib.h"
+#ifdef HAVE_ZSTD
+#include "zstd.h"
+#endif
+
#include "util/crc32.h"
#include "util/debug.h"
#include "util/rand_xor.h"
#include "util/u_queue.h"
#include "util/mesa-sha1.h"
#include "util/ralloc.h"
-#include "main/compiler.h"
-#include "main/errors.h"
+#include "util/compiler.h"
#include "disk_cache.h"
*/
#define CACHE_VERSION 1
+/* 3 is the recomended level, with 22 as the absolute maximum */
+#define ZSTD_COMPRESSION_LEVEL 3
+
struct disk_cache {
/* The path to the cache directory. */
char *path;
disk_cache_destroy(struct disk_cache *cache)
{
if (cache && !cache->path_init_failed) {
+ util_queue_finish(&cache->cache_queue);
util_queue_destroy(&cache->cache_queue);
munmap(cache->index_mmap, cache->index_mmap_size);
}
ralloc_free(cache);
}
+void
+disk_cache_wait_for_idle(struct disk_cache *cache)
+{
+ util_queue_finish(&cache->cache_queue);
+}
+
/* Return a filename within the cache's directory corresponding to 'key'. The
* returned filename is ralloced with 'cache' as the parent context.
*
deflate_and_write_to_disk(const void *in_data, size_t in_data_size, int dest,
const char *filename)
{
+#ifdef HAVE_ZSTD
+ /* from the zstd docs (https://facebook.github.io/zstd/zstd_manual.html):
+ * compression runs faster if `dstCapacity` >= `ZSTD_compressBound(srcSize)`.
+ */
+ size_t out_size = ZSTD_compressBound(in_data_size);
+ void * out = malloc(out_size);
+
+ size_t ret = ZSTD_compress(out, out_size, in_data, in_data_size,
+ ZSTD_COMPRESSION_LEVEL);
+ if (ZSTD_isError(ret)) {
+ free(out);
+ return 0;
+ }
+ ssize_t written = write_all(dest, out, ret);
+ if (written == -1) {
+ free(out);
+ return 0;
+ }
+ free(out);
+ return ret;
+#else
unsigned char *out;
/* allocate deflate state */
(void)deflateEnd(&strm);
free(out);
return compressed_size;
+# endif
}
static struct disk_cache_put_job *
* open with the flock held. So just let that file be responsible
* for writing the file.
*/
+#ifdef HAVE_FLOCK
err = flock(fd, LOCK_EX | LOCK_NB);
+#else
+ struct flock lock = {
+ .l_start = 0,
+ .l_len = 0, /* entire file */
+ .l_type = F_WRLCK,
+ .l_whence = SEEK_SET
+ };
+ err = fcntl(fd, F_SETLK, &lock);
+#endif
if (err == -1)
goto done;
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);
}
}
inflate_cache_data(uint8_t *in_data, size_t in_data_size,
uint8_t *out_data, size_t out_data_size)
{
+#ifdef HAVE_ZSTD
+ size_t ret = ZSTD_decompress(out_data, out_data_size, in_data, in_data_size);
+ return !ZSTD_isError(ret);
+#else
z_stream strm;
/* allocate inflate state */
/* clean up and return */
(void)inflateEnd(&strm);
return true;
+#endif
}
void *