[urcu.git] / tests / benchmark / test_urcu_hash_rw.c

/*
 * test_urcu_hash_rw.c
 *
 * Userspace RCU library - test program
 *
 * Copyright 2009-2012 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#define _GNU_SOURCE
#include "test_urcu_hash.h"

enum urcu_hash_addremove {
	AR_RANDOM = 0,
	AR_ADD = 1,
	AR_REMOVE = -1,
};	/* 1: add, -1 remove, 0: random */

static enum urcu_hash_addremove addremove; /* 1: add, -1 remove, 0: random */

void test_hash_rw_sigusr1_handler(int signo)
{
	switch (addremove) {
	case AR_ADD:
		printf("Add/Remove: random.\n");
		addremove = AR_RANDOM;
		break;
	case AR_RANDOM:
		printf("Add/Remove: remove only.\n");
		addremove = AR_REMOVE;
		break;
	case AR_REMOVE:
		printf("Add/Remove: add only.\n");
		addremove = AR_ADD;
		break;
	}
}

void test_hash_rw_sigusr2_handler(int signo)
{
	char msg[1] = { 0x42 };
	ssize_t ret;

	do {
		ret = write(count_pipe[1], msg, 1);	/* wakeup thread */
	} while (ret == -1L && errno == EINTR);
}

void *test_hash_rw_thr_reader(void *_count)
{
	unsigned long long *count = _count;
	struct lfht_test_node *node;
	struct cds_lfht_iter iter;

	printf_verbose("thread_begin %s, tid %lu\n",
			"reader", urcu_get_thread_id());

	URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);

	set_affinity();

	rcu_register_thread();

	while (!test_go)
	{
	}
	cmm_smp_mb();

	for (;;) {
		rcu_read_lock();
		cds_lfht_test_lookup(test_ht,
			(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % lookup_pool_size) + lookup_pool_offset),
			sizeof(void *), &iter);
		node = cds_lfht_iter_get_test_node(&iter);
		if (node == NULL) {
			if (validate_lookup) {
				printf("[ERROR] Lookup cannot find initial node.\n");
				exit(-1);
			}
			URCU_TLS(lookup_fail)++;
		} else {
			URCU_TLS(lookup_ok)++;
		}
		rcu_debug_yield_read();
		if (caa_unlikely(rduration))
			loop_sleep(rduration);
		rcu_read_unlock();
		URCU_TLS(nr_reads)++;
		if (caa_unlikely(!test_duration_read()))
			break;
		if (caa_unlikely((URCU_TLS(nr_reads) & ((1 << 10) - 1)) == 0))
			rcu_quiescent_state();
	}

	rcu_unregister_thread();

	*count = URCU_TLS(nr_reads);
	printf_verbose("thread_end %s, tid %lu\n",
			"reader", urcu_get_thread_id());
	printf_verbose("read tid : %lx, lookupfail %lu, lookupok %lu\n",
			urcu_get_thread_id(),
			URCU_TLS(lookup_fail),
			URCU_TLS(lookup_ok));
	return ((void*)1);

}

