Changeset 63e27ef in mainline for kernel/generic/src/adt/cht.c

Timestamp:

2017-06-19T21:47:42Z (7 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

deacc58d

Parents:

7354b5e

Message:

ASSERT → assert

File:

• kernel/generic/src/adt/cht.c (modified) (60 diffs)

kernel/generic/src/adt/cht.c

@@ -290 +290 @@
 #include <adt/cht.h>
 #include <adt/hash.h>
-#include <debug.h>
+#include <assert.h>
 #include <mm/slab.h>
 #include <arch/barrier.h>
@@ -522 +522 @@
         bool can_block, cht_ops_t *op)
 {
-        ASSERT(h);
-        ASSERT(op && op->hash && op->key_hash && op->equal && op->key_equal);
+        assert(h);
+        assert(op && op->hash && op->key_hash && op->equal && op->key_equal);
         /* Memoized hashes are stored in the rcu_link.func function pointer. */
-        STATIC_ASSERT(sizeof(size_t) == sizeof(rcu_func_t));
-        ASSERT(sentinel.hash == (uintptr_t)sentinel.rcu_link.func);
+        static_assert(sizeof(size_t) == sizeof(rcu_func_t), "");
+        assert(sentinel.hash == (uintptr_t)sentinel.rcu_link.func);
 
         /* All operations are compulsory. */
@@ -625 +625 @@
         
         /* You must clear the table of items. Otherwise cht_destroy will leak. */
-        ASSERT(atomic_get(&h->item_cnt) == 0);
+        assert(atomic_get(&h->item_cnt) == 0);
 }
 
@@ -685 +685 @@
 static inline cht_link_t *find_lazy(cht_t *h, void *key)
 {
-        ASSERT(h);
+        assert(h);
         /* See docs to cht_find() and cht_find_lazy(). */
-        ASSERT(rcu_read_locked());
+        assert(rcu_read_locked());
         
         size_t hash = calc_key_hash(h, key);
@@ -731 +731 @@
 cht_link_t *cht_find_next_lazy(cht_t *h, const cht_link_t *item)
 {
-        ASSERT(h);
-        ASSERT(rcu_read_locked());
-        ASSERT(item);
+        assert(h);
+        assert(rcu_read_locked());
+        assert(item);
         
         return find_duplicate(h, item, calc_node_hash(h, item), get_next(item->link));
@@ -755 +755 @@
         do {
                 cur = get_next(prev);
-                ASSERT(cur);
+                assert(cur);
                 prev = cur->link;
         } while (node_hash(h, cur) < search_hash);
@@ -770 +770 @@
                 
                 cur = get_next(cur->link);
-                ASSERT(cur);
+                assert(cur);
         } 
         
@@ -790 +790 @@
         marked_ptr_t old_head, size_t old_idx)
 {
-        ASSERT(N_INVALID == get_mark(old_head)); 
-        ASSERT(h->new_b);
+        assert(N_INVALID == get_mark(old_head)); 
+        assert(h->new_b);
         
         size_t new_idx = calc_bucket_idx(hash, h->new_b->order);
@@ -903 +903 @@
                          * traversing search_head.
                          */
-                        ASSERT(N_JOIN & get_mark(get_next(old_head)->link));
+                        assert(N_JOIN & get_mark(get_next(old_head)->link));
                         return search_bucket(h, old_head, key, hash);
                 }
@@ -913 +913 @@
                  * sure all cpus see that the new table replaced the old one.
                  */
-                ASSERT(h->b->order == h->new_b->order);
+                assert(h->b->order == h->new_b->order);
                 /* 
                  * The resizer must ensure all new bucket heads are visible before
                  * replacing the old table.
                  */
-                ASSERT(N_NORMAL == get_mark(new_head));
+                assert(N_NORMAL == get_mark(new_head));
                 return search_bucket(h, new_head, key, hash);
         }
@@ -961 +961 @@
 bool cht_insert_unique(cht_t *h, cht_link_t *item, cht_link_t **dup_item)
 {
-        ASSERT(rcu_read_locked());
-        ASSERT(dup_item);
+        assert(rcu_read_locked());
+        assert(dup_item);
         return insert_impl(h, item, dup_item);
 }
