/*
* apply parent's (left, right] messages to child node
*/
void leaf_apply(struct node *leaf,
struct nmb *msgbuf,
struct msg *left,
struct msg *right)
{
struct mb_iter iter;
struct pma_coord coord_left;
struct pma_coord coord_right;
nmb_get_left_coord(msgbuf, left, &coord_left);
nmb_get_right_coord(msgbuf, right, &coord_right);
mb_iter_init(&iter, msgbuf->pma);
while (mb_iter_on_range(&iter, &coord_left, &coord_right)) {
struct nmb_values values;
nmb_get_values(&iter, &values);
struct bt_cmd cmd = {
.msn = values.msn,
.type = values.type,
.key = &values.key,
.val = &values.val,
.xidpair = values.xidpair
};
if (cmd.msn > leaf->msn) {
leaf_put(leaf, &cmd);
}
}
}
int leaf_find_heaviest_idx(struct node *leaf)
{
int i;
int idx = 0;
uint32_t sz = 0;
uint32_t maxsz = 0;
for (i = 0; i < leaf->n_children; i++) {
struct lmb *msgbuf = (struct lmb*)&leaf->parts[i].msgbuf;
sz = lmb_memsize(msgbuf);
if (sz > maxsz) {
idx = i;
maxsz = sz;
}
}
return idx;
}
uint32_t leaf_size(struct node *leaf)
{
int i;
uint32_t sz = 0U;
nassert(leaf->n_children == 1);
for (i = 0; i < leaf->n_children; i++) {
if (nessunlikely(i < (leaf->n_children - 1)))
sz += msgsize(&leaf->pivots[i]);
sz += sizeof(leaf->parts[i]);
sz += lmb_memsize(leaf->parts[i].msgbuf);
}
sz += sizeof(*leaf);
return sz;
}
uint32_t node_size(struct node *node)
{
int i;
uint32_t sz = 0;
for (i = 0; i < node->n_children; i++) {
struct child_pointer *ptr = &node->parts[i].ptr;
if (node->height > 0)
sz += nmb_memsize(ptr->u.nonleaf->buffer);
else
sz += lmb_memsize(ptr->u.leaf->buffer);
}
return sz;
}
uint32_t node_size(struct node *n)
{
uint32_t size = 0U;
size += (sizeof(*n));
if (nessunlikely(n->height == 0)) {
size += lmb_memsize(n->u.l.buffer);
} else {
uint32_t i;
for (i = 0; i < n->u.n.n_children - 1; i++) {
size += msgsize(&n->u.n.pivots[i]);
}
for (i = 0; i < n->u.n.n_children; i++) {
size += nmb_memsize(n->u.n.parts[i].buffer);
}
}
return size;
}
int node_find_heaviest_idx(struct node *node)
{
int i;
int idx = 0;
uint32_t sz = 0;
uint32_t maxsz = 0;
for (i = 0; i < node->n_children; i++) {
struct child_pointer *ptr = &node->parts[i].ptr;
if (node->height > 0)
sz = nmb_memsize(ptr->u.nonleaf->buffer);
else
sz = lmb_memsize(ptr->u.leaf->buffer);
if (sz > maxsz) {
idx = i;
maxsz = sz;
}
}
return idx;
}
