diff --git a/lfs.c b/lfs.c index 9038a063..ec7fb007 100644 --- a/lfs.c +++ b/lfs.c @@ -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 diff --git a/tests/test_btree.toml b/tests/test_btree.toml index e6799139..556bc371 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -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! diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 714ec3e7..03ecb5cd 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -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;