X-Git-Url: http://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=urcu%2Frculfhash.h;h=06e3eb9cc64d4bc659adb70086662524a3fe8614;hp=008b1d49f55ae86ae4bcdf86c2ce2a8c0a1c7617;hb=0b0627bf31ff2393658a0285e342887df6688b18;hpb=cc6b0c208a9707f8a64609a51167290caeace288 diff --git a/urcu/rculfhash.h b/urcu/rculfhash.h index 008b1d4..06e3eb9 100644 --- a/urcu/rculfhash.h +++ b/urcu/rculfhash.h @@ -26,6 +26,7 @@ */ #include +#include #include #ifdef __cplusplus @@ -33,38 +34,24 @@ extern "C" { #endif /* - * struct cds_lfht_node and struct _cds_lfht_node should be aligned on - * 4-bytes boundaries because the two lower bits are used as flags. - */ - -/* - * _cds_lfht_node: Contains the internal pointers and reverse-hash + * cds_lfht_node: Contains the next pointers and reverse-hash * value required for lookup and traversal of the hash table. - */ -struct _cds_lfht_node { - struct cds_lfht_node *next; /* ptr | DUMMY_FLAG | REMOVED_FLAG */ - unsigned long reverse_hash; -} __attribute__((aligned(4))); - -/* - * cds_lfht_node: Contains the full key and length required to check for - * an actual match, and also contains an rcu_head structure that is used - * by RCU to track a node through a given RCU grace period. There is an - * instance of _cds_lfht_node enclosed as a field within each - * _cds_lfht_node structure. + * + * struct cds_lfht_node should be aligned on 4-bytes boundaries because + * the two lower bits are used as flags. * * struct cds_lfht_node can be embedded into a structure (as a field). * caa_container_of() can be used to get the structure from the struct * cds_lfht_node after a lookup. + * + * The structure which embeds it typically holds the key (or key-value + * pair) of the object. The caller code is responsible for calculation + * of the hash value for cds_lfht APIs. */ struct cds_lfht_node { - /* cache-hot for iteration */ - struct _cds_lfht_node p; /* needs to be first field */ - void *key; - unsigned int key_len; - /* cache-cold for iteration */ - struct rcu_head head; -}; + struct cds_lfht_node *next; /* ptr | BUCKET_FLAG | REMOVED_FLAG */ + unsigned long reverse_hash; +} __attribute__((aligned(4))); /* cds_lfht_iter: Used to track state while traversing a hash chain. */ struct cds_lfht_iter { @@ -86,18 +73,18 @@ struct cds_lfht; typedef unsigned long (*cds_lfht_hash_fct)(void *key, size_t length, unsigned long seed); -typedef unsigned long (*cds_lfht_compare_fct)(void *key1, size_t key1_len, - void *key2, size_t key2_len); +typedef int (*cds_lfht_match_fct)(struct cds_lfht_node *node, void *key); /* * cds_lfht_node_init - initialize a hash table node + * @node: the node to initialize. + * + * This function is kept to be eventually used for debugging purposes + * (detection of memory corruption). */ static inline -void cds_lfht_node_init(struct cds_lfht_node *node, void *key, - size_t key_len) +void cds_lfht_node_init(struct cds_lfht_node *node) { - node->key = key; - node->key_len = key_len; } /* @@ -111,10 +98,7 @@ enum { /* * _cds_lfht_new - API used by cds_lfht_new wrapper. Do not use directly. */ -struct cds_lfht *_cds_lfht_new(cds_lfht_hash_fct hash_fct, - cds_lfht_compare_fct compare_fct, - unsigned long hash_seed, - unsigned long init_size, +struct cds_lfht *_cds_lfht_new(unsigned long init_size, unsigned long min_alloc_size, int flags, void (*cds_lfht_call_rcu)(struct rcu_head *head, @@ -130,9 +114,6 @@ struct cds_lfht *_cds_lfht_new(cds_lfht_hash_fct hash_fct, /* * cds_lfht_new - allocate a hash table. - * @hash_fct: the hashing function. - * @compare_fct: the key comparison function. - * @hash_seed: the seed for hash function. * @init_size: number of nodes to allocate initially. Must be power of two. * @min_alloc_size: the smallest allocation size to use. Must be power of two. * @flags: hash table creation flags (can be combined with bitwise or: '|'). @@ -153,16 +134,12 @@ struct cds_lfht *_cds_lfht_new(cds_lfht_hash_fct hash_fct, * Threads calling this API need to be registered RCU read-side threads. */ static inline -struct cds_lfht *cds_lfht_new(cds_lfht_hash_fct hash_fct, - cds_lfht_compare_fct compare_fct, - unsigned long hash_seed, - unsigned long init_size, +struct cds_lfht *cds_lfht_new(unsigned long init_size, unsigned long min_alloc_size, int flags, pthread_attr_t *attr) { - return _cds_lfht_new(hash_fct, compare_fct, hash_seed, - init_size, min_alloc_size, flags, + return _cds_lfht_new(init_size, min_alloc_size, flags, call_rcu, synchronize_rcu, rcu_read_lock, rcu_read_unlock, rcu_thread_offline, rcu_thread_online, rcu_register_thread, @@ -189,6 +166,7 @@ int cds_lfht_destroy(struct cds_lfht *ht, pthread_attr_t **attr); * @count: Traverse the hash table, count the number of nodes observed. * @removed: Number of logically removed nodes observed during traversal. * @split_count_after: Sample the node count split-counter after traversal. + * * Call with rcu_read_lock held. * Threads calling this API need to be registered RCU read-side threads. */ @@ -200,16 +178,23 @@ void cds_lfht_count_nodes(struct cds_lfht *ht, /* * cds_lfht_lookup - lookup a node by key. + * @ht: the hash table. + * @match: the key match function. + * @hash: the key hash. + * @iter: Node, if found (output). *iter->node set to NULL if not found. * - * Output in "*iter". *iter->node set to NULL if not found. * Call with rcu_read_lock held. * Threads calling this API need to be registered RCU read-side threads. */ -void cds_lfht_lookup(struct cds_lfht *ht, void *key, size_t key_len, - struct cds_lfht_iter *iter); +void cds_lfht_lookup(struct cds_lfht *ht, cds_lfht_match_fct match, + unsigned long hash, void *key, struct cds_lfht_iter *iter); /* * cds_lfht_next_duplicate - get the next item with same key (after a lookup). + * @ht: the hash table. + * @match: the key match function. + * @key: the current node key. + * @iter: Node, if found (output). *iter->node set to NULL if not found. * * Uses an iterator initialized by a lookup. * Sets *iter-node to the following node with same key. @@ -220,10 +205,14 @@ void cds_lfht_lookup(struct cds_lfht *ht, void *key, size_t key_len, * Call with rcu_read_lock held. * Threads calling this API need to be registered RCU read-side threads. */ -void cds_lfht_next_duplicate(struct cds_lfht *ht, struct cds_lfht_iter *iter); +void cds_lfht_next_duplicate(struct cds_lfht *ht, + cds_lfht_match_fct match, void *key, + struct cds_lfht_iter *iter); /* * cds_lfht_first - get the first node in the table. + * @ht: the hash table. + * @iter: First node, if exists (output). *iter->node set to NULL if not found. * * Output in "*iter". *iter->node set to NULL if table is empty. * Call with rcu_read_lock held. @@ -233,6 +222,8 @@ void cds_lfht_first(struct cds_lfht *ht, struct cds_lfht_iter *iter); /* * cds_lfht_next - get the next node in the table. + * @ht: the hash table. + * @iter: Next node, if exists (output). *iter->node set to NULL if not found. * * Input/Output in "*iter". *iter->node set to NULL if *iter was * pointing to the last table node. @@ -243,15 +234,24 @@ void cds_lfht_next(struct cds_lfht *ht, struct cds_lfht_iter *iter); /* * cds_lfht_add - add a node to the hash table. + * @ht: the hash table. + * @hash: the key hash. + * @node: the node to add. * * This function supports adding redundant keys into the table. * Call with rcu_read_lock held. * Threads calling this API need to be registered RCU read-side threads. */ -void cds_lfht_add(struct cds_lfht *ht, struct cds_lfht_node *node); +void cds_lfht_add(struct cds_lfht *ht, unsigned long hash, + struct cds_lfht_node *node); /* * cds_lfht_add_unique - add a node to hash table, if key is not present. + * @ht: the hash table. + * @match: the key match function. + * @key: the node's key. + * @hash: the node's hash. + * @node: the node to try adding. * * Return the node added upon success. * Return the unique node already present upon failure. If @@ -266,10 +266,18 @@ void cds_lfht_add(struct cds_lfht *ht, struct cds_lfht_node *node); * add_unique and add_replace (see below). */ struct cds_lfht_node *cds_lfht_add_unique(struct cds_lfht *ht, + cds_lfht_match_fct match, + void *key, + unsigned long hash, struct cds_lfht_node *node); /* * cds_lfht_add_replace - replace or add a node within hash table. + * @ht: the hash table. + * @match: the key match function. + * @key: the node's key. + * @hash: the node's hash. + * @node: the node to add. * * Return the node replaced upon success. If no node matching the key * was present, return NULL, which also means the operation succeeded. @@ -290,10 +298,16 @@ struct cds_lfht_node *cds_lfht_add_unique(struct cds_lfht *ht, * will never generate duplicated keys. */ struct cds_lfht_node *cds_lfht_add_replace(struct cds_lfht *ht, + cds_lfht_match_fct match, + void *key, + unsigned long hash, struct cds_lfht_node *node); /* * cds_lfht_replace - replace a node pointer to by iter within hash table. + * @ht: the hash table. + * @old_iter: the iterator position of the node to replace. + * @now_node: the new node to try using for replacement. * * Return 0 if replacement is successful, negative value otherwise. * Replacing a NULL old node or an already removed node will fail with a @@ -321,6 +335,8 @@ int cds_lfht_replace(struct cds_lfht *ht, struct cds_lfht_iter *old_iter, /* * cds_lfht_del - remove node pointed to by iterator from hash table. + * @ht: the hash table. + * @iter: the iterator position of the node to delete. * * Return 0 if the node is successfully removed, negative value * otherwise. @@ -339,12 +355,50 @@ int cds_lfht_del(struct cds_lfht *ht, struct cds_lfht_iter *iter); /* * cds_lfht_resize - Force a hash table resize + * @ht: the hash table. * @new_size: update to this hash table size. * * Threads calling this API need to be registered RCU read-side threads. */ void cds_lfht_resize(struct cds_lfht *ht, unsigned long new_size); +/* + * Note: cds_lfht_for_each are safe for element removal during + * iteration. + */ +#define cds_lfht_for_each(ht, iter, node) \ + for (cds_lfht_first(ht, iter), \ + node = cds_lfht_iter_get_node(iter); \ + node != NULL; \ + cds_lfht_next(ht, iter), \ + node = cds_lfht_iter_get_node(iter)) + +#define cds_lfht_for_each_duplicate(ht, match, hash, key, iter, node) \ + for (cds_lfht_lookup(ht, match, hash, key, iter), \ + node = cds_lfht_iter_get_node(iter); \ + node != NULL; \ + cds_lfht_next_duplicate(ht, match, key, iter), \ + node = cds_lfht_iter_get_node(iter)) + +#define cds_lfht_for_each_entry(ht, iter, pos, member) \ + for (cds_lfht_first(ht, iter), \ + pos = caa_container_of(cds_lfht_iter_get_node(iter), \ + typeof(*(pos)), member); \ + &(pos)->member != NULL; \ + cds_lfht_next(ht, iter), \ + pos = caa_container_of(cds_lfht_iter_get_node(iter), \ + typeof(*(pos)), member)) + +#define cds_lfht_for_each_entry_duplicate(ht, match, hash, key, \ + iter, pos, member) \ + for (cds_lfht_lookup(ht, match, hash, key, iter), \ + pos = caa_container_of(cds_lfht_iter_get_node(iter), \ + typeof(*(pos)), member); \ + &(pos)->member != NULL; \ + cds_lfht_next_duplicate(ht, match, key, iter), \ + pos = caa_container_of(cds_lfht_iter_get_node(iter), \ + typeof(*(pos)), member)) + #ifdef __cplusplus } #endif