int l_remove(node_t *head, key_t key) { node_t *pred, *item, *sitem; while (TRUE) { if (!l_find(&pred, &item, head, key)) { trace("remove item failed %d\n", key); return FALSE; } sitem = STRIP_MARK(item); node_t *inext = sitem->next; /* 先标记再删除 */ if (!CAS(&sitem->next, inext, MARK(inext))) { trace("cas item %p mark failed\n", sitem->next); continue; } sitem->val = NULL_VALUE; int tag = GET_TAG(pred->next) + 1; if (CAS(&pred->next, item, TAG(STRIP_MARK(sitem->next), tag))) { trace("remove item %p success\n", item); haz_defer_free(sitem); return TRUE; } trace("cas item remove item %p failed\n", item); } return FALSE; }
int l_find(node_t **pred_ptr, node_t **item_ptr, node_t *head, key_t key) { node_t *pred = head; node_t *item = head->next; /* pred和next会被使用,所以进行标记 */ hazard_t *hp1 = haz_get(0); hazard_t *hp2 = haz_get(1); while (item) { node_t *sitem = STRIP_MARK(item); haz_set_ptr(hp1, STRIP_MARK(pred)); haz_set_ptr(hp2, STRIP_MARK(item)); /* 如果已被标记,那么紧接着item可能被移除链表甚至释放,所以需要重头查找 */ if (HAS_MARK(sitem->next)) { trace("item->next %p %p marked, retry\n", item, sitem->next); return l_find(pred_ptr, item_ptr, head, key); } int d = KEY_CMP(sitem->key, key); if (d >= 0) { trace("item %p match key %d, pred %p\n", item, key, pred); *pred_ptr = pred; *item_ptr = item; return d == 0 ? TRUE : FALSE; } pred = item; item = sitem->next; } trace("not found key %d\n", key); *pred_ptr = pred; *item_ptr = NULL; return FALSE; }
void l_free(node_t *head) { node_t *item = head->next; while (item) { node_t *next = STRIP_MARK(item->next); free((STRIP_MARK(item))); item = next; } free(head); }
int l_count(node_t *head) { int cnt = 0; node_t *item = STRIP_MARK(head->next); while (item) { if (!HAS_MARK(item->next)) { cnt ++; } item = STRIP_MARK(item->next); } return cnt; }
void sl_print (skiplist_t *sl, int verbose) { if (verbose) { for (int level = MAX_LEVELS - 1; level >= 0; --level) { node_t *item = sl->head; if (item->next[level] == DOES_NOT_EXIST) continue; printf("(%d) ", level); int i = 0; while (item) { markable_t next = item->next[level]; printf("%s%p ", HAS_MARK(next) ? "*" : "", item); item = STRIP_MARK(next); if (i++ > 30) { printf("..."); break; } } printf("\n"); fflush(stdout); } node_t *item = sl->head; int i = 0; while (item) { int is_marked = HAS_MARK(item->next[0]); printf("%s%p:0x%llx ", is_marked ? "*" : "", item, (uint64_t)item->key); if (item != sl->head) { printf("[%d]", item->num_levels); } else { printf("[HEAD]"); } for (int level = 1; level < item->num_levels; ++level) { node_t *next = STRIP_MARK(item->next[level]); is_marked = HAS_MARK(item->next[0]); printf(" %p%s", next, is_marked ? "*" : ""); if (item == sl->head && item->next[level] == DOES_NOT_EXIST) break; } printf("\n"); fflush(stdout); item = STRIP_MARK(item->next[0]); if (i++ > 30) { printf("...\n"); break; } } } printf("levels:%-2d count:%-6lld \n", sl->high_water, (uint64_t)sl_count(sl)); }
map_val_t sl_iter_next (sl_iter_t *iter, map_key_t *key_ptr) { assert(iter); node_t *item = iter->next; while (item != NULL && HAS_MARK(item->next[0])) { item = STRIP_MARK(item->next[0]); } if (item == NULL) { iter->next = NULL; return DOES_NOT_EXIST; } iter->next = STRIP_MARK(item->next[0]); if (key_ptr != NULL) { *key_ptr = item->key; } return item->val; }
value_t l_lookup(node_t *head, key_t key) { node_t *pred, *item; if (l_find(&pred, &item, head, key)) { return STRIP_MARK(item)->val; } return NULL_VALUE; }
map_key_t sl_min_key (skiplist_t *sl) { node_t *item = GET_NODE(sl->head->next[0]); while (item != NULL) { markable_t next = item->next[0]; if (!HAS_MARK(next)) return item->key; item = STRIP_MARK(next); } return DOES_NOT_EXIST; }
size_t sl_count (skiplist_t *sl) { size_t count = 0; node_t *item = GET_NODE(sl->head->next[0]); while (item) { if (!HAS_MARK(item->next[0])) { count++; } item = STRIP_MARK(item->next[0]); } return count; }
void sl_free (skiplist_t *sl) { node_t *item = GET_NODE(sl->head->next[0]); while (item) { node_t *next = STRIP_MARK(item->next[0]); if (sl->key_type != NULL) { nbd_free((void *)item->key); } nbd_free(item); item = next; } }
value_t l_insert(node_t *head, key_t key, value_t val) { node_t *pred, *item, *new_item; while (TRUE) { if (l_find(&pred, &item, head, key)) { /* update its value */ /* 更新值时,使用item->val互斥,NULL_VALUE表示被删除 */ node_t *sitem = STRIP_MARK(item); value_t old_val = sitem->val; while (old_val != NULL_VALUE) { value_t ret = CAS_V(&sitem->val, old_val, val); if (ret == old_val) { trace("update item %p value success\n", item); return ret; } trace("update item lost race %p\n", item); old_val = ret; } trace("item %p removed, retry\n", item); continue; /* the item has been removed, we retry */ } new_item = (node_t*) malloc(sizeof(node_t)); new_item->key = key; new_item->val = val; new_item->next = item; /* a). pred是否有效问题:无效只会发生在使用pred->next时,而l_remove正移除该pred 就会在CAS(&item->next)中竞争,如果remove中成功,那么insert CAS就失败, 然后重试;反之,remove失败重试,所以保证了pred有效 b). item本身增加tag一定程度上降低ABA问题几率 */ if (CAS(&pred->next, item, new_item)) { trace("insert item %p(next) %p success\n", item, new_item); return val; } trace("cas item %p failed, retry\n", item); free(new_item); } return NULL_VALUE; }
static node_t *find_preds (node_t **preds, node_t **succs, int n, skiplist_t *sl, map_key_t key, enum unlink unlink) { node_t *pred = sl->head; node_t *item = NULL; TRACE("s2", "find_preds: searching for key %p in skiplist (head is %p)", key, pred); int d = 0; // Traverse the levels of <sl> from the top level to the bottom for (int level = sl->high_water - 1; level >= 0; --level) { markable_t next = pred->next[level]; if (next == DOES_NOT_EXIST && level >= n) continue; TRACE("s3", "find_preds: traversing level %p starting at %p", level, pred); if (EXPECT_FALSE(HAS_MARK(next))) { TRACE("s2", "find_preds: pred %p is marked for removal (next %p); retry", pred, next); ASSERT(level == pred->num_levels - 1 || HAS_MARK(pred->next[level+1])); return find_preds(preds, succs, n, sl, key, unlink); // retry } item = GET_NODE(next); while (item != NULL) { next = item->next[level]; // A tag means an item is logically removed but not physically unlinked yet. while (EXPECT_FALSE(HAS_MARK(next))) { TRACE("s3", "find_preds: found marked item %p (next is %p)", item, next); if (unlink == DONT_UNLINK) { // Skip over logically removed items. item = STRIP_MARK(next); if (EXPECT_FALSE(item == NULL)) break; next = item->next[level]; } else { // Unlink logically removed items. markable_t other = SYNC_CAS(&pred->next[level], (markable_t)item, (markable_t)STRIP_MARK(next)); if (other == (markable_t)item) { TRACE("s3", "find_preds: unlinked item from pred %p", pred, 0); item = STRIP_MARK(next); } else { TRACE("s3", "find_preds: lost race to unlink item pred %p's link changed to %p", pred, other); if (HAS_MARK(other)) return find_preds(preds, succs, n, sl, key, unlink); // retry item = GET_NODE(other); } next = (item != NULL) ? item->next[level] : DOES_NOT_EXIST; } } if (EXPECT_FALSE(item == NULL)) { TRACE("s3", "find_preds: past the last item in the skiplist", 0, 0); break; } TRACE("s4", "find_preds: visiting item %p (next is %p)", item, next); TRACE("s4", "find_preds: key %p val %p", STRIP_MARK(item->key), item->val); if (EXPECT_TRUE(sl->key_type == NULL)) { d = item->key - key; } else { d = sl->key_type->cmp((void *)item->key, (void *)key); } if (d > 0) break; if (d == 0 && unlink != FORCE_UNLINK) break; pred = item; item = GET_NODE(next); } TRACE("s3", "find_preds: found pred %p next %p", pred, item); if (level < n) { if (preds != NULL) { preds[level] = pred; } if (succs != NULL) { succs[level] = item; } } } if (d == 0) { TRACE("s2", "find_preds: found matching item %p in skiplist, pred is %p", item, pred); return item; } TRACE("s2", "find_preds: found proper place for key %p in skiplist, pred is %p. returning null", key, pred); return NULL; }