Add rcu_read_ongoing() API to each urcu flavor

[urcu.git] / rculfhash.c

diff --git a/rculfhash.c b/rculfhash.c
index 3ad3618aa7297ee5403d176d5c7f0e02be504def..e0be7dfa60860187a8e6cd39cf4b3a58d32779c5 100644 (file)
--- a/rculfhash.c
+++ b/rculfhash.c
@@ -129,7 +129,7 @@
  *  - cds_lfht_first followed iteration with cds_lfht_next (and/or
  *    cds_lfht_next_duplicate, although less common).
  *
- * We define "write" operations as any of cds_lfht_add,
+ * We define "write" operations as any of cds_lfht_add, cds_lfht_replace,
  * cds_lfht_add_unique (success), cds_lfht_add_replace, cds_lfht_del.
  *
  * When cds_lfht_add_unique succeeds (returns the node passed as
@@ -281,7 +281,7 @@
  * Split-counters lazily update the global counter each 1024
  * addition/removal. It automatically keeps track of resize required.
  * We use the bucket length as indicator for need to expand for small
- * tables and machines lacking per-cpu data suppport.
+ * tables and machines lacking per-cpu data support.
  */
 #define COUNT_COMMIT_ORDER             10
 #define DEFAULT_SPLIT_COUNT_MASK       0xFUL
@@ -381,7 +381,8 @@ uint8_t bit_reverse_u8(uint8_t v)
        return BitReverseTable256[v];
 }
 
-static __attribute__((unused))
+#if (CAA_BITS_PER_LONG == 32)
+static
 uint32_t bit_reverse_u32(uint32_t v)
 {
        return ((uint32_t) bit_reverse_u8(v) << 24) | 
@@ -389,8 +390,8 @@ uint32_t bit_reverse_u32(uint32_t v)
                ((uint32_t) bit_reverse_u8(v >> 16) << 8) | 
                ((uint32_t) bit_reverse_u8(v >> 24));
 }
-
-static __attribute__((unused))
+#else
+static
 uint64_t bit_reverse_u64(uint64_t v)
 {
        return ((uint64_t) bit_reverse_u8(v) << 56) | 
@@ -402,6 +403,7 @@ uint64_t bit_reverse_u64(uint64_t v)
                ((uint64_t) bit_reverse_u8(v >> 48) << 8) |
                ((uint64_t) bit_reverse_u8(v >> 56));
 }
+#endif
 
 static
 unsigned long bit_reverse_ulong(unsigned long v)
@@ -589,8 +591,6 @@ static void ht_init_nr_cpus_mask(void)
 static
 void alloc_split_items_count(struct cds_lfht *ht)
 {
-       struct ht_items_count *count;
-
        if (nr_cpus_mask == -1) {
                ht_init_nr_cpus_mask();
                if (nr_cpus_mask < 0)
@@ -602,7 +602,8 @@ void alloc_split_items_count(struct cds_lfht *ht)
        assert(split_count_mask >= 0);
 
        if (ht->flags & CDS_LFHT_ACCOUNTING) {
-               ht->split_count = calloc(split_count_mask + 1, sizeof(*count));
+               ht->split_count = calloc(split_count_mask + 1,
+                                       sizeof(struct ht_items_count));
                assert(ht->split_count);
        } else {
                ht->split_count = NULL;
@@ -832,13 +833,16 @@ void _cds_lfht_gc_bucket(struct cds_lfht_node *bucket, struct cds_lfht_node *nod
 
        assert(!is_bucket(bucket));
        assert(!is_removed(bucket));
+       assert(!is_removal_owner(bucket));
        assert(!is_bucket(node));
        assert(!is_removed(node));
+       assert(!is_removal_owner(node));
        for (;;) {
                iter_prev = bucket;
                /* We can always skip the bucket node initially */
                iter = rcu_dereference(iter_prev->next);
                assert(!is_removed(iter));
+               assert(!is_removal_owner(iter));
                assert(iter_prev->reverse_hash <= node->reverse_hash);
                /*
                 * We should never be called with bucket (start of chain)
@@ -859,6 +863,7 @@ void _cds_lfht_gc_bucket(struct cds_lfht_node *bucket, struct cds_lfht_node *nod
                        iter = next;
                }
                assert(!is_removed(iter));
+               assert(!is_removal_owner(iter));
                if (is_bucket(iter))
                        new_next = flag_bucket(clear_flag(next));
                else
@@ -879,8 +884,10 @@ int _cds_lfht_replace(struct cds_lfht *ht, unsigned long size,
                return -ENOENT;
 
        assert(!is_removed(old_node));
+       assert(!is_removal_owner(old_node));
        assert(!is_bucket(old_node));
        assert(!is_removed(new_node));
+       assert(!is_removal_owner(new_node));
        assert(!is_bucket(new_node));
        assert(new_node != old_node);
        for (;;) {
@@ -955,6 +962,7 @@ void _cds_lfht_add(struct cds_lfht *ht,
 
        assert(!is_bucket(node));
        assert(!is_removed(node));
+       assert(!is_removal_owner(node));
        bucket = lookup_bucket(ht, size, hash);
        for (;;) {
                uint32_t chain_len = 0;
@@ -1015,7 +1023,9 @@ void _cds_lfht_add(struct cds_lfht *ht,
        insert:
                assert(node != clear_flag(iter));
                assert(!is_removed(iter_prev));
+               assert(!is_removal_owner(iter_prev));
                assert(!is_removed(iter));
+               assert(!is_removal_owner(iter));
                assert(iter_prev != node);
                if (!bucket_flag)
                        node->next = clear_flag(iter);
@@ -1035,6 +1045,7 @@ void _cds_lfht_add(struct cds_lfht *ht,
 
        gc_node:
                assert(!is_removed(iter));
+               assert(!is_removal_owner(iter));
                if (is_bucket(iter))
                        new_next = flag_bucket(clear_flag(next));
                else
@@ -1667,12 +1678,14 @@ int cds_lfht_replace(struct cds_lfht *ht,
 
 int cds_lfht_del(struct cds_lfht *ht, struct cds_lfht_node *node)
 {
-       unsigned long size, hash;
+       unsigned long size;
        int ret;
 
        size = rcu_dereference(ht->size);
        ret = _cds_lfht_del(ht, size, node);
        if (!ret) {
+               unsigned long hash;
+
                hash = bit_reverse_ulong(node->reverse_hash);
                ht_count_del(ht, size, hash);
        }
@@ -1697,6 +1710,7 @@ int cds_lfht_delete_bucket(struct cds_lfht *ht)
                if (!is_bucket(node))
                        return -EPERM;
                assert(!is_removed(node));
+               assert(!is_removal_owner(node));
        } while (!is_end(node));
        /*
         * size accessed without rcu_dereference because hash table is
@@ -1728,8 +1742,10 @@ int cds_lfht_destroy(struct cds_lfht *ht, pthread_attr_t **attr)
        /* Wait for in-flight resize operations to complete */
        _CMM_STORE_SHARED(ht->in_progress_destroy, 1);
        cmm_smp_mb();   /* Store destroy before load resize */
+       ht->flavor->thread_offline();
        while (uatomic_read(&ht->in_progress_resize))
                poll(NULL, 0, 100);     /* wait for 100ms */
+       ht->flavor->thread_online();
        ret = cds_lfht_delete_bucket(ht);
        if (ret)
                return ret;