X-Git-Url: http://git.liburcu.org/?p=urcu.git;a=blobdiff_plain;f=urcu%2Frculfhash.h;h=359edb574661400d53c3a2a94c79bf185fa67eb7;hp=8f501ea29b7b1e549c9b2d87f9ecf2e769251af0;hb=48ed1c184a1aa1da7d84c2d0bc1b9528627248ac;hpb=01dbfa62037e08aa2d08ab0e721267ccdd99b947 diff --git a/urcu/rculfhash.h b/urcu/rculfhash.h index 8f501ea..359edb5 100644 --- a/urcu/rculfhash.h +++ b/urcu/rculfhash.h @@ -21,6 +21,8 @@ * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Include this file _after_ including your URCU flavor. */ #include @@ -32,13 +34,13 @@ extern "C" { /* * 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. + * 8-bytes boundaries because the two lower bits are used as flags. */ struct _cds_lfht_node { - struct cds_lfht_node *next; /* ptr | DUMMY_FLAG | REMOVED_FLAG */ + struct cds_lfht_node *next; /* ptr | DUMMY_FLAG | GC_FLAG | REMOVED_FLAG */ unsigned long reverse_hash; -}; +} __attribute__((aligned(8))); struct cds_lfht_node { /* cache-hot for iteration */ @@ -80,12 +82,9 @@ enum { }; /* - * cds_lfht_new - allocate a hash table. - * - * init_size must be power of two. - * Return NULL on error. + * _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, +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, @@ -94,14 +93,61 @@ struct cds_lfht *cds_lfht_new(cds_lfht_hash_fct hash_fct, void (*func)(struct rcu_head *head)), void (*cds_lfht_synchronize_rcu)(void), void (*cds_lfht_rcu_read_lock)(void), - void (*cds_lfht_rcu_read_unlock)(void)); + void (*cds_lfht_rcu_read_unlock)(void), + void (*cds_lfht_rcu_thread_offline)(void), + void (*cds_lfht_rcu_thread_online)(void), + void (*cds_lfht_rcu_register_thread)(void), + void (*cds_lfht_rcu_unregister_thread)(void), + pthread_attr_t *attr); + +/* + * 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. + * @flags: hash table creation flags (can be combined with bitwise or: '|'). + * 0: no flags. + * CDS_LFHT_AUTO_RESIZE: automatically resize hash table. + * @attr: optional resize worker thread attributes. NULL for default. + * + * Return NULL on error. + * Note: the RCU flavor must be already included before the hash table header. + * + * The programmer is responsible for ensuring that resize operation has a + * priority equal to hash table updater threads. It should be performed by + * specifying the appropriate priority in the pthread "attr" argument, and, + * for CDS_LFHT_AUTO_RESIZE, by ensuring that call_rcu worker threads also have + * 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. + */ +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, + int flags, + pthread_attr_t *attr) +{ + return _cds_lfht_new(hash_fct, compare_fct, hash_seed, + init_size, flags, + call_rcu, synchronize_rcu, rcu_read_lock, + rcu_read_unlock, rcu_thread_offline, + rcu_thread_online, rcu_register_thread, + rcu_unregister_thread, attr); +} /* * cds_lfht_destroy - destroy a hash table. + * @ht: the hash table to destroy. + * @attr: (output) resize worker thread attributes, as received by cds_lfht_new. + * The caller will typically want to free this pointer if dynamically + * allocated. * * Return 0 on success, negative error value on error. */ -int cds_lfht_destroy(struct cds_lfht *ht); +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. @@ -125,8 +171,8 @@ struct cds_lfht_node *cds_lfht_lookup(struct cds_lfht *ht, void *key, size_t key * * Return NULL if no following node exists with same key. * RCU read-side lock must be held across cds_lfht_lookup and cds_lfht_next calls, and also - * between cds_lfht_next calls using the node returned by a previous cds_lfht_next. - * Call with rcu_read_lock held. + * between cds_lfht_next calls using the node returned by a previous + * cds_lfht_next. Call with rcu_read_lock held. */ struct cds_lfht_node *cds_lfht_next(struct cds_lfht *ht, struct cds_lfht_node *node); @@ -134,6 +180,7 @@ struct cds_lfht_node *cds_lfht_next(struct cds_lfht *ht, struct cds_lfht_node *n * cds_lfht_add - add a node to the hash table. * * Call with rcu_read_lock held. + * This function supports adding redundant keys into the table. */ void cds_lfht_add(struct cds_lfht *ht, struct cds_lfht_node *node); @@ -141,20 +188,56 @@ void cds_lfht_add(struct cds_lfht *ht, struct cds_lfht_node *node); * cds_lfht_add_unique - add a node to hash table, if key is not present. * * 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. + * 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. * Call with rcu_read_lock held. + * + * The semantic of this function is that if only this function is used + * to add keys into the table, no duplicated keys should ever be + * observable in the table. The same guarantee apply for combination of + * add_unique and replace (see below). */ struct cds_lfht_node *cds_lfht_add_unique(struct cds_lfht *ht, struct cds_lfht_node *node); /* - * cds_lfht_remove - remove node from hash table. + * cds_lfht_replace - replace a node within hash table. + * + * Return the node replaced upon success. If no node matching the key + * was present, return NULL, which also means the operation succeeded. + * This replacement operation should never fail. + * Call with rcu_read_lock held. + * 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 insertion and its removal, we guarantee + * that the lookups will always find the key if it is replaced + * concurrently with the lookups. Providing this guarantee require us to + * pin the node to remove in place (disallowing any insertion after this + * node temporarily) before we can proceed to its exchange with the new + * node atomically. This renders the "replace" operation not strictly + * lock-free, because a thread crashing in the middle of the replace + * operation could stop progress for other updaters. + * + * 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 replacement and add_unique updates + * will never generate duplicated keys. + */ +struct cds_lfht_node *cds_lfht_replace(struct cds_lfht *ht, struct cds_lfht_node *node); + +/* + * cds_lfht_del - remove node from hash table. * - * Node can be looked up with cds_lfht_lookup. RCU read-side lock must be held between - * lookup and removal. + * Return 0 if the node is successfully removed. + * Node can be looked up with cds_lfht_lookup. RCU read-side lock must + * be held between lookup and removal. * Call with rcu_read_lock held. + * After successful removal, a grace period must be waited for before + * freeing the memory reserved for node. */ -int cds_lfht_remove(struct cds_lfht *ht, struct cds_lfht_node *node); +int cds_lfht_del(struct cds_lfht *ht, struct cds_lfht_node *node); /* * cds_lfht_resize - Force a hash table resize