@@ -1060 +1060 @@
                 return ret == make_link(wnd->cur, jf_mark);
         } else {
-                ASSERT(walk_mode == WM_LEAVE_JOIN);
+                assert(walk_mode == WM_LEAVE_JOIN);
 
                 item->link = make_link(wnd->cur, N_NORMAL);
@@ -1087 +1087 @@
         cht_link_t *cur, cht_link_t **dup_item)
 {
-        ASSERT(cur);
-        ASSERT(cur == &sentinel || hash <= node_hash(h, cur)
+        assert(cur);
+        assert(cur == &sentinel || hash <= node_hash(h, cur)
                 || node_hash(h, cur) == h->invalid_hash);
         
@@ -1110 +1110 @@
         cht_link_t *start)
 {
-        ASSERT(hash <= node_hash(h, start) || h->invalid_hash == node_hash(h, start));
+        assert(hash <= node_hash(h, start) || h->invalid_hash == node_hash(h, start));
 
         cht_link_t *cur = start;
         
 try_again:      
-        ASSERT(cur);
+        assert(cur);
 
         while (node_hash(h, cur) == hash) {
-                ASSERT(cur != &sentinel);
+                assert(cur != &sentinel);
                 
                 bool deleted = (N_DELETED & get_mark(cur->link));
@@ -1127 +1127 @@
                 
                 cur = get_next(cur->link);
-                ASSERT(cur);
+                assert(cur);
         } 
 
@@ -1142 +1142 @@
 size_t cht_remove_key(cht_t *h, void *key)
 {
-        ASSERT(h);
+        assert(h);
         
         size_t hash = calc_key_hash(h, key);
@@ -1163 +1163 @@
 bool cht_remove_item(cht_t *h, cht_link_t *item)
 {
-        ASSERT(h);
-        ASSERT(item);
+        assert(h);
+        assert(item);
         /* Otherwise a concurrent cht_remove_key might free the item. */
-        ASSERT(rcu_read_locked());
+        assert(rcu_read_locked());
 
         /* 
@@ -1262 +1262 @@
         bool *deleted_but_gc, bool *resizing)
 {
-        ASSERT(wnd->cur && wnd->cur != &sentinel);
+        assert(wnd->cur && wnd->cur != &sentinel);
         
         *deleted_but_gc = false;
@@ -1292 +1292 @@
         bool *resizing)
 {
-        ASSERT(cur && cur != &sentinel);
+        assert(cur && cur != &sentinel);
         
         /* 
@@ -1310 +1310 @@
                 }
         } else {
-                STATIC_ASSERT(N_JOIN == N_JOIN_FOLLOWS);
+                static_assert(N_JOIN == N_JOIN_FOLLOWS, "");
                 
                 /* Keep the N_JOIN/N_JOIN_FOLLOWS mark but strip N_DELETED. */
@@ -1329 +1329 @@
         bool *resizing)
 {
-        ASSERT(wnd->cur != &sentinel);
-        ASSERT(wnd->cur && (N_DELETED & get_mark(wnd->cur->link)));
+        assert(wnd->cur != &sentinel);
+        assert(wnd->cur && (N_DELETED & get_mark(wnd->cur->link)));
         
         cht_link_t *next = get_next(wnd->cur->link);
@@ -1336 +1336 @@
         if (walk_mode == WM_LEAVE_JOIN) {
                 /* Never try to unlink join nodes. */
-                ASSERT(!(N_JOIN & get_mark(wnd->cur->link)));
+                assert(!(N_JOIN & get_mark(wnd->cur->link)));
 
                 mark_t pred_mark = get_mark(*wnd->ppred);
@@ -1348 +1348 @@
                         return false;
         } else {
-                ASSERT(walk_mode == WM_MOVE_JOIN_FOLLOWS || walk_mode == WM_NORMAL);
+                assert(walk_mode == WM_MOVE_JOIN_FOLLOWS || walk_mode == WM_NORMAL);
                 /* Move the JF mark if set. Clear DEL mark. */
                 mark_t cur_mark = N_JOIN_FOLLOWS & get_mark(wnd->cur->link);
@@ -1398 +1398 @@
         equal_pred_t pred, void *pred_arg, wnd_t *wnd, bool *resizing)
 {
-        ASSERT(wnd->cur);
+        assert(wnd->cur);
         
         if (wnd->cur == &sentinel)
@@ -1415 +1415 @@
                 
         while (cur_hash <= hash) {
-                ASSERT(wnd->cur && wnd->cur != &sentinel);
+                assert(wnd->cur && wnd->cur != &sentinel);
                 
                 /* GC any deleted nodes on the way. */
@@ -1436 +1436 @@
         if (cur_hash == h->invalid_hash) {
                 next_wnd(wnd);
-                ASSERT(wnd->cur);
+                assert(wnd->cur);
                 goto try_again;
         }
@@ -1469 +1469 @@
 {
 try_again:
-        ASSERT(wnd->cur);
+        assert(wnd->cur);
 
         while (node_hash(h, wnd->cur) < hash) {
@@ -1482 +1482 @@
                 }
                 
-                ASSERT(wnd->cur);
+                assert(wnd->cur);
         }
         
@@ -1498 +1498 @@
         bool *resizing)
 {
-        ASSERT(N_DELETED & get_mark(wnd->cur->link));
+        assert(N_DELETED & get_mark(wnd->cur->link));
 
         /* Skip deleted JOIN nodes. */
@@ -1505 +1505 @@
         } else {
                 /* Ordinary deleted node or a deleted JOIN_FOLLOWS. */
-                ASSERT(walk_mode != WM_LEAVE_JOIN 
+                assert(walk_mode != WM_LEAVE_JOIN 
                         || !((N_JOIN | N_JOIN_FOLLOWS) & get_mark(wnd->cur->link)));
 
@@ -1546 +1546 @@
          * it 
          */
-        ASSERT(h->b->order > h->new_b->order);
-        ASSERT(wnd->cur);
+        assert(h->b->order > h->new_b->order);
+        assert(wnd->cur);
         
         /* Either we did not need the joining link or we have already followed it.*/
@@ -1620 +1620 @@
                 /* The hash belongs to the moved bucket. */
                 if (move_dest_idx == new_idx) {
-                        ASSERT(pmoved_head == pnew_head);
+                        assert(pmoved_head == pnew_head);
                         /* 
                          * move_head() makes the new head of the moved bucket visible. 
                          * The new head may be marked with a JOIN_FOLLOWS
                          */
-                        ASSERT(!(N_CONST & get_mark(*pmoved_head)));
+                        assert(!(N_CONST & get_mark(*pmoved_head)));
                         *walk_mode = WM_MOVE_JOIN_FOLLOWS;
                 } else {
-                        ASSERT(pmoved_head != pnew_head);
+                        assert(pmoved_head != pnew_head);
                         /* 
                          * The hash belongs to the bucket that is the result of splitting 
@@ -1643 +1643 @@
                                  * JOIN_FOLLOWS in this part of split bucket.
                                  */
-                                ASSERT(N_NORMAL == get_mark(*pnew_head));
+                                assert(N_NORMAL == get_mark(*pnew_head));
                         }
                         
@@ -1675 +1675 @@
                 
                 /* move_head() or join_buckets() makes it so or makes the mark visible.*/
-                ASSERT(N_INVALID == get_mark(*pold_head));
+                assert(N_INVALID == get_mark(*pold_head));
                 /* move_head() makes it visible. No JOIN_FOLLOWS used when shrinking. */
-                ASSERT(N_NORMAL == get_mark(*pnew_head));
+                assert(N_NORMAL == get_mark(*pnew_head));
 
                 *walk_mode = WM_LEAVE_JOIN;
@@ -1685 +1685 @@
                  * readers to notice that the old table had been replaced.
                  */
-                ASSERT(b == h->new_b);
+                assert(b == h->new_b);
                 *walk_mode = WM_NORMAL;
         }
@@ -1712 +1712 @@
 {
         /* Head move has to in progress already when calling this func. */
-        ASSERT(N_CONST & get_mark(*psrc_head));
+        assert(N_CONST & get_mark(*psrc_head));
         
         /* Head already moved. */
@@ -1725 +1725 @@
         }
         
-        ASSERT(!(N_CONST & get_mark(*pdest_head)));
+        assert(!(N_CONST & get_mark(*pdest_head)));
 }
 
@@ -1756 +1756 @@
 static void complete_head_move(marked_ptr_t *psrc_head, marked_ptr_t *pdest_head)
 {
-        ASSERT(N_JOIN_FOLLOWS != get_mark(*psrc_head));
-        ASSERT(N_CONST & get_mark(*psrc_head));
+        assert(N_JOIN_FOLLOWS != get_mark(*psrc_head));
+        assert(N_CONST & get_mark(*psrc_head));
         
         cht_link_t *next = get_next(*psrc_head);
@@ -1763 +1763 @@
         DBG(marked_ptr_t ret = )
                 cas_link(pdest_head, &sentinel, N_INVALID, next, N_NORMAL);
-        ASSERT(ret == make_link(&sentinel, N_INVALID) || (N_NORMAL == get_mark(ret)));
+        assert(ret == make_link(&sentinel, N_INVALID) || (N_NORMAL == get_mark(ret)));
         cas_order_barrier();
         
         DBG(ret = ) 
                 cas_link(psrc_head, next, N_CONST, next, N_INVALID);    
-        ASSERT(ret == make_link(next, N_CONST) || (N_INVALID == get_mark(ret)));
+        assert(ret == make_link(next, N_CONST) || (N_INVALID == get_mark(ret)));
         cas_order_barrier();
 }
@@ -1861 +1861 @@
         DBG(marked_ptr_t ret = )
                 cas_link(pdest_head, &sentinel, N_INVALID, wnd.cur, N_NORMAL);
-        ASSERT(ret == make_link(&sentinel, N_INVALID) || (N_NORMAL == get_mark(ret)));
+        assert(ret == make_link(&sentinel, N_INVALID) || (N_NORMAL == get_mark(ret)));
         cas_order_barrier();
         
@@ -1905 +1905 @@
                 
                 /* Must not report that the table is resizing if WM_MOVE_JOIN_FOLLOWS.*/
-                ASSERT(!resizing);
+                assert(!resizing);
                 /* 
                  * Mark the last node of the first half of the split bucket 
@@ -2042 +2042 @@
         DBG(marked_ptr_t ret = )
                 cas_link(psrc_head, join_node, N_CONST, join_node, N_INVALID);
-        ASSERT(ret == make_link(join_node, N_CONST) || (N_INVALID == get_mark(ret)));
+        assert(ret == make_link(join_node, N_CONST) || (N_INVALID == get_mark(ret)));
         cas_order_barrier();
         
@@ -2073 +2073 @@
                         continue;
 
-                ASSERT(!resizing);
+                assert(!resizing);
                 
                 if (wnd.cur != &sentinel) {
                         /* Must be from the new appended bucket. */
-                        ASSERT(split_hash <= node_hash(h, wnd.cur) 
+                        assert(split_hash <= node_hash(h, wnd.cur) 
                                 || h->invalid_hash == node_hash(h, wnd.cur));
                         return;
@@ -2096 +2096 @@
 static void free_later(cht_t *h, cht_link_t *item)
 {
-        ASSERT(item != &sentinel);
+        assert(item != &sentinel);
         
         /* 
@@ -2156 +2156 @@
         
 #ifdef CONFIG_DEBUG
-        ASSERT(h->b);
+        assert(h->b);
         /* Make resize_reqs visible. */
         read_barrier();
-        ASSERT(0 < atomic_get(&h->resize_reqs));
+        assert(0 < atomic_get(&h->resize_reqs));
 #endif
 
@@ -2336 +2336 @@
                 /* Set the invalid joinee head to NULL. */
                 if (old_idx != move_src_idx) {
-                        ASSERT(N_INVALID == get_mark(h->b->head[old_idx]));
+                        assert(N_INVALID == get_mark(h->b->head[old_idx]));
                         
                         if (&sentinel != get_next(h->b->head[old_idx]))
@@ -2392 +2392 @@
         marked_ptr_t *new_head)
 {
-        ASSERT(join_node != &sentinel);
-        ASSERT(join_node && (N_JOIN & get_mark(join_node->link)));
+        assert(join_node != &sentinel);
+        assert(join_node && (N_JOIN & get_mark(join_node->link)));
         
         bool done;
@@ -2409 +2409 @@
                 /* Done if the mark was cleared. Retry if a new node was inserted. */
                 done = (ret == jn_link);
-                ASSERT(ret == jn_link || (get_mark(ret) & N_JOIN));
+                assert(ret == jn_link || (get_mark(ret) & N_JOIN));
         } while (!done);
         
@@ -2432 +2432 @@
                         join_node, &wnd, &resizing);
                 
-                ASSERT(!resizing);
+                assert(!resizing);
         } while (!done);
 }
@@ -2439 +2439 @@
 static void cleanup_join_follows(cht_t *h, marked_ptr_t *new_head)
 {
-        ASSERT(new_head);
+        assert(new_head);
         
         rcu_read_lock();
@@ -2464 +2464 @@
                 /* GC any deleted nodes on the way - even deleted JOIN_FOLLOWS. */
                 if (N_DELETED & get_mark(*cur_link)) {
-                        ASSERT(cur_link != new_head);
-                        ASSERT(wnd.ppred && wnd.cur && wnd.cur != &sentinel);
-                        ASSERT(cur_link == &wnd.cur->link);
+                        assert(cur_link != new_head);
+                        assert(wnd.ppred && wnd.cur && wnd.cur != &sentinel);
+                        assert(cur_link == &wnd.cur->link);
 
                         bool dummy;
@@ -2484 +2484 @@
                                         cas_link(cur_link, next, N_JOIN_FOLLOWS, &sentinel, N_NORMAL);
                                 
-                                ASSERT(next == &sentinel 
+                                assert(next == &sentinel 
                                         || ((N_JOIN | N_JOIN_FOLLOWS) & get_mark(ret)));
 
@@ -2505 +2505 @@
 
                 /* We must encounter a JF node before we reach the end of the bucket. */
-                ASSERT(wnd.cur && wnd.cur != &sentinel);
+                assert(wnd.cur && wnd.cur != &sentinel);
                 cur_link = &wnd.cur->link;
         }
@@ -2519 +2519 @@
 static inline size_t calc_split_hash(size_t split_idx, size_t order)
 {
-        ASSERT(1 <= order && order <= 8 * sizeof(size_t));
+        assert(1 <= order && order <= 8 * sizeof(size_t));
         return split_idx << (8 * sizeof(size_t) - order);
 }
@@ -2526 +2526 @@
 static inline size_t calc_bucket_idx(size_t hash, size_t order)
 {
-        ASSERT(1 <= order && order <= 8 * sizeof(size_t));
+        assert(1 <= order && order <= 8 * sizeof(size_t));
         return hash >> (8 * sizeof(size_t) - order);
 }
@@ -2558 +2558 @@
 static inline size_t node_hash(cht_t *h, const cht_link_t *item)
 {
-        ASSERT(item->hash == h->invalid_hash 
+        assert(item->hash == h->invalid_hash 
                 || item->hash == sentinel.hash
                 || item->hash == calc_node_hash(h, item));
@@ -2568 +2568 @@
 static inline size_t calc_node_hash(cht_t *h, const cht_link_t *item)
 {
-        ASSERT(item != &sentinel);
+        assert(item != &sentinel);
         /* 
          * Clear the lowest order bit in order for sentinel's node hash
@@ -2587 +2587 @@
         marked_ptr_t ptr = (marked_ptr_t) next;
         
-        ASSERT(!(ptr & N_MARK_MASK));
-        ASSERT(!((unsigned)mark & ~N_MARK_MASK));
+        assert(!(ptr & N_MARK_MASK));
+        assert(!((unsigned)mark & ~N_MARK_MASK));
         
         return ptr | mark;
@@ -2608 +2608 @@
 static inline void next_wnd(wnd_t *wnd)
 {
-        ASSERT(wnd);
-        ASSERT(wnd->cur);
+        assert(wnd);
+        assert(wnd->cur);
 
         wnd->last = wnd->cur;
@@ -2635 +2635 @@
         marked_ptr_t new)
 {
-        ASSERT(link != &sentinel.link);
+        assert(link != &sentinel.link);
         /*
          * cas(x) on the same location x on one cpu must be ordered, but do not