Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d3b55771 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'test_rhashtable-dont-allocate-huge-static-array' 



Florian Westphal says:

====================
test_rhashtable: don't allocate huge static array

Add a test case for the rhlist interface.
While at it, cleanup current rhashtable test a bit and add a check
for max_size support.

No changes since v1, except in last patch.
kbuild robot complained about large onstack allocation caused by
struct rhltable when lockdep is enabled.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 3d5cc728 cdd4de37

lib/test_rhashtable.c

+270 −23
Original line number Diff line number Diff line
@@ -23,14 +23,15 @@ 
#include <linux/semaphore.h>

#include <linux/slab.h>

#include <linux/sched.h>

#include <linux/random.h>

#include <linux/vmalloc.h>



#define MAX_ENTRIES	1000000

#define TEST_INSERT_FAIL INT_MAX



static int entries = 50000;

module_param(entries, int, 0);

MODULE_PARM_DESC(entries, "Number of entries to add (default: 50000)");

static int parm_entries = 50000;

module_param(parm_entries, int, 0);

MODULE_PARM_DESC(parm_entries, "Number of entries to add (default: 50000)");



static int runs = 4;

module_param(runs, int, 0);
@@ -66,14 +67,18 @@ struct test_obj { 
	struct rhash_head	node;

};



struct test_obj_rhl {

	struct test_obj_val	value;

	struct rhlist_head	list_node;

};



struct thread_data {

	unsigned int entries;

	int id;

	struct task_struct *task;

	struct test_obj *objs;

};



static struct test_obj array[MAX_ENTRIES];



static struct rhashtable_params test_rht_params = {

	.head_offset = offsetof(struct test_obj, node),

