From 5f3994c83b59fbbc3d41fe66f520dd3b93ebd3f5 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Thu, 14 Sep 2023 19:00:28 -0500 Subject: [PATCH] Renamed mbits/mlimit to mleaf_bits/mleaf_limit - mbits -> mleaf_bits - mlimit -> mleaf_limit - mweight -> mleaf_weight - lfsr_mridmask -> lfsr_midrmask - lfsr_mbidmask -> lfsr_midbmask This is a bit tricky to name, since we want to clarify it's not the mtree limit and not the mdir's actual rbyd weight. But this also risks confusing around the difference between mdirs/mleaves (mdirs are mtree's leaves). --- lfs.c | 168 +++++++------- lfs.h | 2 +- scripts/dbglfs.py | 42 ++-- scripts/dbgmtree.py | 28 +-- tests/test_alloc.toml | 8 +- tests/test_mtree.toml | 526 +++++++++++++++++++++--------------------- 6 files changed, 388 insertions(+), 386 deletions(-) diff --git a/lfs.c b/lfs.c index 69757ec8..81b6f1fa 100644 --- a/lfs.c +++ b/lfs.c @@ -1534,16 +1534,16 @@ static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data, /// Metadata-id things /// -static inline lfsr_mid_t lfsr_mweight(lfs_t *lfs) { - return 1 << lfs->mbits; +static inline lfsr_mid_t lfsr_mleafweight(lfs_t *lfs) { + return 1 << lfs->mleaf_bits; } -static inline lfsr_smid_t lfsr_mridmask(lfs_t *lfs) { - return (1 << lfs->mbits) - 1; +static inline lfsr_smid_t lfsr_midrmask(lfs_t *lfs) { + return (1 << lfs->mleaf_bits) - 1; } -static inline lfsr_smid_t lfsr_mbidmask(lfs_t *lfs) { - return ~lfsr_mridmask(lfs); +static inline lfsr_smid_t lfsr_midbmask(lfs_t *lfs) { + return ~lfsr_midrmask(lfs); } // we use the root's bookmark at 0.0 to represent root @@ -1693,7 +1693,7 @@ static int lfsr_data_readgrm(lfs_t *lfs, lfsr_data_t *data, LFS_ASSERT(grm->rms[i] < lfs_smax32( lfsr_mtree_weight(lfs), - lfsr_mweight(lfs))); + lfsr_mleafweight(lfs))); } return 0; @@ -4651,7 +4651,7 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, // TODO anything better? mid = (mid == -1 ? -1 - : mid - (lfs_smax32(mdir->mid, 0) & lfsr_mbidmask(lfs))); + : mid - (lfs_smax32(mdir->mid, 0) & lfsr_midbmask(lfs))); lfsr_smid_t mid_; lfsr_tag_t tag__; @@ -4680,7 +4680,7 @@ static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, // TODO anything better? (mid == -1 ? -1 - : mid - (lfs_smax32(mdir->mid, 0) & lfsr_mbidmask(lfs))), + : mid - (lfs_smax32(mdir->mid, 0) & lfsr_midbmask(lfs))), tag, tag_, data_); } @@ -4729,7 +4729,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, lfsr_mdir_t *mdir_) { // looking up mroot? if (lfsr_mtree_isinlined(lfs)) { LFS_ASSERT(mid >= 0); - LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mweight(lfs)); + LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mleafweight(lfs)); mdir_->mid = mid; mdir_->u.m = lfs->mroot.u.m; return 0; @@ -4746,7 +4746,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, lfsr_mdir_t *mdir_) { if (err) { return err; } - LFS_ASSERT((lfsr_smid_t)bid == (mid | lfsr_mridmask(lfs))); + LFS_ASSERT((lfsr_smid_t)bid == (mid | lfsr_midrmask(lfs))); LFS_ASSERT(tag == LFSR_TAG_MDIR); // decode mdir @@ -4805,20 +4805,20 @@ static int lfsr_mtree_seek(lfs_t *lfs, lfsr_mdir_t *mdir, lfs_off_t off) { while (true) { // calculate new mid, be careful to avoid rid overflow - lfsr_bid_t bid = mdir->mid & lfsr_mbidmask(lfs); - lfsr_srid_t rid = (mdir->mid & lfsr_mridmask(lfs)) + off; + lfsr_bid_t bid = mdir->mid & lfsr_midbmask(lfs); + lfsr_srid_t rid = (mdir->mid & lfsr_midrmask(lfs)) + off; // lookup mdirs until we find our rid, we need to do this because // we don't know how many rids are in each mdir until we fetch while (rid >= mdir->u.m.weight) { // end of mtree? - if (bid+lfsr_mweight(lfs) >= lfsr_mtree_weight(lfs)) { + if (bid+lfsr_mleafweight(lfs) >= lfsr_mtree_weight(lfs)) { // if we hit the end of the mtree, park the mdir so all future // seeks return noent mdir->mid = bid + mdir->u.m.weight; return LFS_ERR_NOENT; } - bid += lfsr_mweight(lfs); + bid += lfsr_mleafweight(lfs); rid -= mdir->u.m.weight; int err = lfsr_mtree_lookup(lfs, bid, mdir); if (err) { @@ -4952,7 +4952,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_srid_t rid = (attrs[i].rid == -1 ? -1 : attrs[i].rid - ( - lfs_smax32(mdir_.mid, 0) & lfsr_mbidmask(lfs))); + lfs_smax32(mdir_.mid, 0) & lfsr_midbmask(lfs))); // don't write tags outside of the requested range if (rid >= start_rid @@ -5146,7 +5146,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, || lfsr_mtree_isinlined(lfs) || mdir->u.m.weight > 0); LFS_ASSERT(mid == -1 - || (mdir->mid & lfsr_mridmask(lfs)) <= mdir->u.m.weight); + || (mdir->mid & lfsr_midrmask(lfs)) <= mdir->u.m.weight); // parse out any pending gstate, these will get automatically xored // with on-disk gdeltas in lower-level functions @@ -5178,8 +5178,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, for (lfsr_openedmdir_t *opened = lfs->opened[type]; opened; opened = opened->next) { - if ((opened->mdir.mid & lfsr_mbidmask(lfs)) - == (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs))) { + if ((opened->mdir.mid & lfsr_midbmask(lfs)) + == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))) { lfsr_mdir_unerase(&opened->mdir); } } @@ -5212,7 +5212,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // This makes it so the split logic is the same whether or not // we're uninlining. err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( - LFSR_ATTR(0, MDIR, +lfsr_mweight(lfs), NULL))); + LFSR_ATTR(0, MDIR, +lfsr_mleafweight(lfs), NULL))); if (err) { return err; } @@ -5270,13 +5270,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } // adjust our sibling's mid after committing attrs - msibling_.mid += lfsr_mweight(lfs); + msibling_.mid += lfsr_mleafweight(lfs); LFS_DEBUG("Splitting mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"} " "-> 0x{%"PRIx32",%"PRIx32"}, " "0x{%"PRIx32",%"PRIx32"}", - mid >> lfs->mbits, + mid >> lfs->mleaf_bits, mdir->u.m.blocks[0], mdir->u.m.blocks[1], mdir_.u.m.blocks[0], mdir_.u.m.blocks[1], msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]); @@ -5288,11 +5288,11 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, if (mdir_.u.m.weight == 0 && msibling_.u.m.weight == 0) { LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", - mdir_.mid >> lfs->mbits, + mdir_.mid >> lfs->mleaf_bits, mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]); LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", - msibling_.mid >> lfs->mbits, + msibling_.mid >> lfs->mleaf_bits, msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]); goto drop; @@ -5300,7 +5300,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } else if (msibling_.u.m.weight == 0) { LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", - msibling_.mid >> lfs->mbits, + msibling_.mid >> lfs->mleaf_bits, msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]); goto relocate; @@ -5308,7 +5308,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } else if (mdir_.u.m.weight == 0) { LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", - mdir_.mid >> lfs->mbits, + mdir_.mid >> lfs->mleaf_bits, mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]); mdir_.u.m = msibling_.u.m; msibling_.u.m.weight = 0; @@ -5335,12 +5335,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, uint8_t mdir_buf[LFSR_MDIR_DSIZE]; uint8_t msibling_buf[LFSR_MDIR_DSIZE]; err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( - LFSR_ATTR(mdir_.mid | lfsr_mridmask(lfs), + LFSR_ATTR(mdir_.mid | lfsr_midrmask(lfs), MDIR, 0, FROMMBLOCKS(lfs, mdir_.u.m.blocks, mdir_buf)), - LFSR_ATTR((mdir_.mid | lfsr_mridmask(lfs))+1, - BRANCH, +lfsr_mweight(lfs), DATA(split_data)), - LFSR_ATTR(msibling_.mid | lfsr_mridmask(lfs), + LFSR_ATTR((mdir_.mid | lfsr_midrmask(lfs))+1, + BRANCH, +lfsr_mleafweight(lfs), DATA(split_data)), + LFSR_ATTR(msibling_.mid | lfsr_midrmask(lfs), MDIR, 0, FROMMBLOCKS(lfs, msibling_.u.m.blocks, msibling_buf)))); if (err) { @@ -5351,7 +5351,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } else if (err == LFS_ERR_NOENT) { LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", - mid >> lfs->mbits, + mid >> lfs->mleaf_bits, mdir->u.m.blocks[0], mdir->u.m.blocks[1]); // consume gstate so we don't lose any info @@ -5366,8 +5366,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( - LFSR_ATTR(mdir_.mid | lfsr_mridmask(lfs), - RM, -lfsr_mweight(lfs), NULL))); + LFSR_ATTR(mdir_.mid | lfsr_midrmask(lfs), + RM, -lfsr_mleafweight(lfs), NULL))); if (err) { return err; } @@ -5377,7 +5377,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, && !(mid == -1 || lfsr_mtree_isinlined(lfs))) { LFS_DEBUG("Relocating mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"} -> 0x{%"PRIx32",%"PRIx32"}", - mid >> lfs->mbits, + mid >> lfs->mleaf_bits, mdir->u.m.blocks[0], mdir->u.m.blocks[1], mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]); @@ -5388,7 +5388,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree uint8_t mdir_buf[LFSR_MDIR_DSIZE]; err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( - LFSR_ATTR(mdir_.mid | lfsr_mridmask(lfs), + LFSR_ATTR(mdir_.mid | lfsr_midrmask(lfs), MDIR, 0, FROMMBLOCKS(lfs, mdir_.u.m.blocks, mdir_buf)))); if (err) { @@ -5419,11 +5419,11 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // fix our grm for (int j = 0; j < 2; j++) { - if ((grm->rms[j] & lfsr_mbidmask(lfs)) - == (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs))) { - if ((grm->rms[j] & lfsr_mridmask(lfs)) + if ((grm->rms[j] & lfsr_midbmask(lfs)) + == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))) { + if ((grm->rms[j] & lfsr_midrmask(lfs)) >= mdir_.u.m.weight) { - grm->rms[j] += lfsr_mweight(lfs) + grm->rms[j] += lfsr_mleafweight(lfs) - mdir_.u.m.weight; } // update mid if we had a split or drop @@ -5605,8 +5605,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // first play out any attrs that change our rid for (lfs_size_t i = 0; i < attr_count; i++) { // adjust opened mdirs? - if ((opened->mdir.mid & lfsr_mbidmask(lfs)) - == (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs)) + if ((opened->mdir.mid & lfsr_midbmask(lfs)) + == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs)) && opened->mdir.mid >= attrs[i].rid) { // removed? if (opened->mdir.mid < attrs[i].rid - attrs[i].delta) { @@ -5635,14 +5635,14 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } // update any opened mdirs if we had a split or drop - if ((opened->mdir.mid & lfsr_mbidmask(lfs)) - == (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs))) { + if ((opened->mdir.mid & lfsr_midbmask(lfs)) + == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))) { if (msibling_.u.m.weight > 0 - && (opened->mdir.mid & lfsr_mridmask(lfs)) + && (opened->mdir.mid & lfsr_midrmask(lfs)) >= mdir_.u.m.weight) { LFS_ASSERT(lfsr_btree_weight(&mtree_) != lfsr_mtree_weight(lfs)); - opened->mdir.mid += lfsr_mweight(lfs) + opened->mdir.mid += lfsr_mleafweight(lfs) - mdir_.u.m.weight; opened->mdir.u.m = msibling_.u.m; } else { @@ -5659,8 +5659,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, for (lfs_size_t i = 0; i < attr_count; i++) { // TODO clean this up a bit? // adjust opened mdirs? - if ((dir->bookmark & lfsr_mbidmask(lfs)) - == (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs)) + if ((dir->bookmark & lfsr_midbmask(lfs)) + == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs)) && dir->bookmark >= attrs[i].rid) { // removed? if (dir->bookmark < attrs[i].rid - attrs[i].delta) { @@ -5679,14 +5679,14 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } } - if ((dir->bookmark & lfsr_mbidmask(lfs)) - == (lfs_smax32(mid, 0) & lfsr_mbidmask(lfs))) { + if ((dir->bookmark & lfsr_midbmask(lfs)) + == (lfs_smax32(mid, 0) & lfsr_midbmask(lfs))) { if (msibling_.u.m.weight > 0 - && (dir->bookmark & lfsr_mridmask(lfs)) + && (dir->bookmark & lfsr_midrmask(lfs)) >= mdir_.u.m.weight) { LFS_ASSERT(lfsr_btree_weight(&mtree_) != lfsr_mtree_weight(lfs)); - dir->bookmark += lfsr_mweight(lfs) + dir->bookmark += lfsr_mleafweight(lfs) - mdir_.u.m.weight; } } else if (dir->bookmark > mid) { @@ -5701,9 +5701,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update mdir to follow requested rid if (mid != -1 && msibling_.u.m.weight > 0 - && (mid & lfsr_mridmask(lfs)) >= mdir_.u.m.weight) { + && (mid & lfsr_midrmask(lfs)) >= mdir_.u.m.weight) { LFS_ASSERT(lfsr_btree_weight(&mtree_) != lfsr_mtree_weight(lfs)); - mdir->mid += lfsr_mweight(lfs) - mdir_.u.m.weight; + mdir->mid += lfsr_mleafweight(lfs) - mdir_.u.m.weight; mdir->u.m = msibling_.u.m; } else { mdir->u.m = mdir_.u.m; @@ -5760,7 +5760,7 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, return err; } LFS_ASSERT(tag == LFSR_TAG_MDIR); - LFS_ASSERT(weight == lfsr_mweight(lfs)); + LFS_ASSERT(weight == lfsr_mleafweight(lfs)); // decode mdir err = lfsr_data_readmblocks(lfs, &data, mdir.u.m.blocks); @@ -6068,7 +6068,7 @@ static int lfsr_mtree_traversal_next(lfs_t *lfs, lfs->mtree = LFSR_BTREE_NULL; } else if (tag == LFSR_TAG_MDIR) { err = lfsr_data_readbtreeinlined(lfs, &data, - LFSR_TAG_MDIR, lfsr_mweight(lfs), + LFSR_TAG_MDIR, lfsr_mleafweight(lfs), &lfs->mtree); if (err) { return err; @@ -6235,9 +6235,8 @@ static lfsr_data_t lfsr_data_fromsuperconfig(lfs_t *lfs, LFS_ASSERT(d_ >= 0); d += d_; - // on-disk mlimit - lfsr_mid_t mlimit = lfsr_mweight(lfs)-1; - d_ = lfs_toleb128(mlimit, &buffer[d], 5); + // on-disk mleaf limit + d_ = lfs_toleb128(lfsr_mleafweight(lfs)-1, &buffer[d], 5); LFS_ASSERT(d_ >= 0); d += d_; @@ -6435,16 +6434,17 @@ static int lfsr_mountinited(lfs_t *lfs) { // check the on-disk mtree limit // TODO actually use this - lfsr_mid_t mlimit; - err = lfsr_data_readleb128(lfs, &data, (int32_t*)&mlimit); + lfsr_mid_t mleaf_limit; + err = lfsr_data_readleb128(lfs, &data, (int32_t*)&mleaf_limit); // treat any leb128 overflows as out-of-range values if (err && err != LFS_ERR_CORRUPT) { return err; } - if (err == LFS_ERR_CORRUPT || mlimit != lfsr_mweight(lfs)-1) { - LFS_ERROR("Incompatible mlimit 0x%"PRIx32, - (err ? (lfsr_mid_t)-1 : mlimit)); + if (err == LFS_ERR_CORRUPT + || mleaf_limit != lfsr_mleafweight(lfs)-1) { + LFS_ERROR("Incompatible mleaf limit 0x%"PRIx32, + (err ? (lfsr_mid_t)-1 : mleaf_limit)); return LFS_ERR_INVAL; } @@ -6548,14 +6548,14 @@ static int lfsr_mountinited(lfs_t *lfs) { if (lfsr_grm_count(&lfs->grm) == 2) { LFS_DEBUG("Found pending grm " "%"PRId32".%"PRId32" %"PRId32".%"PRId32, - lfs->grm.rms[0] >> lfs->mbits, - lfs->grm.rms[0] & lfsr_mridmask(lfs), - lfs->grm.rms[1] >> lfs->mbits, - lfs->grm.rms[1] & lfsr_mridmask(lfs)); + lfs->grm.rms[0] >> lfs->mleaf_bits, + lfs->grm.rms[0] & lfsr_midrmask(lfs), + lfs->grm.rms[1] >> lfs->mleaf_bits, + lfs->grm.rms[1] & lfsr_midrmask(lfs)); } else if (lfsr_grm_count(&lfs->grm) == 1) { LFS_DEBUG("Found pending grm %"PRId32".%"PRId32, - lfs->grm.rms[0] >> lfs->mbits, - lfs->grm.rms[0] & lfsr_mridmask(lfs)); + lfs->grm.rms[0] >> lfs->mleaf_bits, + lfs->grm.rms[0] & lfsr_midrmask(lfs)); } } @@ -6961,8 +6961,8 @@ int lfsr_remove(lfs_t *lfs, const char *path) { } // adjust rid if grm is on the same mdir as our dir - if ((grm.rms[0] & lfsr_mbidmask(lfs)) - == (mdir.mid & lfsr_mbidmask(lfs)) + if ((grm.rms[0] & lfsr_midbmask(lfs)) + == (mdir.mid & lfsr_midbmask(lfs)) && grm.rms[0] > mdir.mid) { grm.rms[0] -= 1; } @@ -7024,8 +7024,8 @@ int lfsr_rename(lfs_t *lfs, const char *old_path, const char *new_path) { } // adjust old rid if grm is on the same mdir as new rid - if ((grm.rms[0] & lfsr_mbidmask(lfs)) - == (new_mdir.mid & lfsr_mbidmask(lfs)) + if ((grm.rms[0] & lfsr_midbmask(lfs)) + == (new_mdir.mid & lfsr_midbmask(lfs)) && grm.rms[0] >= new_mdir.mid) { grm.rms[0] += 1; } @@ -7340,7 +7340,7 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { lfsr_mdir_t mdir; LFS_ASSERT(lfs->grm.rms[0] < lfs_smax32( lfsr_mtree_weight(lfs), - lfsr_mweight(lfs))); + lfsr_mleafweight(lfs))); int err = lfsr_mtree_lookup(lfs, lfs->grm.rms[0], &mdir); if (err) { return err; @@ -7351,15 +7351,15 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { lfsr_grm_poprm(&grm); // make sure to adjust any remaining grms - if ((grm.rms[0] & lfsr_mbidmask(lfs)) - == (mdir.mid & lfsr_mbidmask(lfs)) + if ((grm.rms[0] & lfsr_midbmask(lfs)) + == (mdir.mid & lfsr_midbmask(lfs)) && grm.rms[0] >= mdir.mid) { LFS_ASSERT(grm.rms[0] != mdir.mid); grm.rms[0] -= 1; } // remove the rid while also updating our grm - LFS_ASSERT((lfs->grm.rms[0] & lfsr_mridmask(lfs)) < mdir.u.m.weight); + LFS_ASSERT((lfs->grm.rms[0] & lfsr_midrmask(lfs)) < mdir.u.m.weight); err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, RM, -1, NULL), LFSR_ATTR(-1, GRM, 0, GRM(&grm)))); @@ -7377,14 +7377,14 @@ static int lfsr_fs_preparemutation(lfs_t *lfs) { if (lfsr_grm_count(&lfs->grm) == 2) { LFS_DEBUG("Fixing pending grm " "%"PRId32".%"PRId32" %"PRId32".%"PRId32, - lfs->grm.rms[0] >> lfs->mbits, - lfs->grm.rms[0] & lfsr_mridmask(lfs), - lfs->grm.rms[1] >> lfs->mbits, - lfs->grm.rms[1] & lfsr_mridmask(lfs)); + lfs->grm.rms[0] >> lfs->mleaf_bits, + lfs->grm.rms[0] & lfsr_midrmask(lfs), + lfs->grm.rms[1] >> lfs->mleaf_bits, + lfs->grm.rms[1] & lfsr_midrmask(lfs)); } else if (lfsr_grm_count(&lfs->grm) == 1) { LFS_DEBUG("Fixing pending grm %"PRId32".%"PRId32, - lfs->grm.rms[0] >> lfs->mbits, - lfs->grm.rms[0] & lfsr_mridmask(lfs)); + lfs->grm.rms[0] >> lfs->mleaf_bits, + lfs->grm.rms[0] & lfsr_midrmask(lfs)); } int err = lfsr_fs_fixgrm(lfs); @@ -10898,7 +10898,7 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) { // Note we can't assume ~1/2 block utilization here, as an mdir may // temporarily fill with more mids before compaction occurs. // - lfs->mbits = lfs_nlog2(lfs->cfg->block_size/16); + lfs->mleaf_bits = lfs_nlog2(lfs->cfg->block_size/16); // zero linked-lists of opened mdirs lfs->opened[LFS_TYPE_REG] = NULL; diff --git a/lfs.h b/lfs.h index 36aa8dfe..99c4db53 100644 --- a/lfs.h +++ b/lfs.h @@ -514,7 +514,7 @@ typedef struct lfs { uint8_t ggrm[LFSR_GRM_DSIZE]; uint8_t dgrm[LFSR_GRM_DSIZE]; - uint8_t mbits; + uint8_t mleaf_bits; lfsr_mdir_t mroot; lfsr_btree_t mtree; diff --git a/scripts/dbglfs.py b/scripts/dbglfs.py index f9c94a8c..3b5d403c 100755 --- a/scripts/dbglfs.py +++ b/scripts/dbglfs.py @@ -654,10 +654,10 @@ def superconfig(mroot): # collect gstate class GState: - def __init__(self, mweight): + def __init__(self, mleaf_weight): self.gstate = {} self.gdelta = {} - self.mweight = mweight + self.mleaf_weight = mleaf_weight def xor(self, mbid, mw, mdir): tag = TAG_GSTATE-0x1 @@ -691,11 +691,11 @@ class GState: for _ in range(count): mid, d_ = fromleb128(data[d:]); d += d_ rms.append(( - mid - (mid % self.mweight), - mid % self.mweight)) + mid - (mid % self.mleaf_weight), + mid % self.mleaf_weight)) return rms -def grepr(tag, data, mweight): +def grepr(tag, data, mleaf_weight): if tag == TAG_GRM: d = 0 count, d_ = fromleb128(data[d:]); d += d_ @@ -704,11 +704,11 @@ def grepr(tag, data, mweight): for _ in range(count): mid, d_ = fromleb128(data[d:]); d += d_ rms.append(( - mid - (mid % self.mweight), - mid % self.mweight)) + mid - (mid % mleaf_weight), + mid % mleaf_weight)) return 'grm %s' % ( 'none' if count == 0 - else ' '.join('%d.%d' % (mbid//mweight, rid) + else ' '.join('%d.%d' % (mbid//mleaf_weight, rid) for mbid, rid in rms) if count <= 2 else '0x%x' % count) @@ -738,7 +738,7 @@ def frepr(mdir, rid, tag): def main(disk, mroots=None, *, block_size=None, - mweight=None, + mleaf_weight=None, color='auto', **args): # figure out what color should be @@ -761,10 +761,10 @@ def main(disk, mroots=None, *, f.seek(0, os.SEEK_END) block_size = f.tell() - # determine the mweight from the block_size, this is just for + # determine the mleaf_weight from the block_size, this is just for # printing purposes - if mweight is None: - mweight = 1 << m.ceil(m.log2(block_size // 16)) + if mleaf_weight is None: + mleaf_weight = 1 << m.ceil(m.log2(block_size // 16)) # before we print, we need to do a pass for a few things: # - find the actual mroot @@ -776,7 +776,7 @@ def main(disk, mroots=None, *, bweight = 0 rweight = 0 corrupted = False - gstate = GState(mweight) + gstate = GState(mleaf_weight) config = {} dir_dids = [(0, b'', -1, 0, None, -1, TAG_DID, 0)] bookmark_dids = [] @@ -944,10 +944,10 @@ def main(disk, mroots=None, *, print('littlefs v%s.%s %s, rev %d, weight %d.%d' % ( config.get('major_version', ('?',))[0], config.get('minor_version', ('?',))[0], - mroot.addr(), mroot.rev, bweight//mweight, 1*mweight)) + mroot.addr(), mroot.rev, bweight//mleaf_weight, 1*mleaf_weight)) # print header - w_width = (m.ceil(m.log10(max(1, bweight//mweight)+1)) + w_width = (m.ceil(m.log10(max(1, bweight//mleaf_weight)+1)) + 2*m.ceil(m.log10(max(1, rweight)+1)) + 2) if dtree: @@ -1002,7 +1002,7 @@ def main(disk, mroots=None, *, print('%12s %-*s %s' % ( 'gstate:' if i == 0 else '', w_width + 23, - grepr(tag, data, mweight), + grepr(tag, data, mleaf_weight), next(xxd(data, 8), '') if not args.get('no_truncate') else '')) @@ -1037,7 +1037,7 @@ def main(disk, mroots=None, *, ','.join('%04x' % block for block in it.chain([mdir.block], mdir.redund_blocks)), - w_width, mbid//mweight, + w_width, mbid//mleaf_weight, tagrepr(tag, 0, len(data)), next(xxd(data, 8), '') if not args.get('no_truncate') else '', @@ -1140,8 +1140,8 @@ def main(disk, mroots=None, *, mdir.redund_blocks)) if mbid != pmbid else '', w_width, '%d.%d-%d' % ( - mbid//mweight, rid-(w-1), rid) - if w > 1 else '%d.%d' % (mbid//mweight, rid) + mbid//mleaf_weight, rid-(w-1), rid) + if w > 1 else '%d.%d' % (mbid//mleaf_weight, rid) if w > 0 else '', f_width, '%s%s' % ( prefixes[0+(i==len(dir)-1)], @@ -1243,9 +1243,9 @@ if __name__ == "__main__": type=lambda x: int(x, 0), help="Block size in bytes.") parser.add_argument( - '-M', '--mweight', + '-M', '--mleaf-weight', type=lambda x: int(x, 0), - help="Weight of mtree leaves for mid decoding. Defaults to a " + help="Maximum weight of mdirs for mid decoding. Defaults to a " "block_size derived value.") parser.add_argument( '--color', diff --git a/scripts/dbgmtree.py b/scripts/dbgmtree.py index e8f839d3..aea7a6a0 100755 --- a/scripts/dbgmtree.py +++ b/scripts/dbgmtree.py @@ -739,7 +739,7 @@ class Rbyd: def main(disk, mroots=None, *, block_size=None, - mweight=None, + mleaf_weight=None, color='auto', **args): # figure out what color should be @@ -762,10 +762,10 @@ def main(disk, mroots=None, *, f.seek(0, os.SEEK_END) block_size = f.tell() - # determine the mweight from the block_size, this is just for + # determine the mleaf_weight from the block_size, this is just for # printing purposes - if mweight is None: - mweight = 1 << m.ceil(m.log2(block_size // 16)) + if mleaf_weight is None: + mleaf_weight = 1 << m.ceil(m.log2(block_size // 16)) # before we print, we need to do a pass for a few things: # - find the actual mroot @@ -1309,8 +1309,8 @@ def main(disk, mroots=None, *, if args.get('tree') or args.get('btree') else '', '%*s %-22s%s' % ( w_width, '%d.%d-%d' % ( - mbid//mweight, rid-(w-1), rid) - if w > 1 else '%d.%d' % (mbid//mweight, rid) + mbid//mleaf_weight, rid-(w-1), rid) + if w > 1 else '%d.%d' % (mbid//mleaf_weight, rid) if w > 0 or i == 0 else '', tagrepr(tag, w, len(data), j), ' %s' % next(xxd(data, 8), '') @@ -1366,9 +1366,11 @@ def main(disk, mroots=None, *, treerepr(bid, w, bd, rid, 0, tag) if args.get('tree') or args.get('btree') else '', w_width, '' if i != 0 - else '%d-%d' % ((bid-(w-1))//mweight, bid//mweight) - if (w//mweight) > 1 - else bid//mweight if w > 0 + else '%d-%d' % ( + (bid-(w-1))//mleaf_weight, + bid//mleaf_weight) + if (w//mleaf_weight) > 1 + else bid//mleaf_weight if w > 0 else '', tagrepr(tag, w if i == 0 else 0, len(data), None), # note we render names a bit different here @@ -1409,10 +1411,10 @@ def main(disk, mroots=None, *, # print some information about the mtree print('mtree %s, rev %d, weight %d.%d' % ( - mroot.addr(), mroot.rev, bweight//mweight, 1*mweight)) + mroot.addr(), mroot.rev, bweight//mleaf_weight, 1*mleaf_weight)) # print header - w_width = (m.ceil(m.log10(max(1, bweight//mweight)+1)) + w_width = (m.ceil(m.log10(max(1, bweight//mleaf_weight)+1)) + 2*m.ceil(m.log10(max(1, rweight)+1)) + 2) print('%-11s %*s%-*s %-22s %s' % ( @@ -1603,9 +1605,9 @@ if __name__ == "__main__": type=lambda x: int(x, 0), help="Block size in bytes.") parser.add_argument( - '-M', '--mweight', + '-M', '--mleaf-weight', type=lambda x: int(x, 0), - help="Weight of mtree leaves for mid decoding. Defaults to a " + help="Maximum weight of mdirs for mid decoding. Defaults to a " "block_size derived value.") parser.add_argument( '--color', diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml index c5e92542..37f60f51 100644 --- a/tests/test_alloc.toml +++ b/tests/test_alloc.toml @@ -109,7 +109,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; lfs_size_t count = 0; @@ -146,11 +146,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index cf7198da..0110879b 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -182,7 +182,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -193,7 +193,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -207,7 +207,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -217,7 +217,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -255,19 +255,19 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert that our entries are still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "a", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -280,18 +280,18 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "a", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -328,13 +328,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // now add another large entry to the mdir, forcing a split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); @@ -346,7 +346,7 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -356,13 +356,13 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -374,7 +374,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -384,13 +384,13 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -418,7 +418,7 @@ code = ''' // create entries lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, - lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), + lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mleafweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { // force a compaction? @@ -444,11 +444,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -471,11 +471,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -516,12 +516,12 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs))); + lfsr_mleafweight(&lfs))); // fetch mdir lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // limit our mid to our mdir's weight - mdir.mid = (mdir.mid & lfsr_mbidmask(&lfs)) + mdir.mid = (mdir.mid & lfsr_midbmask(&lfs)) | (mdir.mid % (mdir.u.m.weight+1)); // force a compaction? @@ -550,11 +550,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -581,11 +581,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -635,20 +635,20 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // remove the entry, forcing the mdir to be dropped lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -664,7 +664,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -704,13 +704,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // remove the entry, forcing the mdir to be dropped lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); // force mdir to compact while we're removing @@ -720,7 +720,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -736,7 +736,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -779,7 +779,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -795,7 +795,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -839,13 +839,13 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); // assert that one entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -859,12 +859,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -906,13 +906,13 @@ code = ''' LFSR_ATTR(1, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); // assert that one entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -926,12 +926,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -973,7 +973,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -984,7 +984,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1019,13 +1019,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // now add another large entry to the mdir, forcing a split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); @@ -1037,12 +1037,12 @@ code = ''' // remove the left entry as we compact, forcing the left // mdir to be dropped - mdir.mid = 0*lfsr_mweight(&lfs)+0; + mdir.mid = 0*lfsr_mleafweight(&lfs)+0; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1052,7 +1052,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1066,7 +1066,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1076,7 +1076,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1114,13 +1114,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // now add another large entry to the mdir, forcing a split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); @@ -1136,7 +1136,7 @@ code = ''' LFSR_ATTR(1, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1146,7 +1146,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1160,7 +1160,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1170,7 +1170,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1208,13 +1208,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // now add another large entry to the mdir, forcing a split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); @@ -1230,7 +1230,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1246,7 +1246,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1278,7 +1278,7 @@ code = ''' // create entries lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, - lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), + lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mleafweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -1296,7 +1296,7 @@ code = ''' // remove entries for (lfs_size_t i = 0; i < N - REMAINING; i++) { lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_isinlined(&lfs) || mdir.u.m.weight > 0); @@ -1316,11 +1316,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -1343,11 +1343,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -1382,7 +1382,7 @@ code = ''' // create entries lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, - lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), + lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mleafweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -1402,11 +1402,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -1421,7 +1421,7 @@ code = ''' // remove entries for (lfs_size_t i = 0; i < N; i++) { lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_isinlined(&lfs) || mdir.u.m.weight > 0); @@ -1436,7 +1436,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; } - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); assert(lfs.mroot.u.m.weight == 0); } @@ -1446,7 +1446,7 @@ code = ''' // check things stay sane after remount lfsr_mount(&lfs, CFG) => 0; - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); assert(lfs.mroot.u.m.weight == 0); lfsr_unmount(&lfs) => 0; @@ -1477,15 +1477,15 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs))); + lfsr_mleafweight(&lfs))); // fetch mdir lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // limit our mid to our mdir's weight - mdir.mid = (mdir.mid & lfsr_mbidmask(&lfs)) + mdir.mid = (mdir.mid & lfsr_midbmask(&lfs)) | (mdir.mid % (mdir.u.m.weight+1)); // choose to create or delete - uint8_t op = ((mdir.mid & lfsr_mridmask(&lfs)) == mdir.u.m.weight + uint8_t op = ((mdir.mid & lfsr_midrmask(&lfs)) == mdir.u.m.weight ? 0 : TEST_PRNG(&prng) % 2); @@ -1525,15 +1525,15 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_isinlined(&lfs) || mdir.u.m.weight > 0); - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -1560,15 +1560,15 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_isinlined(&lfs) || mdir.u.m.weight > 0); - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -1621,13 +1621,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // force mdir to compact twice, this should relocate lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_t old_mdir = mdir; @@ -1648,7 +1648,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1662,7 +1662,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1675,7 +1675,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1715,13 +1715,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // force mdir to compact twice, this should relocate lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_t old_mdir = mdir; @@ -1737,13 +1737,13 @@ code = ''' assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1756,7 +1756,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1764,13 +1764,13 @@ code = ''' assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1809,13 +1809,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // force mdir to compact twice, this should relocate lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_t old_mdir = mdir; @@ -1831,13 +1831,13 @@ code = ''' assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "a", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1850,7 +1850,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1858,13 +1858,13 @@ code = ''' assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "a", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2088,7 +2088,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2099,7 +2099,7 @@ code = ''' // force mdir to compact twice, this should relocate lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_t old_mdir = mdir; @@ -2123,7 +2123,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2137,7 +2137,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2153,7 +2153,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2193,7 +2193,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2204,7 +2204,7 @@ code = ''' // now add another large entry to the mdir, forcing a split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); @@ -2216,7 +2216,7 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2229,13 +2229,13 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2248,7 +2248,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2261,13 +2261,13 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2306,7 +2306,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2317,14 +2317,14 @@ code = ''' // remove the entry, forcing the mdir to be dropped lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2343,7 +2343,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2395,7 +2395,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2409,7 +2409,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2423,7 +2423,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2436,7 +2436,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2482,7 +2482,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2491,13 +2491,13 @@ code = ''' // assert that our entries are still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "a", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2510,7 +2510,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2518,13 +2518,13 @@ code = ''' assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "a", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2560,15 +2560,15 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs))); + lfsr_mleafweight(&lfs))); // fetch mdir lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // limit our mid to our mdir's weight - mdir.mid = (mdir.mid & lfsr_mbidmask(&lfs)) + mdir.mid = (mdir.mid & lfsr_midbmask(&lfs)) | (mdir.mid % (mdir.u.m.weight+1)); // choose to create or delete - uint8_t op = ((mdir.mid & lfsr_mridmask(&lfs)) == mdir.u.m.weight + uint8_t op = ((mdir.mid & lfsr_midrmask(&lfs)) == mdir.u.m.weight ? 0 : TEST_PRNG(&prng) % 3); @@ -2621,15 +2621,15 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_isinlined(&lfs) || mdir.u.m.weight > 0); - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -2656,15 +2656,15 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_isinlined(&lfs) || mdir.u.m.weight > 0); - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -2864,7 +2864,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2875,7 +2875,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 2); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2884,14 +2884,14 @@ code = ''' // note that our current implementation splits here, which is suboptimal // but saves on code size lfsr_mdir_t msibling; - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &msibling) => 0; assert(msibling.u.m.weight == 1); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); + assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+0); + assert(right_neighbor.mdir.mid == 1*lfsr_mleafweight(&lfs)+0); assert(memcmp(&right_neighbor.mdir.u.m, &msibling.u.m, sizeof(msibling.u.m)) == 0); @@ -2942,30 +2942,30 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert that our entries are still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 2); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); lfsr_mdir_t msibling; - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &msibling) => 0; assert(msibling.u.m.weight == 2); lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "d", 1) == 0); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); + assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+1); + assert(right_neighbor.mdir.mid == 1*lfsr_mleafweight(&lfs)+1); assert(memcmp(&right_neighbor.mdir.u.m, &msibling.u.m, sizeof(msibling.u.m)) == 0); @@ -3002,7 +3002,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3011,14 +3011,14 @@ code = ''' // note we do this after uninlining! this is because uninlining may // aggresively split the mtree if there are already neighbors in the mdir lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid+0, REG, +1, BUF("a", 1)), LFSR_ATTR(mdir.mid+2, REG, +1, BUF("b", 1)))) => 0; // this test only works if these all fit in the mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); assert(mdir.u.m.weight == 3); lfsr_openedmdir_t left_neighbor = { @@ -3030,7 +3030,7 @@ code = ''' // now add another large entry to the mdir, forcing a split memset(buffer, 'e', SIZE); - mdir.mid = 0*lfsr_mweight(&lfs)+2; + mdir.mid = 0*lfsr_mleafweight(&lfs)+2; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; @@ -3039,7 +3039,7 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3049,24 +3049,24 @@ code = ''' assert(memcmp(buffer, "c", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 2); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "d", 1) == 0); lfsr_mdir_t msibling; - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &msibling) => 0; assert(msibling.u.m.weight == 2); lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "e", 1) == 0); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); + assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+1); + assert(right_neighbor.mdir.mid == 1*lfsr_mleafweight(&lfs)+1); assert(memcmp(&right_neighbor.mdir.u.m, &msibling.u.m, sizeof(msibling.u.m)) == 0); @@ -3171,7 +3171,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3180,14 +3180,14 @@ code = ''' // note we do this after uninlining! this is because uninlining may // aggresively split the mtree if there are already neighbors in the mdir lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid+0, REG, +1, BUF("a", 1)), LFSR_ATTR(mdir.mid+2, REG, +1, BUF("b", 1)))) => 0; // this test only works if these all fit in the mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); assert(mdir.u.m.weight == 3); lfsr_openedmdir_t left_neighbor = { @@ -3216,7 +3216,7 @@ code = ''' assert(memcmp(buffer, "c", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 3); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -3224,9 +3224,9 @@ code = ''' assert(memcmp(buffer, "e", 1) == 0); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); + assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+2); + assert(right_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+2); assert(memcmp(&right_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_REG, &left_neighbor); @@ -3265,11 +3265,11 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // we should now have 2 mdirs - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // now force one of our siblings to split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -3280,19 +3280,19 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 3 mdirs - assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mleafweight(&lfs)); //// Now test splitting updates mids correctly // setup our neighbors lfsr_openedmdir_t left_neighbor; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &left_neighbor.mdir) => 0; assert(left_neighbor.mdir.u.m.weight == 1); lfsr_openedmdir_t right_neighbor; - lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 2*lfsr_mleafweight(&lfs)+0, &right_neighbor.mdir) => 0; assert(right_neighbor.mdir.u.m.weight == 1); @@ -3300,7 +3300,7 @@ code = ''' lfsr_mdir_addopened(&lfs, LFS_TYPE_REG, &right_neighbor); // cause middle mdir to split - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'd', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -3311,15 +3311,15 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 4 mdirs - assert(lfsr_mtree_weight(&lfs) == 4*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 4*lfsr_mleafweight(&lfs)); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 3*lfsr_mweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 3*lfsr_mweight(&lfs)+0, &mdir) => 0; + assert(right_neighbor.mdir.mid == 3*lfsr_mleafweight(&lfs)+0); + lfsr_mtree_lookup(&lfs, 3*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(memcmp(&right_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_REG, &left_neighbor); @@ -3358,11 +3358,11 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // we should now have 2 mdirs - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // now force one of our siblings to split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -3373,19 +3373,19 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 3 mdirs - assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mleafweight(&lfs)); //// Now test dropping updates mids correctly // setup our neighbors lfsr_openedmdir_t left_neighbor; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &left_neighbor.mdir) => 0; assert(left_neighbor.mdir.u.m.weight == 1); lfsr_openedmdir_t right_neighbor; - lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 2*lfsr_mleafweight(&lfs)+0, &right_neighbor.mdir) => 0; assert(right_neighbor.mdir.u.m.weight == 1); @@ -3393,21 +3393,21 @@ code = ''' lfsr_mdir_addopened(&lfs, LFS_TYPE_REG, &right_neighbor); // cause middle mdir to drop - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, RM, -1, NULL))) => 0; // we should now have 2 mdirs - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; + assert(right_neighbor.mdir.mid == 1*lfsr_mleafweight(&lfs)+0); + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(memcmp(&right_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_REG, &left_neighbor); @@ -3467,8 +3467,8 @@ code = ''' if (tag_ == LFSR_TAG_BTREE) { lfsr_rbyd_t *branch = (lfsr_rbyd_t *)data_.u.b.buffer; printf("traversal: %d.%d 0x%x btree 0x%x.%x\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, branch->block, branch->trunk); @@ -3477,8 +3477,8 @@ code = ''' } else if (tag_ == LFSR_TAG_MDIR) { lfsr_mdir_t *mdir = (lfsr_mdir_t*)data_.u.b.buffer; printf("traversal: %d.%d 0x%x mdir 0x{%x,%x}\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, mdir->u.m.blocks[0], mdir->u.m.blocks[1]); @@ -3488,8 +3488,8 @@ code = ''' } else { // this shouldn't happen printf("traversal: %d.%d 0x%x %d\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, lfsr_data_size(&data_)); assert(false); @@ -3549,7 +3549,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3560,7 +3560,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -3591,8 +3591,8 @@ code = ''' if (tag_ == LFSR_TAG_BTREE) { lfsr_rbyd_t *branch = (lfsr_rbyd_t *)data_.u.b.buffer; printf("traversal: %d.%d 0x%x btree 0x%x.%x\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, branch->block, branch->trunk); @@ -3601,8 +3601,8 @@ code = ''' } else if (tag_ == LFSR_TAG_MDIR) { lfsr_mdir_t *mdir = (lfsr_mdir_t*)data_.u.b.buffer; printf("traversal: %d.%d 0x%x mdir 0x{%x,%x}\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, mdir->u.m.blocks[0], mdir->u.m.blocks[1]); @@ -3612,8 +3612,8 @@ code = ''' } else { // this shouldn't happen printf("traversal: %d.%d 0x%x %d\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, lfsr_data_size(&data_)); assert(false); @@ -3634,7 +3634,7 @@ code = ''' // and the tree should still work // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3644,7 +3644,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -3683,20 +3683,20 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert that our entries are still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "a", 1) == 0); lfsr_mdir_t msibling; - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &msibling) => 0; assert(msibling.u.m.weight == 1); lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3726,8 +3726,8 @@ code = ''' if (tag_ == LFSR_TAG_BTREE) { lfsr_rbyd_t *branch = (lfsr_rbyd_t *)data_.u.b.buffer; printf("traversal: %d.%d 0x%x btree 0x%x.%x\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, branch->block, branch->trunk); @@ -3736,8 +3736,8 @@ code = ''' } else if (tag_ == LFSR_TAG_MDIR) { lfsr_mdir_t *mdir = (lfsr_mdir_t*)data_.u.b.buffer; printf("traversal: %d.%d 0x%x mdir 0x{%x,%x}\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, mdir->u.m.blocks[0], mdir->u.m.blocks[1]); @@ -3747,8 +3747,8 @@ code = ''' } else { // this shouldn't happen printf("traversal: %d.%d 0x%x %d\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, lfsr_data_size(&data_)); assert(false); @@ -3769,18 +3769,18 @@ code = ''' // and the tree should still work // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "a", 1) == 0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &msibling) => 0; assert(msibling.u.m.weight == 1); lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3853,8 +3853,8 @@ code = ''' if (tag_ == LFSR_TAG_BTREE) { lfsr_rbyd_t *branch = (lfsr_rbyd_t *)data_.u.b.buffer; printf("traversal: %d.%d 0x%x btree 0x%x.%x\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, branch->block, branch->trunk); @@ -3863,8 +3863,8 @@ code = ''' } else if (tag_ == LFSR_TAG_MDIR) { lfsr_mdir_t *mdir = (lfsr_mdir_t*)data_.u.b.buffer; printf("traversal: %d.%d 0x%x mdir 0x{%x,%x}\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, mdir->u.m.blocks[0], mdir->u.m.blocks[1]); @@ -3874,8 +3874,8 @@ code = ''' } else { // this shouldn't happen printf("traversal: %d.%d 0x%x %d\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, lfsr_data_size(&data_)); assert(false); @@ -3925,7 +3925,7 @@ code = ''' // create entries lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, - lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), + lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mleafweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { // force a compaction? @@ -3951,11 +3951,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -3991,8 +3991,8 @@ code = ''' if (tag_ == LFSR_TAG_BTREE) { lfsr_rbyd_t *branch = (lfsr_rbyd_t *)data_.u.b.buffer; printf("traversal: %d.%d 0x%x btree 0x%x.%x\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, branch->block, branch->trunk); @@ -4001,8 +4001,8 @@ code = ''' } else if (tag_ == LFSR_TAG_MDIR) { lfsr_mdir_t *mdir = (lfsr_mdir_t*)data_.u.b.buffer; printf("traversal: %d.%d 0x%x mdir 0x{%x,%x}\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, mdir->u.m.blocks[0], mdir->u.m.blocks[1]); @@ -4012,8 +4012,8 @@ code = ''' } else { // this shouldn't happen printf("traversal: %d.%d 0x%x %d\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, lfsr_data_size(&data_)); assert(false); @@ -4038,11 +4038,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -4083,12 +4083,12 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs))); + lfsr_mleafweight(&lfs))); // fetch mdir lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // limit our mid to our mdir's weight - mdir.mid = (mdir.mid & lfsr_mbidmask(&lfs)) + mdir.mid = (mdir.mid & lfsr_midbmask(&lfs)) | (mdir.mid % (mdir.u.m.weight+1)); // force a compaction? @@ -4117,11 +4117,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -4161,8 +4161,8 @@ code = ''' if (tag_ == LFSR_TAG_BTREE) { lfsr_rbyd_t *branch = (lfsr_rbyd_t *)data_.u.b.buffer; printf("traversal: %d.%d 0x%x btree 0x%x.%x\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, branch->block, branch->trunk); @@ -4171,8 +4171,8 @@ code = ''' } else if (tag_ == LFSR_TAG_MDIR) { lfsr_mdir_t *mdir = (lfsr_mdir_t*)data_.u.b.buffer; printf("traversal: %d.%d 0x%x mdir 0x{%x,%x}\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, mdir->u.m.blocks[0], mdir->u.m.blocks[1]); @@ -4182,8 +4182,8 @@ code = ''' } else { // this shouldn't happen printf("traversal: %d.%d 0x%x %d\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, lfsr_data_size(&data_)); assert(false); @@ -4209,11 +4209,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mweight(&lfs)); - mid += lfsr_mweight(&lfs)) { + lfsr_mleafweight(&lfs)); + mid += lfsr_mleafweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_mridmask(&lfs)) + for (; (mdir.mid & lfsr_midrmask(&lfs)) < (lfs_ssize_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; @@ -4270,22 +4270,22 @@ code = ''' if (tag_ == LFSR_TAG_BTREE) { lfsr_rbyd_t *branch = (lfsr_rbyd_t *)data_.u.b.buffer; printf("traversal: %d.%d 0x%x btree 0x%x.%x\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, branch->block, branch->trunk); } else if (tag_ == LFSR_TAG_MDIR) { lfsr_mdir_t *mdir = (lfsr_mdir_t*)data_.u.b.buffer; printf("traversal: %d.%d 0x%x mdir 0x{%x,%x}\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, mdir->u.m.blocks[0], mdir->u.m.blocks[1]); } else { // this shouldn't happen printf("traversal: %d.%d 0x%x %d\n", - mid_ >> lfs.mbits, - mid_ & lfsr_mridmask(&lfs), + mid_ >> lfs.mleaf_bits, + mid_ & lfsr_midrmask(&lfs), tag_, lfsr_data_size(&data_)); assert(false);