void *test_hash_rw_thr_writer(void *_count)
{
	struct lfht_test_node *node;
	struct cds_lfht_node *ret_node;
	struct cds_lfht_iter iter;
	struct wr_count *count = _count;
	int ret;

	printf_verbose("thread_begin %s, tid %lu\n",
			"writer", urcu_get_thread_id());

	URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);

	set_affinity();

	rcu_register_thread();

	while (!test_go)
	{
	}
	cmm_smp_mb();

	for (;;) {
		if ((addremove == AR_ADD || add_only)
				|| (addremove == AR_RANDOM && rand_r(&URCU_TLS(rand_lookup)) & 1)) {
			node = malloc(sizeof(struct lfht_test_node));
			lfht_test_node_init(node,
				(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
				sizeof(void *));
			rcu_read_lock();
			if (add_unique) {
				ret_node = cds_lfht_add_unique(test_ht,
					test_hash(node->key, node->key_len, TEST_HASH_SEED),
					test_match, node->key, &node->node);
			} else {
				if (add_replace)
					ret_node = cds_lfht_add_replace(test_ht,
							test_hash(node->key, node->key_len, TEST_HASH_SEED),
							test_match, node->key, &node->node);
				else
					cds_lfht_add(test_ht,
						test_hash(node->key, node->key_len, TEST_HASH_SEED),
						&node->node);
			}
			rcu_read_unlock();
			if (add_unique && ret_node != &node->node) {
				free(node);
				URCU_TLS(nr_addexist)++;
			} else {
				if (add_replace && ret_node) {
					call_rcu(&to_test_node(ret_node)->head,
							free_node_cb);
					URCU_TLS(nr_addexist)++;
				} else {
					URCU_TLS(nr_add)++;
				}
			}
		} else {
			/* May delete */
			rcu_read_lock();
			cds_lfht_test_lookup(test_ht,
				(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
				sizeof(void *), &iter);
			ret = cds_lfht_del(test_ht, cds_lfht_iter_get_node(&iter));
			rcu_read_unlock();
			if (ret == 0) {
				node = cds_lfht_iter_get_test_node(&iter);
				call_rcu(&node->head, free_node_cb);
				URCU_TLS(nr_del)++;
			} else
				URCU_TLS(nr_delnoent)++;
		}
#if 0
		//if (URCU_TLS(nr_writes) % 100000 == 0) {
		if (URCU_TLS(nr_writes) % 1000 == 0) {
			rcu_read_lock();
			if (rand_r(&URCU_TLS(rand_lookup)) & 1) {
				ht_resize(test_ht, 1);
			} else {
				ht_resize(test_ht, -1);
			}
			rcu_read_unlock();
		}
#endif //0
		URCU_TLS(nr_writes)++;
		if (caa_unlikely(!test_duration_write()))
			break;
		if (caa_unlikely(wdelay))
			loop_sleep(wdelay);
		if (caa_unlikely((URCU_TLS(nr_writes) & ((1 << 10) - 1)) == 0))
			rcu_quiescent_state();
	}

	rcu_unregister_thread();

	printf_verbose("thread_end %s, tid %lu\n",
			"writer", urcu_get_thread_id());
	printf_verbose("info tid %lu: nr_add %lu, nr_addexist %lu, nr_del %lu, "
			"nr_delnoent %lu\n", urcu_get_thread_id(),
			URCU_TLS(nr_add),
			URCU_TLS(nr_addexist),
			URCU_TLS(nr_del),
			URCU_TLS(nr_delnoent));
	count->update_ops = URCU_TLS(nr_writes);
	count->add = URCU_TLS(nr_add);
	count->add_exist = URCU_TLS(nr_addexist);
	count->remove = URCU_TLS(nr_del);
	return ((void*)2);
}

int test_hash_rw_populate_hash(void)
{
	struct lfht_test_node *node;
	struct cds_lfht_node *ret_node;

	if (!init_populate)
		return 0;

	printf("Starting rw test\n");

	URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);

	if ((add_unique || add_replace) && init_populate * 10 > init_pool_size) {
		printf("WARNING: required to populate %lu nodes (-k), but random "
"pool is quite small (%lu values) and we are in add_unique (-u) or add_replace (-s) mode. Try with a "
"larger random pool (-p option). This may take a while...\n", init_populate, init_pool_size);
	}

	while (URCU_TLS(nr_add) < init_populate) {
		node = malloc(sizeof(struct lfht_test_node));
		lfht_test_node_init(node,
			(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % init_pool_size) + init_pool_offset),
			sizeof(void *));
		rcu_read_lock();
		if (add_unique) {
			ret_node = cds_lfht_add_unique(test_ht,
				test_hash(node->key, node->key_len, TEST_HASH_SEED),
				test_match, node->key, &node->node);
		} else {
			if (add_replace)
				ret_node = cds_lfht_add_replace(test_ht,
						test_hash(node->key, node->key_len, TEST_HASH_SEED),
						test_match, node->key, &node->node);
			else
				cds_lfht_add(test_ht,
					test_hash(node->key, node->key_len, TEST_HASH_SEED),
					&node->node);
		}
		rcu_read_unlock();
		if (add_unique && ret_node != &node->node) {
			free(node);
			URCU_TLS(nr_addexist)++;
		} else {
			if (add_replace && ret_node) {
				call_rcu(&to_test_node(ret_node)->head, free_node_cb);
				URCU_TLS(nr_addexist)++;
			} else {
				URCU_TLS(nr_add)++;
			}
		}
		URCU_TLS(nr_writes)++;
	}
	return 0;
}
Commit	Line	Data
18ca7a5b MD	1	/*
	2	* test_urcu_hash_rw.c
	3	*
	4	* Userspace RCU library - test program
	5	*
	6	* Copyright 2009-2012 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; if not, write to the Free Software Foundation, Inc.,
	20	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	21	*/
	22
	23	#define _GNU_SOURCE
	24	#include "test_urcu_hash.h"
	25
	26	enum urcu_hash_addremove {
	27	AR_RANDOM = 0,
	28	AR_ADD = 1,
	29	AR_REMOVE = -1,
	30	}; /* 1: add, -1 remove, 0: random */
	31
	32	static enum urcu_hash_addremove addremove; /* 1: add, -1 remove, 0: random */
	33
	34	void test_hash_rw_sigusr1_handler(int signo)
	35	{
	36	switch (addremove) {
	37	case AR_ADD:
	38	printf("Add/Remove: random.\n");
	39	addremove = AR_RANDOM;
	40	break;
	41	case AR_RANDOM:
	42	printf("Add/Remove: remove only.\n");
	43	addremove = AR_REMOVE;
	44	break;
	45	case AR_REMOVE:
	46	printf("Add/Remove: add only.\n");
	47	addremove = AR_ADD;
	48	break;
	49	}
	50	}
	51
	52	void test_hash_rw_sigusr2_handler(int signo)
	53	{
	54	char msg[1] = { 0x42 };
	55	ssize_t ret;
	56
	57	do {
	58	ret = write(count_pipe[1], msg, 1); /* wakeup thread */
	59	} while (ret == -1L && errno == EINTR);
	60	}
	61
	62	void test_hash_rw_thr_reader(void _count)
	63	{
	64	unsigned long long *count = _count;
65	struct lfht_test_node *node;
66	struct cds_lfht_iter iter;
67
94df6318 MD	68	printf_verbose("thread_begin %s, tid %lu\n",
94df6318 MD	69	"reader", urcu_get_thread_id());
18ca7a5b	70
98f483d2 MD	71	URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
98f483d2 MD	72
18ca7a5b MD	73	set_affinity();
	74
	75	rcu_register_thread();
	76
	77	while (!test_go)
	78	{
	79	}
	80	cmm_smp_mb();
	81
	82	for (;;) {
	83	rcu_read_lock();
	84	cds_lfht_test_lookup(test_ht,
bd252a04	85	(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % lookup_pool_size) + lookup_pool_offset),
18ca7a5b MD	86	sizeof(void *), &iter);
	87	node = cds_lfht_iter_get_test_node(&iter);
	88	if (node == NULL) {
	89	if (validate_lookup) {
	90	printf("[ERROR] Lookup cannot find initial node.\n");
	91	exit(-1);
	92	}
bd252a04	93	URCU_TLS(lookup_fail)++;
18ca7a5b	94	} else {
bd252a04	95	URCU_TLS(lookup_ok)++;
18ca7a5b	96	}
1de4df4b	97	rcu_debug_yield_read();
18ca7a5b MD	98	if (caa_unlikely(rduration))
	99	loop_sleep(rduration);
	100	rcu_read_unlock();
bd252a04	101	URCU_TLS(nr_reads)++;
18ca7a5b MD	102	if (caa_unlikely(!test_duration_read()))
18ca7a5b MD	103	break;
bd252a04	104	if (caa_unlikely((URCU_TLS(nr_reads) & ((1 << 10) - 1)) == 0))
18ca7a5b MD	105	rcu_quiescent_state();
	106	}
	107
	108	rcu_unregister_thread();
	109
