* 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,
/*
* 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.
* @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.
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
/*
* 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.
* 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.
*
* 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
* 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,
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.
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), \
projects / userspace-rcu.git / commitdiff
