Github/littlefs
1
Fork 0
Code Actions Activity

Added sparse btree tests, fixed found bugs (grow/shrink bisect)

Browse Source 
- 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.
This commit is contained in:
Christopher Haster
2023-03-08 02:52:34 -06:00
parent 0a3c6b39c1
commit ce18bec66d
3 changed files with 421 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+28 -5
View File
@@ -3495,8 +3495,9 @@ static int lfsr_btree_commit(lfs_t *lfs,
// upper layers should make sure this can't fail by limiting the
// maximum commit size
// TODO filter-like tag? "from" but from device?
lfs_ssize_t bisect_ = bisect;
for (const struct lfsr_attr *attr = attrs; attr; attr = attr->next) {
if (attr->id < bisect) {
if (attr->id < bisect_) {
err = lfsr_rbyd_append(lfs, &rbyd_,
attr->tag, attr->id,
LFSR_DATA_BUF(attr->buffer, attr->size));
@@ -3505,6 +3506,15 @@ static int lfsr_btree_commit(lfs_t *lfs,
return err;
}
}
// we need to make sure we keep bisect updated with weight changes
if (attr->id < bisect_) {
if (attr->tag == LFSR_TAG_GROW) {
bisect_ += attr->size;
} else if (attr->tag == LFSR_TAG_SHRINK) {
bisect_ -= attr->size;
}
}
}
// finalize commit
@@ -3567,16 +3577,26 @@ static int lfsr_btree_commit(lfs_t *lfs,
// commit pending attrs, these may need to go into both rbyds,
// upper layers should make sure this can't fail by limiting the
// maximum commit size
bisect_ = bisect;
for (const struct lfsr_attr *attr = attrs; attr; attr = attr->next) {
if (attr->id >= bisect) {
if (attr->id >= bisect_) {
err = lfsr_rbyd_append(lfs, &sibling,
attr->tag, attr->id-bisect,
attr->tag, attr->id-bisect_,
LFSR_DATA_BUF(attr->buffer, attr->size));
if (err) {
assert(!err);
return err;
}
}
// we need to make sure we keep bisect updated with weight changes
if (attr->id < bisect_) {
if (attr->tag == LFSR_TAG_GROW) {
bisect_ += attr->size;
} else if (attr->tag == LFSR_TAG_SHRINK) {
bisect_ -= attr->size;
}
}
}
// finalize commit
@@ -3978,16 +3998,19 @@ static int lfsr_btree_push(lfs_t *lfs,
// return ENOENT, is this ok?
lfsr_rbyd_t rbyd;
lfs_ssize_t rid;
lfs_size_t rweight;
lfs_ssize_t size = lfsr_btree_lookup(lfs, btree,
lfs_min32(id, btree->weight-1),
NULL, NULL, &rbyd, &rid, NULL, NULL, 0);
NULL, NULL, &rbyd, &rid, &rweight, NULL, 0);
if (size < 0) {
return size;
}
// adjust rid if we're appending
// adjust rid for push
if (id >= btree->weight) {
rid += 1;
} else {
rid -= rweight-1;
}
// commit our id into the tree, letting lfsr_btree_commit take care
tests/test_btree.toml
+350 -2
View File
@@ -398,15 +398,26 @@ code = '''
// add to btree
lfsr_btree_push(&lfs, &btree, id, LFSR_TAG_INLINED, 1,
&alphas[i], 1) => 0;
&alphas[i % 26], 1) => 0;
// add to sim
memcpy(&sim[id+1], &sim[id], sim_size-id);
sim[id] = alphas[i];
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];
@@ -433,3 +444,340 @@ code = '''
}
'''
[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!
tests/test_rbyd.toml
+43 -42
View File
@@ -11691,7 +11691,7 @@ code = '''
// choose an id
lfs_ssize_t id = TEST_PRNG(&prng) % (count+1);
// choose a weight
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % (W-1));
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W);
if (id == (lfs_ssize_t)count || op == 0) {
printf("c%dw%d=%c", id, weight, alpha[i % 26]);
@@ -11729,12 +11729,12 @@ code = '''
// choose an id
lfs_ssize_t id = TEST_PRNG(&prng) % (count+1);
// choose a weight
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % (W-1));
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W);
// calculate actual id in rbyd space
lfs_ssize_t id__ = 0;
lfs_ssize_t weighted_id = 0;
for (lfs_ssize_t j = 0; j < id; j++) {
id__ += sim_weights[j];
weighted_id += sim_weights[j];
}
if (id == (lfs_ssize_t)count || op == 0) {
@@ -11747,8 +11747,9 @@ code = '''
count += 1;
// update our rbyd
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(GROW, id__, NULL, weight,
LFSR_ATTR(MKREG, id__+weight-1, &alpha[i % 26], 1,
LFSR_ATTR(GROW, weighted_id, NULL, weight,
LFSR_ATTR(MKREG, weighted_id+weight-1,
&alpha[i % 26], 1,
NULL))) => 0;
} else if (op == 1) {
// get the correct weight from the sim
@@ -11760,14 +11761,14 @@ code = '''
count -= 1;
// update our rbyd
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(SHRINK, id__, NULL, weight,
LFSR_ATTR(SHRINK, weighted_id, NULL, weight,
NULL)) => 0;
} else if (op == 2) {
// update our sim
sim_weights[id] += weight;
// update our rbyd
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(GROW, id__, NULL, weight,
LFSR_ATTR(GROW, weighted_id, NULL, weight,
NULL)) => 0;
} else if (op == 3) {
// don't let shrink go to zero here! this is already hard enough
@@ -11777,7 +11778,7 @@ code = '''
sim_weights[id] -= weight;
// update our rbyd
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(SHRINK, id__, NULL, weight,
LFSR_ATTR(SHRINK, weighted_id, NULL, weight,
NULL)) => 0;
}
}
@@ -11794,13 +11795,13 @@ code = '''
printf("rbyd: [");
for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) {
// calculate actual id in rbyd space
lfs_ssize_t id__ = 0;
lfs_ssize_t weighted_id = 0;
for (lfs_ssize_t j = 0; j < id; j++) {
id__ += sim_weights[j];
weighted_id += sim_weights[j];
}
int err = lfsr_rbyd_lookup(&lfs, &rbyd,
LFSR_TAG_MKREG, id__,
LFSR_TAG_MKREG, weighted_id,
&tag_, &id_, &weight_, &off_, &size_);
if (!err) {
lfs_ssize_t size = lfsr_rbyd_get(&lfs, &rbyd,
@@ -11828,13 +11829,13 @@ code = '''
for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) {
// calculate actual id in rbyd space
lfs_ssize_t id__ = 0;
lfs_ssize_t weighted_id = 0;
for (lfs_ssize_t j = 0; j < id; j++) {
id__ += sim_weights[j];
weighted_id += sim_weights[j];
}
lfsr_rbyd_lookup(&lfs, &rbyd,
LFSR_TAG_MKREG, id__,
LFSR_TAG_MKREG, weighted_id,
&tag_, &id_, &weight_, &off_, &size_) => 0;
lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 1;
assert(memcmp(&sim[id], buffer, 1) == 0);
@@ -11908,9 +11909,9 @@ code = '''
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % (W-1));
// calculate actual id in rbyd space
lfs_ssize_t id__ = 0;
lfs_ssize_t weighted_id = 0;
for (lfs_ssize_t j = 0; j < id; j++) {
id__ += sim_weights[j];
weighted_id += sim_weights[j];
}
if (id == (lfs_ssize_t)count || op == 0) {
@@ -11923,8 +11924,8 @@ code = '''
count += 1;
// update our rbyd
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(GROW, id__, NULL, weight,
LFSR_ATTR(MKREG, id__+weight-1, &alpha[i % 26], 1,
LFSR_ATTR(GROW, weighted_id, NULL, weight,
LFSR_ATTR(MKREG, weighted_id+weight-1, &alpha[i % 26], 1,
NULL))) => 0;
} else if (op == 1) {
// get the correct weight from the sim
@@ -11936,14 +11937,14 @@ code = '''
count -= 1;
// update our rbyd
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(SHRINK, id__, NULL, weight,
LFSR_ATTR(SHRINK, weighted_id, NULL, weight,
NULL)) => 0;
} else if (op == 2) {
// update our sim
sim_weights[id] += weight;
// update our rbyd
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(GROW, id__, NULL, weight,
LFSR_ATTR(GROW, weighted_id, NULL, weight,
NULL)) => 0;
} else if (op == 3) {
// don't let shrink go to zero here! this is already hard enough
@@ -11953,7 +11954,7 @@ code = '''
sim_weights[id] -= weight;
// update our rbyd
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(SHRINK, id__, NULL, weight,
LFSR_ATTR(SHRINK, weighted_id, NULL, weight,
NULL)) => 0;
}
}
@@ -13074,7 +13075,7 @@ code = '''
// choose an id
lfs_ssize_t id = TEST_PRNG(&prng) % (count+1);
// choose a weight
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % (W-1));
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W);
if (id == (lfs_ssize_t)count || op == 0) {
printf("c%dw%d=%c", id, weight, alpha[i % 26]);
@@ -13116,12 +13117,12 @@ code = '''
// choose an id
lfs_ssize_t id = TEST_PRNG(&prng) % (count+1);
// choose a weight
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % (W-1));
lfs_size_t weight = 1 + (TEST_PRNG(&prng) % W);
// calculate actual id in rbyd space
lfs_ssize_t id__ = 0;
lfs_ssize_t weighted_id = 0;
for (lfs_ssize_t j = 0; j < id; j++) {
id__ += sim_weights[j];
weighted_id += sim_weights[j];
}
if (id == (lfs_ssize_t)count || op == 0) {
@@ -13135,8 +13136,8 @@ code = '''
// update our rbyd
if (i < w) {
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(GROW, id__, NULL, weight,
LFSR_ATTR(MKREG, id__+weight-1,
LFSR_ATTR(GROW, weighted_id, NULL, weight,
LFSR_ATTR(MKREG, weighted_id+weight-1,
&alpha[i % 26], 1,
NULL))) => 0;
} else {
@@ -13144,10 +13145,10 @@ code = '''
attrs[a-1].next = &attrs[a];
}
attrs[a] = *LFSR_ATTR(
GROW, id__, NULL, weight,
GROW, weighted_id, NULL, weight,
&attrs[a+1]);
attrs[a+1] = *LFSR_ATTR(
MKREG, id__+weight-1, &alpha[i % 26], 1,
MKREG, weighted_id+weight-1, &alpha[i % 26], 1,
NULL);
a += 2;
}
@@ -13162,14 +13163,14 @@ code = '''
// update our rbyd
if (i < w) {
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(SHRINK, id__, NULL, weight,
LFSR_ATTR(SHRINK, weighted_id, NULL, weight,
NULL)) => 0;
} else {
if (a > 0) {
attrs[a-1].next = &attrs[a];
}
attrs[a] = *LFSR_ATTR(
SHRINK, id__, NULL, weight,
SHRINK, weighted_id, NULL, weight,
NULL);
a += 1;
}
@@ -13179,14 +13180,14 @@ code = '''
// update our rbyd
if (i < w) {
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(GROW, id__, NULL, weight,
LFSR_ATTR(GROW, weighted_id, NULL, weight,
NULL)) => 0;
} else {
if (a > 0) {
attrs[a-1].next = &attrs[a];
}
attrs[a] = *LFSR_ATTR(
GROW, id__, NULL, weight,
GROW, weighted_id, NULL, weight,
NULL);
a += 1;
}
@@ -13199,14 +13200,14 @@ code = '''
// update our rbyd
if (i < w) {
lfsr_rbyd_commit(&lfs, &rbyd,
LFSR_ATTR(SHRINK, id__, NULL, weight,
LFSR_ATTR(SHRINK, weighted_id, NULL, weight,
NULL)) => 0;
} else {
if (a > 0) {
attrs[a-1].next = &attrs[a];
}
attrs[a] = *LFSR_ATTR(
SHRINK, id__, NULL, weight,
SHRINK, weighted_id, NULL, weight,
NULL);
a += 1;
}
@@ -13227,14 +13228,14 @@ code = '''
printf("rbyd: [");
for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) {
// calculate actual id in rbyd space
lfs_ssize_t id__ = 0;
lfs_ssize_t weighted_id = 0;
for (lfs_ssize_t j = 0; j < id; j++) {
id__ += sim_weights[j];
weighted_id += sim_weights[j];
}
int err = lfsr_rbyd_predictedlookup(
&lfs, &rbyd, unwritten,
LFSR_TAG_MKREG, id__,
LFSR_TAG_MKREG, weighted_id,
&tag_, &id_, &data_);
if (!err) {
lfs_ssize_t size = lfsr_rbyd_predictedget(
@@ -13256,13 +13257,13 @@ code = '''
for (lfs_ssize_t id = 0; id < (lfs_ssize_t)count; id++) {
// calculate actual id in rbyd space
lfs_ssize_t id__ = 0;
lfs_ssize_t weighted_id = 0;
for (lfs_ssize_t j = 0; j < id; j++) {
id__ += sim_weights[j];
weighted_id += sim_weights[j];
}
lfsr_rbyd_predictedlookup(&lfs, &rbyd, unwritten,
LFSR_TAG_MKREG, id__,
LFSR_TAG_MKREG, weighted_id,
&tag_, &id_, &data_) => 0;
lfsr_rbyd_predictedget(&lfs, &rbyd, unwritten,
tag_, id_, buffer, 4) => 1;