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

// SPDX-FileCopyrightText: 2009-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
//
// SPDX-License-Identifier: GPL-2.0-or-later

/*
 * Userspace RCU library - test program
 */

#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 __attribute__((unused)))
{
	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 __attribute__((unused)))
{
	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();

	wait_until_go();

	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_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();

	wait_until_go();

	for (;;) {
		struct cds_lfht_node *ret_node = NULL;

		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;

	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) {
		struct cds_lfht_node *ret_node = NULL;

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