bd252a04	110	*count = URCU_TLS(nr_reads);
94df6318 MD	111	printf_verbose("thread_end %s, tid %lu\n",
	112	"reader", urcu_get_thread_id());
	113	printf_verbose("read tid : %lx, lookupfail %lu, lookupok %lu\n",
	114	urcu_get_thread_id(),
	115	URCU_TLS(lookup_fail),
bd252a04	116	URCU_TLS(lookup_ok));
18ca7a5b MD	117	return ((void*)1);
	118
	119	}
	120
	121	void test_hash_rw_thr_writer(void _count)
	122	{
	123	struct lfht_test_node *node;
	124	struct cds_lfht_node *ret_node;
	125	struct cds_lfht_iter iter;
	126	struct wr_count *count = _count;
	127	int ret;
	128
94df6318 MD	129	printf_verbose("thread_begin %s, tid %lu\n",
94df6318 MD	130	"writer", urcu_get_thread_id());
18ca7a5b	131
98f483d2 MD	132	URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
98f483d2 MD	133
18ca7a5b MD	134	set_affinity();
	135
	136	rcu_register_thread();
	137
	138	while (!test_go)
	139	{
	140	}
	141	cmm_smp_mb();
	142
	143	for (;;) {
	144	if ((addremove == AR_ADD \|\| add_only)
bd252a04	145	\|\| (addremove == AR_RANDOM && rand_r(&URCU_TLS(rand_lookup)) & 1)) {
18ca7a5b MD	146	node = malloc(sizeof(struct lfht_test_node));
18ca7a5b MD	147	lfht_test_node_init(node,
bd252a04	148	(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
18ca7a5b MD	149	sizeof(void *));
	150	rcu_read_lock();
	151	if (add_unique) {
	152	ret_node = cds_lfht_add_unique(test_ht,
	153	test_hash(node->key, node->key_len, TEST_HASH_SEED),
	154	test_match, node->key, &node->node);
	155	} else {
	156	if (add_replace)
	157	ret_node = cds_lfht_add_replace(test_ht,
	158	test_hash(node->key, node->key_len, TEST_HASH_SEED),
	159	test_match, node->key, &node->node);
	160	else
	161	cds_lfht_add(test_ht,
	162	test_hash(node->key, node->key_len, TEST_HASH_SEED),
	163	&node->node);
	164	}
	165	rcu_read_unlock();
	166	if (add_unique && ret_node != &node->node) {
	167	free(node);
bd252a04	168	URCU_TLS(nr_addexist)++;
18ca7a5b MD	169	} else {
	170	if (add_replace && ret_node) {
	171	call_rcu(&to_test_node(ret_node)->head,
	172	free_node_cb);
bd252a04	173	URCU_TLS(nr_addexist)++;
18ca7a5b	174	} else {
bd252a04	175	URCU_TLS(nr_add)++;
18ca7a5b MD	176	}
	177	}
	178	} else {
	179	/* May delete */
	180	rcu_read_lock();
	181	cds_lfht_test_lookup(test_ht,
bd252a04	182	(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % write_pool_size) + write_pool_offset),
18ca7a5b MD	183	sizeof(void *), &iter);
	184	ret = cds_lfht_del(test_ht, cds_lfht_iter_get_node(&iter));
	185	rcu_read_unlock();
	186	if (ret == 0) {
	187	node = cds_lfht_iter_get_test_node(&iter);
	188	call_rcu(&node->head, free_node_cb);
bd252a04	189	URCU_TLS(nr_del)++;
18ca7a5b	190	} else
bd252a04	191	URCU_TLS(nr_delnoent)++;
18ca7a5b MD	192	}
18ca7a5b MD	193	#if 0
bd252a04 MD	194	//if (URCU_TLS(nr_writes) % 100000 == 0) {
bd252a04 MD	195	if (URCU_TLS(nr_writes) % 1000 == 0) {
18ca7a5b	196	rcu_read_lock();
bd252a04	197	if (rand_r(&URCU_TLS(rand_lookup)) & 1) {
18ca7a5b MD	198	ht_resize(test_ht, 1);
	199	} else {
	200	ht_resize(test_ht, -1);
	201	}
	202	rcu_read_unlock();
	203	}
	204	#endif //0
bd252a04	205	URCU_TLS(nr_writes)++;
18ca7a5b MD	206	if (caa_unlikely(!test_duration_write()))
	207	break;
	208	if (caa_unlikely(wdelay))
	209	loop_sleep(wdelay);
bd252a04	210	if (caa_unlikely((URCU_TLS(nr_writes) & ((1 << 10) - 1)) == 0))
18ca7a5b MD	211	rcu_quiescent_state();
	212	}
	213
	214	rcu_unregister_thread();
	215
94df6318 MD	216	printf_verbose("thread_end %s, tid %lu\n",
	217	"writer", urcu_get_thread_id());
	218	printf_verbose("info tid %lu: nr_add %lu, nr_addexist %lu, nr_del %lu, "
	219	"nr_delnoent %lu\n", urcu_get_thread_id(),
	220	URCU_TLS(nr_add),
	221	URCU_TLS(nr_addexist),
	222	URCU_TLS(nr_del),
bd252a04 MD	223	URCU_TLS(nr_delnoent));
	224	count->update_ops = URCU_TLS(nr_writes);
	225	count->add = URCU_TLS(nr_add);
	226	count->add_exist = URCU_TLS(nr_addexist);
	227	count->remove = URCU_TLS(nr_del);
18ca7a5b MD	228	return ((void*)2);
	229	}
	230
	231	int test_hash_rw_populate_hash(void)
	232	{
	233	struct lfht_test_node *node;
	234	struct cds_lfht_node *ret_node;
	235
	236	if (!init_populate)
	237	return 0;
	238
2af6e536 MD	239	printf("Starting rw test\n");
2af6e536 MD	240
98f483d2 MD	241	URCU_TLS(rand_lookup) = urcu_get_thread_id() ^ time(NULL);
98f483d2 MD	242
18ca7a5b MD	243	if ((add_unique \|\| add_replace) && init_populate * 10 > init_pool_size) {
	244	printf("WARNING: required to populate %lu nodes (-k), but random "
	245	"pool is quite small (%lu values) and we are in add_unique (-u) or add_replace (-s) mode. Try with a "
	246	"larger random pool (-p option). This may take a while...\n", init_populate, init_pool_size);
	247	}
	248
bd252a04	249	while (URCU_TLS(nr_add) < init_populate) {
18ca7a5b MD	250	node = malloc(sizeof(struct lfht_test_node));
18ca7a5b MD	251	lfht_test_node_init(node,
bd252a04	252	(void *)(((unsigned long) rand_r(&URCU_TLS(rand_lookup)) % init_pool_size) + init_pool_offset),
18ca7a5b MD	253	sizeof(void *));
	254	rcu_read_lock();
	255	if (add_unique) {
	256	ret_node = cds_lfht_add_unique(test_ht,
	257	test_hash(node->key, node->key_len, TEST_HASH_SEED),
	258	test_match, node->key, &node->node);
	259	} else {
	260	if (add_replace)
	261	ret_node = cds_lfht_add_replace(test_ht,
	262	test_hash(node->key, node->key_len, TEST_HASH_SEED),
	263	test_match, node->key, &node->node);
	264	else
	265	cds_lfht_add(test_ht,
	266	test_hash(node->key, node->key_len, TEST_HASH_SEED),
	267	&node->node);
	268	}
	269	rcu_read_unlock();
	270	if (add_unique && ret_node != &node->node) {
	271	free(node);
bd252a04	272	URCU_TLS(nr_addexist)++;
18ca7a5b MD	273	} else {
	274	if (add_replace && ret_node) {
	275	call_rcu(&to_test_node(ret_node)->head, free_node_cb);
bd252a04	276	URCU_TLS(nr_addexist)++;
18ca7a5b	277	} else {
bd252a04	278	URCU_TLS(nr_add)++;
18ca7a5b MD	279	}
18ca7a5b MD	280	}
bd252a04	281	URCU_TLS(nr_writes)++;
18ca7a5b MD	282	}
	283	return 0;
	284	}