Christopher Haster
ce18bec66d
- After a B-tree split, when we're append pending attributes, it's possible for the id chosen for bisection to be itself modified by pending grows/shrinks. This needs to be accounted for in the two passes for the two children. But this means our tests are working.
784 lines
23 KiB
TOML
784 lines
23 KiB
TOML
|
|
# maximize lookahead buffer, we don't actually gc so we only get one pass
|
|
# of the disk for these tests
|
|
defines.LOOKAHEAD_SIZE = 'BLOCK_COUNT / 8'
|
|
|
|
|
|
# test an empty tree
|
|
[cases.test_btree_zero]
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create an empty tree
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
|
|
// try looking up tags
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
|
|
lfsr_btree_get(&lfs, &btree, 0,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
# test an inlined tree
|
|
[cases.test_btree_one]
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a single-entry tree
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
|
|
|
|
// try looking up tags
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
|
|
lfsr_btree_get(&lfs, &btree, 0,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 0);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "a", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
# test a single-rbyd tree
|
|
[cases.test_btree_two]
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a two-entry tree
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
|
|
lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_INLINED, 1, "b", 1) => 0;
|
|
|
|
// try looking up tags
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
|
|
lfsr_btree_get(&lfs, &btree, 0,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 0);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "a", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 1);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "b", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 2,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
[cases.test_btree_two_backwards]
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a two-entry tree
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "b", 1) => 0;
|
|
lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
|
|
|
|
// try looking up tags
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
|
|
lfsr_btree_get(&lfs, &btree, 0,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 0);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "a", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 1);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "b", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 2,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
# still a single-rbyd tree, just making sure it works
|
|
[cases.test_btree_three]
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a two-entry tree
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
|
|
lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_INLINED, 1, "b", 1) => 0;
|
|
lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_INLINED, 1, "c", 1) => 0;
|
|
|
|
// try looking up tags
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
|
|
lfsr_btree_get(&lfs, &btree, 0,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 0);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "a", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 1);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "b", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 2,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 2);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "c", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 3,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
[cases.test_btree_three_backwards]
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a two-entry tree
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "c", 1) => 0;
|
|
lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "b", 1) => 0;
|
|
lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1, "a", 1) => 0;
|
|
|
|
// try looking up tags
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
|
|
lfsr_btree_get(&lfs, &btree, 0,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 0);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "a", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 1);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "b", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 2,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == 2);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, "c", 1) == 0);
|
|
|
|
lfsr_btree_get(&lfs, &btree, 3,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
# try larger trees, when exactly a tree splits depends on the disk geometry, so
|
|
# we don't really have a better way of testing multi-rbyd trees
|
|
[cases.test_btree_push]
|
|
defines.N = [4, 8, 16, 32, 64, 128, 256, 512, 1024]
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a tree with N elements
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
const char *alphas = "abcdefghijklmnopqrstuvwxyz";
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_INLINED, 1,
|
|
&alphas[i % 26], 1) => 0;
|
|
}
|
|
|
|
// check that the elements are in the tree
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
lfsr_btree_get(&lfs, &btree, i,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == i);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
|
|
}
|
|
|
|
// and check that we can't lookup elements that aren't in the tree
|
|
lfsr_btree_get(&lfs, &btree, N,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
[cases.test_btree_push_backwards]
|
|
defines.N = [4, 8, 16, 32, 64, 128, 256, 512, 1024]
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a tree with N elements
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
const char *alphas = "abcdefghijklmnopqrstuvwxyz";
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_INLINED, 1,
|
|
&alphas[(N-1-i) % 26], 1) => 0;
|
|
}
|
|
|
|
// check that the elements are in the tree
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
lfsr_btree_get(&lfs, &btree, i,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == i);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
|
|
}
|
|
|
|
// and check that we can't lookup elements that aren't in the tree
|
|
lfsr_btree_get(&lfs, &btree, N,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
[cases.test_btree_push_fuzz]
|
|
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
|
|
defines.ITER = 10
|
|
in = 'lfs.c'
|
|
code = '''
|
|
const char *alphas = "abcdefghijklmnopqrstuvwxyz";
|
|
|
|
// iterate through severals seeds that we can reproduce easily
|
|
for (uint32_t seed = 1; seed < ITER+1; seed++) {
|
|
// create lfs here since we need to reset each iteration, we're
|
|
// space constrained and we can't expect gc to work at this point
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a btree
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
|
|
// set up a simulation to compare against
|
|
//
|
|
// fun fact this is slower than our actual tree! unfun fact this is
|
|
// starting to be a problem...
|
|
char *sim = malloc(N);
|
|
lfs_size_t sim_size = 0;
|
|
memset(sim, 0, N);
|
|
|
|
uint32_t prng = seed;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
// choose a pseudo-random id
|
|
lfs_size_t id = TEST_PRNG(&prng) % (sim_size+1);
|
|
|
|
// add to btree
|
|
lfsr_btree_push(&lfs, &btree, id, LFSR_TAG_INLINED, 1,
|
|
&alphas[i % 26], 1) => 0;
|
|
|
|
// add to sim
|
|
memcpy(&sim[id+1], &sim[id], sim_size-id);
|
|
sim[id] = alphas[i % 26];
|
|
sim_size += 1;
|
|
}
|
|
|
|
// check that btree matches sim
|
|
printf("expd: [");
|
|
bool first = true;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
if (!first) {
|
|
printf(", ");
|
|
}
|
|
first = false;
|
|
printf("%c", sim[i]);
|
|
}
|
|
printf("]\n");
|
|
|
|
assert(btree.weight == N);
|
|
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
lfsr_btree_get(&lfs, &btree, i,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == i);
|
|
assert(weight_ == 1);
|
|
assert(memcmp(buffer, &sim[i], 1) == 0);
|
|
}
|
|
|
|
// and no extra elements
|
|
lfsr_btree_get(&lfs, &btree, N,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
|
|
// clean up sim
|
|
free(sim);
|
|
}
|
|
'''
|
|
|
|
[cases.test_btree_sparse]
|
|
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
|
|
defines.W = 5
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a tree with N elements
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
const char *alphas = "abcdefghijklmnopqrstuvwxyz";
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_INLINED, W,
|
|
&alphas[i % 26], 1) => 0;
|
|
}
|
|
|
|
// check that the elements are in the tree
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
lfsr_btree_get(&lfs, &btree, i*W+W-1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == i*W+W-1);
|
|
assert(weight_ == W);
|
|
assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
|
|
}
|
|
|
|
// and check that we can't lookup elements that aren't in the tree
|
|
lfsr_btree_get(&lfs, &btree, N*W,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
[cases.test_btree_sparse_fuzz]
|
|
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
|
|
defines.W = 5
|
|
defines.ITER = 10
|
|
in = 'lfs.c'
|
|
code = '''
|
|
const char *alphas = "abcdefghijklmnopqrstuvwxyz";
|
|
|
|
// iterate through severals seeds that we can reproduce easily
|
|
for (uint32_t seed = 1; seed < ITER+1; seed++) {
|
|
// create lfs here since we need to reset each iteration, we're
|
|
// space constrained and we can't expect gc to work at this point
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a btree
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
|
|
// set up a simulation to compare against
|
|
//
|
|
// fun fact this is slower than our actual tree! unfun fact this is
|
|
// starting to be a problem...
|
|
char *sim = malloc(N);
|
|
lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t));
|
|
lfs_size_t sim_size = 0;
|
|
memset(sim, 0, N);
|
|
memset(sim_weights, 0, N*sizeof(lfs_size_t));
|
|
|
|
uint32_t prng = seed;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
// choose a pseudo-random id
|
|
lfs_size_t id = TEST_PRNG(&prng) % (sim_size+1);
|
|
// choose a pseudo-random weight
|
|
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W);
|
|
|
|
// calculate actual id in btree space
|
|
lfs_size_t weighted_id = 0;
|
|
for (lfs_size_t j = 0; j < id; j++) {
|
|
weighted_id += sim_weights[j];
|
|
}
|
|
|
|
// add to btree
|
|
lfsr_btree_push(&lfs, &btree, weighted_id, LFSR_TAG_INLINED, weight,
|
|
&alphas[i % 26], 1) => 0;
|
|
|
|
// add to sim
|
|
memcpy(&sim[id+1], &sim[id], sim_size-id);
|
|
memcpy(&sim_weights[id+1], &sim_weights[id],
|
|
(sim_size-id)*sizeof(lfs_size_t));
|
|
sim[id] = alphas[i % 26];
|
|
sim_weights[id] = weight;
|
|
sim_size += 1;
|
|
}
|
|
|
|
// check that btree matches sim
|
|
printf("expd: [");
|
|
bool first = true;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
// calculate actual id in btree space
|
|
lfs_size_t weighted_id = 0;
|
|
for (lfs_size_t j = 0; j < i; j++) {
|
|
weighted_id += sim_weights[j];
|
|
}
|
|
|
|
if (!first) {
|
|
printf(", ");
|
|
}
|
|
first = false;
|
|
printf("%dw%d=%c", weighted_id+sim_weights[i]-1,
|
|
sim_weights[i], sim[i]);
|
|
}
|
|
printf("]\n");
|
|
|
|
lfs_size_t total_weight = 0;
|
|
for (lfs_size_t j = 0; j < N; j++) {
|
|
total_weight += sim_weights[j];
|
|
}
|
|
assert(btree.weight == total_weight);
|
|
|
|
uint8_t buffer[4];
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t id_;
|
|
lfs_size_t weight_;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
// calculate actual id in btree space
|
|
lfs_size_t weighted_id = 0;
|
|
for (lfs_size_t j = 0; j < i; j++) {
|
|
weighted_id += sim_weights[j];
|
|
}
|
|
|
|
lfsr_btree_get(&lfs, &btree, weighted_id+sim_weights[i]-1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == weighted_id+sim_weights[i]-1);
|
|
assert(weight_ == sim_weights[i]);
|
|
assert(memcmp(buffer, &sim[i], 1) == 0);
|
|
}
|
|
|
|
// and no extra elements
|
|
lfsr_btree_get(&lfs, &btree, total_weight,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
|
|
// clean up sim
|
|
free(sim);
|
|
}
|
|
'''
|
|
|
|
[cases.test_btree_traverse]
|
|
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
|
|
defines.W = 5
|
|
in = 'lfs.c'
|
|
code = '''
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a tree with N elements
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
const char *alphas = "abcdefghijklmnopqrstuvwxyz";
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_INLINED, W,
|
|
&alphas[i % 26], 1) => 0;
|
|
}
|
|
|
|
// traverse the elements in the tree
|
|
uint8_t buffer[4];
|
|
lfs_size_t id_ = -1;
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t weight_;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
lfsr_btree_get(&lfs, &btree, id_+1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == i*W+W-1);
|
|
assert(weight_ == W);
|
|
assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
|
|
}
|
|
|
|
// and check that we can't lookup elements that aren't in the tree
|
|
lfsr_btree_get(&lfs, &btree, id_+1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
'''
|
|
|
|
[cases.test_btree_traverse_fuzz]
|
|
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
|
|
defines.W = 5
|
|
defines.ITER = 10
|
|
in = 'lfs.c'
|
|
code = '''
|
|
const char *alphas = "abcdefghijklmnopqrstuvwxyz";
|
|
|
|
// iterate through severals seeds that we can reproduce easily
|
|
for (uint32_t seed = 1; seed < ITER+1; seed++) {
|
|
// create lfs here since we need to reset each iteration, we're
|
|
// space constrained and we can't expect gc to work at this point
|
|
lfs_t lfs;
|
|
lfs_init(&lfs, cfg) => 0;
|
|
// create free lookahead
|
|
memset(lfs.free.buffer, 0, lfs.cfg->lookahead_size);
|
|
lfs.free.off = 0;
|
|
lfs.free.size = lfs_min(8*lfs.cfg->lookahead_size,
|
|
lfs.cfg->block_count);
|
|
lfs.free.i = 0;
|
|
lfs_alloc_ack(&lfs);
|
|
|
|
// create a btree
|
|
lfsr_btree_t btree = LFSR_BTREE_NULL;
|
|
|
|
// set up a simulation to compare against
|
|
//
|
|
// fun fact this is slower than our actual tree! unfun fact this is
|
|
// starting to be a problem...
|
|
char *sim = malloc(N);
|
|
lfs_size_t *sim_weights = malloc(N*sizeof(lfs_size_t));
|
|
lfs_size_t sim_size = 0;
|
|
memset(sim, 0, N);
|
|
memset(sim_weights, 0, N*sizeof(lfs_size_t));
|
|
|
|
uint32_t prng = seed;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
// choose a pseudo-random id
|
|
lfs_size_t id = TEST_PRNG(&prng) % (sim_size+1);
|
|
// choose a pseudo-random weight
|
|
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W);
|
|
|
|
// calculate actual id in btree space
|
|
lfs_size_t weighted_id = 0;
|
|
for (lfs_size_t j = 0; j < id; j++) {
|
|
weighted_id += sim_weights[j];
|
|
}
|
|
|
|
// add to btree
|
|
lfsr_btree_push(&lfs, &btree, weighted_id, LFSR_TAG_INLINED, weight,
|
|
&alphas[i % 26], 1) => 0;
|
|
|
|
// add to sim
|
|
memcpy(&sim[id+1], &sim[id], sim_size-id);
|
|
memcpy(&sim_weights[id+1], &sim_weights[id],
|
|
(sim_size-id)*sizeof(lfs_size_t));
|
|
sim[id] = alphas[i % 26];
|
|
sim_weights[id] = weight;
|
|
sim_size += 1;
|
|
}
|
|
|
|
// check that btree matches sim
|
|
printf("expd: [");
|
|
bool first = true;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
// calculate actual id in btree space
|
|
lfs_size_t weighted_id = 0;
|
|
for (lfs_size_t j = 0; j < i; j++) {
|
|
weighted_id += sim_weights[j];
|
|
}
|
|
|
|
if (!first) {
|
|
printf(", ");
|
|
}
|
|
first = false;
|
|
printf("%dw%d=%c", weighted_id+sim_weights[i]-1,
|
|
sim_weights[i], sim[i]);
|
|
}
|
|
printf("]\n");
|
|
|
|
lfs_size_t total_weight = 0;
|
|
for (lfs_size_t j = 0; j < N; j++) {
|
|
total_weight += sim_weights[j];
|
|
}
|
|
assert(btree.weight == total_weight);
|
|
|
|
uint8_t buffer[4];
|
|
lfs_size_t id_ = -1;
|
|
lfsr_tag_t tag_;
|
|
lfs_size_t weight_;
|
|
for (lfs_size_t i = 0; i < N; i++) {
|
|
// calculate actual id in btree space
|
|
lfs_size_t weighted_id = 0;
|
|
for (lfs_size_t j = 0; j < i; j++) {
|
|
weighted_id += sim_weights[j];
|
|
}
|
|
|
|
lfsr_btree_get(&lfs, &btree, id_+1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => 1;
|
|
assert(tag_ == LFSR_TAG_INLINED);
|
|
assert(id_ == weighted_id+sim_weights[i]-1);
|
|
assert(weight_ == sim_weights[i]);
|
|
assert(memcmp(buffer, &sim[i], 1) == 0);
|
|
}
|
|
|
|
// and no extra elements
|
|
lfsr_btree_get(&lfs, &btree, id_+1,
|
|
&tag_, &id_, &weight_,
|
|
buffer, 4) => LFS_ERR_NOENT;
|
|
|
|
// clean up sim
|
|
free(sim);
|
|
}
|
|
'''
|
|
|
|
# [cases.test_btree_update]
|
|
# [cases.test_btree_update_fuzz]
|
|
# [cases.test_btree_update_sparse]
|
|
# [cases.test_btree_update_sparse_fuzz]
|
|
# [cases.test_btree_update_traverse]
|
|
# [cases.test_btree_update_traverse_fuzz]
|
|
|
|
# [cases.test_btree_pop]
|
|
# [cases.test_btree_pop_fuzz]
|
|
|
|
# [cases.test_btree_split]
|
|
# [cases.test_btree_split_fuzz]
|
|
|
|
# [cases.test_btree_general_fuzz]
|
|
|
|
# TODO also test copy-on-write!
|