X-Git-Url: https://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=urcu%2Frculfhash.h;fp=urcu%2Frculfhash.h;h=2d8a3104d7c18f5e94a5677c5fcca9870363b12d;hp=004c20817b8585e1cecc21f37068b8725b8a5d43;hb=3a9c66db35077a0437810157ba362a68262048de;hpb=1f67ba508705ff89b0048c9091e94efa938cac71

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),					\