From: Mathieu Desnoyers Date: Sun, 29 Apr 2012 23:04:20 +0000 (-0400) Subject: rculfhash: update API comments X-Git-Tag: v0.7.0~21 X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=3a9c66db35077a0437810157ba362a68262048de;p=userspace-rcu.git rculfhash: update API comments Signed-off-by: Mathieu Desnoyers --- diff --git a/urcu/rculfhash.h b/urcu/rculfhash.h index 004c208..2d8a310 100644 --- a/urcu/rculfhash.h +++ b/urcu/rculfhash.h @@ -150,8 +150,9 @@ struct cds_lfht *_cds_lfht_new(unsigned long init_size, * this priority level. Having lower priority for call_rcu and resize threads * does not pose any correctness issue, but the resize operations could be * starved by updates, thus leading to long hash table bucket chains. - * Threads calling this API are NOT required to be registered RCU read-side - * threads. It can be called very early.(before rcu is initialized ...etc.) + * Threads calling cds_lfht_new are NOT required to be registered RCU + * read-side threads. It can be called very early. (e.g. before RCU is + * initialized) */ static inline struct cds_lfht *cds_lfht_new(unsigned long init_size, @@ -180,9 +181,9 @@ int cds_lfht_destroy(struct cds_lfht *ht, pthread_attr_t **attr); /* * cds_lfht_count_nodes - count the number of nodes in the hash table. * @ht: the hash table. - * @split_count_before: Sample the node count split-counter before traversal. - * @count: Traverse the hash table, count the number of nodes observed. - * @split_count_after: Sample the node count split-counter after traversal. + * @split_count_before: sample the node count split-counter before traversal. + * @count: traverse the hash table, count the number of nodes observed. + * @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. @@ -198,7 +199,7 @@ void cds_lfht_count_nodes(struct cds_lfht *ht, * @hash: the key hash. * @match: the key match function. * @key: the current node key. - * @iter: Node, if found (output). *iter->node set to NULL if not found. + * @iter: node, if found (output). *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. @@ -208,14 +209,16 @@ void cds_lfht_lookup(struct cds_lfht *ht, unsigned long hash, struct cds_lfht_iter *iter); /* - * cds_lfht_next_duplicate - get the next item with same key (after a lookup). + * cds_lfht_next_duplicate - get the next item with same key, after iterator. * @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. + * @iter: input: current iterator. + * output: node, if found. *iter->node set to NULL if not found. * - * Uses an iterator initialized by a lookup. Important: the iterator - * _needs_ to be initialized before calling cds_lfht_next_duplicate. + * Uses an iterator initialized by a lookup or traversal. Important: the + * iterator _needs_ to be initialized before calling + * cds_lfht_next_duplicate. * Sets *iter-node to the following node with same key. * Sets *iter->node to NULL if no following node exists with same key. * RCU read-side lock must be held across cds_lfht_lookup and @@ -242,7 +245,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. + * @iter: input: current iterator. + * output: next node, if exists. *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. @@ -275,7 +279,8 @@ void cds_lfht_add(struct cds_lfht *ht, unsigned long hash, * Return the node added upon success. * Return the unique node already present upon failure. If * cds_lfht_add_unique fails, the node passed as parameter should be - * freed by the caller. + * freed by the caller. In this case, the caller does NOT need to wait + * for a grace period before freeing the node. * Call with rcu_read_lock held. * Threads calling this API need to be registered RCU read-side threads. * @@ -306,10 +311,11 @@ struct cds_lfht_node *cds_lfht_add_unique(struct cds_lfht *ht, * After successful replacement, a grace period must be waited for before * freeing the memory reserved for the returned node. * - * The semantic of replacement vs lookups is the following: if lookups - * are performed between a key unique insertion and its removal, we - * guarantee that the lookups and get next will always find exactly one - * instance of the key if it is replaced concurrently with the lookups. + * The semantic of replacement vs lookups and traversals is the + * following: if lookups and traversals are performed between a key + * unique insertion and its removal, we guarantee that the lookups and + * traversals will always find exactly one instance of the key if it is + * replaced concurrently with the lookups. * * Providing this semantic allows us to ensure that replacement-only * schemes will never generate duplicated keys. It also allows us to @@ -344,15 +350,8 @@ struct cds_lfht_node *cds_lfht_add_replace(struct cds_lfht *ht, * freeing the memory reserved for the old node (which can be accessed * with cds_lfht_iter_get_node). * - * The semantic of replacement vs lookups is the following: if lookups - * are performed between a key unique insertion and its removal, we - * guarantee that the lookups and get next will always find exactly one - * instance of the key if it is replaced concurrently with the lookups. - * - * Providing this semantic allows us to ensure that replacement-only - * schemes will never generate duplicated keys. It also allows us to - * guarantee that a combination of add_replace and add_unique updates - * will never generate duplicated keys. + * The semantic of replacement vs lookups is the same as + * cds_lfht_add_replace(). */ int cds_lfht_replace(struct cds_lfht *ht, struct cds_lfht_iter *old_iter, @@ -382,7 +381,7 @@ int cds_lfht_replace(struct cds_lfht *ht, int cds_lfht_del(struct cds_lfht *ht, struct cds_lfht_node *node); /* - * cds_lfht_is_node_deleted - query if a node is removed from hash table. + * cds_lfht_is_node_deleted - query whether a node is removed from hash table. * * Return non-zero if the node is deleted from the hash table, 0 * otherwise. @@ -405,8 +404,9 @@ int cds_lfht_is_node_deleted(struct cds_lfht_node *node); void cds_lfht_resize(struct cds_lfht *ht, unsigned long new_size); /* - * Note: cds_lfht_for_each are safe for element removal during - * iteration. + * Note: it is safe to perform element removal (del), replacement, or + * any hash table update operation during any of the following hash + * table traversals. */ #define cds_lfht_for_each(ht, iter, node) \ for (cds_lfht_first(ht, iter), \