From becbc0c2ad23960accaf4d427806bab256df3d30 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sun, 26 Nov 2023 00:19:08 -0600 Subject: [PATCH] Moved redundant blocks into the lfsr_rbyd_t struct This simplifies dependent structs with redundancy, mainly lfsr_mdir_t, at a significant RAM cost: code stack structs before: 30976 2496 1072 after: 30948 (-0.1%) 2528 (+1.3%) 1100 (+2.6%) Which, to be honest, is not as bad as I thought it would be. Though it is still pretty bad for no new features. The motivation for this change: 1. The organization of the previous lfsr_mdir_t struct was a bit hacky and relied on exact padding so the redund block array and rbyd block lined up at the right offset. 2. The previous organization prevented theoretical "read-only rbyd structs" that could omit write-related fields, e.g. eoff and cksum. This idea is currently unused. 3. The current mdir=level-1, btree/data=level-0 redund design makes this RAM tradeoff pretty bad, but in theory higher btree redund levels would need the extra redund blocks in the rbyd struct anyways. Still, the RAM impact to the current default configuration means this should probably be reverted... --- lfs.c | 335 ++++++------- lfs.h | 16 +- tests/test_alloc.toml | 51 +- tests/test_btree.toml | 148 +++--- tests/test_mtree.toml | 724 ++++++++++++++-------------- tests/test_rbyd.toml | 1066 ++++++++++++++++++++--------------------- 6 files changed, 1171 insertions(+), 1169 deletions(-) diff --git a/lfs.c b/lfs.c index 253cf510..b94f8aa0 100644 --- a/lfs.c +++ b/lfs.c @@ -2044,8 +2044,8 @@ static inline bool lfsr_rbyd_isfetched(const lfsr_rbyd_t *rbyd) { static inline int lfsr_rbyd_cmp( const lfsr_rbyd_t *a, const lfsr_rbyd_t *b) { - if (a->block != b->block) { - return a->block - b->block; + if (a->blocks[0] != b->blocks[0]) { + return a->blocks[0] - b->blocks[0]; } else { return a->trunk - b->trunk; } @@ -2055,13 +2055,13 @@ static inline int lfsr_rbyd_cmp( // allocate an rbyd block static int lfsr_rbyd_alloc(lfs_t *lfs, lfsr_rbyd_t *rbyd) { *rbyd = (lfsr_rbyd_t){.weight=0, .trunk=0, .eoff=0, .cksum=0}; - int err = lfs_alloc(lfs, &rbyd->block); + int err = lfs_alloc(lfs, &rbyd->blocks[0]); if (err) { return err; } // TODO should erase be implicit in alloc eventually? - err = lfsr_bd_erase(lfs, rbyd->block); + err = lfsr_bd_erase(lfs, rbyd->blocks[0]); if (err) { return err; } @@ -2079,7 +2079,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, return err; } - rbyd->block = block; + rbyd->blocks[0] = block; rbyd->eoff = 0; rbyd->trunk = 0; @@ -2231,7 +2231,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, // this failed most likely a previous prog was interrupted, we // need a new erase uint32_t ecksum_ = 0; - err = lfsr_bd_cksum(lfs, rbyd->block, rbyd->eoff, 0, ecksum.size, + err = lfsr_bd_cksum(lfs, rbyd->blocks[0], rbyd->eoff, 0, ecksum.size, &ecksum_); if (err && err != LFS_ERR_CORRUPT) { return err; @@ -2270,7 +2270,7 @@ static int lfsr_rbyd_fetchvalidate(lfs_t *lfs, lfsr_rbyd_t *rbyd, if (rbyd->cksum != cksum) { LFS_ERROR("Found rbyd cksum mismatch rbyd 0x%"PRIx32".%"PRIx32", " "cksum 0x%08"PRIx32" (!= 0x%08"PRIx32")", - rbyd->block, rbyd->trunk, rbyd->cksum, cksum); + rbyd->blocks[0], rbyd->trunk, rbyd->cksum, cksum); return LFS_ERR_CORRUPT; } @@ -2310,7 +2310,7 @@ static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfsr_rid_t weight; lfs_size_t jump; lfs_ssize_t d = lfsr_bd_readtag(lfs, - rbyd->block, branch, 0, + rbyd->blocks[0], branch, 0, &alt, &weight, &jump, NULL); if (d < 0) { return d; @@ -2353,7 +2353,7 @@ static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd, *weight_ = upper - lower; } if (data_) { - *data_ = LFSR_DATA_DISK(rbyd->block, branch + d, jump); + *data_ = LFSR_DATA_DISK(rbyd->blocks[0], branch + d, jump); } return 0; } @@ -2401,7 +2401,7 @@ static int lfsr_rbyd_appendrev(lfs_t *lfs, lfsr_rbyd_t *rbyd, uint32_t rev) { // intentionally allow the revision count to overflow uint8_t rev_buf[sizeof(uint32_t)]; lfs_tole32_(rev, &rev_buf); - int err = lfsr_bd_prog(lfs, rbyd->block, rbyd->eoff, + int err = lfsr_bd_prog(lfs, rbyd->blocks[0], rbyd->eoff, &rev_buf, sizeof(uint32_t), &rbyd->cksum); if (err) { return err; @@ -2426,7 +2426,7 @@ static int lfsr_rbyd_p_flush(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_rid_t weight = p_weights[3-1-i]; lfs_size_t jump = rbyd->eoff - p_jumps[3-1-i]; - lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff, + lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff, alt, weight, jump, &rbyd->cksum); if (d < 0) { @@ -2652,7 +2652,7 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_rid_t weight; lfs_size_t jump; lfs_ssize_t d = lfsr_bd_readtag(lfs, - rbyd->block, branch, 0, + rbyd->blocks[0], branch, 0, &alt, &weight, &jump, NULL); if (d < 0) { return d; @@ -2990,7 +2990,7 @@ leaf:; // // note we always need a non-alt to terminate the trunk, otherwise we // can't find trunks during fetch - lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff, + lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff, // rm => null or shrubnull, otherwise strip off control bits (lfsr_tag_isrm(tag) ? lfsr_tag_mode(lfsr_tag_shrubkey(tag)) @@ -3004,7 +3004,7 @@ leaf:; rbyd->eoff += d; // don't forget the data! - err = lfsr_bd_progdata(lfs, rbyd->block, rbyd->eoff, data, + err = lfsr_bd_progdata(lfs, rbyd->blocks[0], rbyd->eoff, data, &rbyd->cksum); if (err) { return err; @@ -3064,7 +3064,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) { // read the leading byte in case we need to change the expected // value of the next tag's valid bit int err = lfsr_bd_read(lfs, - rbyd->block, aligned_eoff, lfs->cfg->prog_size, + rbyd->blocks[0], aligned_eoff, lfs->cfg->prog_size, &perturb, 1); if (err && err != LFS_ERR_CORRUPT) { return err; @@ -3073,7 +3073,8 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) { // find the expected ecksum, don't bother avoiding a reread of the // perturb byte, as it should still be in our cache lfsr_ecksum_t ecksum = {.size=lfs->cfg->prog_size, .cksum=0}; - err = lfsr_bd_cksum(lfs, rbyd->block, aligned_eoff, lfs->cfg->prog_size, + err = lfsr_bd_cksum(lfs, + rbyd->blocks[0], aligned_eoff, lfs->cfg->prog_size, lfs->cfg->prog_size, &ecksum.cksum); if (err && err != LFS_ERR_CORRUPT) { @@ -3082,7 +3083,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) { uint8_t ecksum_buf[LFSR_ECKSUM_DSIZE]; lfsr_data_t ecksum_data = lfsr_data_fromecksum(&ecksum, ecksum_buf); - lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff, + lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff, LFSR_TAG_ECKSUM, 0, lfsr_data_size(&ecksum_data), &rbyd->cksum); if (d < 0) { @@ -3090,7 +3091,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) { } rbyd->eoff += d; - err = lfsr_bd_progdata(lfs, rbyd->block, rbyd->eoff, ecksum_data, + err = lfsr_bd_progdata(lfs, rbyd->blocks[0], rbyd->eoff, ecksum_data, &rbyd->cksum); if (err) { return err; @@ -3135,7 +3136,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) { } lfs_tole32_(rbyd->cksum, &cksum_buf[2+1+5]); - int err = lfsr_bd_prog(lfs, rbyd->block, rbyd->eoff, + int err = lfsr_bd_prog(lfs, rbyd->blocks[0], rbyd->eoff, cksum_buf, 2+1+5+4, NULL); if (err) { @@ -3234,7 +3235,7 @@ static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // write the tag - lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff, + lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff, tag, weight, lfsr_data_size(&data), &rbyd->cksum); if (d < 0) { @@ -3243,7 +3244,7 @@ static int lfsr_rbyd_appendcompactattr(lfs_t *lfs, lfsr_rbyd_t *rbyd, rbyd->eoff += d; // and the data - int err = lfsr_bd_progdata(lfs, rbyd->block, rbyd->eoff, data, + int err = lfsr_bd_progdata(lfs, rbyd->blocks[0], rbyd->eoff, data, &rbyd->cksum); if (err) { return err; @@ -3312,7 +3313,7 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd, // empty rbyd? write a null tag so our trunk can still point to something if (rbyd->eoff == off) { - lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff, + lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff, shrub ? LFSR_TAG_SHRUB(NULL) : LFSR_TAG_NULL, 0, 0, &rbyd->cksum); if (d < 0) { @@ -3343,7 +3344,7 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_rid_t weight__; lfs_size_t size__; lfs_ssize_t d = lfsr_bd_readtag(lfs, - rbyd->block, off, layer_ - off, + rbyd->blocks[0], off, layer_ - off, &tag__, &weight__, &size__, NULL); if (d < 0) { return d; @@ -3386,7 +3387,8 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // connect with an altle - lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff, + lfs_ssize_t d = lfsr_bd_progtag(lfs, + rbyd->blocks[0], rbyd->eoff, LFSR_TAG_ALT(LE, B, lfsr_tag_key(tag)), weight, rbyd->eoff - trunk, @@ -3398,7 +3400,7 @@ static int lfsr_rbyd_compact(lfs_t *lfs, lfsr_rbyd_t *rbyd, } // terminate with a null tag - lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->block, rbyd->eoff, + lfs_ssize_t d = lfsr_bd_progtag(lfs, rbyd->blocks[0], rbyd->eoff, shrub ? LFSR_TAG_SHRUB(NULL) : LFSR_TAG_NULL, 0, 0, &rbyd->cksum); if (d < 0) { @@ -3711,7 +3713,7 @@ static lfsr_data_t lfsr_data_frombranch(const lfsr_rbyd_t *branch, uint8_t buffer[static LFSR_BRANCH_DSIZE]) { lfs_ssize_t d = 0; - lfs_ssize_t d_ = lfs_toleb128(branch->block, &buffer[d], 5); + lfs_ssize_t d_ = lfs_toleb128(branch->blocks[0], &buffer[d], 5); LFS_ASSERT(d_ >= 0); d += d_; @@ -3733,7 +3735,7 @@ static int lfsr_data_readbranch(lfs_t *lfs, lfsr_data_t *data, branch->eoff = 0; branch->weight = weight; - int err = lfsr_data_readleb128(lfs, data, (int32_t*)&branch->block); + int err = lfsr_data_readleb128(lfs, data, (int32_t*)&branch->blocks[0]); if (err) { return err; } @@ -3940,7 +3942,8 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree, } // found our child? - if (branch_.block == child->block && branch_.trunk == child->trunk) { + if (branch_.blocks[0] == child->blocks[0] + && branch_.trunk == child->trunk) { // TODO how many of these should be conditional? if (rbyd_) { *rbyd_ = branch; @@ -3998,7 +4001,7 @@ static lfs_ssize_t lfsr_btree_commit_(lfs_t *lfs, lfsr_rbyd_t parent = {.trunk=0, .weight=0}; lfsr_srid_t rid; // are we root? - if (rbyd.block == btree->block || rbyd.trunk == 0) { + if (rbyd.blocks[0] == btree->blocks[0] || rbyd.trunk == 0) { // new root? shrub root? yield creation of new roots to // higher-level bshrub/btree logic if (shrub || rbyd.trunk == 0) { @@ -4034,7 +4037,7 @@ static lfs_ssize_t lfsr_btree_commit_(lfs_t *lfs, // a funny benefit is we cache the root of our btree this way if (!lfsr_rbyd_isfetched(&rbyd)) { int err = lfsr_rbyd_fetchvalidate(lfs, &rbyd, - rbyd.block, rbyd.trunk, rbyd.weight, rbyd.cksum); + rbyd.blocks[0], rbyd.trunk, rbyd.weight, rbyd.cksum); if (err) { return err; } @@ -4728,12 +4731,12 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree, static inline bool lfsr_bshrub_isbshrub( const lfsr_mdir_t *mdir, const lfsr_bshrub_t *bshrub) { - return mdir->u.mdir.blocks[0] == bshrub->rbyd.block; + return mdir->rbyd.blocks[0] == bshrub->rbyd.blocks[0]; } static inline bool lfsr_bshrub_isbtree( const lfsr_mdir_t *mdir, const lfsr_bshrub_t *bshrub) { - return mdir->u.mdir.blocks[0] != bshrub->rbyd.block; + return mdir->rbyd.blocks[0] != bshrub->rbyd.blocks[0]; } static inline int lfsr_bshrub_cmp( @@ -4747,7 +4750,7 @@ static inline int lfsr_bshrub_cmp( static int lfsr_bshrub_alloc(lfs_t *lfs, const lfsr_mdir_t *mdir, lfsr_bshrub_t *bshrub) { (void)lfs; - bshrub->rbyd.block = mdir->u.rbyd.block; + bshrub->rbyd.blocks[0] = mdir->rbyd.blocks[0]; bshrub->rbyd.trunk = 0; bshrub->rbyd.weight = 0; bshrub->progged = 0; @@ -4759,7 +4762,7 @@ static int lfsr_bshrub_alloc(lfs_t *lfs, static int lfsr_bshrub_fetch(lfs_t *lfs, const lfsr_mdir_t *mdir, lfsr_bshrub_t *bshrub, lfs_size_t trunk, lfsr_rid_t weight) { - bshrub->rbyd.block = mdir->u.rbyd.block; + bshrub->rbyd.blocks[0] = mdir->rbyd.blocks[0]; bshrub->rbyd.trunk = trunk; bshrub->rbyd.weight = weight; @@ -5006,7 +5009,7 @@ static int lfsr_data_readmptr(lfs_t *lfs, lfsr_data_t *data, // mdir convenience functions static inline const lfsr_mptr_t *lfsr_mdir_mptr(const lfsr_mdir_t *mdir) { - return (const lfsr_mptr_t*)mdir->u.mdir.blocks; + return (const lfsr_mptr_t*)mdir->rbyd.blocks; } static inline int lfsr_mdir_cmp(const lfsr_mdir_t *a, const lfsr_mdir_t *b) { @@ -5090,7 +5093,7 @@ static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir, // try to fetch rbyds in the order of most recent to least recent for (int i = 0; i < 2; i++) { - int err = lfsr_rbyd_fetch(lfs, &mdir->u.rbyd, blocks_[0], 0); + int err = lfsr_rbyd_fetch(lfs, &mdir->rbyd, blocks_[0], 0); if (err && err != LFS_ERR_CORRUPT) { return err; } @@ -5098,7 +5101,7 @@ static int lfsr_mdir_fetch(lfs_t *lfs, lfsr_mdir_t *mdir, if (err != LFS_ERR_CORRUPT) { mdir->mid = mid; // keep track of other block for compactions - mdir->u.mdir.blocks[1] = blocks_[1]; + mdir->rbyd.blocks[1] = blocks_[1]; return 0; } @@ -5115,7 +5118,7 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, lfsr_tag_t *tag_, lfsr_data_t *data_) { lfsr_smid_t mid_; lfsr_tag_t tag__; - int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.rbyd, + int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd, lfsr_mid_rid(lfs, mid), tag, &mid_, &tag__, NULL, data_); if (err) { @@ -5137,7 +5140,7 @@ static int lfsr_mdir_lookupnext(lfs_t *lfs, const lfsr_mdir_t *mdir, static int lfsr_mdir_lookup(lfs_t *lfs, const lfsr_mdir_t *mdir, lfsr_smid_t mid, lfsr_tag_t tag, lfsr_tag_t *tag_, lfsr_data_t *data_) { - return lfsr_rbyd_lookup(lfs, &mdir->u.rbyd, + return lfsr_rbyd_lookup(lfs, &mdir->rbyd, lfsr_mid_rid(lfs, mid), tag, tag_, data_); } @@ -5200,7 +5203,7 @@ static int lfsr_mtree_lookup(lfs_t *lfs, lfsr_smid_t mid, LFS_ASSERT(mid >= 0); LFS_ASSERT(mid < (lfsr_smid_t)lfsr_mweight(lfs)); mdir_->mid = mid; - mdir_->u = lfs->mroot.u; + mdir_->rbyd = lfs->mroot.rbyd; return 0; // looking up direct mdir? @@ -5248,7 +5251,7 @@ static int lfsr_mtree_seek(lfs_t *lfs, lfsr_mdir_t *mdir, lfs_off_t off) { lfsr_srid_t rid = lfsr_mdir_rid(lfs, mdir) + off; // lookup mdirs until we find our rid, we need to do this because // we don't know how many rids are in each mdir until we fetch - while (rid >= mdir->u.rbyd.weight) { + while (rid >= mdir->rbyd.weight) { // end of mtree? if (bid+lfsr_mweight(lfs) >= lfsr_mtree_weight(lfs)) { // if we hit the end of the mtree, park the mdir so all future @@ -5258,7 +5261,7 @@ static int lfsr_mtree_seek(lfs_t *lfs, lfsr_mdir_t *mdir, lfs_off_t off) { } bid += lfsr_mweight(lfs); - rid -= mdir->u.rbyd.weight; + rid -= mdir->rbyd.weight; int err = lfsr_mtree_lookup(lfs, bid, mdir); if (err) { return err; @@ -5284,23 +5287,23 @@ static int lfsr_mdir_alloc(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_smid_t mid) { // allocate two blocks for (int i = 0; i < 2; i++) { - int err = lfs_alloc(lfs, &mdir->u.mdir.blocks[i]); + int err = lfs_alloc(lfs, &mdir->rbyd.blocks[i]); if (err) { return err; } } - mdir->u.rbyd.weight = 0; - mdir->u.rbyd.trunk = 0; - mdir->u.rbyd.eoff = 0; - mdir->u.rbyd.cksum = 0; + mdir->rbyd.weight = 0; + mdir->rbyd.trunk = 0; + mdir->rbyd.eoff = 0; + mdir->rbyd.cksum = 0; // read the new revision count // // we use whatever is on-disk to avoid needing to rewrite the // redund block uint32_t rev; - int err = lfsr_bd_read(lfs, mdir->u.mdir.blocks[1], 0, sizeof(uint32_t), + int err = lfsr_bd_read(lfs, mdir->rbyd.blocks[1], 0, sizeof(uint32_t), &rev, sizeof(uint32_t)); if (err && err != LFS_ERR_CORRUPT) { return err; @@ -5315,14 +5318,14 @@ static int lfsr_mdir_alloc(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_smid_t mid) { } // erase, preparing for compact - err = lfsr_bd_erase(lfs, mdir->u.mdir.blocks[0]); + err = lfsr_bd_erase(lfs, mdir->rbyd.blocks[0]); if (err) { return err; } // increment our revision count and write it to our rbyd // TODO rev things - err = lfsr_rbyd_appendrev(lfs, &mdir->u.rbyd, rev + 1); + err = lfsr_rbyd_appendrev(lfs, &mdir->rbyd, rev + 1); if (err) { return err; } @@ -5337,7 +5340,7 @@ static int lfsr_mdir_swap(lfs_t *lfs, lfsr_mdir_t *mdir_, // first thing we need to do is read our current revision count uint32_t rev; - int err = lfsr_bd_read(lfs, mdir->u.mdir.blocks[0], 0, sizeof(uint32_t), + int err = lfsr_bd_read(lfs, mdir->rbyd.blocks[0], 0, sizeof(uint32_t), &rev, sizeof(uint32_t)); if (err && err != LFS_ERR_CORRUPT) { return err; @@ -5355,22 +5358,22 @@ static int lfsr_mdir_swap(lfs_t *lfs, lfsr_mdir_t *mdir_, } // swap our blocks - mdir_->u.mdir.blocks[0] = mdir->u.mdir.blocks[1]; - mdir_->u.mdir.blocks[1] = mdir->u.mdir.blocks[0]; - mdir_->u.rbyd.weight = 0; - mdir_->u.rbyd.trunk = 0; - mdir_->u.rbyd.eoff = 0; - mdir_->u.rbyd.cksum = 0; + mdir_->rbyd.blocks[0] = mdir->rbyd.blocks[1]; + mdir_->rbyd.blocks[1] = mdir->rbyd.blocks[0]; + mdir_->rbyd.weight = 0; + mdir_->rbyd.trunk = 0; + mdir_->rbyd.eoff = 0; + mdir_->rbyd.cksum = 0; // erase, preparing for compact - err = lfsr_bd_erase(lfs, mdir_->u.mdir.blocks[0]); + err = lfsr_bd_erase(lfs, mdir_->rbyd.blocks[0]); if (err) { return err; } // increment our revision count and write it to our rbyd // TODO rev things - err = lfsr_rbyd_appendrev(lfs, &mdir_->u.rbyd, rev + 1); + err = lfsr_rbyd_appendrev(lfs, &mdir_->rbyd, rev + 1); if (err) { return err; } @@ -5396,7 +5399,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // try to append a commit lfsr_mdir_t mdir_ = *mdir; // mark as erased in case of failure - mdir->u.rbyd.eoff = -1; + mdir->rbyd.eoff = -1; for (lfs_size_t i = 0; i < attr_count; i++) { // calculate adjusted rid lfsr_srid_t rid = lfsr_mid_rid(lfs, attrs[i].rid); @@ -5434,7 +5437,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } // append the attr - err = lfsr_rbyd_appendattr(lfs, &mdir_.u.rbyd, + err = lfsr_rbyd_appendattr(lfs, &mdir_.rbyd, rid - lfs_smax32(start_rid, 0), tag, 0, data); if (err) { @@ -5455,12 +5458,12 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // // it is important that these rbyds share eoff/cksum/etc // - mdir_.u.rbyd.trunk = bshrubcommit->bshrub->rbyd_.trunk; - mdir_.u.rbyd.weight = bshrubcommit->bshrub->rbyd_.weight; + mdir_.rbyd.trunk = bshrubcommit->bshrub->rbyd_.trunk; + mdir_.rbyd.weight = bshrubcommit->bshrub->rbyd_.weight; // append any shrub attributes for (lfs_size_t j = 0; j < bshrubcommit->attr_count; j++) { - int err = lfsr_rbyd_appendattr(lfs, &mdir_.u.rbyd, + int err = lfsr_rbyd_appendattr(lfs, &mdir_.rbyd, bshrubcommit->attrs[j].rid, LFSR_TAG_SHRUB | bshrubcommit->attrs[j].tag, bshrubcommit->attrs[j].delta, @@ -5471,10 +5474,10 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } // revert mdir to main trunk/weight - bshrubcommit->bshrub->rbyd_.trunk = mdir_.u.rbyd.trunk; - bshrubcommit->bshrub->rbyd_.weight = mdir_.u.rbyd.weight; - mdir_.u.rbyd.trunk = mdir->u.rbyd.trunk; - mdir_.u.rbyd.weight = mdir->u.rbyd.weight; + bshrubcommit->bshrub->rbyd_.trunk = mdir_.rbyd.trunk; + bshrubcommit->bshrub->rbyd_.weight = mdir_.rbyd.weight; + mdir_.rbyd.trunk = mdir->rbyd.trunk; + mdir_.rbyd.weight = mdir->rbyd.weight; // lazily encode inlined trunks in case they change underneath // us due to mdir compactions @@ -5486,7 +5489,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, = (lfsr_bshrub_t*)attrs[i].data.u.buf.buffer; uint8_t trunk_buf[LFSR_TRUNK_DSIZE]; - int err = lfsr_rbyd_appendattr(lfs, &mdir_.u.rbyd, + int err = lfsr_rbyd_appendattr(lfs, &mdir_.rbyd, rid - lfs_smax32(start_rid, 0), lfsr_tag_mode(attrs[i].tag) | LFSR_TAG_TRUNK, attrs[i].delta, @@ -5503,7 +5506,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, } else { LFS_ASSERT(!lfsr_tag_isinternal(attrs[i].tag)); - int err = lfsr_rbyd_appendattr(lfs, &mdir_.u.rbyd, + int err = lfsr_rbyd_appendattr(lfs, &mdir_.rbyd, rid - lfs_smax32(start_rid, 0), attrs[i].tag, attrs[i].delta, attrs[i].data); if (err) { @@ -5527,25 +5530,25 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, // If we finish the commit it becomes immediately visibile, but we really // need to remove this mdir_ from the mtree. Leave the actual remove up to // upper layers. - if (mdir_.u.rbyd.weight == 0 + if (mdir_.rbyd.weight == 0 // unless we are an mroot && !(mdir_.mid == -1 || lfsr_mdir_cmp(&mdir_, &lfs->mroot) == 0)) { // mark weight as zero, but note! we can not longer read from this mdir // as our pcache may get clobbered - mdir->u.rbyd.weight = 0; + mdir->rbyd.weight = 0; return LFS_ERR_NOENT; } // append any gstate? if (start_rid == -1) { - int err = lfsr_rbyd_appendgdelta(lfs, &mdir_.u.rbyd); + int err = lfsr_rbyd_appendgdelta(lfs, &mdir_.rbyd); if (err) { return err; } } // finalize commit - int err = lfsr_rbyd_appendcksum(lfs, &mdir_.u.rbyd); + int err = lfsr_rbyd_appendcksum(lfs, &mdir_.rbyd); if (err) { return err; } @@ -5555,7 +5558,7 @@ static int lfsr_mdir_commit__(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_fs_flushgdelta(lfs); } - mdir->u = mdir_.u; + mdir->rbyd = mdir_.rbyd; return 0; } @@ -5579,7 +5582,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, while (true) { lfsr_rid_t weight; lfsr_data_t data; - int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.rbyd, + int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd, rid, tag+1, &rid, &tag, &weight, &data); if (err) { @@ -5599,7 +5602,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // we need to update any opened inlined files if (tag == LFSR_TAG_DATA) { // write the tag - err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->u.rbyd, + err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, tag, weight, data); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -5621,8 +5624,8 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // this is a bit tricky since we don't know the tag size, // but we have just enough info file->u.bsprout.data = LFSR_DATA_DISK( - mdir_->u.rbyd.block, - mdir_->u.rbyd.eoff - lfsr_data_size(&data), + mdir_->rbyd.blocks[0], + mdir_->rbyd.eoff - lfsr_data_size(&data), lfsr_data_size(&data)); } } @@ -5630,7 +5633,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // found an inlined shrub? we need to compact the shrub as well to // bring it along with us } else if (tag == LFSR_TAG_TRUNK) { - lfsr_rbyd_t shrub = mdir->u.rbyd; + lfsr_rbyd_t shrub = mdir->rbyd; err = lfsr_data_readtrunk(lfs, &data, &shrub.trunk, (lfsr_rid_t*)&shrub.weight); if (err) { @@ -5638,17 +5641,17 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, } // keep track of the start of our new tree - lfs_size_t off = mdir_->u.rbyd.eoff; + lfs_size_t off = mdir_->rbyd.eoff; // compact our inlined tree - err = lfsr_rbyd_appendcompactrbyd(lfs, &mdir_->u.rbyd, true, + err = lfsr_rbyd_appendcompactrbyd(lfs, &mdir_->rbyd, true, -1, -1, &shrub); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; } - err = lfsr_rbyd_compact(lfs, &mdir_->u.rbyd, true, off); + err = lfsr_rbyd_compact(lfs, &mdir_->rbyd, true, off); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -5656,9 +5659,9 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // write the new shrub tag uint8_t trunk_buf[LFSR_TRUNK_DSIZE]; - err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->u.rbyd, + err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, LFSR_TAG_TRUNK, weight, lfsr_data_fromtrunk( - mdir_->u.rbyd.trunk, mdir_->u.rbyd.weight, + mdir_->rbyd.trunk, mdir_->rbyd.weight, trunk_buf)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -5674,13 +5677,13 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, lfsr_file_t *file = (lfsr_file_t*)opened; if (lfsr_file_isbshrub(file) && lfsr_rbyd_cmp(&file->u.bshrub.rbyd, &shrub) == 0) { - file->u.bshrub.rbyd_ = mdir_->u.rbyd; + file->u.bshrub.rbyd_ = mdir_->rbyd; } } } else { // write the tag - err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->u.rbyd, + err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, tag, weight, data); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -5689,7 +5692,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, } } - int err = lfsr_rbyd_compact(lfs, &mdir_->u.rbyd, false, sizeof(uint32_t)); + int err = lfsr_rbyd_compact(lfs, &mdir_->rbyd, false, sizeof(uint32_t)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; @@ -5714,7 +5717,7 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // inlined sprout? if (lfsr_file_isbsprout(file)) { // write the data as a shrub tag - err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->u.rbyd, + err = lfsr_rbyd_appendcompactattr(lfs, &mdir_->rbyd, LFSR_TAG_SHRUB(DATA), 0, file->u.bsprout.data); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -5724,20 +5727,20 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, // this is a bit tricky since we don't know the tag size, // but we have just enough info file->u.bsprout.data_ = LFSR_DATA_DISK( - mdir_->u.rbyd.block, - mdir_->u.rbyd.eoff + mdir_->rbyd.blocks[0], + mdir_->rbyd.eoff - lfsr_data_size(&file->u.bsprout.data), lfsr_data_size(&file->u.bsprout.data)); // inlined shrub? } else if (lfsr_file_isbshrub(file)) { // save our current off/trunk/weight - lfs_size_t off = mdir_->u.rbyd.eoff; - lfs_size_t trunk = mdir_->u.rbyd.trunk; - lfsr_srid_t weight = mdir_->u.rbyd.weight; + lfs_size_t off = mdir_->rbyd.eoff; + lfs_size_t trunk = mdir_->rbyd.trunk; + lfsr_srid_t weight = mdir_->rbyd.weight; // compact our shrub - err = lfsr_rbyd_appendcompactrbyd(lfs, &mdir_->u.rbyd, true, + err = lfsr_rbyd_appendcompactrbyd(lfs, &mdir_->rbyd, true, -1, -1, &file->u.bshrub.rbyd); if (err) { @@ -5745,16 +5748,16 @@ static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, return err; } - err = lfsr_rbyd_compact(lfs, &mdir_->u.rbyd, true, off); + err = lfsr_rbyd_compact(lfs, &mdir_->rbyd, true, off); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); return err; } // stage our new trunk and revert to mdir trunk/weight - file->u.bshrub.rbyd_ = mdir_->u.rbyd; - mdir_->u.rbyd.trunk = trunk; - mdir_->u.rbyd.weight = weight; + file->u.bshrub.rbyd_ = mdir_->rbyd; + mdir_->rbyd.trunk = trunk; + mdir_->rbyd.weight = weight; } } } @@ -5771,7 +5774,7 @@ static lfs_ssize_t lfsr_mdir_estimate_(lfs_t *lfs, const lfsr_mdir_t *mdir, while (true) { lfsr_srid_t rid__; lfsr_data_t data; - int err = lfsr_rbyd_lookupnext(lfs, &mdir->u.rbyd, + int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd, rid, tag+1, &rid__, &tag, NULL, &data); if (err) { @@ -5791,7 +5794,7 @@ static lfs_ssize_t lfsr_mdir_estimate_(lfs_t *lfs, const lfsr_mdir_t *mdir, // need a second function... // if (tag == LFSR_TAG_TRUNK) { - lfsr_rbyd_t rbyd = mdir->u.rbyd; + lfsr_rbyd_t rbyd = mdir->rbyd; err = lfsr_data_readtrunk(lfs, &data, &rbyd.trunk, (lfsr_rid_t*)&rbyd.weight); if (err) { @@ -5864,7 +5867,7 @@ static lfs_ssize_t lfsr_mdir_estimate(lfs_t *lfs, const lfsr_mdir_t *mdir, // during a split so they shouldn't affect the split_rid // lfsr_srid_t lower_rid = lfs_smax32(start_rid, 0); - lfsr_srid_t upper_rid = lfs_min32(mdir->u.rbyd.weight, end_rid)-1; + lfsr_srid_t upper_rid = lfs_min32(mdir->rbyd.weight, end_rid)-1; lfs_size_t lower_dsize = 0; lfs_size_t upper_dsize = 0; @@ -5894,7 +5897,7 @@ static lfs_ssize_t lfsr_mdir_estimate(lfs_t *lfs, const lfsr_mdir_t *mdir, // can't handle -1 rids lfs_ssize_t dsize = 0; if (start_rid == -1) { - dsize = lfsr_rbyd_estimate_(lfs, &mdir->u.rbyd, -1, NULL, NULL); + dsize = lfsr_rbyd_estimate_(lfs, &mdir->rbyd, -1, NULL, NULL); if (dsize < 0) { return dsize; } @@ -6021,14 +6024,14 @@ static int lfsr_mroot_commit(lfs_t *lfs, lfsr_mdir_t mroot_ = lfs->mroot; // mark any copies of our mroot as unerased - lfs->mroot.u.rbyd.eoff = -1; + lfs->mroot.rbyd.eoff = -1; for (int type = LFS_TYPE_REG; type < LFS_TYPE_REG+3; type++) { for (lfsr_openedmdir_t *opened = lfs->opened[type-LFS_TYPE_REG]; opened; opened = opened->next) { if (lfsr_mdir_cmp(&opened->mdir, &lfs->mroot) == 0) { - opened->mdir.u.rbyd.eoff = -1; + opened->mdir.rbyd.eoff = -1; } } } @@ -6058,8 +6061,8 @@ static int lfsr_mroot_commit(lfs_t *lfs, LFS_DEBUG("Relocating mroot 0x{%"PRIx32",%"PRIx32"} " "-> 0x{%"PRIx32",%"PRIx32"}", - mrootchild.u.mdir.blocks[0], mrootchild.u.mdir.blocks[1], - mrootchild_.u.mdir.blocks[0], mrootchild_.u.mdir.blocks[1]); + mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1], + mrootchild_.rbyd.blocks[0], mrootchild_.rbyd.blocks[1]); mrootchild = mrootparent_; @@ -6085,9 +6088,9 @@ static int lfsr_mroot_commit(lfs_t *lfs, LFS_DEBUG("Extending mroot 0x{%"PRIx32",%"PRIx32"}" " -> 0x{%"PRIx32",%"PRIx32"}" ", 0x{%"PRIx32",%"PRIx32"}", - mrootchild.u.mdir.blocks[0], mrootchild.u.mdir.blocks[1], - mrootchild.u.mdir.blocks[0], mrootchild.u.mdir.blocks[1], - mrootchild_.u.mdir.blocks[0], mrootchild_.u.mdir.blocks[1]); + mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1], + mrootchild.rbyd.blocks[0], mrootchild.rbyd.blocks[1], + mrootchild_.rbyd.blocks[0], mrootchild_.rbyd.blocks[1]); // compact into the new mroot anchor lfsr_mdir_t mrootanchor_; @@ -6102,7 +6105,7 @@ static int lfsr_mroot_commit(lfs_t *lfs, lfsr_srid_t rid; lfsr_rid_t weight; lfsr_data_t data; - err = lfsr_rbyd_lookupnext(lfs, &mrootchild.u.rbyd, + err = lfsr_rbyd_lookupnext(lfs, &mrootchild.rbyd, -1, tag+1, &rid, &tag, &weight, &data); if (err) { @@ -6116,7 +6119,7 @@ static int lfsr_mroot_commit(lfs_t *lfs, } // write the tag - err = lfsr_rbyd_appendcompactattr(lfs, &mrootanchor_.u.rbyd, + err = lfsr_rbyd_appendcompactattr(lfs, &mrootanchor_.rbyd, tag, weight, data); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -6124,7 +6127,7 @@ static int lfsr_mroot_commit(lfs_t *lfs, } } - err = lfsr_rbyd_compact(lfs, &mrootanchor_.u.rbyd, false, + err = lfsr_rbyd_compact(lfs, &mrootanchor_.rbyd, false, sizeof(uint32_t)); if (err) { LFS_ASSERT(err != LFS_ERR_RANGE); @@ -6163,7 +6166,7 @@ static int lfsr_mroot_commit(lfs_t *lfs, } // update any opened mdirs in our mroot - opened->mdir.u = mroot_.u; + opened->mdir.rbyd = mroot_.rbyd; } } } @@ -6235,8 +6238,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, const lfsr_attr_t *attrs, lfs_size_t attr_count) { LFS_ASSERT(mdir->mid == -1 || lfsr_mtree_isnull(lfs) - || mdir->u.rbyd.weight > 0); - LFS_ASSERT(lfsr_mdir_rid(lfs, mdir) <= mdir->u.rbyd.weight); + || mdir->rbyd.weight > 0); + LFS_ASSERT(lfsr_mdir_rid(lfs, mdir) <= mdir->rbyd.weight); // parse out any pending gstate, these will get automatically xored // with on-disk gdeltas in lower-level functions @@ -6271,7 +6274,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // would force the mroot to always compact // if (lfsr_mdir_cmp(&opened->mdir, mdir) == 0) { - opened->mdir.u.rbyd.eoff = -1; + opened->mdir.rbyd.eoff = -1; } // stage all bsprouts/bshrubs @@ -6299,12 +6302,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, } // keep mdir_ in sync with mroot - mdir_.u = lfs->mroot.u; + mdir_.rbyd = lfs->mroot.rbyd; // otherwise commit normally } else { // mark our mdir as unerased in case we fail - mdir->u.rbyd.eoff = -1; + mdir->rbyd.eoff = -1; err = lfsr_mdir_commit_(lfs, &mdir_, -1, -1, &split_rid, attrs, attr_count); @@ -6380,40 +6383,40 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, "-> 0x{%"PRIx32",%"PRIx32"}, " "0x{%"PRIx32",%"PRIx32"}", mdir->mid >> lfs->mbits, - mdir->u.mdir.blocks[0], mdir->u.mdir.blocks[1], - mdir_.u.mdir.blocks[0], mdir_.u.mdir.blocks[1], - msibling_.u.mdir.blocks[0], msibling_.u.mdir.blocks[1]); + mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], + mdir_.rbyd.blocks[0], mdir_.rbyd.blocks[1], + msibling_.rbyd.blocks[0], msibling_.rbyd.blocks[1]); // because of defered commits, both children can still be reduced // to zero, need to catch this here // both siblings reduced to zero - if (mdir_.u.rbyd.weight == 0 && msibling_.u.rbyd.weight == 0) { + if (mdir_.rbyd.weight == 0 && msibling_.rbyd.weight == 0) { LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", mdir_.mid >> lfs->mbits, - mdir_.u.mdir.blocks[0], mdir_.u.mdir.blocks[1]); + mdir_.rbyd.blocks[0], mdir_.rbyd.blocks[1]); LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", msibling_.mid >> lfs->mbits, - msibling_.u.mdir.blocks[0], msibling_.u.mdir.blocks[1]); + msibling_.rbyd.blocks[0], msibling_.rbyd.blocks[1]); goto drop; // one sibling reduced to zero - } else if (msibling_.u.rbyd.weight == 0) { + } else if (msibling_.rbyd.weight == 0) { LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", msibling_.mid >> lfs->mbits, - msibling_.u.mdir.blocks[0], msibling_.u.mdir.blocks[1]); + msibling_.rbyd.blocks[0], msibling_.rbyd.blocks[1]); goto relocate; // other sibling reduced to zero - } else if (mdir_.u.rbyd.weight == 0) { + } else if (mdir_.rbyd.weight == 0) { LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", mdir_.mid >> lfs->mbits, - mdir_.u.mdir.blocks[0], mdir_.u.mdir.blocks[1]); - mdir_.u = msibling_.u; + mdir_.rbyd.blocks[0], mdir_.rbyd.blocks[1]); + mdir_.rbyd = msibling_.rbyd; goto relocate; } @@ -6443,9 +6446,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, if (lfsr_mid_bid(lfs, grm->rms[j]) == lfsr_mid_bid(lfs, lfs_smax32(mdir->mid, 0))) { if (lfsr_mid_rid(lfs, grm->rms[j]) - >= mdir_.u.rbyd.weight) { + >= mdir_.rbyd.weight) { grm->rms[j] += lfsr_mweight(lfs) - - mdir_.u.rbyd.weight; + - mdir_.rbyd.weight; } } else if (grm->rms[j] > mdir->mid) { grm->rms[j] += mdelta; @@ -6466,7 +6469,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // note we need to do this after playing out pending attrs in // case they introduce a new name! lfsr_data_t split_data; - err = lfsr_rbyd_lookup(lfs, &msibling_.u.rbyd, 0, LFSR_TAG_WIDE(NAME), + err = lfsr_rbyd_lookup(lfs, &msibling_.rbyd, 0, LFSR_TAG_WIDE(NAME), NULL, &split_data); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); @@ -6512,7 +6515,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, LFS_DEBUG("Dropping mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"}", mdir->mid >> lfs->mbits, - mdir->u.mdir.blocks[0], mdir->u.mdir.blocks[1]); + mdir->rbyd.blocks[0], mdir->rbyd.blocks[1]); // consume gstate so we don't lose any info err = lfsr_fs_consumegdelta(lfs, mdir); @@ -6584,8 +6587,8 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, LFS_DEBUG("Relocating mdir %"PRId32" " "0x{%"PRIx32",%"PRIx32"} -> 0x{%"PRIx32",%"PRIx32"}", mdir->mid >> lfs->mbits, - mdir->u.mdir.blocks[0], mdir->u.mdir.blocks[1], - mdir_.u.mdir.blocks[0], mdir_.u.mdir.blocks[1]); + mdir->rbyd.blocks[0], mdir->rbyd.blocks[1], + mdir_.rbyd.blocks[0], mdir_.rbyd.blocks[1]); relocate:; // new mtree? @@ -6685,12 +6688,12 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, if (lfsr_mdir_cmp(&opened->mdir, mdir) == 0) { if (mdelta > 0 && lfsr_mdir_rid(lfs, &opened->mdir) - >= mdir_.u.rbyd.weight) { + >= mdir_.rbyd.weight) { opened->mdir.mid += lfsr_mweight(lfs) - - mdir_.u.rbyd.weight; - opened->mdir.u = msibling_.u; + - mdir_.rbyd.weight; + opened->mdir.rbyd = msibling_.rbyd; } else { - opened->mdir.u = mdir_.u; + opened->mdir.rbyd = mdir_.rbyd; } } else if (opened->mdir.mid > mdir->mid) { opened->mdir.mid += mdelta; @@ -6727,9 +6730,9 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, == lfsr_mid_bid(lfs, lfs_smax32(mdir->mid, 0))) { if (mdelta > 0 && lfsr_mid_rid(lfs, dir->bookmark) - >= mdir_.u.rbyd.weight) { + >= mdir_.rbyd.weight) { dir->bookmark += lfsr_mweight(lfs) - - mdir_.u.rbyd.weight; + - mdir_.rbyd.weight; } } else if (dir->bookmark > mdir->mid) { dir->bookmark += mdelta; @@ -6741,13 +6744,13 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, // update mdir to follow requested rid if (mdir->mid == -1) { - mdir->u = lfs->mroot.u; + mdir->rbyd = lfs->mroot.rbyd; } else if (mdelta > 0 - && lfsr_mdir_rid(lfs, mdir) >= mdir_.u.rbyd.weight) { - mdir->mid += lfsr_mweight(lfs) - mdir_.u.rbyd.weight; - mdir->u = msibling_.u; + && lfsr_mdir_rid(lfs, mdir) >= mdir_.rbyd.weight) { + mdir->mid += lfsr_mweight(lfs) - mdir_.rbyd.weight; + mdir->rbyd = msibling_.rbyd; } else { - mdir->u = mdir_.u; + mdir->rbyd = mdir_.rbyd; } return 0; @@ -6761,7 +6764,7 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir, lfsr_did_t did, const char *name, lfs_size_t name_size, lfsr_srid_t *rid_, lfsr_tag_t *tag_, lfsr_data_t *data_) { // empty mdir? make sure rid_ = 0 at least - if (mdir->u.rbyd.weight == 0) { + if (mdir->rbyd.weight == 0) { if (rid_) { *rid_ = 0; } @@ -6769,7 +6772,7 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir, } lfsr_srid_t rid; - lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->u.rbyd, + lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->rbyd, did, name, name_size, &rid, tag_, NULL, data_); if (cmp < 0) { @@ -7187,7 +7190,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal, // match if (lfsr_traversal_isvalidate(traversal)) { err = lfsr_rbyd_fetchvalidate(lfs, &tinfo->u.rbyd, - tinfo->u.rbyd.block, tinfo->u.rbyd.trunk, + tinfo->u.rbyd.blocks[0], tinfo->u.rbyd.trunk, tinfo->u.rbyd.weight, tinfo->u.rbyd.cksum); if (err) { @@ -7237,7 +7240,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal, // uninitialized in mountinited and 2. stack really matters since // we're at the bottom of lfs_alloc) if (binfo.tag == LFSR_TAG_BRANCH - && binfo.u.rbyd.block == lfs->mtree.u.btree.block) { + && binfo.u.rbyd.blocks[0] == lfs->mtree.u.btree.blocks[0]) { continue; } @@ -7248,7 +7251,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal, // match if (lfsr_traversal_isvalidate(traversal)) { err = lfsr_rbyd_fetchvalidate(lfs, &binfo.u.rbyd, - binfo.u.rbyd.block, binfo.u.rbyd.trunk, + binfo.u.rbyd.blocks[0], binfo.u.rbyd.trunk, binfo.u.rbyd.weight, binfo.u.rbyd.cksum); if (err) { @@ -7293,7 +7296,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal, // return to mtree traversal if (!lfsr_traversal_isall(traversal) || lfsr_mdir_rid(lfs, &traversal->mdir) - >= traversal->mdir.u.rbyd.weight) { + >= traversal->mdir.rbyd.weight) { traversal->state = LFSR_TRAVERSAL_MTREE; continue; } @@ -7323,7 +7326,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal, // found a bshrub (inlined btree)? } else if (err != LFS_ERR_NOENT && tag == LFSR_TAG_TRUNK) { - traversal->bshrub.rbyd = traversal->mdir.u.rbyd; + traversal->bshrub.rbyd = traversal->mdir.rbyd; err = lfsr_data_readtrunk(lfs, &data, &traversal->bshrub.rbyd.trunk, (lfsr_rid_t*)&traversal->bshrub.rbyd.weight); @@ -7425,7 +7428,7 @@ static int lfsr_traversal_read(lfs_t *lfs, lfsr_traversal_t *traversal, // match if (lfsr_traversal_isvalidate(traversal)) { err = lfsr_rbyd_fetchvalidate(lfs, &binfo.u.rbyd, - binfo.u.rbyd.block, binfo.u.rbyd.trunk, + binfo.u.rbyd.blocks[0], binfo.u.rbyd.trunk, binfo.u.rbyd.weight, binfo.u.rbyd.cksum); if (err) { @@ -8067,9 +8070,9 @@ static int lfsr_formatinited(lfs_t *lfs) { for (int i = 0; i < 2; i++) { // write superblock to both rbyds in the root mroot to hopefully // avoid mounting an older filesystem on disk - lfsr_rbyd_t rbyd = {.block=i, .eoff=0, .trunk=0}; + lfsr_rbyd_t rbyd = {.blocks[0]=i, .eoff=0, .trunk=0}; - int err = lfsr_bd_erase(lfs, rbyd.block); + int err = lfsr_bd_erase(lfs, rbyd.blocks[0]); if (err) { return err; } @@ -8136,9 +8139,9 @@ int lfsr_mount(lfs_t *lfs, const struct lfs_config *cfg) { "bd %"PRId32"x%"PRId32, LFS_DISK_VERSION_MAJOR, LFS_DISK_VERSION_MINOR, - lfs->mroot.u.mdir.blocks[0], - lfs->mroot.u.mdir.blocks[1], - lfs->mroot.u.rbyd.trunk, + lfs->mroot.rbyd.blocks[0], + lfs->mroot.rbyd.blocks[1], + lfs->mroot.rbyd.trunk, lfsr_mtree_weight(lfs) / lfsr_mweight(lfs), lfsr_mweight(lfs), lfs->cfg->block_size, @@ -8267,11 +8270,11 @@ static int lfs_alloc(lfs_t *lfs, lfs_block_t *block) { // mark any blocks we see at in-use, including any btree/mdir blocks if (tinfo.tag == LFSR_TAG_MDIR) { - lfs_alloc_setinuse(lfs, tinfo.u.mdir.u.mdir.blocks[1]); - lfs_alloc_setinuse(lfs, tinfo.u.mdir.u.mdir.blocks[0]); + lfs_alloc_setinuse(lfs, tinfo.u.mdir.rbyd.blocks[1]); + lfs_alloc_setinuse(lfs, tinfo.u.mdir.rbyd.blocks[0]); } else if (tinfo.tag == LFSR_TAG_BRANCH) { - lfs_alloc_setinuse(lfs, tinfo.u.rbyd.block); + lfs_alloc_setinuse(lfs, tinfo.u.rbyd.blocks[0]); } else if (tinfo.tag == LFSR_TAG_BLOCK) { lfs_alloc_setinuse(lfs, tinfo.u.bptr.block); @@ -8348,7 +8351,7 @@ static int lfsr_fs_fixgrm(lfs_t *lfs) { } // remove the rid while also updating our grm - LFS_ASSERT(lfsr_mid_rid(lfs, lfs->grm.rms[0]) < mdir.u.rbyd.weight); + LFS_ASSERT(lfsr_mid_rid(lfs, lfs->grm.rms[0]) < mdir.rbyd.weight); err = lfsr_mdir_commit(lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, RM, -1, NULL()), LFSR_ATTR(-1, GRM, 0, GRM(&grm)))); @@ -9008,14 +9011,14 @@ static inline bool lfsr_file_isbsprout(const lfsr_file_t *file) { return (lfs_size_t)file->u.bsprout.data.u.disk.size > (LFSR_FILE_ISDIRECT | 0) && file->u.bsprout.data.u.disk.block - == file->mdir.u.mdir.blocks[0]; + == file->mdir.rbyd.blocks[0]; } static inline bool lfsr_file_isbptr(const lfsr_file_t *file) { return (lfs_size_t)file->u.bsprout.data.u.disk.size > (LFSR_FILE_ISDIRECT | 0) && file->u.bsprout.data.u.disk.block - != file->mdir.u.mdir.blocks[0]; + != file->mdir.rbyd.blocks[0]; } static inline bool lfsr_file_isbshrub(const lfsr_file_t *file) { diff --git a/lfs.h b/lfs.h index fa228d33..2a052e3b 100644 --- a/lfs.h +++ b/lfs.h @@ -363,14 +363,13 @@ typedef struct lfs_cache { typedef struct lfsr_rbyd { // note this lines up with weight in lfsr_btree_t lfsr_srid_t weight; + lfs_block_t blocks[2]; // eoff=0, trunk=0 => not yet committed // eoff=0, trunk>0 => not yet fetched // eoff>=block_size => rbyd not erased/needs compaction lfs_size_t trunk; lfs_size_t eoff; uint32_t cksum; - // note this lines up with arrays of redundant blocks in lfsr_mdir_t - lfs_block_t block; } lfsr_rbyd_t; typedef struct lfsr_bptr { @@ -389,18 +388,7 @@ typedef struct lfsr_mptr { typedef struct lfsr_mdir { lfsr_smid_t mid; - union { - // here we make sure to line up our block array so it overlaps with - // the block stored as the first entry in the rbyd - struct { - lfsr_srid_t weight; - lfs_off_t trunk; - lfs_off_t eoff; - uint32_t cksum; - lfs_block_t blocks[2]; - } mdir; - lfsr_rbyd_t rbyd; - } u; + lfsr_rbyd_t rbyd; } lfsr_mdir_t; typedef struct lfsr_openedmdir { diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml index 1b848cba..31f77c4e 100644 --- a/tests/test_alloc.toml +++ b/tests/test_alloc.toml @@ -176,22 +176,23 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); // keep track of seen blocks - seen[tinfo.u.mdir.u.mdir.blocks[1] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8); - seen[tinfo.u.mdir.u.mdir.blocks[0] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8); + seen[tinfo.u.mdir.rbyd.blocks[1] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8); + seen[tinfo.u.mdir.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); // keep track of seen blocks - seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8); + seen[tinfo.u.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.rbyd.blocks[0] % 8); } else { // this shouldn't happen @@ -332,22 +333,23 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); // keep track of seen blocks - seen[tinfo.u.mdir.u.mdir.blocks[1] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8); - seen[tinfo.u.mdir.u.mdir.blocks[0] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8); + seen[tinfo.u.mdir.rbyd.blocks[1] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8); + seen[tinfo.u.mdir.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); // keep track of seen blocks - seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8); + seen[tinfo.u.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BLOCK) { printf("traversal: 0x%x block 0x%x\n", @@ -478,22 +480,23 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); // keep track of seen blocks - seen[tinfo.u.mdir.u.mdir.blocks[1] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8); - seen[tinfo.u.mdir.u.mdir.blocks[0] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8); + seen[tinfo.u.mdir.rbyd.blocks[1] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8); + seen[tinfo.u.mdir.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); // keep track of seen blocks - seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8); + seen[tinfo.u.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BLOCK) { printf("traversal: 0x%x block 0x%x\n", diff --git a/tests/test_btree.toml b/tests/test_btree.toml index a15e1184..4d707359 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -120,7 +120,7 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 0); @@ -154,7 +154,7 @@ code = ''' LFSR_DATA_BUF("a", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -196,7 +196,7 @@ code = ''' LFSR_DATA_BUF("b", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 2); @@ -243,7 +243,7 @@ code = ''' LFSR_DATA_BUF("a", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 2); @@ -293,7 +293,7 @@ code = ''' LFSR_DATA_BUF("c", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 3); @@ -348,7 +348,7 @@ code = ''' LFSR_DATA_BUF("a", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 3); @@ -412,7 +412,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == n); @@ -465,7 +465,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == n); @@ -549,7 +549,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == sim_size); @@ -605,7 +605,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == n*W); @@ -727,7 +727,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); lfs_size_t total_weight = 0; @@ -810,7 +810,7 @@ code = ''' LFSR_DATA_BUF("A", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -856,7 +856,7 @@ code = ''' LFSR_DATA_BUF("B", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 2); @@ -912,7 +912,7 @@ code = ''' LFSR_DATA_BUF("C", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 3); @@ -969,7 +969,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -983,7 +983,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -991,7 +991,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == N); @@ -1042,7 +1042,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1089,7 +1089,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == N); @@ -1139,7 +1139,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1153,7 +1153,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1161,7 +1161,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == N*W); @@ -1228,7 +1228,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1294,7 +1294,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); lfs_size_t total_weight = 0; @@ -1377,7 +1377,7 @@ code = ''' lfsr_btree_pop(&lfs, &btree, 0) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 0); @@ -1394,7 +1394,7 @@ code = ''' LFSR_DATA_BUF("A", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -1433,7 +1433,7 @@ code = ''' lfsr_btree_pop(&lfs, &btree, 1) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -1456,7 +1456,7 @@ code = ''' LFSR_DATA_BUF("B", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 2); @@ -1501,7 +1501,7 @@ code = ''' lfsr_btree_pop(&lfs, &btree, 0) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -1524,7 +1524,7 @@ code = ''' LFSR_DATA_BUF("A", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 2); @@ -1571,7 +1571,7 @@ code = ''' lfsr_btree_pop(&lfs, &btree, 2) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 2); @@ -1600,7 +1600,7 @@ code = ''' LFSR_DATA_BUF("C", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 3); @@ -1654,7 +1654,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1667,7 +1667,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1676,7 +1676,7 @@ code = ''' printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == REMAINING); @@ -1746,7 +1746,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1759,7 +1759,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1767,7 +1767,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == REMAINING); @@ -1839,7 +1839,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1887,7 +1887,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == sim_size); @@ -1938,7 +1938,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1951,7 +1951,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -1959,7 +1959,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == REMAINING*W); @@ -2079,7 +2079,7 @@ code = ''' if (err == LFS_ERR_NOSPC) { printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); return; } @@ -2136,7 +2136,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); lfs_size_t total_weight = 0; @@ -2228,7 +2228,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == n); @@ -2318,7 +2318,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == sim_size); @@ -2377,7 +2377,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == n*W); @@ -2518,7 +2518,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); lfs_size_t total_weight = 0; @@ -2621,7 +2621,7 @@ code = ''' printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -2687,7 +2687,7 @@ code = ''' printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -2748,7 +2748,7 @@ code = ''' printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -2818,7 +2818,7 @@ code = ''' printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -2932,7 +2932,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == sim_size); @@ -3074,7 +3074,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); lfs_size_t total_weight = 0; @@ -3150,7 +3150,7 @@ code = ''' lfsr_btree_alloc(&lfs, &btree) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 0); @@ -3188,7 +3188,7 @@ code = ''' LFSR_ATTR(0, DATA, 0, BUF("0", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 1); @@ -3244,7 +3244,7 @@ code = ''' LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 2); @@ -3312,7 +3312,7 @@ code = ''' LFSR_TAG_DATA, 1, LFSR_DATA_BUF("2", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 3); @@ -3388,7 +3388,7 @@ code = ''' LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == 3); @@ -3478,7 +3478,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == n); @@ -3593,7 +3593,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == sim_size); @@ -3665,7 +3665,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == n*W); @@ -3808,7 +3808,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); lfs_size_t total_weight = 0; @@ -3991,7 +3991,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == sim_size); @@ -4193,7 +4193,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); lfs_size_t total_weight = 0; @@ -4264,7 +4264,7 @@ code = ''' } printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == n); @@ -4306,10 +4306,11 @@ code = ''' binfo.bid, binfo.tag, binfo.weight, - binfo.u.rbyd.block, binfo.u.rbyd.trunk); + binfo.u.rbyd.blocks[0], binfo.u.rbyd.trunk); // keep track of seen blocks - seen[binfo.u.rbyd.block / 8] |= 1 << (binfo.u.rbyd.block % 8); + seen[binfo.u.rbyd.blocks[0] / 8] + |= 1 << (binfo.u.rbyd.blocks[0] % 8); } else if (binfo.tag == LFSR_TAG_DATA) { printf("traversal: %d 0x%x w%d data %d\n", @@ -4417,7 +4418,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == sim_size); @@ -4458,10 +4459,11 @@ code = ''' binfo.bid, binfo.tag, binfo.weight, - binfo.u.rbyd.block, binfo.u.rbyd.trunk); + binfo.u.rbyd.blocks[0], binfo.u.rbyd.trunk); // keep track of seen blocks - seen[binfo.u.rbyd.block / 8] |= 1 << (binfo.u.rbyd.block % 8); + seen[binfo.u.rbyd.blocks[0] / 8] + |= 1 << (binfo.u.rbyd.blocks[0] % 8); } else if (binfo.tag == LFSR_TAG_DATA) { printf("traversal: %d 0x%x w%d data %d\n", @@ -4506,7 +4508,7 @@ code = ''' printf("]\n"); printf("btree: w%d 0x%x.%x\n", btree.weight, - btree.block, + btree.blocks[0], btree.trunk); assert(btree.weight == sim_size); diff --git a/tests/test_mtree.toml b/tests/test_mtree.toml index 54843fbd..b5356437 100644 --- a/tests/test_mtree.toml +++ b/tests/test_mtree.toml @@ -81,7 +81,7 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(i), 0, BUF(&alphas[i % 26], 1)))) => 0; @@ -178,13 +178,13 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -194,7 +194,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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -209,7 +209,7 @@ code = ''' // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -218,7 +218,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -251,24 +251,24 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; 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 mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); @@ -282,17 +282,17 @@ code = ''' // assert mdirs were unininlined and split assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); @@ -324,31 +324,31 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; // force mdir to compact - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -357,13 +357,13 @@ code = ''' // assert that our entries are still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); @@ -376,7 +376,7 @@ code = ''' // assert mdir was split correctly assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -385,13 +385,13 @@ code = ''' // assert that our entries are still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); @@ -425,8 +425,8 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { // force a compaction? if (FORCE_COMPACTION) { - mdir.u.rbyd.eoff = -1; - lfs.mroot.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -450,7 +450,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -476,7 +476,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -522,12 +522,12 @@ code = ''' lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // limit our mid to our mdir's weight mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1) - + (mdir.mid % (mdir.u.rbyd.weight+1)); + + (mdir.mid % (mdir.rbyd.weight+1)); // force a compaction? if (FORCE_COMPACTION) { - mdir.u.rbyd.eoff = -1; - lfs.mroot.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; } // add to rbyd, potentially splitting the mdir @@ -554,7 +554,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -584,7 +584,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -629,18 +629,18 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(0, RM, -1, NULL()))) => 0; @@ -648,7 +648,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -664,7 +664,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -698,21 +698,21 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); // force mdir to compact while we're removing - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(0, RM, -1, NULL()))) => 0; @@ -720,7 +720,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -736,7 +736,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -770,7 +770,7 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; // remove the entry as we compact, forcing the mdir to be dropped lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( @@ -779,7 +779,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -795,7 +795,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -829,7 +829,7 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; // remove the left entry as we compact, forcing the left // mdir to be dropped @@ -839,12 +839,12 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -859,11 +859,11 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that one entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -896,7 +896,7 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; // remove the right entry as we compact, forcing the right mdir // to be dropped @@ -906,12 +906,12 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -926,11 +926,11 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that one entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -963,7 +963,7 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; // remove both entries as we compact, forcing both mdirs to be dropped lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( @@ -973,7 +973,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); lfsr_unmount(&lfs) => 0; @@ -984,7 +984,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); lfsr_unmount(&lfs) => 0; ''' @@ -1013,25 +1013,25 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; // force mdir to compact - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; // remove the left entry as we compact, forcing the left // mdir to be dropped @@ -1042,7 +1042,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1051,7 +1051,7 @@ code = ''' // assert that one entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1066,7 +1066,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1075,7 +1075,7 @@ code = ''' // assert that one entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1108,25 +1108,25 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; // force mdir to compact - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; // remove the right entry as we compact, forcing the right // mdir to be dropped @@ -1136,7 +1136,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1145,7 +1145,7 @@ code = ''' // assert that one entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1160,7 +1160,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1169,7 +1169,7 @@ code = ''' // assert that one entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1202,25 +1202,25 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; // force mdir to compact - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; // remove both entries as we compact, forcing both mdirs to be dropped lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -1230,7 +1230,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1246,7 +1246,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -1301,12 +1301,12 @@ code = ''' 0*lfsr_mweight(&lfs)+0, &mdir) => 0; // drop should make sure we never have empty mdirs - assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0); + assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0); // force a compaction? if (FORCE_COMPACTION) { - mdir.u.rbyd.eoff = -1; - lfs.mroot.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -1322,7 +1322,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1348,7 +1348,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1410,7 +1410,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1428,12 +1428,12 @@ code = ''' 0*lfsr_mweight(&lfs)+0, &mdir) => 0; // drop should make sure we never have empty mdirs - assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0); + assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0); // force a compaction? if (FORCE_COMPACTION) { - mdir.u.rbyd.eoff = -1; - lfs.mroot.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -1449,7 +1449,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1476,7 +1476,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1521,18 +1521,18 @@ code = ''' lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // limit our mid to our mdir's weight mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1) - + (mdir.mid % (mdir.u.rbyd.weight+1)); + + (mdir.mid % (mdir.rbyd.weight+1)); // choose to create or delete, note we make sure to never delete to zero - uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) == mdir.u.rbyd.weight - || (lfsr_mdir_rid(&lfs, &mdir) == mdir.u.rbyd.weight-1 + uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) == mdir.rbyd.weight + || (lfsr_mdir_rid(&lfs, &mdir) == mdir.rbyd.weight-1 && lfsr_mtree_weight(&lfs) == lfsr_mweight(&lfs)) ? 0 : TEST_PRNG(&prng) % 2); // force a compaction? if (FORCE_COMPACTION) { - mdir.u.rbyd.eoff = -1; - lfs.mroot.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; } // create @@ -1571,9 +1571,9 @@ code = ''' lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs - assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0); + assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0); - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1605,9 +1605,9 @@ code = ''' lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs - assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0); + assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0); - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -1655,24 +1655,24 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mtree has one mdir assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_t old_mdir = mdir; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0; @@ -1687,7 +1687,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1702,7 +1702,7 @@ code = ''' // assert mtree has one mdir assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -1714,7 +1714,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -1749,24 +1749,24 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; 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 mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_t old_mdir = mdir; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0; @@ -1776,13 +1776,13 @@ code = ''' // assert that our entries are still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); @@ -1796,20 +1796,20 @@ code = ''' // assert mdirs were unininlined and split assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated 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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); @@ -1843,24 +1843,24 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; 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 mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_t old_mdir = mdir; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0; @@ -1870,13 +1870,13 @@ code = ''' // assert that our entries are still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); @@ -1890,20 +1890,20 @@ code = ''' // assert mdirs were unininlined and split assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated 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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); @@ -1935,9 +1935,9 @@ code = ''' // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; memset(buffer, 'b', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; @@ -1995,10 +1995,10 @@ code = ''' lfsr_mdir_t old_mroot = lfs.mroot; for (int i = 0; i < 4; i++) { - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; } - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; memset(buffer, 'b', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; @@ -2052,9 +2052,9 @@ code = ''' // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert we relocated @@ -2063,9 +2063,9 @@ code = ''' // force mroot to compact twice again, this should relocate the mroot old_mroot = lfs.mroot; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; memset(buffer, 'b', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; @@ -2122,29 +2122,29 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mtree has one mdir assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // setup mroot to need to compact, this should trigger a relocation when // we relocate the mdir below - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_t old_mroot = lfs.mroot; // force mdir to compact twice, this should relocate lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_t old_mdir = mdir; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, 0, BUF(buffer, SIZE)))) => 0; @@ -2162,7 +2162,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2177,7 +2177,7 @@ code = ''' // assert mtree has one mdir assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated our mdir assert(lfsr_mdir_cmp(&old_mdir, &mdir) != 0); @@ -2192,7 +2192,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2227,36 +2227,36 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // setup mroot to need to compact, this should trigger a relocation when // we relocate the mdir below - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_t old_mroot = lfs.mroot; // 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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; // force mdir to compact - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated our mroot assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2268,13 +2268,13 @@ code = ''' // assert that our entries are still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); @@ -2288,7 +2288,7 @@ code = ''' // assert mdir was split correctly assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated our mroot assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2300,13 +2300,13 @@ code = ''' // assert that our entries are still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); @@ -2340,23 +2340,23 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // setup mroot to need to compact, this should trigger a relocation when // we relocate the mdir below - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_t old_mroot = lfs.mroot; // remove the entry, forcing the mdir to be dropped lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, RM, -1, NULL()))) => 0; @@ -2364,7 +2364,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated our mroot assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2383,7 +2383,7 @@ code = ''' // assert mdir was dropped assert(lfsr_mtree_weight(&lfs) == 0*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated our mroot assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2413,7 +2413,7 @@ code = ''' // force mroot to compact once, so the second compact below will trigger // a relocation - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // prepare mroot with a large attr so the next entry can not fit @@ -2429,13 +2429,13 @@ code = ''' // force mroot to compact, this should trigger a relocation lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated our mroot assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2448,7 +2448,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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2463,7 +2463,7 @@ code = ''' // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated our mroot assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2475,7 +2475,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -2501,7 +2501,7 @@ code = ''' // force mroot to compact once, so the second compact below will trigger // a relocation - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // create 2 large entries that needs to be uninlined and split @@ -2516,13 +2516,13 @@ code = ''' // force mroot to compact, this should trigger a relocation lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; 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 mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated our mroot assert(lfsr_mdir_cmp(&old_mroot, &lfs.mroot) != 0); @@ -2530,13 +2530,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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); @@ -2550,20 +2550,20 @@ code = ''' // assert mdirs were unininlined and split assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert we relocated our mroot 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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); @@ -2604,18 +2604,18 @@ code = ''' lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // limit our mid to our mdir's weight mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1) - + (mdir.mid % (mdir.u.rbyd.weight+1)); + + (mdir.mid % (mdir.rbyd.weight+1)); // choose to create or delete, note we make sure to never delete to zero - uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) == mdir.u.rbyd.weight - || (lfsr_mdir_rid(&lfs, &mdir) == mdir.u.rbyd.weight-1 + uint8_t op = (lfsr_mdir_rid(&lfs, &mdir) == mdir.rbyd.weight + || (lfsr_mdir_rid(&lfs, &mdir) == mdir.rbyd.weight-1 && lfsr_mtree_weight(&lfs) == lfsr_mweight(&lfs)) ? 0 : TEST_PRNG(&prng) % 3); // force a compaction? if (FORCE_COMPACTION) { - mdir.u.rbyd.eoff = -1; - lfs.mroot.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; } // create @@ -2667,9 +2667,9 @@ code = ''' lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs - assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0); + assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0); - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2701,9 +2701,9 @@ code = ''' lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // drop should make sure we never have empty mdirs - assert(lfsr_mtree_ismptr(&lfs) || mdir.u.rbyd.weight > 0); + assert(lfsr_mtree_ismptr(&lfs) || mdir.rbyd.weight > 0); - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -2742,9 +2742,9 @@ code = ''' assert(lfsr_mtree_ismptr(&lfs)); lfsr_openedmdir_t left_neighbor = { - .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}}; lfsr_openedmdir_t right_neighbor = { - .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}}; lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -2753,7 +2753,7 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF("c", 1)))) => 0; // assert that our entry is still in the mtree - assert(lfs.mroot.u.rbyd.weight == 3); + assert(lfs.mroot.rbyd.weight == 3); uint8_t buffer[1]; lfsr_mdir_get(&lfs, &lfs.mroot, 1, LFSR_TAG_REG, @@ -2762,11 +2762,11 @@ code = ''' // assert that our neighbors were updated correctly assert(left_neighbor.mdir.mid == 0); - assert(memcmp(&left_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir, - sizeof(lfs.mroot.u.mdir)) == 0); + assert(memcmp(&left_neighbor.mdir.rbyd, &lfs.mroot.rbyd, + sizeof(lfs.mroot.rbyd)) == 0); assert(right_neighbor.mdir.mid == 2); - assert(memcmp(&right_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir, - sizeof(lfs.mroot.u.mdir)) == 0); + assert(memcmp(&right_neighbor.mdir.rbyd, &lfs.mroot.rbyd, + sizeof(lfs.mroot.rbyd)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -2792,9 +2792,9 @@ code = ''' assert(lfsr_mtree_ismptr(&lfs)); lfsr_openedmdir_t left_neighbor = { - .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}}; lfsr_openedmdir_t right_neighbor = { - .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}}; lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -2803,13 +2803,13 @@ code = ''' LFSR_ATTR(0, RM, -1, NULL()))) => 0; // assert that an entry was removed - assert(lfs.mroot.u.rbyd.weight == 1); + assert(lfs.mroot.rbyd.weight == 1); // assert that our neighbors were updated correctly assert(left_neighbor.mdir.mid == -1); assert(right_neighbor.mdir.mid == 0); - assert(memcmp(&right_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir, - sizeof(lfs.mroot.u.mdir)) == 0); + assert(memcmp(&right_neighbor.mdir.rbyd, &lfs.mroot.rbyd, + sizeof(lfs.mroot.rbyd)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -2835,9 +2835,9 @@ code = ''' assert(lfsr_mtree_ismptr(&lfs)); lfsr_openedmdir_t left_neighbor = { - .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}}; lfsr_openedmdir_t right_neighbor = { - .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}}; lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -2846,12 +2846,12 @@ code = ''' LFSR_ATTR(1, RM, -1, NULL()))) => 0; // assert that an entry was removed - assert(lfs.mroot.u.rbyd.weight == 1); + assert(lfs.mroot.rbyd.weight == 1); // assert that our neighbors were updated correctly assert(left_neighbor.mdir.mid == 0); - assert(memcmp(&left_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir, - sizeof(lfs.mroot.u.mdir)) == 0); + assert(memcmp(&left_neighbor.mdir.rbyd, &lfs.mroot.rbyd, + sizeof(lfs.mroot.rbyd)) == 0); assert(right_neighbor.mdir.mid == -1); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); @@ -2880,9 +2880,9 @@ code = ''' assert(lfsr_mtree_ismptr(&lfs)); lfsr_openedmdir_t left_neighbor = { - .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}}; lfsr_openedmdir_t right_neighbor = { - .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}}; lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -2898,13 +2898,13 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -2914,7 +2914,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; - assert(mdir.u.rbyd.weight == 2); + assert(mdir.rbyd.weight == 2); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "d", 1) == 0); @@ -2924,15 +2924,15 @@ code = ''' lfsr_mdir_t msibling; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; - assert(msibling.u.rbyd.weight == 1); + assert(msibling.rbyd.weight == 1); // assert that our neighbors were updated correctly assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); - assert(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir, - sizeof(mdir.u.mdir)) == 0); + assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd, + sizeof(mdir.rbyd)) == 0); assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+0); - assert(memcmp(&right_neighbor.mdir.u.mdir, &msibling.u.mdir, - sizeof(msibling.u.mdir)) == 0); + assert(memcmp(&right_neighbor.mdir.rbyd, &msibling.rbyd, + sizeof(msibling.rbyd)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -2960,9 +2960,9 @@ code = ''' assert(lfsr_mtree_ismptr(&lfs)); lfsr_openedmdir_t left_neighbor = { - .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}}; lfsr_openedmdir_t right_neighbor = { - .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}}; lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -2977,18 +2977,18 @@ code = ''' LFSR_ATTR(2, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; 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 mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 2); + assert(mdir.rbyd.weight == 2); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "c", 1) == 0); @@ -2996,18 +2996,18 @@ code = ''' lfsr_mdir_t msibling; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; - assert(msibling.u.rbyd.weight == 2); + assert(msibling.rbyd.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(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir, - sizeof(mdir.u.mdir)) == 0); + assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd, + sizeof(mdir.rbyd)) == 0); assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+1); - assert(memcmp(&right_neighbor.mdir.u.mdir, &msibling.u.mdir, - sizeof(msibling.u.mdir)) == 0); + assert(memcmp(&right_neighbor.mdir.rbyd, &msibling.rbyd, + sizeof(msibling.rbyd)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -3038,13 +3038,13 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // setup our neighbors // @@ -3052,19 +3052,19 @@ code = ''' // 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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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(mdir.u.rbyd.weight == 3); + assert(mdir.rbyd.weight == 3); lfsr_openedmdir_t left_neighbor = { - .mdir={.mid=mdir.mid+0, .u.mdir=mdir.u.mdir}}; + .mdir={.mid=mdir.mid+0, .rbyd=mdir.rbyd}}; lfsr_openedmdir_t right_neighbor = { - .mdir={.mid=mdir.mid+2, .u.mdir=mdir.u.mdir}}; + .mdir={.mid=mdir.mid+2, .rbyd=mdir.rbyd}}; lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -3075,13 +3075,13 @@ code = ''' LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; // force mdir to compact - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // assert mdir was split correctly assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot still has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -3090,7 +3090,7 @@ code = ''' // assert that our entries are still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; - assert(mdir.u.rbyd.weight == 2); + assert(mdir.rbyd.weight == 2); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "d", 1) == 0); @@ -3098,18 +3098,18 @@ code = ''' lfsr_mdir_t msibling; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; - assert(msibling.u.rbyd.weight == 2); + assert(msibling.rbyd.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(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir, - sizeof(mdir.u.mdir)) == 0); + assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd, + sizeof(mdir.rbyd)) == 0); assert(right_neighbor.mdir.mid == 1*lfsr_mweight(&lfs)+1); - assert(memcmp(&right_neighbor.mdir.u.mdir, &msibling.u.mdir, - sizeof(msibling.u.mdir)) == 0); + assert(memcmp(&right_neighbor.mdir.rbyd, &msibling.rbyd, + sizeof(msibling.rbyd)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -3139,9 +3139,9 @@ code = ''' assert(lfsr_mtree_ismptr(&lfs)); lfsr_openedmdir_t left_neighbor = { - .mdir={.mid=0, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=0, .rbyd=lfs.mroot.rbyd}}; lfsr_openedmdir_t right_neighbor = { - .mdir={.mid=1, .u.mdir=lfs.mroot.u.mdir}}; + .mdir={.mid=1, .rbyd=lfs.mroot.rbyd}}; lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -3154,9 +3154,9 @@ code = ''' // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; memset(buffer, 'b', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; @@ -3171,11 +3171,11 @@ code = ''' // assert that our neighbors were updated correctly assert(left_neighbor.mdir.mid == 0); - assert(memcmp(&left_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir, - sizeof(lfs.mroot.u.mdir)) == 0); + assert(memcmp(&left_neighbor.mdir.rbyd, &lfs.mroot.rbyd, + sizeof(lfs.mroot.rbyd)) == 0); assert(right_neighbor.mdir.mid == 1); - assert(memcmp(&right_neighbor.mdir.u.mdir, &lfs.mroot.u.mdir, - sizeof(lfs.mroot.u.mdir)) == 0); + assert(memcmp(&right_neighbor.mdir.rbyd, &lfs.mroot.rbyd, + sizeof(lfs.mroot.rbyd)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -3208,13 +3208,13 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // setup our neighbors // @@ -3222,28 +3222,28 @@ code = ''' // 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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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(mdir.u.rbyd.weight == 3); + assert(mdir.rbyd.weight == 3); lfsr_openedmdir_t left_neighbor = { - .mdir={.mid=mdir.mid+0, .u.mdir=mdir.u.mdir}}; + .mdir={.mid=mdir.mid+0, .rbyd=mdir.rbyd}}; lfsr_openedmdir_t right_neighbor = { - .mdir={.mid=mdir.mid+2, .u.mdir=mdir.u.mdir}}; + .mdir={.mid=mdir.mid+2, .rbyd=mdir.rbyd}}; lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); // force mdir to compact twice, this should relocate lfsr_mdir_t old_mdir = mdir; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; memset(buffer, 'e', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(1, REG, 0, BUF(buffer, SIZE)))) => 0; @@ -3258,7 +3258,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+1, &mdir) => 0; - assert(mdir.u.rbyd.weight == 3); + assert(mdir.rbyd.weight == 3); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3266,11 +3266,11 @@ code = ''' // assert that our neighbors were updated correctly assert(left_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+0); - assert(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir, - sizeof(mdir.u.mdir)) == 0); + assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd, + sizeof(mdir.rbyd)) == 0); assert(right_neighbor.mdir.mid == 0*lfsr_mweight(&lfs)+2); - assert(memcmp(&right_neighbor.mdir.u.mdir, &mdir.u.mdir, - sizeof(mdir.u.mdir)) == 0); + assert(memcmp(&right_neighbor.mdir.rbyd, &mdir.rbyd, + sizeof(mdir.rbyd)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -3304,7 +3304,7 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // we should now have 2 mdirs @@ -3313,13 +3313,13 @@ code = ''' // now force one of our siblings to split lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; // force mdir to compact - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 3 mdirs @@ -3332,25 +3332,25 @@ code = ''' lfsr_openedmdir_t left_neighbor; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &left_neighbor.mdir) => 0; - assert(left_neighbor.mdir.u.rbyd.weight == 1); + assert(left_neighbor.mdir.rbyd.weight == 1); lfsr_openedmdir_t right_neighbor; lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &right_neighbor.mdir) => 0; - assert(right_neighbor.mdir.u.rbyd.weight == 1); + assert(right_neighbor.mdir.rbyd.weight == 1); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); // cause middle mdir to split lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); memset(buffer, 'd', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; // force mdir to compact - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 4 mdirs @@ -3359,13 +3359,13 @@ code = ''' // 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(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir, - sizeof(mdir.u.mdir)) == 0); + assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd, + sizeof(mdir.rbyd)) == 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.mdir, &mdir.u.mdir, - sizeof(mdir.u.mdir)) == 0); + assert(memcmp(&right_neighbor.mdir.rbyd, &mdir.rbyd, + sizeof(mdir.rbyd)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -3399,7 +3399,7 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // we should now have 2 mdirs @@ -3408,13 +3408,13 @@ code = ''' // now force one of our siblings to split lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+1, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); memset(buffer, 'c', SIZE); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, REG, +1, BUF(buffer, SIZE)))) => 0; // force mdir to compact - mdir.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &mdir, NULL, 0) => 0; // we should now have 3 mdirs @@ -3427,19 +3427,19 @@ code = ''' lfsr_openedmdir_t left_neighbor; lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &left_neighbor.mdir) => 0; - assert(left_neighbor.mdir.u.rbyd.weight == 1); + assert(left_neighbor.mdir.rbyd.weight == 1); lfsr_openedmdir_t right_neighbor; lfsr_mtree_lookup(&lfs, 2*lfsr_mweight(&lfs)+0, &right_neighbor.mdir) => 0; - assert(right_neighbor.mdir.u.rbyd.weight == 1); + assert(right_neighbor.mdir.rbyd.weight == 1); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_addopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); // cause middle mdir to drop lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( LFSR_ATTR(mdir.mid, RM, -1, NULL()))) => 0; @@ -3449,13 +3449,13 @@ code = ''' // 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(memcmp(&left_neighbor.mdir.u.mdir, &mdir.u.mdir, - sizeof(mdir.u.mdir)) == 0); + assert(memcmp(&left_neighbor.mdir.rbyd, &mdir.rbyd, + sizeof(mdir.rbyd)) == 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.mdir, &mdir.u.mdir, - sizeof(mdir.u.mdir)) == 0); + assert(memcmp(&right_neighbor.mdir.rbyd, &mdir.rbyd, + sizeof(mdir.rbyd)) == 0); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &left_neighbor); lfsr_mdir_removeopened(&lfs, LFS_TYPE_INTERNAL, &right_neighbor); @@ -3483,7 +3483,7 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF("a", 1)))) => 0; // assert that our entry is still in the mtree - assert(lfs.mroot.u.rbyd.weight == 1); + assert(lfs.mroot.rbyd.weight == 1); uint8_t buffer[1]; lfsr_mdir_get(&lfs, &lfs.mroot, 0, LFSR_TAG_REG, @@ -3510,22 +3510,23 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); // keep track of seen blocks - seen[tinfo.u.mdir.u.mdir.blocks[1] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8); - seen[tinfo.u.mdir.u.mdir.blocks[0] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8); + seen[tinfo.u.mdir.rbyd.blocks[1] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8); + seen[tinfo.u.mdir.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); // keep track of seen blocks - seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8); + seen[tinfo.u.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.rbyd.blocks[0] % 8); } else { // this shouldn't happen @@ -3548,7 +3549,7 @@ code = ''' // and the tree should still work // assert that our entry is still in the mtree - assert(lfs.mroot.u.rbyd.weight == 1); + assert(lfs.mroot.rbyd.weight == 1); lfsr_mdir_get(&lfs, &lfs.mroot, 0, LFSR_TAG_REG, buffer, 1) => 1; @@ -3583,13 +3584,13 @@ code = ''' LFSR_ATTR(0, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -3599,7 +3600,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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3625,22 +3626,23 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); // keep track of seen blocks - seen[tinfo.u.mdir.u.mdir.blocks[1] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8); - seen[tinfo.u.mdir.u.mdir.blocks[0] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8); + seen[tinfo.u.mdir.rbyd.blocks[1] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8); + seen[tinfo.u.mdir.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); // keep track of seen blocks - seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8); + seen[tinfo.u.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.rbyd.blocks[0] % 8); } else { // this shouldn't happen @@ -3665,7 +3667,7 @@ code = ''' // assert mdir was unininlined correctly assert(lfsr_mtree_weight(&lfs) == 1*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our attr is still in the mroot lfsr_mdir_get(&lfs, &lfs.mroot, -1, LFSR_TAG_UATTR(1), @@ -3674,7 +3676,7 @@ code = ''' // assert that our entry is still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; @@ -3708,18 +3710,18 @@ code = ''' LFSR_ATTR(1, REG, +1, BUF(buffer, SIZE)))) => 0; // force mroot to compact - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; 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 mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.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; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.weight == 1); lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "a", 1) == 0); @@ -3727,7 +3729,7 @@ code = ''' lfsr_mdir_t msibling; lfsr_mtree_lookup(&lfs, 1*lfsr_mweight(&lfs)+0, &msibling) => 0; - assert(msibling.u.rbyd.weight == 1); + assert(msibling.rbyd.weight == 1); lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); @@ -3752,22 +3754,23 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); // keep track of seen blocks - seen[tinfo.u.mdir.u.mdir.blocks[1] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8); - seen[tinfo.u.mdir.u.mdir.blocks[0] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8); + seen[tinfo.u.mdir.rbyd.blocks[1] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8); + seen[tinfo.u.mdir.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); // keep track of seen blocks - seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8); + seen[tinfo.u.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.rbyd.blocks[0] % 8); } else { // this shouldn't happen @@ -3792,18 +3795,18 @@ code = ''' // assert mdirs were unininlined and split assert(lfsr_mtree_weight(&lfs) == 2*lfsr_mweight(&lfs)); // assert mroot now has no entries - assert(lfs.mroot.u.rbyd.weight == 0); + assert(lfs.mroot.rbyd.weight == 0); // assert that our entries are still in the mtree lfsr_mtree_lookup(&lfs, 0*lfsr_mweight(&lfs)+0, &mdir) => 0; - assert(mdir.u.rbyd.weight == 1); + assert(mdir.rbyd.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; - assert(msibling.u.rbyd.weight == 1); + assert(msibling.rbyd.weight == 1); lfsr_mdir_get(&lfs, &msibling, msibling.mid, LFSR_TAG_REG, buffer, SIZE) => SIZE; assert(memcmp(buffer, "b", 1) == 0); @@ -3836,9 +3839,9 @@ code = ''' // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; memset(buffer, 'b', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; @@ -3871,22 +3874,23 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); // keep track of seen blocks - seen[tinfo.u.mdir.u.mdir.blocks[1] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8); - seen[tinfo.u.mdir.u.mdir.blocks[0] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8); + seen[tinfo.u.mdir.rbyd.blocks[1] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8); + seen[tinfo.u.mdir.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); // keep track of seen blocks - seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8); + seen[tinfo.u.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.rbyd.blocks[0] % 8); } else { // this shouldn't happen @@ -3945,8 +3949,8 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { // force a compaction? if (FORCE_COMPACTION) { - mdir.u.rbyd.eoff = -1; - lfs.mroot.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; } lfsr_mdir_commit(&lfs, &mdir, LFSR_ATTRS( @@ -3970,7 +3974,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -4001,22 +4005,23 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); // keep track of seen blocks - seen[tinfo.u.mdir.u.mdir.blocks[1] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8); - seen[tinfo.u.mdir.u.mdir.blocks[0] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8); + seen[tinfo.u.mdir.rbyd.blocks[1] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8); + seen[tinfo.u.mdir.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); // keep track of seen blocks - seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8); + seen[tinfo.u.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.rbyd.blocks[0] % 8); } else { // this shouldn't happen @@ -4047,7 +4052,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -4093,12 +4098,12 @@ code = ''' lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; // limit our mid to our mdir's weight mdir.mid = lfsr_mdir_bid(&lfs, &mdir)-(lfsr_mweight(&lfs)-1) - + (mdir.mid % (mdir.u.rbyd.weight+1)); + + (mdir.mid % (mdir.rbyd.weight+1)); // force a compaction? if (FORCE_COMPACTION) { - mdir.u.rbyd.eoff = -1; - lfs.mroot.u.rbyd.eoff = -1; + mdir.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; } // add to rbyd, potentially splitting the mdir @@ -4125,7 +4130,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -4160,22 +4165,23 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); // keep track of seen blocks - seen[tinfo.u.mdir.u.mdir.blocks[1] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[1] % 8); - seen[tinfo.u.mdir.u.mdir.blocks[0] / 8] - |= 1 << (tinfo.u.mdir.u.mdir.blocks[0] % 8); + seen[tinfo.u.mdir.rbyd.blocks[1] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[1] % 8); + seen[tinfo.u.mdir.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.mdir.rbyd.blocks[0] % 8); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); // keep track of seen blocks - seen[tinfo.u.rbyd.block / 8] |= 1 << (tinfo.u.rbyd.block % 8); + seen[tinfo.u.rbyd.blocks[0] / 8] + |= 1 << (tinfo.u.rbyd.blocks[0] % 8); } else { // this shouldn't happen @@ -4207,7 +4213,7 @@ code = ''' mid += lfsr_mweight(&lfs)) { lfsr_mdir_t mdir; lfsr_mtree_lookup(&lfs, mid, &mdir) => 0; - for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.u.rbyd.weight; + for (; lfsr_mdir_rid(&lfs, &mdir) < mdir.rbyd.weight; mdir.mid += 1) { uint8_t buffer[4]; lfsr_mdir_get(&lfs, &mdir, mdir.mid, LFSR_TAG_REG, @@ -4257,13 +4263,13 @@ code = ''' if (tinfo.tag == LFSR_TAG_MDIR) { printf("traversal: 0x%x mdir 0x{%x,%x}\n", tinfo.tag, - tinfo.u.mdir.u.mdir.blocks[0], - tinfo.u.mdir.u.mdir.blocks[1]); + tinfo.u.mdir.rbyd.blocks[0], + tinfo.u.mdir.rbyd.blocks[1]); } else if (tinfo.tag == LFSR_TAG_BRANCH) { printf("traversal: 0x%x btree 0x%x.%x\n", tinfo.tag, - tinfo.u.rbyd.block, tinfo.u.rbyd.trunk); + tinfo.u.rbyd.blocks[0], tinfo.u.rbyd.trunk); } else { // this shouldn't happen @@ -4319,9 +4325,9 @@ code = ''' // force mroot to compact twice, this should extend the mroot lfsr_mdir_t old_mroot = lfs.mroot; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; memset(buffer, 'b', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; @@ -4374,10 +4380,10 @@ code = ''' lfsr_mdir_t old_mroot = lfs.mroot; for (int i = 0; i < 4; i++) { - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; lfsr_mdir_commit(&lfs, &lfs.mroot, NULL, 0) => 0; } - lfs.mroot.u.rbyd.eoff = -1; + lfs.mroot.rbyd.eoff = -1; memset(buffer, 'b', SIZE); lfsr_mdir_commit(&lfs, &lfs.mroot, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF(buffer, SIZE)))) => 0; diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 8c3fa8a3..47b6c14a 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -36,7 +36,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -46,18 +46,18 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' [cases.test_rbyd_multi_commit] @@ -67,7 +67,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -77,19 +77,19 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' [cases.test_rbyd_commit_fetch_commit] @@ -99,7 +99,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -109,15 +109,15 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with the second attribute lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' # [cases.test_rbyd_fetchmatch] @@ -132,7 +132,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -145,7 +145,7 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -157,7 +157,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -168,7 +168,7 @@ code = ''' // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -186,7 +186,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -202,7 +202,7 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -220,7 +220,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -242,7 +242,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -255,7 +255,7 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -267,7 +267,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -278,7 +278,7 @@ code = ''' // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -297,7 +297,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -313,7 +313,7 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -332,7 +332,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -354,7 +354,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -365,7 +365,7 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -375,7 +375,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -384,7 +384,7 @@ code = ''' // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -396,7 +396,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) => 4; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) @@ -406,7 +406,7 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -417,7 +417,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) => 4; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) @@ -433,7 +433,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -444,7 +444,7 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -454,7 +454,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -463,7 +463,7 @@ code = ''' // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -476,7 +476,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) => 4; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) @@ -486,7 +486,7 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -498,7 +498,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) => 4; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) @@ -514,7 +514,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -530,12 +530,12 @@ code = ''' // => .-'| // 1 1 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -552,12 +552,12 @@ code = ''' // => .-'| // 2 2 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -577,7 +577,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -593,13 +593,13 @@ code = ''' // .-'| => .----'| // 1 2 1 2 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -616,13 +616,13 @@ code = ''' // .-'| => .-'| // 1 2 1 2 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -642,7 +642,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -660,13 +660,13 @@ code = ''' // .-'| | .-'| // 1 2 1 2 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -690,13 +690,13 @@ code = ''' // .-'| .--|-'| // 2 3 2 3 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -721,7 +721,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -739,14 +739,14 @@ code = ''' // | .-'| | .----'| // 1 2 3 1 2 3 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -770,14 +770,14 @@ code = ''' // | .-'| | .-'| // 1 2 3 1 2 3 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -801,14 +801,14 @@ code = ''' // | .-'| .--|-'| // 1 2 3 1 2 3 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -832,14 +832,14 @@ code = ''' // .--|-'| | .-'| // 3 1 2 3 1 2 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -864,7 +864,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -884,14 +884,14 @@ code = ''' // | .-'| | | .-'| // 1 2 3 1 2 3 4 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -922,14 +922,14 @@ code = ''' // | .-'| | .--|-'| .--|--|-'| // 1 3 4 1 3 4 2 1 3 4 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -960,14 +960,14 @@ code = ''' // | .-'| .--|--|-'| // 2 3 4 2 3 4 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -998,14 +998,14 @@ code = ''' // .--|-'| | .--|-'| // 4 2 3 4 2 3 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1035,7 +1035,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -1055,14 +1055,14 @@ code = ''' // | .-'| | | .-'| // 1 2 3 1 2 3 4 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1093,14 +1093,14 @@ code = ''' // | .-'| | | .-'| // 1 2 4 1 2 4 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1131,14 +1131,14 @@ code = ''' // | .-'| | | .-'| | .--|-'| // 1 4 2 1 4 2 3 1 4 2 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1169,14 +1169,14 @@ code = ''' // | .-'| | | .-'| .--|--|-'| // 4 1 2 4 1 2 3 4 1 2 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1206,7 +1206,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -1228,7 +1228,7 @@ code = ''' // | | .-'| | | .----'| // 1 2 3 4 1 2 3 4 4 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1236,7 +1236,7 @@ code = ''' LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1269,7 +1269,7 @@ code = ''' // | | .-'| | | .-'| // 1 2 3 4 1 2 3 4 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1277,7 +1277,7 @@ code = ''' LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1308,7 +1308,7 @@ code = ''' // | | .-'| | .-'| | // 1 2 3 4 1 2 3 4 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1316,7 +1316,7 @@ code = ''' LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1347,7 +1347,7 @@ code = ''' // | | .-'| | .-'| | // 1 2 3 4 1 2 3 4 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1355,7 +1355,7 @@ code = ''' LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1385,7 +1385,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -1409,7 +1409,7 @@ code = ''' // | | .-'| | | | .-'| // 1 2 3 4 1 2 3 4 5 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1417,7 +1417,7 @@ code = ''' LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1457,7 +1457,7 @@ code = ''' // | | .-'| | | .--|-'| // 1 2 4 5 1 2 4 5 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1465,7 +1465,7 @@ code = ''' LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1503,7 +1503,7 @@ code = ''' // | | .-'| | | .-'| | // 1 3 4 5 1 3 4 5 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -1511,7 +1511,7 @@ code = ''' LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1549,7 +1549,7 @@ code = ''' // | | .-'| | | .-'| | // 2 3 4 5 2 3 4 5 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -1557,7 +1557,7 @@ code = ''' LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1592,7 +1592,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -1616,7 +1616,7 @@ code = ''' // | | | .-'| | | | .----'| // 1 2 3 4 5 1 2 3 4 5 5 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1625,7 +1625,7 @@ code = ''' LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1665,7 +1665,7 @@ code = ''' // | | | .-'| | | .-'| | // 1 2 3 4 5 1 2 3 4 5 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1674,7 +1674,7 @@ code = ''' LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1714,7 +1714,7 @@ code = ''' // | | | .-'| | | .-'| | // 1 2 3 4 5 1 2 3 4 5 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1723,7 +1723,7 @@ code = ''' LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1758,7 +1758,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -1784,7 +1784,7 @@ code = ''' // | | | .-'| | | | | .-'| // 1 2 3 4 5 1 2 3 4 5 6 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1793,7 +1793,7 @@ code = ''' LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), LFSR_ATTR(-1, UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1838,7 +1838,7 @@ code = ''' // | | | .-'| | | | .-'| | // 1 3 4 5 6 1 3 4 5 6 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -1847,7 +1847,7 @@ code = ''' LFSR_ATTR(-1, UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1892,7 +1892,7 @@ code = ''' // | | | .-'| | | | .-'| | // 2 3 4 5 6 2 3 4 5 6 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -1901,7 +1901,7 @@ code = ''' LFSR_ATTR(-1, UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -1945,7 +1945,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -1988,10 +1988,10 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), &rid_, &tag_, NULL, &data_) => 0; @@ -2035,7 +2035,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2071,14 +2071,14 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(perm[j]+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), &rid_, &tag_, NULL, &data_) => 0; @@ -2116,7 +2116,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2131,7 +2131,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -2149,7 +2149,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -2165,7 +2165,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -2183,7 +2183,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -2205,7 +2205,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2220,7 +2220,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -2239,7 +2239,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -2255,7 +2255,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -2274,7 +2274,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -2300,7 +2300,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2339,10 +2339,10 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // try traversing all tags tag_ = 0; rid_ = -1; @@ -2371,7 +2371,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2404,14 +2404,14 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(perm[j]+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // try traversing all tags tag_ = 0; rid_ = -1; @@ -2442,7 +2442,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2459,7 +2459,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -2470,7 +2470,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -2493,9 +2493,9 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // update each tag in permutation order @@ -2506,7 +2506,7 @@ code = ''' } // check that all tags have been updated - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), &rid_, &tag_, NULL, &data_) => 0; @@ -2552,7 +2552,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2565,7 +2565,7 @@ code = ''' // create the rbyd tree rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; // keep appending tags until we run out of space // @@ -2590,7 +2590,7 @@ code = ''' // check that we can still lookup all the tags prng = 42; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (lfs_size_t i = 0; i < count; i++) { lfs_size_t x = (ORDER == 0) ? i @@ -2614,7 +2614,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2627,7 +2627,7 @@ code = ''' // add and remove one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -2638,7 +2638,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), @@ -2646,7 +2646,7 @@ code = ''' // commit with two attributes, remove the first one rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -2666,7 +2666,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -2682,7 +2682,7 @@ code = ''' // commit with two attributes, remove the second one rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -2699,7 +2699,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -2726,7 +2726,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2762,7 +2762,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(perm[j]+1), 0, @@ -2773,7 +2773,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -2781,16 +2781,16 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RM(UATTR(j+1)), 0, NULL()))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { int err = lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(k+1), @@ -2818,7 +2818,7 @@ code = ''' LFSR_ATTR(-1, UATTR(j+1), 0, BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(k+1), @@ -2875,7 +2875,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2907,7 +2907,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(perm[j]+1), 0, @@ -2918,7 +2918,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -2926,16 +2926,16 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, RM(UATTR(j+1)), 0, NULL()))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; tag_ = 0; rid_ = -1; @@ -2969,7 +2969,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -2982,7 +2982,7 @@ code = ''' // create a tree two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; @@ -3086,7 +3086,7 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3118,7 +3118,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -3131,7 +3131,7 @@ code = ''' // create a tree rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -3321,7 +3321,7 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3353,7 +3353,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -3366,7 +3366,7 @@ code = ''' // commit with one attribute, remove it rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -3377,7 +3377,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), @@ -3385,7 +3385,7 @@ code = ''' // commit with two attributes, remove both rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -3398,7 +3398,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), @@ -3406,7 +3406,7 @@ code = ''' // commit with two attributes, remove both in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -3419,7 +3419,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), @@ -3441,7 +3441,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -3458,7 +3458,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -3469,7 +3469,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -3492,9 +3492,9 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // remove each tag in permutation order @@ -3504,7 +3504,7 @@ code = ''' } // check that all tags are now removed - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(j+1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3515,7 +3515,7 @@ code = ''' LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); @@ -3564,7 +3564,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -3597,7 +3597,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; prng = SEED; for (unsigned i = 0; i < N; i++) { @@ -3673,7 +3673,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -3684,7 +3684,7 @@ code = ''' // try to create one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -3692,14 +3692,14 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); // try to create two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -3710,7 +3710,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3719,7 +3719,7 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -3730,7 +3730,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3739,7 +3739,7 @@ code = ''' // create a third to the right rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -3753,7 +3753,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3764,7 +3764,7 @@ code = ''' // create a third to the left rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -3778,7 +3778,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3789,7 +3789,7 @@ code = ''' // create a third in the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -3803,7 +3803,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3820,7 +3820,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -3831,7 +3831,7 @@ code = ''' // try to create one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -3840,7 +3840,7 @@ code = ''' => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -3848,7 +3848,7 @@ code = ''' // try to create two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -3860,7 +3860,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3869,7 +3869,7 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -3881,7 +3881,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3890,7 +3890,7 @@ code = ''' // create a third to the right rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -3906,7 +3906,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3917,7 +3917,7 @@ code = ''' // create a third to the left rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -3933,7 +3933,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3944,7 +3944,7 @@ code = ''' // create a third in the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -3960,7 +3960,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -3981,7 +3981,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -4037,10 +4037,10 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4; @@ -4082,7 +4082,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -4124,7 +4124,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -4138,7 +4138,7 @@ code = ''' LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, @@ -4175,7 +4175,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -4191,7 +4191,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -4213,7 +4213,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -4233,7 +4233,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -4255,7 +4255,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -4281,7 +4281,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -4297,7 +4297,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -4320,7 +4320,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -4340,7 +4340,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -4363,7 +4363,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -4393,7 +4393,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -4448,10 +4448,10 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); // try traversing all tags tag_ = 0; @@ -4484,7 +4484,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -4525,7 +4525,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -4539,7 +4539,7 @@ code = ''' LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); // try traversing all tags tag_ = 0; @@ -4571,7 +4571,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -4589,7 +4589,7 @@ code = ''' // create the rbyd tree rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; // keep inserting tags until we run out of space // @@ -4619,7 +4619,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t rid_; lfsr_data_t data_; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_REG, &rid_, &tag_, NULL, &data_) => 0; @@ -4639,7 +4639,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -4650,7 +4650,7 @@ code = ''' // try to create one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; @@ -4661,7 +4661,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4670,7 +4670,7 @@ code = ''' // try to create two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -4687,7 +4687,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4700,7 +4700,7 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb", 2)), @@ -4717,7 +4717,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4730,7 +4730,7 @@ code = ''' // create a third to the right rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -4747,7 +4747,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4770,7 +4770,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4787,7 +4787,7 @@ code = ''' // create a third to the left rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb", 2)), @@ -4810,7 +4810,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4827,7 +4827,7 @@ code = ''' // create a third in the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -4850,7 +4850,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4873,7 +4873,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -4884,7 +4884,7 @@ code = ''' // try to create one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -4896,7 +4896,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4905,7 +4905,7 @@ code = ''' // try to create two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -4925,7 +4925,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4938,7 +4938,7 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -4958,7 +4958,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -4971,7 +4971,7 @@ code = ''' // create a third to the right rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -4993,7 +4993,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -5016,7 +5016,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -5033,7 +5033,7 @@ code = ''' // create a third to the left rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -5061,7 +5061,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -5078,7 +5078,7 @@ code = ''' // create a third in the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -5106,7 +5106,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -5134,7 +5134,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -5196,10 +5196,10 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, attrs, (1+M)*N) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4; @@ -5248,7 +5248,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -5290,7 +5290,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -5310,7 +5310,7 @@ code = ''' } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4; @@ -5352,7 +5352,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -5368,7 +5368,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -5406,7 +5406,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -5440,7 +5440,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb", 2)), @@ -5478,7 +5478,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -5518,7 +5518,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -5534,7 +5534,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -5575,7 +5575,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -5609,7 +5609,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -5650,7 +5650,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -5695,7 +5695,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -5756,10 +5756,10 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, attrs, (1+M)*N) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); // try traversing all tags @@ -5805,7 +5805,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -5846,7 +5846,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -5866,7 +5866,7 @@ code = ''' } } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); // try traversing all tags @@ -5914,7 +5914,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -5937,7 +5937,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -5953,7 +5953,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N*M); @@ -5976,9 +5976,9 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // update each tag in permutation order @@ -5989,7 +5989,7 @@ code = ''' } // check that all tags have been updated - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); @@ -6042,7 +6042,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -6087,7 +6087,7 @@ code = ''' // create given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -6111,7 +6111,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N*M; j++) { @@ -6119,15 +6119,15 @@ code = ''' printf("--- remove: rid%jd, %jd ---\n", j/M, (j%M)+1); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j/M, RM(UATTR((j%M)+1)), 0, NULL()))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -6168,7 +6168,7 @@ code = ''' LFSR_ATTR(j/M, UATTR((j%M)+1), 0, BUF(names[(j/M)%6], 3)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -6237,7 +6237,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -6260,7 +6260,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -6276,7 +6276,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N*M); @@ -6299,9 +6299,9 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // remove each tag in permutation order @@ -6312,7 +6312,7 @@ code = ''' } // check that all tags have been removed - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); @@ -6361,7 +6361,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -6379,7 +6379,7 @@ code = ''' // create the rbyd tree rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; // keep inserting tags until we run out of space // @@ -6416,7 +6416,7 @@ code = ''' lfsr_tag_t tag_; lfs_ssize_t rid_; lfsr_data_t data_; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, x, LFSR_TAG_REG, &rid_, &tag_, NULL, &data_) => 0; @@ -6450,7 +6450,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -6492,7 +6492,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -6513,7 +6513,7 @@ code = ''' } // try looking up each tag - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, @@ -6589,7 +6589,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -6631,7 +6631,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -6657,7 +6657,7 @@ code = ''' } // try looking up each tag - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, @@ -6745,7 +6745,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -6756,7 +6756,7 @@ code = ''' // try to delete one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -6768,7 +6768,7 @@ code = ''' assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); @@ -6776,7 +6776,7 @@ code = ''' // try to delete the other rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -6788,7 +6788,7 @@ code = ''' assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); @@ -6796,7 +6796,7 @@ code = ''' // try to delete the largest of three rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -6819,7 +6819,7 @@ code = ''' // try to delete the smallest of three rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -6842,7 +6842,7 @@ code = ''' // try to delete the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -6871,7 +6871,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -6882,7 +6882,7 @@ code = ''' // try to delete one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -6903,7 +6903,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -6918,7 +6918,7 @@ code = ''' // try to delete the other rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -6939,7 +6939,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -6954,7 +6954,7 @@ code = ''' // try to delete the largest of three rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -6982,7 +6982,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -7003,7 +7003,7 @@ code = ''' // try to delete the smallest of three rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -7032,7 +7032,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -7053,7 +7053,7 @@ code = ''' // try to delete the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -7082,7 +7082,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -7117,7 +7117,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -7159,7 +7159,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -7179,7 +7179,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -7187,16 +7187,16 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j, RM, -1, NULL()))) => 0; assert(rbyd.weight == N-1); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N-1); for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4; @@ -7215,7 +7215,7 @@ code = ''' LFSR_ATTR(j, REG, +1, BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N); for (unsigned k = 0; k < N; k++) { if (k == j) { @@ -7271,7 +7271,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -7313,7 +7313,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -7339,7 +7339,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -7347,16 +7347,16 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j, RM, -1, NULL()))) => 0; assert(rbyd.weight == N-1); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N-1); for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_get(&lfs, &rbyd, k, LFSR_TAG_REG, buffer, 4) => 4; @@ -7392,7 +7392,7 @@ code = ''' } assert(rbyd.weight == N); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N); for (unsigned k = 0; k < N; k++) { if (k == j) { @@ -7461,7 +7461,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -7502,7 +7502,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -7522,7 +7522,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -7530,9 +7530,9 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -7540,7 +7540,7 @@ code = ''' assert(rbyd.weight == N-1); // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N-1); tag_ = 0; @@ -7585,7 +7585,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -7626,7 +7626,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -7652,7 +7652,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -7660,9 +7660,9 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -7670,7 +7670,7 @@ code = ''' assert(rbyd.weight == N-1); // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N-1); tag_ = 0; @@ -7723,7 +7723,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -7734,7 +7734,7 @@ code = ''' // create and delete one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -7744,14 +7744,14 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; // create and delete two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -7763,14 +7763,14 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; // create and delete two ids in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -7782,14 +7782,14 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; // create and delete three ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -7803,14 +7803,14 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; // create and delete three ids in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -7824,7 +7824,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; @@ -7837,7 +7837,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -7848,7 +7848,7 @@ code = ''' // create and delete one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; @@ -7859,14 +7859,14 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; // create and delete two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -7880,14 +7880,14 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; // create and delete two ids in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -7901,14 +7901,14 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; // create and delete three ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -7925,14 +7925,14 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; // create and delete three ids in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), @@ -7949,7 +7949,7 @@ code = ''' lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; @@ -7970,7 +7970,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -7993,7 +7993,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -8005,7 +8005,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -8028,9 +8028,9 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // delete each rid in permutation order @@ -8050,7 +8050,7 @@ code = ''' } // check that all tags are now removed - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -8062,7 +8062,7 @@ code = ''' BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 6) @@ -8113,7 +8113,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -8136,7 +8136,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -8153,7 +8153,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -8176,9 +8176,9 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // delete each rid in permutation order @@ -8198,7 +8198,7 @@ code = ''' } // check that all tags are now removed - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -8214,7 +8214,7 @@ code = ''' } assert(rbyd.weight == 1); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 6) @@ -8271,7 +8271,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -8308,7 +8308,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; prng = SEED; count = 0; @@ -8377,7 +8377,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -8391,7 +8391,7 @@ code = ''' // make id0 with weight w1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -8402,7 +8402,7 @@ code = ''' assert(weight_ == 1); assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -8427,7 +8427,7 @@ code = ''' assert(weight_ == 2); assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -8464,7 +8464,7 @@ code = ''' assert(weight_ == 3); assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -8513,7 +8513,7 @@ code = ''' assert(weight_ == 4); assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -8574,7 +8574,7 @@ code = ''' assert(weight_ == 5); assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -8614,7 +8614,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -8627,7 +8627,7 @@ code = ''' lfsr_data_t data_; rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( // make id0 with weight w1 LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), @@ -8674,7 +8674,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_REG); @@ -8723,7 +8723,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -8765,7 +8765,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -8780,7 +8780,7 @@ code = ''' BUF(names[perm[j] % 6], 4)))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N*W); for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, j*W+W-1, LFSR_TAG_REG, @@ -8810,7 +8810,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -8852,7 +8852,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -8867,7 +8867,7 @@ code = ''' BUF(names[perm[j] % 6], 4)))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N*W); // try traversing all tags tag_ = 0; @@ -8896,7 +8896,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -8910,7 +8910,7 @@ code = ''' // make id0 with weight w1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)), LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), @@ -8942,7 +8942,7 @@ code = ''' assert(weight_ == 0); assert(lfsr_data_size(&data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); @@ -9018,7 +9018,7 @@ code = ''' assert(weight_ == 0); assert(lfsr_data_size(&data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); @@ -9130,7 +9130,7 @@ code = ''' assert(weight_ == 0); assert(lfsr_data_size(&data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); @@ -9278,7 +9278,7 @@ code = ''' assert(weight_ == 0); assert(lfsr_data_size(&data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); @@ -9462,7 +9462,7 @@ code = ''' assert(weight_ == 0); assert(lfsr_data_size(&data_) == 2); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); @@ -9568,7 +9568,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -9581,7 +9581,7 @@ code = ''' lfsr_data_t data_; rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)), // make id0 with weight w1 @@ -9709,7 +9709,7 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, &rid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, &weight_, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); @@ -9824,7 +9824,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -9866,7 +9866,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)))) => 0; @@ -9887,7 +9887,7 @@ code = ''' BUF(names[perm[j] % 6], 2)))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -9935,7 +9935,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -9977,7 +9977,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)))) => 0; @@ -9998,7 +9998,7 @@ code = ''' BUF(names[perm[j] % 6], 2)))) => 0; } - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N*W); // try traversing all tags tag_ = 0; @@ -10056,7 +10056,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -10098,7 +10098,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10118,7 +10118,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try growing each rid for (unsigned j = 0; j < N; j++) { @@ -10126,16 +10126,16 @@ code = ''' printf("--- growing: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j*W+W-1, RM, +D, NULL()))) => 0; assert(rbyd.weight == N*W+D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W+D); for (unsigned k = 0; k < N; k++) { if (k == j) { @@ -10183,7 +10183,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -10225,7 +10225,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10245,7 +10245,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try growing each rid for (unsigned j = 0; j < N; j++) { @@ -10253,9 +10253,9 @@ code = ''' printf("--- growing: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -10263,7 +10263,7 @@ code = ''' BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W+D); for (unsigned k = 0; k < N; k++) { if (k == j) { @@ -10319,7 +10319,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -10361,7 +10361,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10381,7 +10381,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try growing each rid for (unsigned j = 0; j < N; j++) { @@ -10389,9 +10389,9 @@ code = ''' printf("--- growing: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -10399,7 +10399,7 @@ code = ''' BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W+D); for (unsigned k = 0; k < N; k++) { if (k == j) { @@ -10467,7 +10467,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -10509,7 +10509,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10529,7 +10529,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try shrinking each rid for (unsigned j = 0; j < N; j++) { @@ -10537,16 +10537,16 @@ code = ''' printf("--- shrinking: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j*W+W-1, GROW, -D, NULL()))) => 0; assert(rbyd.weight == N*W-D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W-D); for (unsigned k = 0; k < N; k++) { if (k == j) { @@ -10594,7 +10594,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -10636,7 +10636,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10656,7 +10656,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try shrinking each rid for (unsigned j = 0; j < N; j++) { @@ -10664,9 +10664,9 @@ code = ''' printf("--- shrinking: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -10674,7 +10674,7 @@ code = ''' BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W-D); for (unsigned k = 0; k < N; k++) { if (k == j) { @@ -10730,7 +10730,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -10772,7 +10772,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10792,7 +10792,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try shrinking each rid for (unsigned j = 0; j < N; j++) { @@ -10800,9 +10800,9 @@ code = ''' printf("--- shrinking: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -10810,7 +10810,7 @@ code = ''' BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W-D); for (unsigned k = 0; k < N; k++) { if (k == j) { @@ -10877,7 +10877,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -10919,7 +10919,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10939,7 +10939,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -10947,16 +10947,16 @@ code = ''' printf("--- deleting: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( LFSR_ATTR(j*W+W-1, RM, -W, NULL()))) => 0; assert(rbyd.weight == (N-1)*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == (N-1)*W); for (unsigned k = 0; k < N-1; k++) { if (k >= j) { @@ -10988,7 +10988,7 @@ code = ''' LFSR_ATTR(j*W, REG, +W, BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { if (k == j) { @@ -11031,7 +11031,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -11073,7 +11073,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11093,7 +11093,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try appending an attr to each rid, this should not affect // weights at all! @@ -11102,9 +11102,9 @@ code = ''' printf("--- appending: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( @@ -11112,7 +11112,7 @@ code = ''' BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, @@ -11142,7 +11142,7 @@ code = ''' LFSR_ATTR(j*W+W-1, RM(UATTR(1)), 0, NULL()))) => 0; assert(rbyd.weight == N*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, @@ -11168,7 +11168,7 @@ code = ''' BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; assert(rbyd.weight == N*W); for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookupnext(&lfs, &rbyd, k*W+W-1, LFSR_TAG_REG, @@ -11210,7 +11210,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -11255,7 +11255,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; prng = SEED; count = 0; @@ -11361,7 +11361,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -11412,7 +11412,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; prng = SEED; count = 0; @@ -11556,7 +11556,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -11593,7 +11593,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11612,7 +11612,7 @@ code = ''' assert(rbyd.weight == N); // test that we can lookup each attr with a wide lookup - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { @@ -11643,7 +11643,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -11680,7 +11680,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11702,7 +11702,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -11710,9 +11710,9 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // remove with a wide tag @@ -11720,7 +11720,7 @@ code = ''' LFSR_ATTR(j, RM(WIDE(UATTR)), 0, NULL()))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; lfsr_tag_t tag_ = 0; lfs_ssize_t rid_ = -1; lfs_size_t weight_; @@ -11780,7 +11780,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -11817,7 +11817,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11839,7 +11839,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -11847,9 +11847,9 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // replace with bitwise inverse @@ -11858,7 +11858,7 @@ code = ''' BUF(names[j % 6], 3)))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; lfsr_tag_t tag_ = 0; lfs_ssize_t rid_ = -1; lfs_size_t weight_; @@ -11919,7 +11919,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -11956,7 +11956,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11977,7 +11977,7 @@ code = ''' assert(rbyd.weight == N); // test that we can lookup each attr with a wide lookup - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { @@ -12008,7 +12008,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -12045,7 +12045,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12069,7 +12069,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -12077,9 +12077,9 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // remove with a wide tag @@ -12087,7 +12087,7 @@ code = ''' LFSR_ATTR(j, RM(WIDE(UATTR)), 0, NULL()))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; lfsr_tag_t tag_ = 0; lfs_ssize_t rid_ = -1; lfs_size_t weight_; @@ -12154,7 +12154,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -12191,7 +12191,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12215,7 +12215,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -12223,9 +12223,9 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // replace with bitwise inverse @@ -12234,7 +12234,7 @@ code = ''' BUF(names[j % 6], 3)))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; lfsr_tag_t tag_ = 0; lfs_ssize_t rid_ = -1; lfs_size_t weight_; @@ -12302,7 +12302,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -12339,7 +12339,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12357,7 +12357,7 @@ code = ''' assert(rbyd.weight == N); // test that we can lookup each attr with a wide lookup - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, 0) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { @@ -12388,7 +12388,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -12425,7 +12425,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12446,7 +12446,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -12454,9 +12454,9 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // remove with a wide tag @@ -12464,7 +12464,7 @@ code = ''' LFSR_ATTR(j, RM(WIDE(UATTR)), 0, NULL()))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; lfsr_tag_t tag_ = 0; lfs_ssize_t rid_ = -1; lfs_size_t weight_; @@ -12527,7 +12527,7 @@ code = ''' lfs_init(&lfs, CFG) => 0; lfsr_rbyd_t init_rbyd = { - .block = 0, + .blocks[0] = 0, .eoff = 0, .cksum = 0, .trunk = 0, @@ -12564,7 +12564,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12585,7 +12585,7 @@ code = ''' lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -12593,9 +12593,9 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.block, 0, backup_block, rbyd.eoff) => 0; + rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; // replace with bitwise inverse @@ -12604,7 +12604,7 @@ code = ''' BUF(names[j % 6], 6)))) => 0; // try traversing over the tags - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, CFG->block_size) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; lfsr_tag_t tag_ = 0; lfs_ssize_t rid_ = -1; lfs_size_t weight_;