Comment cleanup: fix ascii art

[urcu.git] / rculfhash.c

diff --git a/rculfhash.c b/rculfhash.c
index b9c184fcc5f22e0e3043dd7f8b2c8a3ad2f6756f..5264a8ec7fc9747afeccbc544dad3d2b3a80a54a 100644 (file)
--- a/rculfhash.c
+++ b/rculfhash.c
@@ -119,12 +119,9 @@
  * 
  * order              bits       reverse
  * 0               0  000        000
- *                 |
- * 1               |  1  001        100       <-    <-
- *                 |  |                        |     |
- * 2               |  |  2  010        010     |     |
+ * 1               |  1  001        100             <-
+ * 2               |  |  2  010        010    <-     |
  *                 |  |  |  3  011        110  | <-  |
- *                 |  |  |  |                  |  |  |
  * 3               -> |  |  |  4  100        001  |  |
  *                    -> |  |     5  101        101  |
  *                       -> |        6  110        011
@@ -748,6 +745,7 @@ void _cds_lfht_gc_bucket(struct cds_lfht_node *dummy, struct cds_lfht_node *node
                iter_prev = dummy;
                /* We can always skip the dummy node initially */
                iter = rcu_dereference(iter_prev->p.next);
+               assert(!is_removed(iter));
                assert(iter_prev->p.reverse_hash <= node->p.reverse_hash);
                /*
                 * We should never be called with dummy (start of chain)
@@ -772,8 +770,6 @@ void _cds_lfht_gc_bucket(struct cds_lfht_node *dummy, struct cds_lfht_node *node
                        new_next = flag_dummy(clear_flag(next));
                else
                        new_next = clear_flag(next);
-               if (is_removed(iter))
-                       new_next = flag_removed(new_next);
                (void) uatomic_cmpxchg(&iter_prev->p.next, iter, new_next);
        }
        return;
@@ -787,10 +783,9 @@ int _cds_lfht_replace(struct cds_lfht *ht, unsigned long size,
 {
        struct cds_lfht_node *dummy, *ret_next;
        struct _cds_lfht_node *lookup;
-       int flagged = 0;
 
        if (!old_node)  /* Return -ENOENT if asked to replace NULL node */
-               goto end;
+               return -ENOENT;
 
        assert(!is_removed(old_node));
        assert(!is_dummy(old_node));
@@ -804,7 +799,7 @@ int _cds_lfht_replace(struct cds_lfht *ht, unsigned long size,
                         * Too late, the old node has been removed under us
                         * between lookup and replace. Fail.
                         */
-                       goto end;
+                       return -ENOENT;
                }
                assert(!is_dummy(old_next));
                assert(new_node != clear_flag(old_next));
@@ -822,13 +817,10 @@ int _cds_lfht_replace(struct cds_lfht *ht, unsigned long size,
                ret_next = uatomic_cmpxchg(&old_node->p.next,
                              old_next, flag_removed(new_node));
                if (ret_next == old_next)
-                       break;
+                       break;          /* We performed the replacement. */
                old_next = ret_next;
        }
 
-       /* We performed the replacement. */
-       flagged = 1;
-
        /*
         * Ensure that the old node is not visible to readers anymore:
         * lookup for the node, and remove it (along with any other
@@ -837,17 +829,9 @@ int _cds_lfht_replace(struct cds_lfht *ht, unsigned long size,
        lookup = lookup_bucket(ht, size, bit_reverse_ulong(old_node->p.reverse_hash));
        dummy = (struct cds_lfht_node *) lookup;
        _cds_lfht_gc_bucket(dummy, new_node);
-end:
-       /*
-        * Only the flagging action indicated that we (and no other)
-        * replaced the node from the hash table.
-        */
-       if (flagged) {
-               assert(is_removed(rcu_dereference(old_node->p.next)));
-               return 0;
-       } else {
-               return -ENOENT;
-       }
+
+       assert(is_removed(rcu_dereference(old_node->p.next)));
+       return 0;
 }
 
 /*
@@ -958,10 +942,9 @@ int _cds_lfht_del(struct cds_lfht *ht, unsigned long size,
 {
        struct cds_lfht_node *dummy, *next, *old;
        struct _cds_lfht_node *lookup;
-       int flagged = 0;
 
        if (!node)      /* Return -ENOENT if asked to delete NULL node */
-               goto end;
+               return -ENOENT;
 
        /* logically delete the node */
        assert(!is_dummy(node));
@@ -972,7 +955,7 @@ int _cds_lfht_del(struct cds_lfht *ht, unsigned long size,
 
                next = old;
                if (unlikely(is_removed(next)))
-                       goto end;
+                       return -ENOENT;
                if (dummy_removal)
                        assert(is_dummy(next));
                else
@@ -980,9 +963,7 @@ int _cds_lfht_del(struct cds_lfht *ht, unsigned long size,
                new_next = flag_removed(next);
                old = uatomic_cmpxchg(&node->p.next, next, new_next);
        } while (old != next);
-
        /* We performed the (logical) deletion. */
-       flagged = 1;
 
        /*
         * Ensure that the node is not visible to readers anymore: lookup for
@@ -992,17 +973,9 @@ int _cds_lfht_del(struct cds_lfht *ht, unsigned long size,
        lookup = lookup_bucket(ht, size, bit_reverse_ulong(node->p.reverse_hash));
        dummy = (struct cds_lfht_node *) lookup;
        _cds_lfht_gc_bucket(dummy, node);
-end:
-       /*
-        * Only the flagging action indicated that we (and no other)
-        * removed the node from the hash.
-        */
-       if (flagged) {
-               assert(is_removed(rcu_dereference(node->p.next)));
-               return 0;
-       } else {
-               return -ENOENT;
-       }
+
+       assert(is_removed(rcu_dereference(node->p.next)));
+       return 0;
 }
 
 static