New API: _new() then _set_XXX() then _add().

Avoids breaking API every time we add a new knob that needs to be set
at cache creation.

benchmarks/bench_micro.c

@@ -72,13 +72,14 @@ struct context {
  */
 static VMEMcache *
 bench_init(const char *path, size_t size, size_t extent_size,
-		enum vmemcache_repl_p replacement_policy,
+		enum vmemcache_repl_p repl_p,
 		unsigned n_threads, struct context *ctx)
 {
-	VMEMcache *cache = vmemcache_new(path, size, extent_size,
-						replacement_policy);
-	if (cache == NULL)
-		UT_FATAL("vmemcache_new: %s (%s)", vmemcache_errormsg(), path);
+	VMEMcache *cache = vmemcache_new();
+	vmemcache_set_size(cache, size);
+	vmemcache_set_eviction_policy(cache, repl_p);
+	if (vmemcache_add(cache, path))
+		UT_FATAL("vmemcache_add: %s (%s)", vmemcache_errormsg(), path);
 
 	for (unsigned i = 0; i < n_threads; ++i) {
 		ctx[i].cache = cache;
@@ -197,12 +198,12 @@ print_bench_results(const char *op_name, unsigned n_threads,
  */
 static void
 run_bench_put(const char *path, size_t size, size_t extent_size,
-		enum vmemcache_repl_p replacement_policy,
+		enum vmemcache_repl_p repl_p,
 		unsigned n_threads, os_thread_t *threads,
 		unsigned ops_count, struct context *ctx)
 {
 	VMEMcache *cache = bench_init(path, size, extent_size,
-					replacement_policy, n_threads, ctx);
+					repl_p, n_threads, ctx);
 
 	unsigned ops_per_thread = ops_count / n_threads;
 
@@ -238,12 +239,12 @@ on_evict_cb(VMEMcache *cache, const void *key, size_t key_size, void *arg)
  */
 static void
 run_bench_get(const char *path, size_t size, size_t extent_size,
-		enum vmemcache_repl_p replacement_policy,
+		enum vmemcache_repl_p repl_p,
 		unsigned n_threads, os_thread_t *threads,
 		unsigned ops_count, struct context *ctx)
 {
 	VMEMcache *cache = bench_init(path, size, extent_size,
-					replacement_policy, n_threads, ctx);
+					repl_p, n_threads, ctx);
 
 	int cache_is_full = 0;
 	vmemcache_callback_on_evict(cache, on_evict_cb, &cache_is_full);

benchmarks/bench_simul.c

@@ -603,10 +603,13 @@ static void run_bench()
 	os_mutex_init(&ready.mutex);
 	ready.wanted = n_threads;
 
-	cache = vmemcache_new(dir, cache_size, cache_extent_size,
+	cache = vmemcache_new();
+	vmemcache_set_size(cache, cache_size);
+	vmemcache_set_extent_size(cache, cache_extent_size);
+	vmemcache_set_eviction_policy(cache,
 		(enum vmemcache_repl_p)repl_policy);
-	if (!cache)
-		UT_FATAL("vmemcache_new: %s (%s)", vmemcache_errormsg(), dir);
+	if (vmemcache_add(cache, dir))
+		UT_FATAL("vmemcache_add: %s (%s)", vmemcache_errormsg(), dir);
 
 	if (latency_samples) {
 		latencies = malloc((ops_count * n_threads + 1) *

src/libvmemcache.h

@@ -115,16 +115,19 @@ typedef void vmemcache_on_evict(VMEMcache *cache,
 typedef void vmemcache_on_miss(VMEMcache *cache,
 	const void *key, size_t key_size, void *arg);
 
+VMEMcache *
+vmemcache_new(void);
+
+int vmemcache_set_eviction_policy(VMEMcache *cache,
+	enum vmemcache_repl_p repl_p);
+int vmemcache_set_size(VMEMcache *cache, size_t size);
+int vmemcache_set_extent_size(VMEMcache *cache, size_t extent_size);
+
 #ifndef _WIN32
-VMEMcache *vmemcache_new(const char *path, size_t max_size, size_t extent_size,
-		enum vmemcache_repl_p replacement_policy);
+int vmemcache_add(VMEMcache *cache, const char *path);
 #else
-VMEMcache *vmemcache_newU(const char *path, size_t max_size,
-		size_t extent_size,
-		enum vmemcache_repl_p replacement_policy);
-VMEMcache *vmemcache_newW(const wchar_t *path, size_t max_size,
-		size_t extent_size,
-		enum vmemcache_repl_p replacement_policy);
+int vmemcache_addU(VMEMcache *cache, const char *path);
+int vmemcache_addW(VMEMcache *cache, const wchar_t *path);
 #endif
 
 void vmemcache_delete(VMEMcache *cache);

src/libvmemcache.map

@@ -36,6 +36,10 @@ LIBVMEMCACHE_1.0 {
 	global:
 		vmemcache_new;
 		vmemcache_delete;
+		vmemcache_set_eviction_policy;
+		vmemcache_set_size;
+		vmemcache_set_extent_size;
+		vmemcache_add;
 		vmemcache_put;
 		vmemcache_get;
 		vmemcache_evict;