CTEST(basement, insert_and_lookup)
{
int i;
int ret;
int R = 1000;
char kbuf[KEY_SIZE];
char vbuf[VAL_SIZE];
struct basement_iter iter;
struct basement *bsm = basement_new();
struct msg **msgs = xcalloc(R, sizeof(*msgs));
struct txnid_pair xidpair = {
.child_xid = TXNID_NONE,
.parent_xid = TXNID_NONE
};
MSN msn = 0U;
_random_key(vbuf, VAL_SIZE);
for (i = 0; i < R; i++) {
memset(kbuf, 0, KEY_SIZE);
snprintf(kbuf, KEY_SIZE, "key-%d", i);
struct msg k = {.data = kbuf, .size = KEY_SIZE};
struct msg v = {.data = vbuf, .size = VAL_SIZE};
msgs[i] = msgdup(&k);
basement_put(bsm,
msn++,
MSG_INSERT,
&k,
&v,
&xidpair
);
}
basement_iter_init(&iter, bsm);
basement_iter_seektolast(&iter);
ret = basement_iter_valid(&iter);
ASSERT_EQUAL(1, ret);
for (i = 0; i < R; i++) {
basement_iter_seek(&iter, msgs[i]);
ret = basement_iter_valid(&iter);
ASSERT_EQUAL(1, ret);
ret = msg_key_compare(msgs[i], &iter.key);
ASSERT_EQUAL(0, ret);
}
/* do msg free */
for (i = 0; i < R; i++) {
xfree(msgs[i]->data);
xfree(msgs[i]);
}
xfree(msgs);
basement_free(bsm);
xcheck_all_free();
}
/*
* save the newly pivot bound to search->pivot_bound
*/
void _save_pivot_bound(struct search *so, struct node *n, int child_searched)
{
nassert(n->height > 0);
int p = (so->direction == SEARCH_FORWARD) ?
child_searched : child_searched - 1;
if (p >= 0 && p < (int)(n->u.n.n_children - 1)) {
if (so->pivot_bound)
msgfree(so->pivot_bound);
so->pivot_bound = msgdup(&n->u.n.pivots[p]);
}
}
/*
* apply parent's [leaf, right] messages to child node
*/
void _apply_msg_to_child(struct node *parent,
int child_num,
struct node *child,
struct msg *left,
struct msg *right)
{
int height;
struct basement *bsm;
struct basement_iter iter;
nassert(child != NULL);
nassert(parent->height > 0);
height = child->height;
if (height == 0)
bsm = child->u.l.le->bsm;
else
bsm = child->u.n.parts[child_num].buffer;
basement_iter_init(&iter, bsm);
basement_iter_seek(&iter, left);
while (basement_iter_valid_lessorequal(&iter, right)) {
struct bt_cmd cmd = {
.msn = iter.msn,
.type = iter.type,
.key = &iter.key,
.val = &iter.val,
.xidpair = iter.xidpair
};
if (nessunlikely(height == 0))
leaf_put_cmd(child, &cmd);
else
nonleaf_put_cmd(child, &cmd);
}
}
/*
* apply msgs from ances to leaf basement which are between(include) left and right
* REQUIRES:
* 1) leaf write-lock
* 2) ances all write-lock
*/
int leaf_apply_ancestors(struct node *leaf, struct ancestors *ances)
{
struct ancestors *ance;
struct msg *left = NULL;
struct msg *right = NULL;
struct basement_iter iter;
struct basement *bsm = leaf->u.l.le->bsm;
basement_iter_init(&iter, bsm);
basement_iter_seektofirst(&iter);
if (basement_iter_valid(&iter))
left = msgdup(&iter.key);
basement_iter_seektolast(&iter);
if (basement_iter_valid(&iter))
right = msgdup(&iter.key);
ance = ances;
while (ance && ance->next) {
/* apply [leaf, right] to leaf */
_apply_msg_to_child(ance->v,
ance->childnum,
ance->next->v,
left,
right);
ance = ances->next;
}
msgfree(left);
msgfree(right);
return NESS_OK;
}
/*
* +-----------------------------------------------+
* | 5 | 7 | 9 |
* +-----------------------------------------------+
* |
* +---------------+
* | 60 | 61 | 62 |
* +---------------+
*
* +---------------------------------------------------------------+
* | 5 | 60 | 7 | 9 |
* +---------------------------------------------------------------+
* | |
* +--------+ +---------+
* | 60 | | 61 | 62 |
* +--------+ +---------+
*
*
* ENTER:
* - node is already locked(L_WRITE)
* EXITS:
* - a is locked(L_WRITE)
* - b is locked(L_WRITE)
*/
static void _node_split(struct tree *t,
struct node *node,
struct node **a,
struct node **b,
struct msg **split_key)
{
int i;
int pivots_old;
int pivots_in_a;
int pivots_in_b;
struct node *nodea;
struct node *nodeb;
struct msg *spk;
__DEBUG("nonleaf split begin, NID %"PRIu64""
", nodesz %d"
", nodec %d"
", children %d"
, node->nid
, node_size(node)
, node_count(node)
, node->n_children);
nodea = node;
pivots_old = node->n_children - 1;
nassert(pivots_old > 2);
pivots_in_a = pivots_old / 2;
pivots_in_b = pivots_old - pivots_in_a;
/* node a */
nodea->n_children = pivots_in_a + 1;
/* node b */
NID nid = hdr_next_nid(t->hdr);
node_create_light(nid, node->height > 0 ? 1 : 0, pivots_in_b + 1, t->hdr->version, t->e, &nodeb);
cache_put_and_pin(t->cf, nid, nodeb);
for (i = 0; i < (pivots_in_b); i++)
nodeb->pivots[i] = nodea->pivots[pivots_in_a + i];
for (i = 0; i < (pivots_in_b + 1); i++)
nodeb->parts[i] = nodea->parts[pivots_in_a + i];
/* the rightest partition of nodea */
struct child_pointer *ptr = &nodea->parts[pivots_in_a].ptr;
if (nodea->height > 0)
ptr->u.nonleaf = create_nonleaf(t->e);
else
ptr->u.leaf = create_leaf(t->e);
/* split key */
spk = msgdup(&node->pivots[pivots_in_a - 1]);
node_set_dirty(nodea);
node_set_dirty(nodeb);
__DEBUG("nonleaf split end, nodea NID %"PRIu64""
", nodesz %d"
", nodec %d"
", children %d"
, nodea->nid
, node_size(nodea)
, node_count(nodea)
, nodea->n_children);
__DEBUG("nonleaf split end, nodeb NID %"PRIu64""
", nodesz %d"
", nodec %d"
", children %d"
, nodeb->nid
, node_size(nodeb)
, node_count(nodeb)
, nodeb->n_children);
*a = nodea;
*b = nodeb;
*split_key = spk;
}
