bcachefs: btree perf testsbcachefs-v4.13

4 files changed, 320 insertions, 0 deletions

diff --git a/fs/bcachefs/Makefile b/fs/bcachefs/Makefile
index 36136ec0525a..c3acb8858ac7 100644
--- a/fs/bcachefs/Makefile
+++ b/fs/bcachefs/Makefile
@@ -41,6 +41,7 @@ bcachefs-y		:=	\
 	super.o			\
 	super-io.o		\
 	sysfs.o			\
+	tests.o			\
 	tier.o			\
 	trace.o			\
 	util.o			\
diff --git a/fs/bcachefs/sysfs.c b/fs/bcachefs/sysfs.c
index 597e1f02bd6a..9a617dba21ef 100644
--- a/fs/bcachefs/sysfs.c
+++ b/fs/bcachefs/sysfs.c
@@ -25,6 +25,7 @@
 #include "opts.h"
 #include "super-io.h"
 #include "tier.h"
+#include "tests.h"
 
 #include <linux/blkdev.h>
 #include <linux/sort.h>
@@ -181,6 +182,8 @@ rw_attribute(pd_controllers_update_seconds);
 read_attribute(meta_replicas_have);
 read_attribute(data_replicas_have);
 
+write_attribute(perf_test);
+
 #define BCH_DEBUG_PARAM(name, description)				\
 	rw_attribute(name);
 
@@ -432,6 +435,24 @@ STORE(__bch2_fs)
 		c->btree_cache.shrink.scan_objects(&c->btree_cache.shrink, &sc);
 	}
 
+	if (attr == &sysfs_perf_test) {
+		char *tmp = kstrdup(buf, GFP_KERNEL), *p = tmp;
+		char *test		= strsep(&p, " \t\n");
+		char *nr_str		= strsep(&p, " \t\n");
+		char *threads_str	= strsep(&p, " \t\n");
+		unsigned threads;
+		u64 nr;
+		int ret = -EINVAL;
+
+		if (threads_str &&
+		    !(ret = kstrtouint(threads_str, 10, &threads)) &&
+		    !(ret = bch2_strtoull_h(nr_str, &nr)))
+			btree_perf_test(c, test, nr, threads);
+		else
+			size = ret;
+		kfree(tmp);
+	}
+
 	return size;
 }
 
@@ -462,6 +483,8 @@ struct attribute *bch2_fs_files[] = {
 	&sysfs_tiering_percent,
 
 	&sysfs_compression_stats,
+
+	&sysfs_perf_test,
 	NULL
 };
 
