static void *ileaf_resize(struct btree *btree, tuxkey_t inum, vleaf *base, unsigned newsize)
{
assert(ileaf_sniff(btree, base));
struct ileaf *leaf = base;
assert(inum >= ibase(leaf));
be_u16 *dict = base + btree->sb->blocksize;
unsigned at = inum - ibase(leaf);
if (at >= btree->entries_per_leaf)
return NULL;
unsigned extend_empty = at < icount(leaf) ? 0 : at - icount(leaf) + 1;
unsigned offset = at && icount(leaf) ? from_be_u16(*(dict - (at < icount(leaf) ? at : icount(leaf)))) : 0;
unsigned size = at < icount(leaf) ? from_be_u16(*(dict - at - 1)) - offset : 0;
int more = newsize - size;
if (more > 0 && sizeof(*dict) * extend_empty + more > ileaf_free(btree, leaf))
return NULL;
for (; extend_empty--; leaf->count = to_be_u16(from_be_u16(leaf->count) + 1))
*(dict - icount(leaf) - 1) = to_be_u16(atdict(dict, icount(leaf)));
assert(icount(leaf));
unsigned itop = from_be_u16(*(dict - icount(leaf)));
void *attrs = leaf->table + offset;
printf("resize inum 0x%Lx at 0x%x from %x to %x\n", (L)inum, offset, size, newsize);
assert(itop >= offset + size);
memmove(attrs + newsize, attrs + size, itop - offset - size);
for (int i = at + 1; i <= icount(leaf); i++)
add_idict(dict - i, more);
return attrs;
}
static tuxkey_t ileaf_split(struct btree *btree, tuxkey_t hint,
void *from, void *into)
{
assert(ileaf_sniff(btree, from));
struct ileaf *leaf = from, *dest = into;
__be16 *dict = ileaf_dict(btree, from);
__be16 *destdict = ileaf_dict(btree, into);
#ifdef SPLIT_AT_INUM
/*
* This is to prevent to have same ibase on both of from and into
* FIXME: we would want to split at better position.
*/
if (hint == ibase(leaf))
hint++;
trace("split at inum 0x%Lx", hint);
unsigned at = min_t(tuxkey_t, hint - ibase(leaf), icount(leaf));
#else
/* binsearch inum starting nearest middle of block */
unsigned at = 1, hi = icount(leaf);
while (at < hi) {
int mid = (at + hi) / 2;
if (*(dict - mid) < (btree->sb->blocksize / 2))
at = mid + 1;
else
hi = mid;
}
#endif
/* should trim leading empty inodes on copy */
unsigned split = atdict(dict, at), free = atdict(dict, icount(leaf));
trace("split at %x of %x", at, icount(leaf));
trace("copy out %x bytes at %x", free - split, split);
assert(free >= split);
memcpy(dest->table, leaf->table + split, free - split);
dest->count = cpu_to_be16(icount(leaf) - at);
veccopy(destdict - icount(dest), dict - icount(leaf), icount(dest));
for (int i = 1; i <= icount(dest); i++)
add_idict(destdict - i, -split);
#ifdef SPLIT_AT_INUM
/* round down to multiple of 64 above ibase */
inum_t round = hint & ~(inum_t)(btree->entries_per_leaf - 1);
dest->ibase = cpu_to_be64(round > ibase(leaf) + icount(leaf) ? round : hint);
#else
dest->ibase = cpu_to_be64(ibase(leaf) + at);
#endif
leaf->count = cpu_to_be16(at);
memset(leaf->table + split, 0, (char *)(dict - icount(leaf)) - (leaf->table + split));
ileaf_trim(btree, leaf);
return ibase(dest);
}
static tuxkey_t ileaf_split(struct btree *btree, tuxkey_t inum, vleaf *from, vleaf *into)
{
assert(ileaf_sniff(btree, from));
struct ileaf *leaf = from, *dest = into;
be_u16 *dict = from + btree->sb->blocksize, *destdict = into + btree->sb->blocksize;
#ifdef SPLIT_AT_INUM
printf("split at inum 0x%Lx\n", (L)inum);
assert(inum >= ibase(leaf));
unsigned at = inum - ibase(leaf) < icount(leaf) ? inum - ibase(leaf) : icount(leaf);
#else
/* binsearch inum starting nearest middle of block */
unsigned at = 1, hi = icount(leaf);
while (at < hi) {
int mid = (at + hi) / 2;
if (*(dict - mid) < (btree->sb->blocksize / 2))
at = mid + 1;
else
hi = mid;
}
#endif
/* should trim leading empty inodes on copy */
unsigned split = atdict(dict, at), free = from_be_u16(*(dict - icount(leaf)));
printf("split at %x of %x\n", at, icount(leaf));
printf("copy out %x bytes at %x\n", free - split, split);
assert(free >= split);
memcpy(dest->table, leaf->table + split, free - split);
dest->count = to_be_u16(icount(leaf) - at);
veccopy(destdict - icount(dest), dict - icount(leaf), icount(dest));
for (int i = 1; i <= icount(dest); i++)
add_idict(destdict - i, -split);
#ifdef SPLIT_AT_INUM
/* round down to multiple of 64 above ibase */
inum_t round = inum & ~(inum_t)(btree->entries_per_leaf - 1);
dest->ibase = to_be_u64(round > ibase(leaf) + icount(leaf) ? round : inum);
#else
dest->ibase = to_be_u64(ibase(leaf) + at);
#endif
leaf->count = to_be_u16(at);
memset(leaf->table + split, 0, (char *)(dict - icount(leaf)) - (leaf->table + split));
ileaf_trim(btree, leaf);
return ibase(dest);
}
static void ileaf_destroy(struct btree *btree, struct ileaf *leaf)
{
assert(ileaf_sniff(btree, leaf));
free(leaf);
}
