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