diff --git a/fs/bcachefs/tests.c b/fs/bcachefs/tests.c
new file mode 100644
index 000000000000..2fe60151a1e5
--- /dev/null
+++ b/fs/bcachefs/tests.c
@@ -0,0 +1,290 @@
+
+#include "bcachefs.h"
+#include "btree_update.h"
+#include "tests.h"
+
+#include "linux/kthread.h"
+#include "linux/random.h"
+
+static void delete_test(struct bch_fs *c)
+{
+	struct btree_iter iter;
+	struct bkey_i_cookie k;
+	int ret;
+
+	bkey_cookie_init(&k.k_i);
+
+	bch2_btree_iter_init(&iter, c, BTREE_ID_DIRENTS, k.k.p, BTREE_ITER_INTENT);
+
+	ret = bch2_btree_iter_traverse(&iter);
+	BUG_ON(ret);
+
+	ret = bch2_btree_insert_at(c, NULL, NULL, NULL, 0,
+				   BTREE_INSERT_ENTRY(&iter, &k.k_i));
+	BUG_ON(ret);
+
+	pr_info("deleting once");
+	ret = bch2_btree_delete_at(&iter, 0);
+	BUG_ON(ret);
+
+	pr_info("deleting twice");
+	ret = bch2_btree_delete_at(&iter, 0);
+	BUG_ON(ret);
+
+	bch2_btree_iter_unlock(&iter);
+}
+
+void bch2_run_tests(struct bch_fs *c)
+{
+	delete_test(c);
+}
+
+static u64 test_rand(void)
+{
+	u64 v;
+#if 0
+	v = prandom_u32();
+#else
+	prandom_bytes(&v, sizeof(v));
+#endif
+	return v;
+}
+
+static void rand_insert(struct bch_fs *c, u64 nr)
+{
+	struct bkey_i_cookie k;
+	int ret;
+	u64 i;
+
+	for (i = 0; i < nr; i++) {
+		bkey_cookie_init(&k.k_i);
+		k.k.p.offset = test_rand();
+
+		ret = bch2_btree_insert(c, BTREE_ID_DIRENTS, &k.k_i,
+					NULL, NULL, NULL, 0);
+		BUG_ON(ret);
+	}
+}
+
+static void rand_lookup(struct bch_fs *c, u64 nr)
+{
+	u64 i;
+
+	for (i = 0; i < nr; i++) {
+		struct btree_iter iter;
+		struct bkey_s_c k;
+
+		bch2_btree_iter_init(&iter, c, BTREE_ID_DIRENTS,
+				     POS(0, test_rand()), 0);
+
+		k = bch2_btree_iter_peek(&iter);
+		bch2_btree_iter_unlock(&iter);
+	}
+}
+
+static void rand_mixed(struct bch_fs *c, u64 nr)
+{
+	int ret;
+	u64 i;
+
+	for (i = 0; i < nr; i++) {
+		struct btree_iter iter;
+		struct bkey_s_c k;
+
+		bch2_btree_iter_init(&iter, c, BTREE_ID_DIRENTS,
+				     POS(0, test_rand()), 0);
+
+		k = bch2_btree_iter_peek(&iter);
+
+		if (!(i & 3) && k.k) {
+			struct bkey_i_cookie k;
+
+			bkey_cookie_init(&k.k_i);
+			k.k.p = iter.pos;
+
+			ret = bch2_btree_insert_at(c, NULL, NULL, NULL, 0,
+						   BTREE_INSERT_ENTRY(&iter, &k.k_i));
+			BUG_ON(ret);
+		}
+
+		bch2_btree_iter_unlock(&iter);
+	}
+
+}
+
+static void rand_delete(struct bch_fs *c, u64 nr)
+{
+	struct bkey_i k;
+	int ret;
+	u64 i;
+
+	for (i = 0; i < nr; i++) {
+		bkey_init(&k.k);
+		k.k.p.offset = test_rand();
+
+		ret = bch2_btree_insert(c, BTREE_ID_DIRENTS, &k,
+					NULL, NULL, NULL, 0);
+		BUG_ON(ret);
+	}
+}
+
+static void seq_insert(struct bch_fs *c, u64 nr)
+{
+	struct bkey_i_cookie k;
+	struct btree_iter iter;
+	int ret;
+	u64 i;
+
+	bkey_cookie_init(&k.k_i);
+	bch2_btree_iter_init(&iter, c, BTREE_ID_DIRENTS, POS_MIN,
+			     BTREE_ITER_INTENT);
+
+	for (i = 0; i < nr; i++) {
+		ret = bch2_btree_iter_traverse(&iter);
+		BUG_ON(ret);
+
+		k.k.p = iter.pos;
+
+		ret = bch2_btree_insert_at(c, NULL, NULL, NULL, 0,
+					   BTREE_INSERT_ENTRY(&iter, &k.k_i));
+		BUG_ON(ret);
+
+		bch2_btree_iter_set_pos(&iter,
+			btree_type_successor(BTREE_ID_DIRENTS, iter.pos));
+	}
+	bch2_btree_iter_unlock(&iter);
+}
+
+static void seq_lookup(struct bch_fs *c, u64 nr)
+{
+	struct btree_iter iter;
+	struct bkey_s_c k;
+
+	for_each_btree_key(&iter, c, BTREE_ID_DIRENTS, POS_MIN, 0, k)
+		;
+	bch2_btree_iter_unlock(&iter);
+}
+
+static void seq_overwrite(struct bch_fs *c, u64 nr)
+{
+	struct btree_iter iter;
+	struct bkey_s_c k;
+	int ret;
+
+	for_each_btree_key(&iter, c, BTREE_ID_DIRENTS, POS_MIN,
+			   BTREE_ITER_INTENT, k) {
+		struct bkey_i_cookie u;
+
+		bkey_reassemble(&u.k_i, k);
+
+		ret = bch2_btree_insert_at(c, NULL, NULL, NULL, 0,
+					   BTREE_INSERT_ENTRY(&iter, &u.k_i));
+		BUG_ON(ret);
+	}
+	bch2_btree_iter_unlock(&iter);
+}
+
+static void seq_delete(struct bch_fs *c, u64 nr)
+{
+	int ret;
+
+	ret = bch2_btree_delete_range(c, BTREE_ID_DIRENTS,
+				      POS_MIN, POS_MAX,
+				      ZERO_VERSION, NULL, NULL, NULL);
+	BUG_ON(ret);
+}
+
+typedef void (*perf_test_fn)(struct bch_fs *, u64);
+
+struct test_job {
+	struct bch_fs			*c;
+	u64				nr;
+	unsigned			nr_threads;
+	perf_test_fn			fn;
+
+	atomic_t			ready;
+	wait_queue_head_t		ready_wait;
+
+	atomic_t			done;
+	struct completion		done_completion;
+
+	u64				start;
+	u64				finish;
+};
+
+static int btree_perf_test_thread(void *data)
+{
+	struct test_job *j = data;
+
+	if (atomic_dec_and_test(&j->ready)) {
+		wake_up(&j->ready_wait);
+		j->start = sched_clock();
+	} else {
+		wait_event(j->ready_wait, !atomic_read(&j->ready));
+	}
+
+	j->fn(j->c, j->nr / j->nr_threads);
+
+	if (atomic_dec_and_test(&j->done)) {
+		j->finish = sched_clock();
+		complete(&j->done_completion);
+	}
+
+	return 0;
+}
+
+void btree_perf_test(struct bch_fs *c, const char *testname,
+		     u64 nr, unsigned nr_threads)
+{
+	struct test_job j = { .c = c, .nr = nr, .nr_threads = nr_threads };
+	char name_buf[20], nr_buf[20], per_sec_buf[20];
+	unsigned i;
+	u64 time;
+
+	atomic_set(&j.ready, nr_threads);
+	init_waitqueue_head(&j.ready_wait);
+
+	atomic_set(&j.done, nr_threads);
+	init_completion(&j.done_completion);
+
+#define perf_test(_test)				\
+	if (!strcmp(testname, #_test)) j.fn = _test
+
+	perf_test(rand_insert);
+	perf_test(rand_lookup);
+	perf_test(rand_mixed);
+	perf_test(rand_delete);
+
+	perf_test(seq_insert);
+	perf_test(seq_lookup);
+	perf_test(seq_overwrite);
+	perf_test(seq_delete);
+
+	if (!j.fn) {
+		pr_err("unknown test %s", testname);
+		return;
+	}
+
+	//pr_info("running test %s:", testname);
+
+	if (nr_threads == 1)
+		btree_perf_test_thread(&j);
+	else
+		for (i = 0; i < nr_threads; i++)
+			kthread_run(btree_perf_test_thread, &j,
+				    "bcachefs perf test[%u]", i);
+
+	while (wait_for_completion_interruptible(&j.done_completion))
+		;
+
+	time = j.finish - j.start;
+
+	scnprintf(name_buf, sizeof(name_buf), "%s:", testname);
+	bch2_hprint(nr_buf, nr);
+	bch2_hprint(per_sec_buf, nr * NSEC_PER_SEC / time);
+	printk(KERN_INFO "%-12s %s with %u threads in %5llu sec, %5llu nsec per iter, %5s per sec\n",
+		name_buf, nr_buf, nr_threads,
+		time / NSEC_PER_SEC,
+		time * nr_threads / nr,
+		per_sec_buf);
+}
diff --git a/fs/bcachefs/tests.h b/fs/bcachefs/tests.h
new file mode 100644
index 000000000000..e094bb9ac46c
--- /dev/null
+++ b/fs/bcachefs/tests.h
@@ -0,0 +1,6 @@
+
+struct bch_fs;
+
+void btree_perf_test(struct bch_fs *, const char *, u64, unsigned);
+
+void bch2_run_tests(struct bch_fs *);