projects / userspace-rcu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
rcuja: fix 8-bit overflow in 1d/2d distribution sum
[userspace-rcu.git] / rcuja / rcuja.c
diff --git a/rcuja/rcuja.c b/rcuja/rcuja.c
index 29b7d8b488d0abdad71fcef77adacb596fe6e65f..22ee01cef781e3977ba4884538b66a08697b633a 100644 (file)
--- a/rcuja/rcuja.c
+++ b/rcuja/rcuja.c
@@ -120,7 +120,9 @@ const struct cds_ja_type ja_types[] = {
        { .type_class = RCU_JA_LINEAR, .min_child = 10, .max_child = ja_type_4_max_child, .max_linear_child = ja_type_4_max_linear_child, .order = 7, },
 
        /* Pools may fill sooner than max_child */
+       /* This pool is hardcoded at index 5. See ja_node_ptr(). */
        { .type_class = RCU_JA_POOL, .min_child = 20, .max_child = ja_type_5_max_child, .max_linear_child = ja_type_5_max_linear_child, .order = 8, .nr_pool_order = ja_type_5_nr_pool_order, .pool_size_order = 7, },
+       /* This pool is hardcoded at index 6. See ja_node_ptr(). */
        { .type_class = RCU_JA_POOL, .min_child = 45, .max_child = ja_type_6_max_child, .max_linear_child = ja_type_6_max_linear_child, .order = 9, .nr_pool_order = ja_type_6_nr_pool_order, .pool_size_order = 7, },
 
        /*
@@ -168,7 +170,9 @@ const struct cds_ja_type ja_types[] = {
        { .type_class = RCU_JA_LINEAR, .min_child = 10, .max_child = ja_type_4_max_child, .max_linear_child = ja_type_4_max_linear_child, .order = 8, },
 
        /* Pools may fill sooner than max_child. */
+       /* This pool is hardcoded at index 5. See ja_node_ptr(). */
        { .type_class = RCU_JA_POOL, .min_child = 22, .max_child = ja_type_5_max_child, .max_linear_child = ja_type_5_max_linear_child, .order = 9, .nr_pool_order = ja_type_5_nr_pool_order, .pool_size_order = 8, },
+       /* This pool is hardcoded at index 6. See ja_node_ptr(). */
        { .type_class = RCU_JA_POOL, .min_child = 51, .max_child = ja_type_6_max_child, .max_linear_child = ja_type_6_max_linear_child, .order = 10, .nr_pool_order = ja_type_6_nr_pool_order, .pool_size_order = 8, },
 
        /*
@@ -261,30 +265,6 @@ unsigned long ja_node_type(struct cds_ja_inode_flag *node)
        return type;
 }
 
-struct cds_ja_inode *ja_node_ptr(struct cds_ja_inode_flag *node)
-{
-       unsigned long type_index = ja_node_type(node);
-       const struct cds_ja_type *type;
-
-       type = &ja_types[type_index];
-       switch (type->type_class) {
-       case RCU_JA_LINEAR:
-       case RCU_JA_PIGEON:     /* fall-through */
-       case RCU_JA_NULL:       /* fall-through */
-       default:                /* fall-through */
-               return _ja_node_mask_ptr(node);
-       case RCU_JA_POOL:
-               switch (type->nr_pool_order) {
-               case 1:
-                       return (struct cds_ja_inode *) (((unsigned long) node) & ~(JA_POOL_1D_MASK | JA_TYPE_MASK));
-               case 2:
-                       return (struct cds_ja_inode *) (((unsigned long) node) & ~(JA_POOL_2D_MASK | JA_POOL_1D_MASK | JA_TYPE_MASK));
-               default:
-                       assert(0);
-               }
-       }
-}
-
 static
 struct cds_ja_inode *alloc_cds_ja_node(struct cds_ja *ja,
                const struct cds_ja_type *ja_type)
@@ -1052,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;
@@ -1111,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]++;
+                                               }
                                        }
                                }
                        }
@@ -1153,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]++;
+                                                       }
                                                }
                                        }
                                }
@@ -1187,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]++;
+                                               }
                                        }
                                }
                        }
@@ -1216,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]++;
+                                       }
                                }
                        }
                }
@@ -1244,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])
Userspace RCU (urcu) for Linux
This page took 0.026023 seconds and 4 git commands to generate.