From 41b9caf25dcdfcbb106c79bec8e88936abc1cb6e Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sat, 25 Nov 2023 12:52:50 -0600 Subject: [PATCH] Renamed mid related functions and tried to make them less cumbersome - lfs->mleaf_bits -> lfs->mbits - lfsr_mleafweight -> lfsr_mweight - lfsr_midbmask -> lfsr_mid_bid - lfsr_midrmask -> lfsr_mid_rid - added lfsr_mid_cbid - added lfsr_mid_crid - added lfsr_mdir_* variants --- lfs.c | 236 ++++++++++---------- lfs.h | 2 +- tests/test_mtree.toml | 487 ++++++++++++++++++++---------------------- 3 files changed, 360 insertions(+), 365 deletions(-) diff --git a/lfs.c b/lfs.c index 4b248606..f8089e94 100644 --- a/lfs.c +++ b/lfs.c @@ -1707,16 +1707,24 @@ static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data, /// Metadata-id things /// -static inline lfsr_mid_t lfsr_mleafweight(lfs_t *lfs) { - return 1 << lfs->mleaf_bits; +static inline lfsr_mid_t lfsr_mweight(lfs_t *lfs) { + return 1 << lfs->mbits; } -static inline lfsr_smid_t lfsr_midrmask(lfs_t *lfs) { - return (1 << lfs->mleaf_bits) - 1; +static inline lfsr_bid_t lfsr_mid_bid(lfs_t *lfs, lfsr_mid_t mid) { + return mid | ((1 << lfs->mbits) - 1); } -static inline lfsr_smid_t lfsr_midbmask(lfs_t *lfs) { - return ~lfsr_midrmask(lfs); +static inline lfsr_rid_t lfsr_mid_rid(lfs_t *lfs, lfsr_mid_t mid) { + return mid & ((1 << lfs->mbits) - 1); +} + +static inline lfsr_bid_t lfsr_mid_cbid(lfs_t *lfs, lfsr_smid_t mid) { + return lfsr_mid_bid(lfs, lfs_smax32(mid, 0)); +} + +static inline lfsr_srid_t lfsr_mid_crid(lfs_t *lfs, lfsr_smid_t mid) { + return (mid < 0) ? -1 : (lfsr_srid_t)lfsr_mid_rid(lfs, mid); } // we use the root's bookmark at 0.0 to represent root @@ -1724,10 +1732,6 @@ static inline bool lfsr_mid_isroot(lfsr_smid_t mid) { return mid == 0; } -static inline bool lfsr_mdir_isroot(const lfsr_mdir_t *mdir) { - return lfsr_mid_isroot(mdir->mid); -} - /// Global-state things /// @@ -1868,7 +1872,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_mleafweight(lfs))); + lfsr_mweight(lfs))); } return 0; @@ -5031,6 +5035,26 @@ static inline void lfsr_mdir_unerase(lfsr_mdir_t *mdir) { lfsr_rbyd_unerase(&mdir->u.rbyd); } +static inline lfsr_bid_t lfsr_mdir_bid(lfs_t *lfs, const lfsr_mdir_t *mdir) { + return lfsr_mid_bid(lfs, mdir->mid); +} + +static inline lfsr_rid_t lfsr_mdir_rid(lfs_t *lfs, const lfsr_mdir_t *mdir) { + return lfsr_mid_rid(lfs, mdir->mid); +} + +static inline lfsr_bid_t lfsr_mdir_cbid(lfs_t *lfs, const lfsr_mdir_t *mdir) { + return lfsr_mid_cbid(lfs, mdir->mid); +} + +static inline lfsr_rid_t lfsr_mdir_crid(lfs_t *lfs, const lfsr_mdir_t *mdir) { + return lfsr_mid_crid(lfs, mdir->mid); +} + +static inline bool lfsr_mdir_isroot(const lfsr_mdir_t *mdir) { + return lfsr_mid_isroot(mdir->mid); +} + // track opened mdirs that may need to by updated static void lfsr_mdir_addopened(lfs_t *lfs, int type, lfsr_openedmdir_t *opened) { @@ -5115,14 +5139,10 @@ static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir, static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, lfsr_smid_t mid, lfsr_tag_t tag, lfsr_tag_t *tag_, lfsr_data_t *data_) { - // TODO anything better? - mid = (mid == -1 - ? -1 - : mid - (lfs_smax32(mdir->mid, 0) & lfsr_midbmask(lfs))); - lfsr_smid_t mid_; lfsr_tag_t tag__; - int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.rbyd, mid, tag, + int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.rbyd, + lfsr_mid_crid(lfs, mid), tag, &mid_, &tag__, NULL, data_); if (err) { return err; @@ -5130,7 +5150,7 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, // this is very similar to lfsr_rbyd_lookupnext, but we error if // lookupnext would change mids - if (mid_ != mid) { + if (mid_ != lfsr_mid_crid(lfs, mid)) { return LFS_ERR_NOENT; } @@ -5144,11 +5164,7 @@ static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, lfsr_smid_t mid, lfsr_tag_t tag, lfsr_tag_t *tag_, lfsr_data_t *data_) { return lfsr_rbyd_lookup(lfs, &mdir->u.rbyd, - // TODO anything better? - (mid == -1 - ? -1 - : mid - (lfs_smax32(mdir->mid, 0) & lfsr_midbmask(lfs))), - tag, + lfsr_mid_crid(lfs, mid), tag, tag_, data_); } @@ -5209,7 +5225,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, // looking up mroot? if (lfsr_mtree_isnull(lfs)) { LFS_ASSERT(mid >= 0); - LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mleafweight(lfs)); + LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mweight(lfs)); mdir_->mid = mid; mdir_->u.m = lfs->mroot.u.m; return 0; @@ -5217,7 +5233,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, // looking up direct mdir? } else if (lfsr_mtree_ismptr(lfs)) { LFS_ASSERT(mid >= 0); - LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mleafweight(lfs)); + LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mweight(lfs)); // fetch mdir return lfsr_mdir_fetch(lfs, mdir_, mid, &lfs->mtree.u.mptr.mptr); @@ -5234,7 +5250,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, if (err) { return err; } - LFS_ASSERT((lfsr_smid_t)bid == (mid | lfsr_midrmask(lfs))); + LFS_ASSERT(bid == lfsr_mid_bid(lfs, mid)); LFS_ASSERT(tag == LFSR_TAG_MDIR); // decode mdir @@ -5255,20 +5271,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_midbmask(lfs); - lfsr_srid_t rid = (mdir->mid & lfsr_midrmask(lfs)) + off; + lfsr_bid_t bid = lfsr_mdir_bid(lfs, mdir); + lfsr_srid_t rid = lfsr_mdir_rid(lfs, mdir) + 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_mleafweight(lfs) >= lfsr_mtree_weight(lfs)) { + if (bid+lfsr_mweight(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; + mdir->mid = bid + lfsr_mweight(lfs); return LFS_ERR_NOENT; } - bid += lfsr_mleafweight(lfs); + bid += lfsr_mweight(lfs); rid -= mdir->u.m.weight; int err = lfsr_mtree_lookup(lfs, bid, mdir); if (err) { @@ -5276,7 +5292,7 @@ static int lfsr_mtree_seek(lfs_t *lfs, lfsr_mdir_t *mdir, lfs_off_t off) { } } - mdir->mid = bid + rid; + mdir->mid = bid-(lfsr_mweight(lfs)-1) + rid; // wait are we grmed? pretend this mid doesn't exist if (mdir->mid == lfs->grm.rms[0] @@ -5410,10 +5426,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_mdir_unerase(mdir); for (lfs_size_t i = 0; i < attr_count; i++) { // calculate adjusted rid - lfsr_srid_t rid = (attrs[i].rid == -1 - ? -1 - : attrs[i].rid - ( - lfs_smax32(mdir_.mid, 0) & lfsr_midbmask(lfs))); + lfsr_srid_t rid = lfsr_mid_crid(lfs, attrs[i].rid); // don't write tags outside of the requested range if (rid >= start_rid @@ -5722,9 +5735,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // belongs to our mdir? if (lfsr_file_isunsynced(file) && lfsr_mdir_cmp(&file->m.mdir, mdir) == 0 - && (file->m.mdir.mid & lfsr_midrmask(lfs)) >= start_rid - && (lfs_size_t)(file->m.mdir.mid & lfsr_midrmask(lfs)) - < (lfs_size_t)end_rid) { + && (lfsr_srid_t)lfsr_mdir_rid(lfs, &file->m.mdir) >= start_rid + && lfsr_mdir_rid(lfs, &file->m.mdir) < (lfsr_rid_t)end_rid) { // inlined sprout? if (lfsr_file_isbsprout(file)) { // write the data as a shrub tag @@ -6251,7 +6263,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, || lfsr_mtree_isnull(lfs) || mdir->u.m.weight > 0); LFS_ASSERT(mdir->mid == -1 - || (mdir->mid & lfsr_midrmask(lfs)) <= mdir->u.m.weight); + || lfsr_mdir_rid(lfs, mdir) <= (lfsr_rid_t)mdir->u.m.weight); // parse out any pending gstate, these will get automatically xored // with on-disk gdeltas in lower-level functions @@ -6390,13 +6402,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } // adjust our sibling's mid after committing attrs - msibling_.mid += lfsr_mleafweight(lfs); + msibling_.mid += lfsr_mweight(lfs); LFS_DEBUG("Splitting mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"} " "-> 0x{%"PRIx32",%"PRIx32"}, " "0x{%"PRIx32",%"PRIx32"}", - mdir->mid >> lfs->mleaf_bits, + mdir->mid >> lfs->mbits, 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]); @@ -6408,11 +6420,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->mleaf_bits, + mdir_.mid >> lfs->mbits, mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]); LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", - msibling_.mid >> lfs->mleaf_bits, + msibling_.mid >> lfs->mbits, msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]); goto drop; @@ -6420,7 +6432,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->mleaf_bits, + msibling_.mid >> lfs->mbits, msibling_.u.m.blocks[0], msibling_.u.m.blocks[1]); goto relocate; @@ -6428,14 +6440,14 @@ 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->mleaf_bits, + mdir_.mid >> lfs->mbits, mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]); mdir_.u.m = msibling_.u.m; goto relocate; } // no siblings reduced to zero, update our mtree - mdelta = +lfsr_mleafweight(lfs); + mdelta = +lfsr_mweight(lfs); // fix any pending grms for (lfs_size_t i = 0; i < attr_count; i++) { @@ -6457,12 +6469,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_midbmask(lfs)) - == (lfs_smax32(mdir->mid, 0) - & lfsr_midbmask(lfs))) { - if ((grm->rms[j] & lfsr_midrmask(lfs)) - >= mdir_.u.m.weight) { - grm->rms[j] += lfsr_mleafweight(lfs) + if (lfsr_mid_bid(lfs, grm->rms[j]) + == lfsr_mdir_cbid(lfs, mdir)) { + if (lfsr_mid_rid(lfs, grm->rms[j]) + >= (lfsr_rid_t)mdir_.u.m.weight) { + grm->rms[j] += lfsr_mweight(lfs) - mdir_.u.m.weight; } } else if (grm->rms[j] > mdir->mid) { @@ -6497,11 +6508,11 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, uint8_t msibling_buf[LFSR_MPTR_DSIZE]; err = lfsr_mtree_commit(lfs, LFSR_ATTRS( LFSR_ATTR(0, - MDIR, +lfsr_mleafweight(lfs), + MDIR, +lfsr_mweight(lfs), FROMMPTR(lfsr_mdir_mptr(&mdir_), mdir_buf)), - LFSR_ATTR((mdir_.mid | lfsr_midrmask(lfs))+1, - NAME, +lfsr_mleafweight(lfs), DATA(split_data)), - LFSR_ATTR(msibling_.mid | lfsr_midrmask(lfs), + LFSR_ATTR(lfsr_mweight(lfs), + NAME, +lfsr_mweight(lfs), DATA(split_data)), + LFSR_ATTR(lfsr_mweight(lfs)+lfsr_mweight(lfs)-1, MDIR, 0, FROMMPTR(lfsr_mdir_mptr(&msibling_), msibling_buf)))); if (err) { @@ -6513,11 +6524,11 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, uint8_t mdir_buf[LFSR_MPTR_DSIZE]; uint8_t msibling_buf[LFSR_MPTR_DSIZE]; err = lfsr_mtree_commit(lfs, LFSR_ATTRS( - LFSR_ATTR(mdir_.mid | lfsr_midrmask(lfs), + LFSR_ATTR(lfsr_mdir_bid(lfs, &mdir_), MDIR, 0, FROMMPTR(lfsr_mdir_mptr(&mdir_), mdir_buf)), - LFSR_ATTR((mdir_.mid | lfsr_midrmask(lfs))+1, - NAME, +lfsr_mleafweight(lfs), DATA(split_data)), - LFSR_ATTR(msibling_.mid | lfsr_midrmask(lfs), + LFSR_ATTR(lfsr_mdir_bid(lfs, &mdir_)+1, + NAME, +lfsr_mweight(lfs), DATA(split_data)), + LFSR_ATTR(lfsr_mdir_bid(lfs, &msibling_), MDIR, 0, FROMMPTR(lfsr_mdir_mptr(&msibling_), msibling_buf)))); if (err) { @@ -6529,7 +6540,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"}", - mdir->mid >> lfs->mleaf_bits, + mdir->mid >> lfs->mbits, mdir->u.m.blocks[0], mdir->u.m.blocks[1]); // consume gstate so we don't lose any info @@ -6539,7 +6550,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } drop:; - mdelta = -lfsr_mleafweight(lfs); + mdelta = -lfsr_mweight(lfs); // fix any pending grms for (lfs_size_t i = 0; i < attr_count; i++) { @@ -6589,8 +6600,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree } else { err = lfsr_mtree_commit(lfs, LFSR_ATTRS( - LFSR_ATTR(mdir_.mid | lfsr_midrmask(lfs), - RM, -lfsr_mleafweight(lfs), NULL))); + LFSR_ATTR(lfsr_mdir_bid(lfs, &mdir_), + RM, -lfsr_mweight(lfs), NULL))); if (err) { return err; } @@ -6601,7 +6612,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, && !(mdir->mid == -1 || lfsr_mtree_isnull(lfs))) { LFS_DEBUG("Relocating mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"} -> 0x{%"PRIx32",%"PRIx32"}", - mdir->mid >> lfs->mleaf_bits, + mdir->mid >> lfs->mbits, mdir->u.m.blocks[0], mdir->u.m.blocks[1], mdir_.u.m.blocks[0], mdir_.u.m.blocks[1]); @@ -6619,13 +6630,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, lfs->mtree = LFSR_MTREE_MPTR( *lfsr_mdir_mptr(&mdir_), - lfsr_mleafweight(lfs)); + lfsr_mweight(lfs)); } else { // update our mtree uint8_t mdir_buf[LFSR_MPTR_DSIZE]; err = lfsr_mtree_commit(lfs, LFSR_ATTRS( - LFSR_ATTR(mdir_.mid | lfsr_midrmask(lfs), + LFSR_ATTR(lfsr_mdir_bid(lfs, &mdir_), MDIR, 0, FROMMPTR(lfsr_mdir_mptr(&mdir_), mdir_buf)))); if (err) { return err; @@ -6671,8 +6682,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_midbmask(lfs)) - == (lfs_smax32(mdir->mid, 0) & lfsr_midbmask(lfs)) + if (lfsr_mdir_bid(lfs, &opened->mdir) + == lfsr_mdir_cbid(lfs, mdir) && opened->mdir.mid >= attrs[i].rid) { // removed? if (opened->mdir.mid < attrs[i].rid - attrs[i].delta) { @@ -6703,9 +6714,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update any opened mdirs if we had a split or drop if (lfsr_mdir_cmp(&opened->mdir, mdir) == 0) { if (mdelta > 0 - && (opened->mdir.mid & lfsr_midrmask(lfs)) - >= mdir_.u.m.weight) { - opened->mdir.mid += lfsr_mleafweight(lfs) + && lfsr_mdir_rid(lfs, &opened->mdir) + >= (lfsr_rid_t)mdir_.u.m.weight) { + opened->mdir.mid += lfsr_mweight(lfs) - mdir_.u.m.weight; opened->mdir.u.m = msibling_.u.m; } else { @@ -6722,9 +6733,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_midbmask(lfs)) - == (lfs_smax32(mdir->mid, 0) - & lfsr_midbmask(lfs)) + if (lfsr_mid_bid(lfs, dir->bookmark) + == lfsr_mdir_cbid(lfs, mdir) && dir->bookmark >= attrs[i].rid) { // removed? if (dir->bookmark < attrs[i].rid - attrs[i].delta) { @@ -6743,12 +6753,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } } - if ((dir->bookmark & lfsr_midbmask(lfs)) - == (lfs_smax32(mdir->mid, 0) & lfsr_midbmask(lfs))) { + if (lfsr_mid_bid(lfs, dir->bookmark) + == lfsr_mdir_cbid(lfs, mdir)) { if (mdelta > 0 - && (dir->bookmark & lfsr_midrmask(lfs)) - >= mdir_.u.m.weight) { - dir->bookmark += lfsr_mleafweight(lfs) + && lfsr_mid_rid(lfs, dir->bookmark) + >= (lfsr_rid_t)mdir_.u.m.weight) { + dir->bookmark += lfsr_mweight(lfs) - mdir_.u.m.weight; } } else if (dir->bookmark > mdir->mid) { @@ -6763,8 +6773,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, if (mdir->mid == -1) { mdir->u.m = lfs->mroot.u.m; } else if (mdelta > 0 - && (mdir->mid & lfsr_midrmask(lfs)) >= mdir_.u.m.weight) { - mdir->mid += lfsr_mleafweight(lfs) - mdir_.u.m.weight; + && lfsr_mdir_rid(lfs, mdir) >= (lfsr_rid_t)mdir_.u.m.weight) { + mdir->mid += lfsr_mweight(lfs) - mdir_.u.m.weight; mdir->u.m = msibling_.u.m; } else { mdir->u.m = mdir_.u.m; @@ -6842,7 +6852,7 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, return cmp; } LFS_ASSERT(tag == LFSR_TAG_MDIR); - LFS_ASSERT(weight == lfsr_mleafweight(lfs)); + LFS_ASSERT(weight == lfsr_mweight(lfs)); // decode mdir lfsr_mptr_t mptr; @@ -7289,7 +7299,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal, } err = lfsr_mdir_fetch(lfs, &traversal->mdir, - binfo.bid & lfsr_midbmask(lfs), + binfo.bid-(lfsr_mweight(lfs)-1), &mptr); if (err) { return err; @@ -7312,8 +7322,8 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal, // not traversing all blocks? have we exceeded our mdir's weight? // return to mtree traversal if (!lfsr_traversal_isall(traversal) - || (traversal->mdir.mid & lfsr_midrmask(lfs)) - >= traversal->mdir.u.m.weight) { + || lfsr_mdir_rid(lfs, &traversal->mdir) + >= (lfsr_rid_t)traversal->mdir.u.m.weight) { traversal->state = LFSR_TRAVERSAL_MTREE; continue; } @@ -7540,7 +7550,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal, // d += d_; // // // on-disk mleaf limit -// d_ = lfs_toleb128(lfsr_mleafweight(lfs)-1, &buffer[d], 5); +// d_ = lfs_toleb128(lfsr_mweight(lfs)-1, &buffer[d], 5); // LFS_ASSERT(d_ >= 0); // d += d_; // @@ -7983,7 +7993,7 @@ static int lfsr_mountinited(lfs_t *lfs) { return LFS_ERR_INVAL; } - lfs->mleaf_bits = lfs_nlog2(mdir_limit+1); + lfs->mbits = lfs_nlog2(mdir_limit+1); // read the mtree limit err = lfsr_mdir_lookup(lfs, &tinfo.u.mdir, @@ -8023,7 +8033,7 @@ static int lfsr_mountinited(lfs_t *lfs) { if (lfsr_mtree_isnull(lfs)) { lfs->mtree = LFSR_MTREE_MPTR( *lfsr_mdir_mptr(&tinfo.u.mdir), - lfsr_mleafweight(lfs)); + lfsr_mweight(lfs)); } } @@ -8069,14 +8079,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->mleaf_bits, - lfs->grm.rms[0] & lfsr_midrmask(lfs), - lfs->grm.rms[1] >> lfs->mleaf_bits, - lfs->grm.rms[1] & lfsr_midrmask(lfs)); + lfsr_mid_bid(lfs, lfs->grm.rms[0]) >> lfs->mbits, + lfsr_mid_rid(lfs, lfs->grm.rms[0]), + lfsr_mid_bid(lfs, lfs->grm.rms[1]) >> lfs->mbits, + lfsr_mid_rid(lfs, lfs->grm.rms[1])); } else if (lfsr_grm_count(&lfs->grm) == 1) { LFS_DEBUG("Found pending grm %"PRId32".%"PRId32, - lfs->grm.rms[0] >> lfs->mleaf_bits, - lfs->grm.rms[0] & lfsr_midrmask(lfs)); + lfsr_mid_bid(lfs, lfs->grm.rms[0]) >> lfs->mbits, + lfsr_mid_rid(lfs, lfs->grm.rms[0])); } } @@ -8119,7 +8129,7 @@ static int lfsr_formatinited(lfs_t *lfs) { LFSR_ATTR(-1, UATTRLIMIT, 0, LEB128(lfs->uattr_limit)), LFSR_ATTR(-1, STAGLIMIT, 0, LEB128(0x7f)), LFSR_ATTR(-1, SATTRLIMIT, 0, LEB128(lfs->sattr_limit)), - LFSR_ATTR(-1, MDIRLIMIT, 0, LEB128(lfsr_mleafweight(lfs)-1)), + LFSR_ATTR(-1, MDIRLIMIT, 0, LEB128(lfsr_mweight(lfs)-1)), LFSR_ATTR(-1, MTREELIMIT, 0, LEB128(lfs->size_limit)), LFSR_ATTR(0, BOOKMARK, +1, LEB128(0)))); if (err) { @@ -8159,8 +8169,8 @@ int lfsr_mount(lfs_t *lfs, const struct lfs_config *cfg) { lfs->mroot.u.m.blocks[0], lfs->mroot.u.m.blocks[1], lfs->mroot.u.m.trunk, - lfsr_mtree_weight(lfs) / lfsr_mleafweight(lfs), - lfsr_mleafweight(lfs), + lfsr_mtree_weight(lfs) / lfsr_mweight(lfs), + lfsr_mweight(lfs), lfs->cfg->block_size, lfs->cfg->block_count); @@ -8349,7 +8359,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_mleafweight(lfs))); + lfsr_mweight(lfs))); int err = lfsr_mtree_lookup(lfs, lfs->grm.rms[0], &mdir); if (err) { @@ -8361,15 +8371,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_midbmask(lfs)) - == (mdir.mid & lfsr_midbmask(lfs)) + if (lfsr_mid_bid(lfs, grm.rms[0]) == lfsr_mdir_bid(lfs, &mdir) && 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_midrmask(lfs)) < mdir.u.m.weight); + LFS_ASSERT(lfsr_mid_rid(lfs, lfs->grm.rms[0]) + < (lfsr_rid_t)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)))); @@ -8387,14 +8397,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->mleaf_bits, - lfs->grm.rms[0] & lfsr_midrmask(lfs), - lfs->grm.rms[1] >> lfs->mleaf_bits, - lfs->grm.rms[1] & lfsr_midrmask(lfs)); + lfsr_mid_bid(lfs, lfs->grm.rms[0]) >> lfs->mbits, + lfsr_mid_rid(lfs, lfs->grm.rms[0]), + lfsr_mid_bid(lfs, lfs->grm.rms[1]) >> lfs->mbits, + lfsr_mid_rid(lfs, lfs->grm.rms[1])); } else if (lfsr_grm_count(&lfs->grm) == 1) { LFS_DEBUG("Fixing pending grm %"PRId32".%"PRId32, - lfs->grm.rms[0] >> lfs->mleaf_bits, - lfs->grm.rms[0] & lfsr_midrmask(lfs)); + lfsr_mid_bid(lfs, lfs->grm.rms[0]) >> lfs->mbits, + lfsr_mid_rid(lfs, lfs->grm.rms[0])); } int err = lfsr_fs_fixgrm(lfs); @@ -8608,8 +8618,7 @@ 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_midbmask(lfs)) - == (mdir.mid & lfsr_midbmask(lfs)) + if (lfsr_mid_bid(lfs, grm.rms[0]) == lfsr_mdir_bid(lfs, &mdir) && grm.rms[0] > mdir.mid) { grm.rms[0] -= 1; } @@ -8671,8 +8680,7 @@ 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_midbmask(lfs)) - == (new_mdir.mid & lfsr_midbmask(lfs)) + if (lfsr_mid_bid(lfs, grm.rms[0]) == lfsr_mdir_bid(lfs, &new_mdir) && grm.rms[0] >= new_mdir.mid) { grm.rms[0] += 1; } @@ -14069,7 +14077,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->mleaf_bits = lfs_nlog2(lfs->cfg->block_size/16); + lfs->mbits = lfs_nlog2(lfs->cfg->block_size/16); // zero linked-lists of opened mdirs lfs->opened[LFS_TYPE_REG - LFS_TYPE_REG] = NULL; diff --git a/lfs.h b/lfs.h index f32310f0..4828b33d 100644 --- a/lfs.h +++ b/lfs.h @@ -620,7 +620,7 @@ typedef struct lfs { uint8_t ggrm[LFSR_GRM_DSIZE]; uint8_t dgrm[LFSR_GRM_DSIZE]; - uint8_t mleaf_bits; + uint8_t mbits; lfsr_mdir_t mroot; lfsr_mtree_t mtree; diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index 2f2efdc0..7076f0dd 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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -419,7 +419,7 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, lfs_smax32( - lfsr_mtree_weight(&lfs) - lfsr_mleafweight(&lfs), + lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { @@ -446,12 +446,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -473,12 +472,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -518,13 +516,13 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs))); + lfsr_mweight(&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_midbmask(&lfs)) - | (mdir.mid % (mdir.u.m.weight+1)); + mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1) + + (mdir.mid % (mdir.u.m.weight+1)); // force a compaction? if (FORCE_COMPACTION) { @@ -552,12 +550,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -583,12 +580,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -637,20 +633,20 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -666,7 +662,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -706,13 +702,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); // force mdir to compact while we're removing @@ -722,7 +718,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -738,7 +734,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -781,7 +777,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -797,7 +793,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -841,13 +837,13 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -861,12 +857,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -908,13 +904,13 @@ code = ''' LFSR_ATTR(1, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -928,12 +924,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -975,7 +971,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -986,7 +982,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1021,13 +1017,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); @@ -1039,12 +1035,12 @@ code = ''' // remove the left entry as we compact, forcing the left // mdir to be dropped - mdir.mid = 0*lfsr_mleafweight(&lfs)+0; + mdir.mid = 0*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1054,7 +1050,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1068,7 +1064,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1078,7 +1074,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1116,13 +1112,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); @@ -1138,7 +1134,7 @@ code = ''' LFSR_ATTR(1, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1148,7 +1144,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1162,7 +1158,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1172,7 +1168,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that one entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1210,13 +1206,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); @@ -1232,7 +1228,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1248,7 +1244,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1282,7 +1278,7 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, lfs_smax32( - lfsr_mtree_weight(&lfs) - lfsr_mleafweight(&lfs), + lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { @@ -1302,7 +1298,7 @@ code = ''' for (lfs_size_t i = 0; i < N - REMAINING; i++) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, - 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + 0*lfsr_mweight(&lfs)+0, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_ismptr(&lfs) || mdir.u.m.weight > 0); @@ -1322,12 +1318,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1349,12 +1344,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1391,7 +1385,7 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, lfs_smax32( - lfsr_mtree_weight(&lfs) - lfsr_mleafweight(&lfs), + lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < (cycle == 0 ? N : N-1); i++) { @@ -1412,12 +1406,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1432,7 +1425,7 @@ code = ''' for (lfs_size_t i = 0; i < N-1; i++) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, - 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + 0*lfsr_mweight(&lfs)+0, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_ismptr(&lfs) || mdir.u.m.weight > 0); @@ -1452,12 +1445,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1480,12 +1472,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1524,18 +1515,20 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs))); + lfsr_mweight(&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_midbmask(&lfs)) - | (mdir.mid % (mdir.u.m.weight+1)); + mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1) + + (mdir.mid % (mdir.u.m.weight+1)); // choose to create or delete, note we make sure to never delete to zero - uint8_t op = ((mdir.mid & lfsr_midrmask(&lfs)) == mdir.u.m.weight - || ((mdir.mid & lfsr_midrmask(&lfs)) == mdir.u.m.weight-1 + uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) + == (lfsr_rid_t)mdir.u.m.weight + || (lfsr_mdir_rid(&lfs, &mdir) + == (lfsr_rid_t)mdir.u.m.weight-1 && lfsr_mtree_weight(&lfs) - == lfsr_mleafweight(&lfs)) + == lfsr_mweight(&lfs)) ? 0 : TEST_PRNG(&prng) % 2); @@ -1575,16 +1568,15 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_ismptr(&lfs) || mdir.u.m.weight > 0); - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1610,16 +1602,15 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_ismptr(&lfs) || mdir.u.m.weight > 0); - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1671,13 +1662,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_t old_mdir = mdir; @@ -1698,7 +1689,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1712,7 +1703,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1725,7 +1716,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1765,13 +1756,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_t old_mdir = mdir; @@ -1787,13 +1778,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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1806,7 +1797,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1814,13 +1805,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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1859,13 +1850,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_t old_mdir = mdir; @@ -1881,13 +1872,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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1900,7 +1891,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -1908,13 +1899,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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2138,7 +2129,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2149,7 +2140,7 @@ code = ''' // force mdir to compact twice, this should relocate lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_t old_mdir = mdir; @@ -2173,7 +2164,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2187,7 +2178,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2203,7 +2194,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2243,7 +2234,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2254,7 +2245,7 @@ code = ''' // now add another large entry to the mdir, forcing a split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); @@ -2266,7 +2257,7 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2279,13 +2270,13 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2298,7 +2289,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2311,13 +2302,13 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2356,7 +2347,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2367,14 +2358,14 @@ code = ''' // remove the entry, forcing the mdir to be dropped lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2393,7 +2384,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2445,7 +2436,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2459,7 +2450,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2473,7 +2464,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2486,7 +2477,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2532,7 +2523,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2541,13 +2532,13 @@ code = ''' // assert that our entries are still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2560,7 +2551,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2568,13 +2559,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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2610,18 +2601,20 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs))); + lfsr_mweight(&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_midbmask(&lfs)) - | (mdir.mid % (mdir.u.m.weight+1)); + mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1) + + (mdir.mid % (mdir.u.m.weight+1)); // choose to create or delete, note we make sure to never delete to zero - uint8_t op = ((mdir.mid & lfsr_midrmask(&lfs)) == mdir.u.m.weight - || ((mdir.mid & lfsr_midrmask(&lfs)) == mdir.u.m.weight-1 + uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) + == (lfsr_rid_t)mdir.u.m.weight + || (lfsr_mdir_rid(&lfs, &mdir) + == (lfsr_rid_t)mdir.u.m.weight-1 && lfsr_mtree_weight(&lfs) - == lfsr_mleafweight(&lfs)) + == lfsr_mweight(&lfs)) ? 0 : TEST_PRNG(&prng) % 3); @@ -2674,16 +2667,15 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_ismptr(&lfs) || mdir.u.m.weight > 0); - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2709,16 +2701,15 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_ismptr(&lfs) || mdir.u.m.weight > 0); - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2917,7 +2908,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2928,7 +2919,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 2); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2938,14 +2929,14 @@ code = ''' // but saves on code size lfsr_mdir_t msibling; lfsr_mtree_lookup(&lfs, - 1*lfsr_mleafweight(&lfs)+0, &msibling) => 0; + 1*lfsr_mweight(&lfs)+0, &msibling) => 0; assert(msibling.u.m.weight == 1); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); + assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 1*lfsr_mleafweight(&lfs)+0); + assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+0); assert(memcmp(&right_neighbor.mdir.u.m, &msibling.u.m, sizeof(msibling.u.m)) == 0); @@ -2996,13 +2987,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&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_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 2); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3010,17 +3001,17 @@ code = ''' lfsr_mdir_t msibling; lfsr_mtree_lookup(&lfs, - 1*lfsr_mleafweight(&lfs)+0, &msibling) => 0; + 1*lfsr_mweight(&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_mleafweight(&lfs)+0); + assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 1*lfsr_mleafweight(&lfs)+1); + assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+1); assert(memcmp(&right_neighbor.mdir.u.m, &msibling.u.m, sizeof(msibling.u.m)) == 0); @@ -3057,7 +3048,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3066,14 +3057,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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); assert(mdir.u.m.weight == 3); lfsr_openedmdir_t left_neighbor = { @@ -3085,7 +3076,7 @@ code = ''' // now add another large entry to the mdir, forcing a split memset(buffer, 'e', SIZE); - mdir.mid = 0*lfsr_mleafweight(&lfs)+2; + mdir.mid = 0*lfsr_mweight(&lfs)+2; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; @@ -3094,7 +3085,7 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3104,7 +3095,7 @@ code = ''' assert(memcmp(buffer, "c", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 2); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3112,17 +3103,17 @@ code = ''' lfsr_mdir_t msibling; lfsr_mtree_lookup(&lfs, - 1*lfsr_mleafweight(&lfs)+0, &msibling) => 0; + 1*lfsr_mweight(&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_mleafweight(&lfs)+0); + assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 1*lfsr_mleafweight(&lfs)+1); + assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+1); assert(memcmp(&right_neighbor.mdir.u.m, &msibling.u.m, sizeof(msibling.u.m)) == 0); @@ -3227,7 +3218,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3236,14 +3227,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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); assert(mdir.u.m.weight == 3); lfsr_openedmdir_t left_neighbor = { @@ -3272,7 +3263,7 @@ code = ''' assert(memcmp(buffer, "c", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 3); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -3280,9 +3271,9 @@ code = ''' assert(memcmp(buffer, "e", 1) == 0); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); + assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); assert(memcmp(&left_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); - assert(right_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+2); + assert(right_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+2); assert(memcmp(&right_neighbor.mdir.u.m, &mdir.u.m, sizeof(mdir.u.m)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); @@ -3321,11 +3312,11 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // we should now have 2 mdirs - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // now force one of our siblings to split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -3336,19 +3327,19 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 3 mdirs - assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mweight(&lfs)); //// Now test splitting updates mids correctly // setup our neighbors lfsr_openedmdir_t left_neighbor; - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &right_neighbor.mdir) => 0; assert(right_neighbor.mdir.u.m.weight == 1); @@ -3356,7 +3347,7 @@ code = ''' lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); // cause middle mdir to split - lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'd', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -3367,15 +3358,15 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 4 mdirs - assert(lfsr_mtree_weight(&lfs) == 4*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 4*lfsr_mweight(&lfs)); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 3*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + assert(right_neighbor.mdir.mid == 3*lfsr_mweight(&lfs)+0); + lfsr_mtree_lookup(&lfs, 3*lfsr_mweight(&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_INTERNAL, &left_neighbor); @@ -3414,11 +3405,11 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // we should now have 2 mdirs - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // now force one of our siblings to split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+1, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0; assert(mdir.u.m.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -3429,19 +3420,19 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 3 mdirs - assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mweight(&lfs)); //// Now test dropping updates mids correctly // setup our neighbors lfsr_openedmdir_t left_neighbor; - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &right_neighbor.mdir) => 0; assert(right_neighbor.mdir.u.m.weight == 1); @@ -3449,21 +3440,21 @@ code = ''' lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); // cause middle mdir to drop - lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&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_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert that our neighbors were updated correctly - assert(left_neighbor.mdir.mid == 0*lfsr_mleafweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+0); + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&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_INTERNAL, &left_neighbor); @@ -3595,7 +3586,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3606,7 +3597,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -3670,7 +3661,7 @@ code = ''' // and the tree should still work // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3680,7 +3671,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -3719,13 +3710,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; assert(mdir.u.m.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3733,7 +3724,7 @@ code = ''' lfsr_mdir_t msibling; lfsr_mtree_lookup(&lfs, - 1*lfsr_mleafweight(&lfs)+0, &msibling) => 0; + 1*lfsr_mweight(&lfs)+0, &msibling) => 0; assert(msibling.u.m.weight == 1); lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3796,19 +3787,19 @@ code = ''' // and the tree should still work // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mleafweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&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_mleafweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mleafweight(&lfs)+0, &msibling) => 0; + 1*lfsr_mweight(&lfs)+0, &msibling) => 0; assert(msibling.u.m.weight == 1); lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3944,7 +3935,7 @@ code = ''' lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, lfs_smax32( - lfsr_mtree_weight(&lfs) - lfsr_mleafweight(&lfs), + lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { @@ -3971,12 +3962,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -4048,12 +4038,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -4093,13 +4082,13 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs))); + lfsr_mweight(&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_midbmask(&lfs)) - | (mdir.mid % (mdir.u.m.weight+1)); + mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1) + + (mdir.mid % (mdir.u.m.weight+1)); // force a compaction? if (FORCE_COMPACTION) { @@ -4127,12 +4116,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -4209,12 +4197,11 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mleafweight(&lfs)); - mid += lfsr_mleafweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; (mdir.mid & lfsr_midrmask(&lfs)) - < (lfs_ssize_t)mdir.u.m.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < (lfsr_rid_t)mdir.u.m.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG,