rcuja: rename new_node to node in add functions

[userspace-rcu.git] / rcuja / rcuja.c

diff --git a/rcuja/rcuja.c b/rcuja/rcuja.c
index c6095956ab14f23e20227f8f05b8b317ce65646f..ca72e040d7087396dfb46ed307dd7f5ff4d0ee16 100644 (file)
--- a/rcuja/rcuja.c
+++ b/rcuja/rcuja.c
@@ -1032,7 +1032,7 @@ unsigned int ja_node_sum_distribution_1d(enum ja_recompact mode,
        for (bit_i = 0; bit_i < JA_BITS_PER_BYTE; bit_i++) {
                unsigned int distance_to_best;
 
-               distance_to_best = abs_int((nr_one[bit_i] << 1U) - distrib_nr_child);
+               distance_to_best = abs_int(((unsigned int) nr_one[bit_i] << 1U) - distrib_nr_child);
                if (distance_to_best < overall_best_distance) {
                        overall_best_distance = distance_to_best;
                        bitsel = bit_i;
@@ -1091,17 +1091,18 @@ void ja_node_sum_distribution_2d(enum ja_recompact mode,
                                continue;
                        for (bit_i = 0; bit_i < JA_BITS_PER_BYTE; bit_i++) {
                                for (bit_j = 0; bit_j < bit_i; bit_j++) {
-                                       if ((v & (1U << bit_i)) && (v & (1U << bit_j))) {
-                                               nr_2d_11[bit_i][bit_j]++;
-                                       }
-                                       if ((v & (1U << bit_i)) && !(v & (1U << bit_j))) {
-                                               nr_2d_10[bit_i][bit_j]++;
-                                       }
-                                       if (!(v & (1U << bit_i)) && (v & (1U << bit_j))) {
-                                               nr_2d_01[bit_i][bit_j]++;
-                                       }
-                                       if (!(v & (1U << bit_i)) && !(v & (1U << bit_j))) {
-                                               nr_2d_00[bit_i][bit_j]++;
+                                       if (v & (1U << bit_i)) {
+                                               if (v & (1U << bit_j)) {
+                                                       nr_2d_11[bit_i][bit_j]++;
+                                               } else {
+                                                       nr_2d_10[bit_i][bit_j]++;
+                                               }
+                                       } else {
+                                               if (v & (1U << bit_j)) {
+                                                       nr_2d_01[bit_i][bit_j]++;
+                                               } else {
+                                                       nr_2d_00[bit_i][bit_j]++;
+                                               }
                                        }
                                }
                        }
@@ -1133,17 +1134,18 @@ void ja_node_sum_distribution_2d(enum ja_recompact mode,
                                        continue;
                                for (bit_i = 0; bit_i < JA_BITS_PER_BYTE; bit_i++) {
                                        for (bit_j = 0; bit_j < bit_i; bit_j++) {
-                                               if ((v & (1U << bit_i)) && (v & (1U << bit_j))) {
-                                                       nr_2d_11[bit_i][bit_j]++;
-                                               }
-                                               if ((v & (1U << bit_i)) && !(v & (1U << bit_j))) {
-                                                       nr_2d_10[bit_i][bit_j]++;
-                                               }
-                                               if (!(v & (1U << bit_i)) && (v & (1U << bit_j))) {
-                                                       nr_2d_01[bit_i][bit_j]++;
-                                               }
-                                               if (!(v & (1U << bit_i)) && !(v & (1U << bit_j))) {
-                                                       nr_2d_00[bit_i][bit_j]++;
+                                               if (v & (1U << bit_i)) {
+                                                       if (v & (1U << bit_j)) {
+                                                               nr_2d_11[bit_i][bit_j]++;
+                                                       } else {
+                                                               nr_2d_10[bit_i][bit_j]++;
+                                                       }
+                                               } else {
+                                                       if (v & (1U << bit_j)) {
+                                                               nr_2d_01[bit_i][bit_j]++;
+                                                       } else {
+                                                               nr_2d_00[bit_i][bit_j]++;
+                                                       }
                                                }
                                        }
                                }
@@ -1167,17 +1169,18 @@ void ja_node_sum_distribution_2d(enum ja_recompact mode,
                                continue;
                        for (bit_i = 0; bit_i < JA_BITS_PER_BYTE; bit_i++) {
                                for (bit_j = 0; bit_j < bit_i; bit_j++) {
-                                       if ((i & (1U << bit_i)) && (i & (1U << bit_j))) {
-                                               nr_2d_11[bit_i][bit_j]++;
-                                       }
-                                       if ((i & (1U << bit_i)) && !(i & (1U << bit_j))) {
-                                               nr_2d_10[bit_i][bit_j]++;
-                                       }
-                                       if (!(i & (1U << bit_i)) && (i & (1U << bit_j))) {
-                                               nr_2d_01[bit_i][bit_j]++;
-                                       }
-                                       if (!(i & (1U << bit_i)) && !(i & (1U << bit_j))) {
-                                               nr_2d_00[bit_i][bit_j]++;
+                                       if (i & (1U << bit_i)) {
+                                               if (i & (1U << bit_j)) {
+                                                       nr_2d_11[bit_i][bit_j]++;
+                                               } else {
+                                                       nr_2d_10[bit_i][bit_j]++;
+                                               }
+                                       } else {
+                                               if (i & (1U << bit_j)) {
+                                                       nr_2d_01[bit_i][bit_j]++;
+                                               } else {
+                                                       nr_2d_00[bit_i][bit_j]++;
+                                               }
                                        }
                                }
                        }
@@ -1196,17 +1199,18 @@ void ja_node_sum_distribution_2d(enum ja_recompact mode,
        if (mode == JA_RECOMPACT_ADD_NEXT || mode == JA_RECOMPACT_ADD_SAME) {
                for (bit_i = 0; bit_i < JA_BITS_PER_BYTE; bit_i++) {
                        for (bit_j = 0; bit_j < bit_i; bit_j++) {
-                               if ((n & (1U << bit_i)) && (n & (1U << bit_j))) {
-                                       nr_2d_11[bit_i][bit_j]++;
-                               }
-                               if ((n & (1U << bit_i)) && !(n & (1U << bit_j))) {
-                                       nr_2d_10[bit_i][bit_j]++;
-                               }
-                               if (!(n & (1U << bit_i)) && (n & (1U << bit_j))) {
-                                       nr_2d_01[bit_i][bit_j]++;
-                               }
-                               if (!(n & (1U << bit_i)) && !(n & (1U << bit_j))) {
-                                       nr_2d_00[bit_i][bit_j]++;
+                               if (n & (1U << bit_i)) {
+                                       if (n & (1U << bit_j)) {
+                                               nr_2d_11[bit_i][bit_j]++;
+                                       } else {
+                                               nr_2d_10[bit_i][bit_j]++;
+                                       }
+                               } else {
+                                       if (n & (1U << bit_j)) {
+                                               nr_2d_01[bit_i][bit_j]++;
+                                       } else {
+                                               nr_2d_00[bit_i][bit_j]++;
+                                       }
                                }
                        }
                }
@@ -1224,10 +1228,10 @@ void ja_node_sum_distribution_2d(enum ja_recompact mode,
                for (bit_j = 0; bit_j < bit_i; bit_j++) {
                        int distance_to_best[4];
 
-                       distance_to_best[0] = (nr_2d_11[bit_i][bit_j] << 2U) - distrib_nr_child;
-                       distance_to_best[1] = (nr_2d_10[bit_i][bit_j] << 2U) - distrib_nr_child;
-                       distance_to_best[2] = (nr_2d_01[bit_i][bit_j] << 2U) - distrib_nr_child;
-                       distance_to_best[3] = (nr_2d_00[bit_i][bit_j] << 2U) - distrib_nr_child;
+                       distance_to_best[0] = ((unsigned int) nr_2d_11[bit_i][bit_j] << 2U) - distrib_nr_child;
+                       distance_to_best[1] = ((unsigned int) nr_2d_10[bit_i][bit_j] << 2U) - distrib_nr_child;
+                       distance_to_best[2] = ((unsigned int) nr_2d_01[bit_i][bit_j] << 2U) - distrib_nr_child;
+                       distance_to_best[3] = ((unsigned int) nr_2d_00[bit_i][bit_j] << 2U) - distrib_nr_child;
 
                        /* Consider worse distance above best */
                        if (distance_to_best[1] > 0 && distance_to_best[1] > distance_to_best[0])
@@ -2011,7 +2015,7 @@ end:
 
 static
 int _cds_ja_add(struct cds_ja *ja, uint64_t key,
-               struct cds_ja_node *new_node,
+               struct cds_ja_node *node,
                struct cds_ja_node **unique_node_ret)
 {
        unsigned int tree_depth, i;
@@ -2032,7 +2036,7 @@ int _cds_ja_add(struct cds_ja *ja, uint64_t key,
 
 retry:
        dbg_printf("cds_ja_add attempt: key %" PRIu64 ", node %p\n",
-               key, new_node);
+               key, node);
        parent2_node_flag = NULL;
        parent_node_flag =
                (struct cds_ja_inode_flag *) &ja->root; /* Use root ptr address as key for mutex */
@@ -2075,7 +2079,7 @@ retry:
                                parent_attach_node_flag,
                                node_flag_ptr,
                                node_flag,
-                               key, i, new_node);
+                               key, i, node);
        } else {
                if (unique_node_ret) {
                        *unique_node_ret = (struct cds_ja_node *) ja_node_ptr(node_flag);
@@ -2093,7 +2097,7 @@ retry:
                        parent_attach_node_flag,
                        attach_node_flag_ptr,
                        attach_node_flag,
-                       new_node);
+                       node);
        }
        if (ret == -EAGAIN || ret == -EEXIST)
                goto retry;
@@ -2102,22 +2106,22 @@ retry:
 }
 
 int cds_ja_add(struct cds_ja *ja, uint64_t key,
-               struct cds_ja_node *new_node)
+               struct cds_ja_node *node)
 {
-       return _cds_ja_add(ja, key, new_node, NULL);
+       return _cds_ja_add(ja, key, node, NULL);
 }
 
 struct cds_ja_node *cds_ja_add_unique(struct cds_ja *ja, uint64_t key,
-               struct cds_ja_node *new_node)
+               struct cds_ja_node *node)
 {
        int ret;
        struct cds_ja_node *ret_node;
 
-       ret = _cds_ja_add(ja, key, new_node, &ret_node);
+       ret = _cds_ja_add(ja, key, node, &ret_node);
        if (ret == -EEXIST)
                return ret_node;
        else
-               return new_node;
+               return node;
 }
 
 /*