test_rhashtable: add test case for rhl_table interface

also test rhltable.  rhltable remove operations are slow as
deletions require a list walk, thus test with 1/16th of the given
entry count number to get a run duration similar to rhashtable one.

Signed-off-by: Florian Westphal <fw@strlen.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Florian Westphal 2017-09-20 01:12:14 +02:00 committed by David S. Miller
parent a6359bd8dd
commit cdd4de372e

View File

@ -23,6 +23,7 @@
#include <linux/semaphore.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/random.h>
#include <linux/vmalloc.h>
#define MAX_ENTRIES 1000000
@ -66,6 +67,11 @@ 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;
@ -245,6 +251,186 @@ static s64 __init test_rhashtable(struct rhashtable *ht, struct test_obj *array,
}
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)
@ -480,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;
}