diff --git a/lfs.c b/lfs.c index 64cd0138..30d815c6 100644 --- a/lfs.c +++ b/lfs.c @@ -1536,12 +1536,12 @@ static int lfsr_data_readecksum(lfs_t *lfs, lfsr_data_t *data, /// Metadata-id things /// -static inline lfs_size_t lfsr_mbidweight(lfs_t *lfs) { - return 1 << lfs->mrid_bits; +static inline lfs_size_t lfsr_mweight(lfs_t *lfs) { + return 1 << lfs->mbits; } static inline lfs_ssize_t lfsr_mridmask(lfs_t *lfs) { - return (1 << lfs->mrid_bits) - 1; + return (1 << lfs->mbits) - 1; } static inline lfs_ssize_t lfsr_mbidmask(lfs_t *lfs) { @@ -1653,7 +1653,7 @@ static int lfsr_grm_todisk(lfs_t *lfs, const lfsr_grm_t *grm, return 0; } -// needed in lfsr_grm_fromdisk +// required by lfsr_grm_fromdisk static inline bool lfsr_mtree_isinlined(lfs_t *lfs); static inline lfs_size_t lfsr_mtree_weight(lfs_t *lfs); @@ -1677,8 +1677,9 @@ static int lfsr_data_readgrm(lfs_t *lfs, lfsr_data_t *data, return err; } - LFS_ASSERT(grm->rms[i] - < lfs_smax32(lfsr_mtree_weight(lfs), lfsr_mbidweight(lfs))); + LFS_ASSERT(grm->rms[i] < lfs_smax32( + lfsr_mtree_weight(lfs), + lfsr_mweight(lfs))); } return 0; @@ -2854,6 +2855,11 @@ failed:; return err; } +// required by lfsr_rbyd_appendattrs +static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, + lfs_ssize_t rid, lfsr_tag_t tag, + lfsr_tag_t *tag_, lfsr_data_t *data_); + static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfs_size_t bid, lfs_ssize_t start_rid, lfs_ssize_t end_rid, const lfsr_attr_t *attrs, lfs_size_t attr_count) { @@ -2891,16 +2897,14 @@ static int lfsr_rbyd_appendattrs(lfs_t *lfs, lfsr_rbyd_t *rbyd, // skip the name tag, this is always replaced by upper layers lfsr_tag_t tag = LFSR_TAG_NAME + 0xff; while (true) { - lfs_ssize_t rid_; lfsr_data_t data; - int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.r.rbyd, - mdir->mid & lfsr_mridmask(lfs), lfsr_tag_next(tag), - &rid_, &tag, NULL, &data); + int err = lfsr_mdir_lookupnext(lfs, mdir, + mdir->mid, lfsr_tag_next(tag), + &tag, &data); if (err && err != LFS_ERR_NOENT) { return err; } - if (err == LFS_ERR_NOENT - || rid_ != (mdir->mid & lfsr_mridmask(lfs))) { + if (err == LFS_ERR_NOENT) { break; } @@ -4580,9 +4584,9 @@ static int lfsr_btree_traversal_next(lfs_t *lfs, /// Metadata pair operations /// // the mroot anchor, mdir 0x{0,1} is the entry point into the filesystem -#define LFSR_MDIR_MROOTANCHOR ((const lfs_block_t[2]){0, 1}) +#define LFSR_MROOTANCHOR ((const lfs_block_t[2]){0, 1}) -static inline int lfsr_mdir_cmp( +static inline int lfsr_mblocks_cmp( const lfs_block_t a[static 2], const lfs_block_t b[static 2]) { // note these can be in either order @@ -4594,13 +4598,21 @@ static inline int lfsr_mdir_cmp( } } -static inline bool lfsr_mdir_ismrootanchor( +static inline bool lfsr_mblocks_ismrootanchor( const lfs_block_t blocks[static 2]) { // mrootanchor is always at 0x{0,1} // just check that the first block is in mroot anchor range return blocks[0] <= 1; } +static inline int lfsr_mdir_cmp(const lfsr_mdir_t *a, const lfsr_mdir_t *b) { + return lfsr_mblocks_cmp(a->u.m.blocks, b->u.m.blocks); +} + +static inline bool lfsr_mdir_ismrootanchor(const lfsr_mdir_t *mdir) { + return lfsr_mblocks_ismrootanchor(mdir->u.m.blocks); +} + // 2 leb128 => 10 bytes (worst case) #define LFSR_MDIR_DSIZE (5+5) @@ -4667,7 +4679,7 @@ static bool lfsr_mdir_isopened(lfs_t *lfs, // actual mdir functions static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir, - const lfs_block_t blocks[static 2], lfs_ssize_t mid) { + lfs_ssize_t mid, const lfs_block_t blocks[static 2]) { // create a copy of blocks, this is so we can swap the blocks // to keep track of the current revision, this also prevents issues // if blocks points to the blocks in the mdir @@ -4713,6 +4725,34 @@ static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir, return LFS_ERR_CORRUPT; } +static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, + lfs_ssize_t rid, lfsr_tag_t tag, + lfsr_tag_t *tag_, lfsr_data_t *data_) { + // TODO anything better? + rid = (rid == -1 + ? -1 + : rid - (lfs_smax32(mdir->mid, 0) & lfsr_mbidmask(lfs))); + + lfs_ssize_t rid_; + lfsr_tag_t tag__; + int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.r.rbyd, rid, tag, + &rid_, &tag__, NULL, data_); + if (err) { + return err; + } + + // this is very similar to lfsr_rbyd_lookupnext, but we error if + // lookupnext would change rids + if (rid_ != rid) { + return LFS_ERR_NOENT; + } + + if (tag_) { + *tag_ = tag__; + } + return 0; +} + static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, lfs_ssize_t rid, lfsr_tag_t tag, lfsr_tag_t *tag_, lfsr_data_t *data_) { @@ -4769,7 +4809,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfs_ssize_t mid, lfsr_mdir_t *mdir_) { // looking up mroot? if (lfsr_mtree_isinlined(lfs)) { LFS_ASSERT(mid >= 0); - LFS_ASSERT(mid < (lfs_ssize_t)lfsr_mbidweight(lfs)); + LFS_ASSERT(mid < (lfs_ssize_t)lfsr_mweight(lfs)); mdir_->mid = mid; mdir_->u.m = lfs->mroot.u.m; return 0; @@ -4796,25 +4836,25 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfs_ssize_t mid, lfsr_mdir_t *mdir_) { } // fetch mdir - return lfsr_mdir_fetch(lfs, mdir_, mdir_->u.m.blocks, mid); + return lfsr_mdir_fetch(lfs, mdir_, mid, mdir_->u.m.blocks); } } static int lfsr_mtree_parent(lfs_t *lfs, const lfs_block_t blocks[static 2], lfsr_mdir_t *mparent_) { // if mdir is our initial 0x{0,1} blocks, we have no parent - if (lfsr_mdir_ismrootanchor(blocks)) { + if (lfsr_mblocks_ismrootanchor(blocks)) { return LFS_ERR_NOENT; } // scan list of mroots for our requested pair lfs_block_t blocks_[2] = { - LFSR_MDIR_MROOTANCHOR[0], - LFSR_MDIR_MROOTANCHOR[1]}; + LFSR_MROOTANCHOR[0], + LFSR_MROOTANCHOR[1]}; while (true) { // fetch next possible superblock lfsr_mdir_t mdir; - int err = lfsr_mdir_fetch(lfs, &mdir, blocks_, -1); + int err = lfsr_mdir_fetch(lfs, &mdir, -1, blocks_); if (err) { return err; } @@ -4834,7 +4874,7 @@ static int lfsr_mtree_parent(lfs_t *lfs, const lfs_block_t blocks[static 2], } // found our child? - if (lfsr_mdir_cmp(blocks_, blocks) == 0) { + if (lfsr_mblocks_cmp(blocks_, blocks) == 0) { *mparent_ = mdir; return 0; } @@ -4849,14 +4889,14 @@ static int lfsr_mtree_seek(lfs_t *lfs, lfsr_mdir_t *mdir, lfs_off_t off) { // 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_mbidweight(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; return LFS_ERR_NOENT; } - bid += lfsr_mbidweight(lfs); + bid += lfsr_mweight(lfs); rid -= mdir->u.m.weight; int err = lfsr_mtree_lookup(lfs, bid, mdir); if (err) { @@ -5016,7 +5056,7 @@ static int lfsr_mdir_compact_(lfs_t *lfs, lfsr_mdir_t *mdir_, if (mdir_->mid == -1 || (lfsr_mtree_isinlined(lfs) && reason == LFSR_MDIR_COMPACTING) - || lfsr_mdir_cmp(mdir_->u.m.blocks, mdir->u.m.blocks) == 0) { + || lfsr_mdir_cmp(mdir_, mdir) == 0) { err = lfsr_rbyd_appendgdelta(lfs, &mdir_->u.r.rbyd); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -5213,7 +5253,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. int err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( - LFSR_ATTR(0, MDIR, +lfsr_mbidweight(lfs), NULL))); + LFSR_ATTR(0, MDIR, +lfsr_mweight(lfs), NULL))); if (err) { return err; } @@ -5280,7 +5320,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree int err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( LFSR_ATTR(mdir_.mid | lfsr_mridmask(lfs), - RM, -lfsr_mbidweight(lfs), NULL))); + RM, -lfsr_mweight(lfs), NULL))); if (err) { return err; } @@ -5341,7 +5381,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } else { // adjust our sibling's mid, do this here in case other sibling // was dropped - msibling_.mid += lfsr_mbidweight(lfs); + msibling_.mid += lfsr_mweight(lfs); // update out mtree @@ -5375,7 +5415,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, LFSR_ATTR(mdir_.mid | lfsr_mridmask(lfs), MDIR, 0, BUF(mdir_buf, mdir_dsize)), LFSR_ATTR((mdir_.mid | lfsr_mridmask(lfs))+1, - BRANCH, +lfsr_mbidweight(lfs), DATA(split_data)), + BRANCH, +lfsr_mweight(lfs), DATA(split_data)), LFSR_ATTR(msibling_.mid | lfsr_mridmask(lfs), MDIR, 0, BUF(msibling_buf, msibling_dsize)))); if (err) { @@ -5401,7 +5441,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update our mtree int err = lfsr_btree_commit(lfs, &mtree_, LFSR_ATTRS( LFSR_ATTR(mdir->mid | lfsr_mridmask(lfs), - RM, -lfsr_mbidweight(lfs), NULL))); + RM, -lfsr_mweight(lfs), NULL))); if (err) { return err; } @@ -5409,7 +5449,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, dirtymtree = true; // need to relocate? - } else if (lfsr_mdir_cmp(mdir->u.m.blocks, mdir_.u.m.blocks) != 0) { + } else if (lfsr_mdir_cmp(mdir, &mdir_) != 0) { // relocate mroot if (mdir->mid == -1 || lfsr_mtree_isinlined(lfs)) { // if we're relocating our root, just mark the root as dirty @@ -5478,7 +5518,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, <= (lfs_ssize_t)mdir->u.m.weight); if ((grm->rms[j] & lfsr_mridmask(lfs)) >= (lfs_ssize_t)mdir_.u.m.weight) { - grm->rms[j] += lfsr_mbidweight(lfs) + grm->rms[j] += lfsr_mweight(lfs) - mdir_.u.m.weight; } // update mid if we had a split or drop @@ -5534,9 +5574,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, return err; } - dirtymroot = (lfsr_mdir_cmp( - lfs->mroot.u.m.blocks, - mroot_.u.m.blocks) != 0); + dirtymroot = (lfsr_mdir_cmp(&lfs->mroot, &mroot_) != 0); } // need to update mroot? tail recurse, updating mroots until a commit sticks @@ -5577,7 +5615,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, mchildroot_[0] = mparentroot.u.m.blocks[0]; mchildroot_[1] = mparentroot.u.m.blocks[1]; - dirtymroot = (lfsr_mdir_cmp( + dirtymroot = (lfsr_mblocks_cmp( mchildroot.u.m.blocks, mchildroot_) != 0); } @@ -5585,7 +5623,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // uh oh, we ran out of mrootparents, need to extend mroot chain if (dirtymroot) { // mchildroot should be our initial mroot at this point - LFS_ASSERT(lfsr_mdir_ismrootanchor(mchildroot.u.m.blocks)); + LFS_ASSERT(lfsr_mdir_ismrootanchor(&mchildroot)); LFS_DEBUG("Extending mroot 0x{%"PRIx32",%"PRIx32"}" " -> 0x{%"PRIx32",%"PRIx32"}" @@ -5713,7 +5751,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, >= (lfs_ssize_t)mdir_.u.m.weight) { LFS_ASSERT(lfsr_btree_weight(&mtree_) != lfsr_mtree_weight(lfs)); - opened_mdir->mid += lfsr_mbidweight(lfs) + opened_mdir->mid += lfsr_mweight(lfs) - mdir_.u.m.weight; opened_mdir->u.m = msibling_.u.m; } else { @@ -5736,7 +5774,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // TODO this can happen if we split+drop while removing this mid, // can we still assert for this? //LFS_ASSERT(lfsr_btree_weight(&mtree_) != lfsr_mtree_weight(lfs)); - mdir->mid += lfsr_mbidweight(lfs) + mdir->mid += lfsr_mweight(lfs) - mdir_.u.m.weight; mdir->u.m = msibling_.u.m; } else { @@ -5794,7 +5832,7 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, return err; } LFS_ASSERT(tag == LFSR_TAG_MDIR); - LFS_ASSERT(weight == lfsr_mbidweight(lfs)); + LFS_ASSERT(weight == lfsr_mweight(lfs)); // decode mdir err = lfsr_data_readmdir(lfs, &data, mdir.u.m.blocks); @@ -5803,7 +5841,7 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, } // fetch mdir - err = lfsr_mdir_fetch(lfs, &mdir, mdir.u.m.blocks, bid-(weight-1)); + err = lfsr_mdir_fetch(lfs, &mdir, bid-(weight-1), mdir.u.m.blocks); if (err) { return err; } @@ -6004,7 +6042,7 @@ static int lfsr_mtree_traversal_next(lfs_t *lfs, if (traversal->mdir.u.r.rbyd.trunk == 0) { // fetch the first mroot 0x{0,1} int err = lfsr_mdir_fetch(lfs, &traversal->mdir, - LFSR_MDIR_MROOTANCHOR, -1); + -1, LFSR_MROOTANCHOR); if (err) { return err; } @@ -6045,7 +6083,7 @@ static int lfsr_mtree_traversal_next(lfs_t *lfs, // inner nodes require checksums of their pointers, so creating // a valid cycle is actually quite difficult // - if (lfsr_mdir_cmp( + if (lfsr_mblocks_cmp( traversal->mdir.u.m.blocks, traversal->u.m.tortoise.blocks) == 0) { LFS_ERROR("Cycle detected during mtree traversal " @@ -6067,7 +6105,7 @@ static int lfsr_mtree_traversal_next(lfs_t *lfs, // fetch this mroot err = lfsr_mdir_fetch(lfs, &traversal->mdir, - traversal->mdir.u.m.blocks, -1); + -1, traversal->mdir.u.m.blocks); if (err) { return err; } @@ -6093,7 +6131,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_mbidweight(lfs), + LFSR_TAG_MDIR, lfsr_mweight(lfs), &lfs->mtree); if (err) { return err; @@ -6187,7 +6225,7 @@ static int lfsr_mtree_traversal_next(lfs_t *lfs, } err = lfsr_mdir_fetch(lfs, &traversal->mdir, - traversal->mdir.u.m.blocks, bid); + bid, traversal->mdir.u.m.blocks); if (err) { return err; } @@ -7366,8 +7404,9 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { while (lfsr_grm_hasrm(&lfs->grm)) { // find our mdir lfsr_mdir_t mdir; - LFS_ASSERT(lfs->grm.rms[0] - < lfs_smax32(lfsr_mtree_weight(lfs), lfsr_mbidweight(lfs))); + LFS_ASSERT(lfs->grm.rms[0] < lfs_smax32( + lfsr_mtree_weight(lfs), + lfsr_mweight(lfs))); int err = lfsr_mtree_lookup(lfs, lfs->grm.rms[0], &mdir); if (err) { return err; @@ -10926,7 +10965,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->mrid_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] = NULL; diff --git a/lfs.h b/lfs.h index de1a5307..70783730 100644 --- a/lfs.h +++ b/lfs.h @@ -511,7 +511,7 @@ typedef struct lfs { uint8_t pgrm[LFSR_GRM_DSIZE]; uint8_t dgrm[LFSR_GRM_DSIZE]; - uint8_t mrid_bits; + uint8_t mbits; lfsr_mdir_t mroot; lfsr_btree_t mtree; diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml index caa059f4..c5e92542 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_mbidweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; lfs_size_t count = 0; @@ -146,8 +146,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index 53d581e6..d764a792 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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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_mbidweight(&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; @@ -418,7 +418,7 @@ code = ''' // create entries lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, - lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mbidweight(&lfs), 0), + lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { // force a compaction? @@ -444,8 +444,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -471,8 +471,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -516,7 +516,7 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs))); + lfsr_mweight(&lfs))); // fetch mdir lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; @@ -550,8 +550,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -581,8 +581,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -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_mbidweight(&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_mbidweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&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_mbidweight(&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 @@ -720,7 +720,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&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_mbidweight(&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, @@ -859,12 +859,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&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_mbidweight(&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, @@ -906,13 +906,13 @@ code = ''' LFSR_ATTR(1, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&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_mbidweight(&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, @@ -926,12 +926,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&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_mbidweight(&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, @@ -973,7 +973,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&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_mbidweight(&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); @@ -1037,12 +1037,12 @@ code = ''' // remove the left entry as we compact, forcing the left // mdir to be dropped - mdir.mid = 0*lfsr_mbidweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mbidweight(&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, @@ -1066,7 +1066,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mbidweight(&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, @@ -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_mbidweight(&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_mbidweight(&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); @@ -1136,7 +1136,7 @@ code = ''' LFSR_ATTR(1, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mbidweight(&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, @@ -1160,7 +1160,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&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_mbidweight(&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, @@ -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_mbidweight(&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_mbidweight(&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); @@ -1230,7 +1230,7 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL))) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&lfs), 0), + lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mweight(&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_mbidweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; // drop should make sure we never have empty mdirs assert(lfsr_mtree_isinlined(&lfs) || mdir.u.m.weight > 0); @@ -1316,8 +1316,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -1343,8 +1343,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -1382,7 +1382,7 @@ code = ''' // create entries lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, - lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mbidweight(&lfs), 0), + lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -1402,8 +1402,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -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_mbidweight(&lfs)+0, &mdir) => 0; + lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); assert(lfs.mroot.u.m.weight == 0); lfsr_unmount(&lfs) => 0; @@ -1477,7 +1477,7 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs))); + lfsr_mweight(&lfs))); // fetch mdir lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; @@ -1526,8 +1526,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; @@ -1561,8 +1561,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; @@ -1622,13 +1622,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&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_mbidweight(&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; @@ -1641,7 +1641,7 @@ code = ''' LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mdir.u.m.blocks, mdir.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1649,7 +1649,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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, @@ -1663,12 +1663,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated - assert(lfsr_mdir_cmp(old_mdir.u.m.blocks, mdir.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1676,7 +1676,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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, @@ -1716,13 +1716,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&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_mbidweight(&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; @@ -1735,16 +1735,16 @@ code = ''' LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mdir.u.m.blocks, mdir.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&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; @@ -1757,21 +1757,21 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated - assert(lfsr_mdir_cmp(old_mdir.u.m.blocks, mdir.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&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; @@ -1810,13 +1810,13 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&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_mbidweight(&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; @@ -1829,16 +1829,16 @@ code = ''' LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mdir.u.m.blocks, mdir.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&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; @@ -1851,21 +1851,21 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated - assert(lfsr_mdir_cmp(old_mdir.u.m.blocks, mdir.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&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; @@ -1906,7 +1906,7 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1920,7 +1920,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1967,7 +1967,7 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1981,7 +1981,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2021,7 +2021,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // force mroot to compact twice again, this should relocate the mroot old_mroot = lfs.mroot; @@ -2034,7 +2034,7 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2048,7 +2048,7 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2089,7 +2089,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2100,7 +2100,7 @@ code = ''' // force mdir to compact twice, this should relocate lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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; @@ -2113,10 +2113,10 @@ code = ''' LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0; // assert we relocated our mdir - assert(lfsr_mdir_cmp(old_mdir.u.m.blocks, mdir.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2124,7 +2124,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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, @@ -2138,15 +2138,15 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mtree has one mdir - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated our mdir - assert(lfsr_mdir_cmp(old_mdir.u.m.blocks, mdir.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2154,7 +2154,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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, @@ -2194,7 +2194,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2205,7 +2205,7 @@ code = ''' // now add another large entry to the mdir, forcing a split lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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); @@ -2217,12 +2217,12 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2230,13 +2230,13 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&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; @@ -2249,12 +2249,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2262,13 +2262,13 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&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; @@ -2307,7 +2307,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2318,19 +2318,19 @@ code = ''' // remove the entry, forcing the mdir to be dropped lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2344,12 +2344,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was dropped - assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2396,12 +2396,12 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2410,7 +2410,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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, @@ -2424,12 +2424,12 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2437,7 +2437,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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, @@ -2483,22 +2483,22 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our entries are still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&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; @@ -2511,21 +2511,21 @@ code = ''' lfsr_mount(&lfs, CFG) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); // assert we relocated our mroot - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&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; @@ -2561,7 +2561,7 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs))); + lfsr_mweight(&lfs))); // fetch mdir lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; @@ -2623,8 +2623,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; @@ -2658,8 +2658,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; @@ -2870,7 +2870,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -2881,7 +2881,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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; @@ -2890,16 +2890,16 @@ 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_mbidweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; assert(msibling.u.m.weight == 1); // assert that our neighbors were updated correctly assert(!lfsr_mdir_isdropped(&left_neighbor.mdir)); - assert(left_neighbor.mdir.mid == 0*lfsr_mbidweight(&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(!lfsr_mdir_isdropped(&right_neighbor.mdir)); - assert(right_neighbor.mdir.mid == 1*lfsr_mbidweight(&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); @@ -2950,20 +2950,20 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&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_mbidweight(&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; assert(memcmp(buffer, "c", 1) == 0); lfsr_mdir_t msibling; - lfsr_mtree_lookup(&lfs, 1*lfsr_mbidweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 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; @@ -2971,11 +2971,11 @@ code = ''' // assert that our neighbors were updated correctly assert(!lfsr_mdir_isdropped(&left_neighbor.mdir)); - assert(left_neighbor.mdir.mid == 0*lfsr_mbidweight(&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(!lfsr_mdir_isdropped(&right_neighbor.mdir)); - assert(right_neighbor.mdir.mid == 1*lfsr_mbidweight(&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); @@ -3012,7 +3012,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3021,14 +3021,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_mbidweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); assert(mdir.u.m.weight == 3); lfsr_openedmdir_t left_neighbor = { @@ -3040,7 +3040,7 @@ code = ''' // now add another large entry to the mdir, forcing a split memset(buffer, 'e', SIZE); - mdir.mid = 0*lfsr_mbidweight(&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; @@ -3049,7 +3049,7 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3059,14 +3059,14 @@ code = ''' assert(memcmp(buffer, "c", 1) == 0); // assert that our entries are still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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; assert(memcmp(buffer, "d", 1) == 0); lfsr_mdir_t msibling; - lfsr_mtree_lookup(&lfs, 1*lfsr_mbidweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 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; @@ -3074,11 +3074,11 @@ code = ''' // assert that our neighbors were updated correctly assert(!lfsr_mdir_isdropped(&left_neighbor.mdir)); - assert(left_neighbor.mdir.mid == 0*lfsr_mbidweight(&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(!lfsr_mdir_isdropped(&right_neighbor.mdir)); - assert(right_neighbor.mdir.mid == 1*lfsr_mbidweight(&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); @@ -3133,7 +3133,7 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -3185,7 +3185,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3194,14 +3194,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_mbidweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); assert(mdir.u.m.weight == 3); lfsr_openedmdir_t left_neighbor = { @@ -3222,7 +3222,7 @@ code = ''' LFSR_ATTR(1, REG, 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mdir.u.m.blocks, mdir.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -3230,7 +3230,7 @@ code = ''' assert(memcmp(buffer, "c", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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, @@ -3239,10 +3239,10 @@ code = ''' // assert that our neighbors were updated correctly assert(!lfsr_mdir_isdropped(&left_neighbor.mdir)); - assert(left_neighbor.mdir.mid == 0*lfsr_mbidweight(&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(!lfsr_mdir_isdropped(&right_neighbor.mdir)); - assert(right_neighbor.mdir.mid == 0*lfsr_mbidweight(&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_REG, &left_neighbor); @@ -3281,11 +3281,11 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // we should now have 2 mdirs - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&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_mbidweight(&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( @@ -3296,19 +3296,19 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 3 mdirs - assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mbidweight(&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_mbidweight(&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_mbidweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &right_neighbor.mdir) => 0; assert(right_neighbor.mdir.u.m.weight == 1); @@ -3316,7 +3316,7 @@ code = ''' lfsr_mdir_addopened(&lfs, LFS_TYPE_REG, &right_neighbor); // cause middle mdir to split - lfsr_mtree_lookup(&lfs, 1*lfsr_mbidweight(&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( @@ -3327,16 +3327,16 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 4 mdirs - assert(lfsr_mtree_weight(&lfs) == 4*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 4*lfsr_mweight(&lfs)); // assert that our neighbors were updated correctly assert(!lfsr_mdir_isdropped(&left_neighbor.mdir)); - assert(left_neighbor.mdir.mid == 0*lfsr_mbidweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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_mbidweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 3*lfsr_mbidweight(&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_REG, &left_neighbor); @@ -3375,11 +3375,11 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // we should now have 2 mdirs - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&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_mbidweight(&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( @@ -3390,19 +3390,19 @@ code = ''' lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 3 mdirs - assert(lfsr_mtree_weight(&lfs) == 3*lfsr_mbidweight(&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_mbidweight(&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_mbidweight(&lfs)+0, + lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &right_neighbor.mdir) => 0; assert(right_neighbor.mdir.u.m.weight == 1); @@ -3410,23 +3410,23 @@ code = ''' lfsr_mdir_addopened(&lfs, LFS_TYPE_REG, &right_neighbor); // cause middle mdir to drop - lfsr_mtree_lookup(&lfs, 1*lfsr_mbidweight(&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_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert that our neighbors were updated correctly assert(!lfsr_mdir_isdropped(&left_neighbor.mdir)); - assert(left_neighbor.mdir.mid == 0*lfsr_mbidweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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(!lfsr_mdir_isdropped(&right_neighbor.mdir)); - assert(right_neighbor.mdir.mid == 1*lfsr_mbidweight(&lfs)+0); - lfsr_mtree_lookup(&lfs, 1*lfsr_mbidweight(&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_REG, &left_neighbor); @@ -3568,7 +3568,7 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3579,7 +3579,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mdir_t mdir; - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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, @@ -3653,7 +3653,7 @@ code = ''' // and the tree should still work // assert mdir was unininlined correctly - assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mbidweight(&lfs)); + assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries assert(lfs.mroot.u.m.weight == 0); @@ -3663,7 +3663,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); // assert that our entry is still in the mtree - lfsr_mtree_lookup(&lfs, 0*lfsr_mbidweight(&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, @@ -3702,20 +3702,20 @@ code = ''' lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&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_mbidweight(&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_mdir_t msibling; - lfsr_mtree_lookup(&lfs, 1*lfsr_mbidweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 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; @@ -3788,18 +3788,18 @@ code = ''' // and the tree should still work // assert mdirs were unininlined and split - assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mbidweight(&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_mbidweight(&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_mbidweight(&lfs)+0, &msibling) => 0; + lfsr_mtree_lookup(&lfs, 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; @@ -3841,7 +3841,7 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -3915,7 +3915,7 @@ code = ''' // and the tree should still work // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -3944,7 +3944,7 @@ code = ''' // create entries lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, - lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mbidweight(&lfs), 0), + lfs_smax32(lfsr_mtree_weight(&lfs) - lfsr_mweight(&lfs), 0), &mdir) => 0; for (lfs_size_t i = 0; i < N; i++) { // force a compaction? @@ -3970,8 +3970,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -4057,8 +4057,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -4102,7 +4102,7 @@ code = ''' lfs_ssize_t mid = (lfs_ssize_t)( TEST_PRNG(&prng) % lfs_max32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs))); + lfsr_mweight(&lfs))); // fetch mdir lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; @@ -4136,8 +4136,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -4228,8 +4228,8 @@ code = ''' for (lfs_ssize_t mid = 0; mid < lfs_smax32( lfsr_mtree_weight(&lfs), - lfsr_mbidweight(&lfs)); - mid += lfsr_mbidweight(&lfs)) { + lfsr_mweight(&lfs)); + mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; for (; (mdir.mid & lfsr_mridmask(&lfs)) @@ -4263,7 +4263,7 @@ code = ''' lfs_alloc_ack(&lfs); uint8_t buffer[LFSR_MDIR_DSIZE]; - lfs_ssize_t d = lfsr_mdir_todisk(&lfs, LFSR_MDIR_MROOTANCHOR, buffer); + lfs_ssize_t d = lfsr_mdir_todisk(&lfs, LFSR_MROOTANCHOR, buffer); assert(d >= 0); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR(-1, MROOT, 0, BUF(buffer, d)))) => 0; @@ -4366,7 +4366,7 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -4422,7 +4422,7 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; // assert we relocated - assert(lfsr_mdir_cmp(old_mroot.u.m.blocks, lfs.mroot.u.m.blocks) != 0); + assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1),