X-Git-Url: http://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=tests%2Ftest_urcu_hash.c;h=043a33a9353105eac57e2363693bdfb41c49f12c;hp=31113533b25187cbf71c0fd8832671d8addc24d1;hb=747d725c1dd45d5072e0e411642c4d5c6403b4be;hpb=0422d92c2d658f6093b8209f75808efd2109a110

diff --git a/tests/test_urcu_hash.c b/tests/test_urcu_hash.c
index 3111353..043a33a 100644
--- a/tests/test_urcu_hash.c
+++ b/tests/test_urcu_hash.c
@@ -109,6 +109,8 @@ struct test_data {
 
 struct lfht_test_node {
 	struct cds_lfht_node node;
+	void *key;
+	unsigned int key_len;
 	/* cache-cold for iteration */
 	struct rcu_head head;
 };
@@ -123,7 +125,9 @@ static inline
 void lfht_test_node_init(struct lfht_test_node *node, void *key,
 			size_t key_len)
 {
-	cds_lfht_node_init(&node->node, key, key_len);
+	cds_lfht_node_init(&node->node);
+	node->key = key;
+	node->key_len = key_len;
 }
 
 static inline struct lfht_test_node *
@@ -380,7 +384,7 @@ void hashword2(
 
 #if (CAA_BITS_PER_LONG == 32)
 static
-unsigned long test_hash(void *_key, size_t length, unsigned long seed)
+unsigned long test_hash(const void *_key, size_t length, unsigned long seed)
 {
 	unsigned int key = (unsigned int) _key;
 
@@ -389,7 +393,7 @@ unsigned long test_hash(void *_key, size_t length, unsigned long seed)
 }
 #else
 static
-unsigned long test_hash(void *_key, size_t length, unsigned long seed)
+unsigned long test_hash(const void *_key, size_t length, unsigned long seed)
 {
 	union {
 		uint64_t v64;
@@ -409,8 +413,8 @@ unsigned long test_hash(void *_key, size_t length, unsigned long seed)
 #endif
 
 static
-unsigned long test_compare(void *key1, size_t key1_len,
-                           void *key2, size_t key2_len)
+unsigned long test_compare(const void *key1, size_t key1_len,
+                           const void *key2, size_t key2_len)
 {
 	if (caa_unlikely(key1_len != key2_len))
 		return -1;
@@ -422,10 +426,12 @@ unsigned long test_compare(void *key1, size_t key1_len,
 }
 
 static
-int test_match(struct cds_lfht_node *node, void *arg)
+int test_match(struct cds_lfht_node *node, const void *key)
 {
-	return !test_compare(node->key, node->key_len,
-			arg, sizeof(unsigned long));
+	struct lfht_test_node *test_node = to_test_node(node);
+
+	return !test_compare(test_node->key, test_node->key_len,
+			key, sizeof(unsigned long));
 }
 
 static
@@ -434,9 +440,8 @@ void cds_lfht_test_lookup(struct cds_lfht *ht, void *key, size_t key_len,
 {
 	assert(key_len == sizeof(unsigned long));
 
-	cds_lfht_lookup(ht, test_match,
-			test_hash(key, key_len, TEST_HASH_SEED),
-			key, iter);
+	cds_lfht_lookup(ht, test_hash(key, key_len, TEST_HASH_SEED),
+			test_match, key, iter);
 }
 
 void *thr_count(void *arg)
@@ -571,17 +576,17 @@ void *thr_writer(void *_count)
 				sizeof(void *));
 			rcu_read_lock();
 			if (add_unique) {
-				ret_node = cds_lfht_add_unique(test_ht, test_match,
-					test_hash(node->node.key, node->node.key_len, TEST_HASH_SEED),
-					&node->node);
+				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_match,
-							test_hash(node->node.key, node->node.key_len, TEST_HASH_SEED),
-							&node->node);
+					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->node.key, node->node.key_len, TEST_HASH_SEED),
+						test_hash(node->key, node->key_len, TEST_HASH_SEED),
 						&node->node);
 			}
 			rcu_read_unlock();
@@ -668,17 +673,17 @@ static int populate_hash(void)
 			sizeof(void *));
 		rcu_read_lock();
 		if (add_unique) {
-			ret_node = cds_lfht_add_unique(test_ht, test_match,
-				test_hash(node->node.key, node->node.key_len, TEST_HASH_SEED),
-				&node->node);
+			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_match,
-						test_hash(node->node.key, node->node.key_len, TEST_HASH_SEED),
-						&node->node);
+				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->node.key, node->node.key_len, TEST_HASH_SEED),
+					test_hash(node->key, node->key_len, TEST_HASH_SEED),
 					&node->node);
 		}
 		rcu_read_unlock();
@@ -705,14 +710,12 @@ void test_delete_all_nodes(struct cds_lfht *ht)
 	struct lfht_test_node *node;
 	unsigned long count = 0;
 
-	cds_lfht_first(ht, &iter);
-	while ((node = cds_lfht_iter_get_test_node(&iter)) != NULL) {
+	cds_lfht_for_each_entry(ht, &iter, node, node) {
 		int ret;
 
 		ret = cds_lfht_del(test_ht, &iter);
 		assert(!ret);
 		call_rcu(&node->head, free_node_cb);
-		cds_lfht_next(ht, &iter);
 		count++;
 	}
 	printf("deleted %lu nodes.\n", count);
@@ -893,7 +896,7 @@ int main(int argc, char **argv)
 		return -1;
 	}
 
-	if (min_hash_alloc_size && min_hash_alloc_size * (min_hash_alloc_size - 1)) {
+	if (min_hash_alloc_size && min_hash_alloc_size & (min_hash_alloc_size - 1)) {
 		printf("Error: Min hash alloc size %lu is not a power of 2.\n",
 			min_hash_alloc_size);
 		return -1;
@@ -964,7 +967,7 @@ int main(int argc, char **argv)
 	 * thread from the point of view of resize.
 	 */
 	rcu_register_thread();
-	test_ht = cds_lfht_new(init_hash_size, min_hash_alloc_size,
+	test_ht = cds_lfht_new(init_hash_size, min_hash_alloc_size, (1UL << 18),
 			(opt_auto_resize ? CDS_LFHT_AUTO_RESIZE : 0) |
 			CDS_LFHT_ACCOUNTING, NULL);
       	ret = populate_hash();