	.key_offset = offsetof(struct test_obj, value),
@@ -85,7 +90,7 @@ static struct rhashtable_params test_rht_params = { 
static struct semaphore prestart_sem;

static struct semaphore startup_sem = __SEMAPHORE_INITIALIZER(startup_sem, 0);



static int insert_retry(struct rhashtable *ht, struct rhash_head *obj,

static int insert_retry(struct rhashtable *ht, struct test_obj *obj,

                        const struct rhashtable_params params)

{

	int err, retries = -1, enomem_retries = 0;
@@ -93,7 +98,7 @@ static int insert_retry(struct rhashtable *ht, struct rhash_head *obj, 
	do {

		retries++;

		cond_resched();

		err = rhashtable_insert_fast(ht, obj, params);

		err = rhashtable_insert_fast(ht, &obj->node, params);

		if (err == -ENOMEM && enomem_retry) {

			enomem_retries++;

			err = -EBUSY;
@@ -107,11 +112,12 @@ static int insert_retry(struct rhashtable *ht, struct rhash_head *obj, 
	return err ? : retries;

}



static int __init test_rht_lookup(struct rhashtable *ht)

static int __init test_rht_lookup(struct rhashtable *ht, struct test_obj *array,

				  unsigned int entries)

{

	unsigned int i;



	for (i = 0; i < entries * 2; i++) {

	for (i = 0; i < entries; i++) {

		struct test_obj *obj;

		bool expected = !(i % 2);

		struct test_obj_val key = {
@@ -144,7 +150,7 @@ static int __init test_rht_lookup(struct rhashtable *ht) 
	return 0;

}



static void test_bucket_stats(struct rhashtable *ht)

static void test_bucket_stats(struct rhashtable *ht, unsigned int entries)

{

	unsigned int err, total = 0, chain_len = 0;

	struct rhashtable_iter hti;
@@ -186,7 +192,8 @@ static void test_bucket_stats(struct rhashtable *ht) 
		pr_warn("Test failed: Total count mismatch ^^^");

}



static s64 __init test_rhashtable(struct rhashtable *ht)

static s64 __init test_rhashtable(struct rhashtable *ht, struct test_obj *array,

				  unsigned int entries)

{

	struct test_obj *obj;

	int err;
@@ -203,7 +210,7 @@ static s64 __init test_rhashtable(struct rhashtable *ht) 
		struct test_obj *obj = &array[i];



		obj->value.id = i * 2;

		err = insert_retry(ht, &obj->node, test_rht_params);

		err = insert_retry(ht, obj, test_rht_params);

		if (err > 0)

			insert_retries += err;

		else if (err)
@@ -214,12 +221,12 @@ static s64 __init test_rhashtable(struct rhashtable *ht) 
		pr_info("  %u insertions retried due to memory pressure\n",

			insert_retries);



	test_bucket_stats(ht);

	test_bucket_stats(ht, entries);

	rcu_read_lock();

	test_rht_lookup(ht);

	test_rht_lookup(ht, array, entries);

	rcu_read_unlock();



	test_bucket_stats(ht);

	test_bucket_stats(ht, entries);



	pr_info("  Deleting %d keys\n", entries);

	for (i = 0; i < entries; i++) {
@@ -244,9 +251,227 @@ static s64 __init test_rhashtable(struct rhashtable *ht) 
}



static struct rhashtable ht;

static struct rhltable rhlt __initdata;



static int __init test_rhltable(unsigned int entries)

{

	struct test_obj_rhl *rhl_test_objects;

	unsigned long *obj_in_table;

	unsigned int i, j, k;

	int ret, err;



	if (entries == 0)

		entries = 1;



	rhl_test_objects = vzalloc(sizeof(*rhl_test_objects) * entries);

	if (!rhl_test_objects)

		return -ENOMEM;



	ret = -ENOMEM;

	obj_in_table = vzalloc(BITS_TO_LONGS(entries) * sizeof(unsigned long));

	if (!obj_in_table)

		goto out_free;



	/* nulls_base not supported in rhlist interface */

	test_rht_params.nulls_base = 0;

	err = rhltable_init(&rhlt, &test_rht_params);

	if (WARN_ON(err))

		goto out_free;



	k = prandom_u32();

	ret = 0;

	for (i = 0; i < entries; i++) {

		rhl_test_objects[i].value.id = k;

		err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node,

				      test_rht_params);

		if (WARN(err, "error %d on element %d\n", err, i))

			break;

		if (err == 0)

			set_bit(i, obj_in_table);

	}



	if (err)

		ret = err;



	pr_info("test %d add/delete pairs into rhlist\n", entries);

	for (i = 0; i < entries; i++) {

		struct rhlist_head *h, *pos;

		struct test_obj_rhl *obj;

		struct test_obj_val key = {

			.id = k,

		};

		bool found;



		rcu_read_lock();

		h = rhltable_lookup(&rhlt, &key, test_rht_params);

		if (WARN(!h, "key not found during iteration %d of %d", i, entries)) {

			rcu_read_unlock();

			break;

		}



		if (i) {

			j = i - 1;

			rhl_for_each_entry_rcu(obj, pos, h, list_node) {

				if (WARN(pos == &rhl_test_objects[j].list_node, "old element found, should be gone"))

					break;

			}

		}



		cond_resched_rcu();



		found = false;



		rhl_for_each_entry_rcu(obj, pos, h, list_node) {

			if (pos == &rhl_test_objects[i].list_node) {

				found = true;

				break;

			}

		}



		rcu_read_unlock();



		if (WARN(!found, "element %d not found", i))

			break;



		err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);

		WARN(err, "rhltable_remove: err %d for iteration %d\n", err, i);

		if (err == 0)

			clear_bit(i, obj_in_table);

	}



	if (ret == 0 && err)

		ret = err;



	for (i = 0; i < entries; i++) {

		WARN(test_bit(i, obj_in_table), "elem %d allegedly still present", i);



		err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node,

				      test_rht_params);

		if (WARN(err, "error %d on element %d\n", err, i))

			break;

		if (err == 0)

			set_bit(i, obj_in_table);

	}



	pr_info("test %d random rhlist add/delete operations\n", entries);

	for (j = 0; j < entries; j++) {

		u32 i = prandom_u32_max(entries);

		u32 prand = prandom_u32();



		cond_resched();



		if (prand == 0)

			prand = prandom_u32();



		if (prand & 1) {

			prand >>= 1;

			continue;

		}



		err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);

		if (test_bit(i, obj_in_table)) {

			clear_bit(i, obj_in_table);

			if (WARN(err, "cannot remove element at slot %d", i))

				continue;

		} else {

			if (WARN(err != -ENOENT, "removed non-existant element %d, error %d not %d",

			     i, err, -ENOENT))

				continue;

		}



		if (prand & 1) {

			prand >>= 1;

			continue;

		}



		err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);

		if (err == 0) {

			if (WARN(test_and_set_bit(i, obj_in_table), "succeeded to insert same object %d", i))

				continue;

		} else {

			if (WARN(!test_bit(i, obj_in_table), "failed to insert object %d", i))

				continue;

		}



		if (prand & 1) {

			prand >>= 1;

			continue;

		}



		i = prandom_u32_max(entries);

		if (test_bit(i, obj_in_table)) {

			err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);

			WARN(err, "cannot remove element at slot %d", i);

			if (err == 0)

				clear_bit(i, obj_in_table);

		} else {

			err = rhltable_insert(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);

			WARN(err, "failed to insert object %d", i);

			if (err == 0)

				set_bit(i, obj_in_table);

		}

	}



	for (i = 0; i < entries; i++) {

		cond_resched();

		err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);

		if (test_bit(i, obj_in_table)) {

			if (WARN(err, "cannot remove element at slot %d", i))

				continue;

		} else {

			if (WARN(err != -ENOENT, "removed non-existant element, error %d not %d",

				 err, -ENOENT))

			continue;

		}

	}



	rhltable_destroy(&rhlt);

out_free:

	vfree(rhl_test_objects);

	vfree(obj_in_table);

	return ret;

}



static int __init test_rhashtable_max(struct test_obj *array,

				      unsigned int entries)

{

	unsigned int i, insert_retries = 0;

	int err;



	test_rht_params.max_size = roundup_pow_of_two(entries / 8);

	err = rhashtable_init(&ht, &test_rht_params);

	if (err)

		return err;



	for (i = 0; i < ht.max_elems; i++) {

		struct test_obj *obj = &array[i];



		obj->value.id = i * 2;

		err = insert_retry(&ht, obj, test_rht_params);

		if (err > 0)

			insert_retries += err;

		else if (err)

			return err;

	}



	err = insert_retry(&ht, &array[ht.max_elems], test_rht_params);

	if (err == -E2BIG) {

		err = 0;

	} else {

		pr_info("insert element %u should have failed with %d, got %d\n",

				ht.max_elems, -E2BIG, err);

		if (err == 0)

			err = -1;

	}



	rhashtable_destroy(&ht);



	return err;

}



static int thread_lookup_test(struct thread_data *tdata)

{

	unsigned int entries = tdata->entries;

	int i, err = 0;



	for (i = 0; i < entries; i++) {
@@ -283,10 +508,10 @@ static int threadfunc(void *data) 
	if (down_interruptible(&startup_sem))

		pr_err("  thread[%d]: down_interruptible failed\n", tdata->id);



	for (i = 0; i < entries; i++) {

	for (i = 0; i < tdata->entries; i++) {

		tdata->objs[i].value.id = i;

		tdata->objs[i].value.tid = tdata->id;

		err = insert_retry(&ht, &tdata->objs[i].node, test_rht_params);

		err = insert_retry(&ht, &tdata->objs[i], test_rht_params);

		if (err > 0) {

			insert_retries += err;

		} else if (err) {
@@ -307,7 +532,7 @@ static int threadfunc(void *data) 
	}



	for (step = 10; step > 0; step--) {

		for (i = 0; i < entries; i += step) {

		for (i = 0; i < tdata->entries; i += step) {

			if (tdata->objs[i].value.id == TEST_INSERT_FAIL)

				continue;

			err = rhashtable_remove_fast(&ht, &tdata->objs[i].node,
@@ -338,17 +563,25 @@ static int threadfunc(void *data) 


static int __init test_rht_init(void)

{

	unsigned int entries;

	int i, err, started_threads = 0, failed_threads = 0;

	u64 total_time = 0;

	struct thread_data *tdata;

	struct test_obj *objs;



	entries = min(entries, MAX_ENTRIES);

	if (parm_entries < 0)

		parm_entries = 1;



	entries = min(parm_entries, MAX_ENTRIES);



	test_rht_params.automatic_shrinking = shrinking;

	test_rht_params.max_size = max_size ? : roundup_pow_of_two(entries);

	test_rht_params.nelem_hint = size;



	objs = vzalloc((test_rht_params.max_size + 1) * sizeof(struct test_obj));

	if (!objs)

		return -ENOMEM;



	pr_info("Running rhashtable test nelem=%d, max_size=%d, shrinking=%d\n",

		size, max_size, shrinking);
@@ -356,7 +589,8 @@ static int __init test_rht_init(void) 
		s64 time;



		pr_info("Test %02d:\n", i);

		memset(&array, 0, sizeof(array));

		memset(objs, 0, test_rht_params.max_size * sizeof(struct test_obj));



		err = rhashtable_init(&ht, &test_rht_params);

		if (err < 0) {

			pr_warn("Test failed: Unable to initialize hashtable: %d\n",
@@ -364,9 +598,10 @@ static int __init test_rht_init(void) 
			continue;

		}



		time = test_rhashtable(&ht);

		time = test_rhashtable(&ht, objs, entries);

		rhashtable_destroy(&ht);

		if (time < 0) {

			vfree(objs);

			pr_warn("Test failed: return code %lld\n", time);

			return -EINVAL;

		}
@@ -374,6 +609,11 @@ static int __init test_rht_init(void) 
		total_time += time;

	}



	pr_info("test if its possible to exceed max_size %d: %s\n",

			test_rht_params.max_size, test_rhashtable_max(objs, entries) == 0 ?

			"no, ok" : "YES, failed");

	vfree(objs);



	do_div(total_time, runs);

	pr_info("Average test time: %llu\n", total_time);
@@ -404,6 +644,7 @@ static int __init test_rht_init(void) 
	}

	for (i = 0; i < tcount; i++) {

		tdata[i].id = i;

		tdata[i].entries = entries;

		tdata[i].objs = objs + i * entries;

		tdata[i].task = kthread_run(threadfunc, &tdata[i],

		                            "rhashtable_thrad[%d]", i);
@@ -425,11 +666,17 @@ static int __init test_rht_init(void) 
			failed_threads++;

		}

	}

	pr_info("Started %d threads, %d failed\n",

	        started_threads, failed_threads);

	rhashtable_destroy(&ht);

	vfree(tdata);

	vfree(objs);



	/*

	 * rhltable_remove is very expensive, default values can cause test

	 * to run for 2 minutes or more,  use a smaller number instead.

	 */

	err = test_rhltable(entries / 16);

	pr_info("Started %d threads, %d failed, rhltable test returns %d\n",

	        started_threads, failed_threads, err);

	return 0;

}