From 677c078b5095f7c0ccf1726847d4bba17f3b508f Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Mon, 28 Apr 2025 13:59:10 -0500 Subject: [PATCH] Added LFSR_TAG_BNAME/MNAME, stop btree lookups at first tag Now that we don't have to worry about name tag conflicts as much, we can add name tags for things that aren't files. This adds LFSR_TAG_BNAME for branch names, and LFSR_TAG_MNAME for mtree names. Note that the upper 4 bits of the subtype match LFSR_TAG_BRANCH and LFSR_TAG_MDIR respectively: LFSR_TAG_BNAME 0x0200 v--- --1- ---- ---- LFSR_TAG_MNAME 0x0220 v--- --1- --1- ---- LFSR_TAG_BRANCH 0x030r v--- --11 ---- --rr LFSR_TAG_MDIR 0x0324 v--- --11 --1- -1rr The encoding is somewhat arbitrary, but I figured reserving ~31 types for files is probably going to be plenty for littlefs. POSIX seems to do just fine with only ~7 all these years, and I think custom attributes will be more enticing for "niche" file types (symlinks, compressed files, etc), given the easy backwards compatibility. --- In addition to the debugging benefits, the new name tags let us stop btree lookups on the first non-bname/branch tag. Previously we always had to fetch the first struct tag as well to check if it was a branch. In theory this saves one rbyd lookup, but in practice it's a bit muddy. The problem is that there's two ways to use named btrees: 1. As buckets: mtree -> mdir -> mid 2. As a table: ddtree -> ddid The only named btree we _currently_ have is the mtree. And the mtree operates in bucket mode, with each mdir acting more-or-less as an extension to the btree. So we end up needing to do the second tag lookup anyways, and all we've done is complicated up the code. But we will _eventually_ need the table mode for the ddtree, where we care if the ddname is an exact match. And returning the first tag is arguably the more "correct" internal API, vs arbitrarily the first struct tag. But then again this change is pretty pricey... code stack ctx before: 35732 2440 640 after: 35888 (+0.4%) 2480 (+1.6%) 640 (+0.0%) --- It's worth noting the new BNAME/MNAME tags don't _require_ the btree lookup changes (which is why we can get away with not touching the dbg scripts). The previous algorithm of always checking for branch tags still works. Maybe there's an argument for conditionally using the previous API when compiling without the ddtree, but that sounds horrendously messy... --- lfs.c | 135 +++++++++++++++--------- scripts/dbgbmap.py | 5 +- scripts/dbgbmapd3.py | 5 +- scripts/dbgbtree.py | 5 +- scripts/dbglfs.py | 5 +- scripts/dbgmtree.py | 5 +- scripts/dbgrbyd.py | 5 +- scripts/dbgtag.py | 5 +- tests/test_btree.toml | 233 ++++++++++++++++++++++++++---------------- tests/test_rbyd.toml | 102 +++++++++--------- 10 files changed, 315 insertions(+), 190 deletions(-) diff --git a/lfs.c b/lfs.c index 5a7ba125..88895b9c 100644 --- a/lfs.c +++ b/lfs.c @@ -1104,6 +1104,7 @@ enum lfsr_tag { LFSR_TAG_GEOMETRY = 0x0038, LFSR_TAG_FILELIMIT = 0x0039, LFSR_TAG_NAMELIMIT = 0x003a, + // in-device only, to help find unknown config tags LFSR_TAG_UNKNOWNCONFIG = 0x003b, // global-state tags @@ -1112,15 +1113,17 @@ enum lfsr_tag { // name tags LFSR_TAG_NAME = 0x0200, + LFSR_TAG_BNAME = 0x0200, LFSR_TAG_REG = 0x0201, LFSR_TAG_DIR = 0x0202, LFSR_TAG_STICKYNOTE = 0x0203, LFSR_TAG_BOOKMARK = 0x0204, - // in-device only name tags, these should never get written to disk LFSR_TAG_ORPHAN = 0x0205, LFSR_TAG_TRAVERSAL = 0x0206, LFSR_TAG_UNKNOWN = 0x0207, + // non-file name tags + LFSR_TAG_MNAME = 0x0220, // struct tags LFSR_TAG_STRUCT = 0x0300, @@ -3336,7 +3339,7 @@ static int lfsr_rbyd_lookupnext_(lfs_t *lfs, const lfsr_rbyd_t *rbyd, } -// finds the next rid+tag such that rid_+tag_ >= rid+tag +// finds the next rid_+tag_ such that rid_+tag_ >= rid+tag static int lfsr_rbyd_lookupnext(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfsr_srid_t rid, lfsr_tag_t tag, lfsr_srid_t *rid_, lfsr_tag_t *tag_, lfsr_rid_t *weight_, @@ -5247,6 +5250,8 @@ static int lfsr_btree_lookupleaf(lfs_t *lfs, const lfsr_btree_t *btree, lfsr_srid_t rid = bid; while (true) { // each branch is a pair of optional name + on-disk structure + + // lookup our bid in the rbyd lfsr_srid_t rid__; lfsr_tag_t tag__; lfsr_rid_t weight__; @@ -5257,9 +5262,9 @@ static int lfsr_btree_lookupleaf(lfs_t *lfs, const lfsr_btree_t *btree, return err; } - if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { - err = lfsr_rbyd_lookup(lfs, &branch, rid__, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + // if we found a bname, lookup the branch + if (tag__ == LFSR_TAG_BNAME) { + err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_BRANCH, &tag__, &data__); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); @@ -5366,9 +5371,9 @@ static int lfsr_btree_parent(lfs_t *lfs, const lfsr_btree_t *btree, return err; } - if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { - err = lfsr_rbyd_lookup(lfs, &branch, rid__, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + // if we found a bname, lookup the branch + if (tag__ == LFSR_TAG_BNAME) { + err = lfsr_rbyd_lookup(lfs, &branch, rid__, LFSR_TAG_BRANCH, &tag__, &data__); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); @@ -5522,7 +5527,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, return err; } - goto recurse; + goto commit; compact:; // estimate our compacted size @@ -5551,8 +5556,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, lfsr_tag_t sibling_tag; lfsr_rid_t sibling_weight; lfsr_data_t sibling_data; - err = lfsr_rbyd_lookupnext(lfs, &parent, - pid+1, LFSR_TAG_NAME, + err = lfsr_rbyd_lookupnext(lfs, &parent, pid+1, 0, &sibling_rid, &sibling_tag, &sibling_weight, &sibling_data); if (err) { @@ -5560,9 +5564,10 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, return err; } - if (sibling_tag == LFSR_TAG_NAME) { - err = lfsr_rbyd_lookup(lfs, &parent, sibling_rid, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + // if we found a bname, lookup the branch + if (sibling_tag == LFSR_TAG_BNAME) { + err = lfsr_rbyd_lookup(lfs, &parent, + sibling_rid, LFSR_TAG_BRANCH, &sibling_tag, &sibling_data); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); @@ -5599,8 +5604,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, lfsr_tag_t sibling_tag; lfsr_rid_t sibling_weight; lfsr_data_t sibling_data; - err = lfsr_rbyd_lookupnext(lfs, &parent, - pid-rbyd_.weight, LFSR_TAG_NAME, + err = lfsr_rbyd_lookupnext(lfs, &parent, pid-rbyd_.weight, 0, &sibling_rid, &sibling_tag, &sibling_weight, &sibling_data); if (err) { @@ -5608,9 +5612,10 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, return err; } - if (sibling_tag == LFSR_TAG_NAME) { - err = lfsr_rbyd_lookup(lfs, &parent, sibling_rid, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + // if we found a bname, lookup the branch + if (sibling_tag == LFSR_TAG_BNAME) { + err = lfsr_rbyd_lookup(lfs, &parent, + sibling_rid, LFSR_TAG_BRANCH, &sibling_tag, &sibling_data); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); @@ -5694,7 +5699,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, return err; } - goto recurse; + goto commit; split:; // we should have something to split here @@ -5819,7 +5824,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, if (rbyd__.weight == 0) { rbyd__ = sibling; } - goto recurse; + goto commit; } // lookup first name in sibling to use as the split name @@ -5827,7 +5832,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, // note we need to do this after playing out pending rattrs in case // they introduce a new name! lfsr_tag_t split_tag; - err = lfsr_rbyd_lookupnext(lfs, &sibling, 0, LFSR_TAG_NAME, + err = lfsr_rbyd_lookupnext(lfs, &sibling, 0, 0, NULL, &split_tag, NULL, &bctx->split_name); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); @@ -5852,7 +5857,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, branch_r.u.buffer, lfsr_data_size(branch_r)); if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { bctx->rattrs[rattr_count_++] = LFSR_RATTR_DATA( - LFSR_TAG_NAME, 0, + LFSR_TAG_BNAME, 0, &bctx->split_name); } // split root? @@ -5874,7 +5879,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, branch_r.u.buffer, lfsr_data_size(branch_r)); if (lfsr_tag_suptype(split_tag) == LFSR_TAG_NAME) { bctx->rattrs[rattr_count_++] = LFSR_RATTR_DATA( - LFSR_TAG_NAME, 0, + LFSR_TAG_BNAME, 0, &bctx->split_name); } } @@ -5980,7 +5985,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, rid_ = pid + sibling.weight; continue; - recurse:; + commit:; // done? if (!lfsr_rbyd_trunk(&parent)) { *btree = rbyd__; @@ -6097,26 +6102,30 @@ static lfs_scmp_t lfsr_btree_namelookupleaf(lfs_t *lfs, lfsr_rbyd_t branch = *btree; lfsr_bid_t bid = 0; while (true) { + // each branch is a pair of optional name + on-disk structure + // lookup our name in the rbyd via binary search lfsr_srid_t rid__; + lfsr_tag_t tag__; lfsr_rid_t weight__; + lfsr_data_t data__; lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &branch, did, name, name_len, - &rid__, NULL, &weight__, NULL); + &rid__, &tag__, &weight__, &data__); if (cmp < 0) { LFS_ASSERT(cmp != LFS_ERR_NOENT); return cmp; } - // the name may not match exactly, but indicates which branch to follow - lfsr_tag_t tag__; - lfsr_data_t data__; - int err = lfsr_rbyd_lookup(lfs, &branch, rid__, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, - &tag__, &data__); - if (err < 0) { - LFS_ASSERT(err != LFS_ERR_NOENT); - return err; + // if we found a bname, lookup the branch + if (tag__ == LFSR_TAG_BNAME) { + int err = lfsr_rbyd_lookup(lfs, &branch, rid__, + LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag__, &data__); + if (err < 0) { + LFS_ASSERT(err != LFS_ERR_NOENT); + return err; + } } // found another branch @@ -6125,7 +6134,7 @@ static lfs_scmp_t lfsr_btree_namelookupleaf(lfs_t *lfs, bid += rid__ - (weight__-1); // fetch the next branch - err = lfsr_data_fetchbranch(lfs, &data__, weight__, + int err = lfsr_data_fetchbranch(lfs, &data__, weight__, &branch); if (err < 0) { return err; @@ -6223,9 +6232,9 @@ static int lfsr_btree_traverse(lfs_t *lfs, const lfsr_btree_t *btree, return err; } - if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { - err = lfsr_rbyd_lookup(lfs, bt->branch, rid__, - LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + // if we found a bname, lookup the branch + if (tag__ == LFSR_TAG_BNAME) { + err = lfsr_rbyd_lookup(lfs, bt->branch, rid__, LFSR_TAG_BRANCH, &tag__, &data__); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); @@ -7648,16 +7657,31 @@ static int lfsr_mtree_lookupleaf(lfs_t *lfs, lfsr_smid_t mid, // look up mdir in actual mtree } else { lfsr_bid_t bid; + lfsr_rbyd_t rbyd; + lfsr_srid_t rid; lfsr_tag_t tag; + lfsr_bid_t weight; lfsr_data_t data; - int err = lfsr_btree_lookupnext(lfs, &lfs->mtree, mid, - &bid, &tag, NULL, &data); + int err = lfsr_btree_lookupleaf(lfs, &lfs->mtree, mid, + &bid, &rbyd, &rid, &tag, &weight, &data); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); return err; } LFS_ASSERT((lfsr_sbid_t)bid == lfsr_mbid(lfs, mid)); - LFS_ASSERT(tag == LFSR_TAG_MDIR); + LFS_ASSERT(weight == (lfsr_bid_t)(1 << lfs->mbits)); + LFS_ASSERT(tag == LFSR_TAG_MNAME + || tag == LFSR_TAG_MDIR); + + // if we found an mname, lookup the mdir + if (tag == LFSR_TAG_MNAME) { + err = lfsr_rbyd_lookup(lfs, &rbyd, rid, LFSR_TAG_MDIR, + NULL, &data); + if (err) { + LFS_ASSERT(err != LFS_ERR_NOENT); + return err; + } + } // fetch mdir err = lfsr_data_fetchmdir(lfs, &data, mid, @@ -8722,7 +8746,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, LFSR_TAG_MDIR, +(1 << lfs->mbits), mdir_[0].rbyd.blocks), LFSR_RATTR_DATA( - LFSR_TAG_NAME, +(1 << lfs->mbits), + LFSR_TAG_MNAME, +(1 << lfs->mbits), &split_name), LFSR_RATTR_MPTR( LFSR_TAG_MDIR, 0, @@ -8742,7 +8766,7 @@ static int lfsr_mdir_commit(lfs_t *lfs, lfsr_mdir_t *mdir, LFSR_TAG_MDIR, 0, mdir_[0].rbyd.blocks), LFSR_RATTR_DATA( - LFSR_TAG_NAME, +(1 << lfs->mbits), + LFSR_TAG_MNAME, +(1 << lfs->mbits), &split_name), LFSR_RATTR_MPTR( LFSR_TAG_MDIR, 0, @@ -9179,21 +9203,34 @@ static int lfsr_mtree_namelookupleaf(lfs_t *lfs, // lookup name in actual mtree } else { lfsr_bid_t bid; + lfsr_rbyd_t rbyd; + lfsr_srid_t rid; lfsr_tag_t tag; lfsr_bid_t weight; lfsr_data_t data; - lfs_scmp_t cmp = lfsr_btree_namelookup(lfs, &lfs->mtree, + lfs_scmp_t cmp = lfsr_btree_namelookupleaf(lfs, &lfs->mtree, did, name, name_len, - &bid, &tag, &weight, &data); + &bid, &rbyd, &rid, &tag, &weight, &data); if (cmp < 0) { LFS_ASSERT(cmp != LFS_ERR_NOENT); return cmp; } - LFS_ASSERT(tag == LFSR_TAG_MDIR); - LFS_ASSERT(weight == (1U << lfs->mbits)); + LFS_ASSERT(weight == (lfsr_bid_t)(1 << lfs->mbits)); + LFS_ASSERT(tag == LFSR_TAG_MNAME + || tag == LFSR_TAG_MDIR); + + // if we found an mname, lookup the mdir + if (tag == LFSR_TAG_MNAME) { + int err = lfsr_rbyd_lookup(lfs, &rbyd, rid, LFSR_TAG_MDIR, + NULL, &data); + if (err) { + LFS_ASSERT(err != LFS_ERR_NOENT); + return err; + } + } // fetch mdir - int err = lfsr_data_fetchmdir(lfs, &data, bid-(weight-1), + int err = lfsr_data_fetchmdir(lfs, &data, bid-((1 << lfs->mbits)-1), &mdir); if (err) { return err; diff --git a/scripts/dbgbmap.py b/scripts/dbgbmap.py index b5a104b2..7a254616 100755 --- a/scripts/dbgbmap.py +++ b/scripts/dbgbmap.py @@ -42,10 +42,12 @@ TAG_NAMELIMIT = 0x003a # 0x003a v--- ---- --11 1-1- TAG_GDELTA = 0x0100 ## 0x01tt v--- ---1 -ttt ttrr TAG_GRMDELTA = 0x0100 # 0x0100 v--- ---1 ---- ---- TAG_NAME = 0x0200 ## 0x02tt v--- --1- -ttt tttt +TAG_BNAME = 0x0200 # 0x0200 v--- --1- ---- ---- TAG_REG = 0x0201 # 0x0201 v--- --1- ---- ---1 TAG_DIR = 0x0202 # 0x0202 v--- --1- ---- --1- TAG_STICKYNOTE = 0x0203 # 0x0203 v--- --1- ---- --11 TAG_BOOKMARK = 0x0204 # 0x0204 v--- --1- ---- -1-- +TAG_MNAME = 0x0220 # 0x0220 v--- --1- --1- ---- TAG_STRUCT = 0x0300 ## 0x03tt v--- --11 -ttt ttrr TAG_BRANCH = 0x0300 # 0x030r v--- --11 ---- --rr TAG_DATA = 0x0304 # 0x0304 v--- --11 ---- -1-- @@ -314,11 +316,12 @@ def tagrepr(tag, weight=None, size=None, *, elif (tag & 0x6f00) == TAG_NAME: return '%s%s%s%s' % ( 'shrub' if tag & TAG_SHRUB else '', - 'name' if (tag & 0xfff) == TAG_NAME + 'bname' if (tag & 0xfff) == TAG_BNAME else 'reg' if (tag & 0xfff) == TAG_REG else 'dir' if (tag & 0xfff) == TAG_DIR else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK + else 'mname' if (tag & 0xfff) == TAG_MNAME else 'name 0x%02x' % (tag & 0xff), ' w%d' % weight if weight else '', ' %s' % size if size is not None else '') diff --git a/scripts/dbgbmapd3.py b/scripts/dbgbmapd3.py index 7a597bde..b1797565 100755 --- a/scripts/dbgbmapd3.py +++ b/scripts/dbgbmapd3.py @@ -40,10 +40,12 @@ TAG_NAMELIMIT = 0x003a # 0x003a v--- ---- --11 1-1- TAG_GDELTA = 0x0100 ## 0x01tt v--- ---1 -ttt ttrr TAG_GRMDELTA = 0x0100 # 0x0100 v--- ---1 ---- ---- TAG_NAME = 0x0200 ## 0x02tt v--- --1- -ttt tttt +TAG_BNAME = 0x0200 # 0x0200 v--- --1- ---- ---- TAG_REG = 0x0201 # 0x0201 v--- --1- ---- ---1 TAG_DIR = 0x0202 # 0x0202 v--- --1- ---- --1- TAG_STICKYNOTE = 0x0203 # 0x0203 v--- --1- ---- --11 TAG_BOOKMARK = 0x0204 # 0x0204 v--- --1- ---- -1-- +TAG_MNAME = 0x0220 # 0x0220 v--- --1- --1- ---- TAG_STRUCT = 0x0300 ## 0x03tt v--- --11 -ttt ttrr TAG_BRANCH = 0x0300 # 0x030r v--- --11 ---- --rr TAG_DATA = 0x0304 # 0x0304 v--- --11 ---- -1-- @@ -344,11 +346,12 @@ def tagrepr(tag, weight=None, size=None, *, elif (tag & 0x6f00) == TAG_NAME: return '%s%s%s%s' % ( 'shrub' if tag & TAG_SHRUB else '', - 'name' if (tag & 0xfff) == TAG_NAME + 'bname' if (tag & 0xfff) == TAG_BNAME else 'reg' if (tag & 0xfff) == TAG_REG else 'dir' if (tag & 0xfff) == TAG_DIR else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK + else 'mname' if (tag & 0xfff) == TAG_MNAME else 'name 0x%02x' % (tag & 0xff), ' w%d' % weight if weight else '', ' %s' % size if size is not None else '') diff --git a/scripts/dbgbtree.py b/scripts/dbgbtree.py index c667114d..99660d30 100755 --- a/scripts/dbgbtree.py +++ b/scripts/dbgbtree.py @@ -31,10 +31,12 @@ TAG_NAMELIMIT = 0x003a # 0x003a v--- ---- --11 1-1- TAG_GDELTA = 0x0100 ## 0x01tt v--- ---1 -ttt ttrr TAG_GRMDELTA = 0x0100 # 0x0100 v--- ---1 ---- ---- TAG_NAME = 0x0200 ## 0x02tt v--- --1- -ttt tttt +TAG_BNAME = 0x0200 # 0x0200 v--- --1- ---- ---- TAG_REG = 0x0201 # 0x0201 v--- --1- ---- ---1 TAG_DIR = 0x0202 # 0x0202 v--- --1- ---- --1- TAG_STICKYNOTE = 0x0203 # 0x0203 v--- --1- ---- --11 TAG_BOOKMARK = 0x0204 # 0x0204 v--- --1- ---- -1-- +TAG_MNAME = 0x0220 # 0x0220 v--- --1- --1- ---- TAG_STRUCT = 0x0300 ## 0x03tt v--- --11 -ttt ttrr TAG_BRANCH = 0x0300 # 0x030r v--- --11 ---- --rr TAG_DATA = 0x0304 # 0x0304 v--- --11 ---- -1-- @@ -222,11 +224,12 @@ def tagrepr(tag, weight=None, size=None, *, elif (tag & 0x6f00) == TAG_NAME: return '%s%s%s%s' % ( 'shrub' if tag & TAG_SHRUB else '', - 'name' if (tag & 0xfff) == TAG_NAME + 'bname' if (tag & 0xfff) == TAG_BNAME else 'reg' if (tag & 0xfff) == TAG_REG else 'dir' if (tag & 0xfff) == TAG_DIR else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK + else 'mname' if (tag & 0xfff) == TAG_MNAME else 'name 0x%02x' % (tag & 0xff), ' w%d' % weight if weight else '', ' %s' % size if size is not None else '') diff --git a/scripts/dbglfs.py b/scripts/dbglfs.py index cd7feeab..a5a29030 100755 --- a/scripts/dbglfs.py +++ b/scripts/dbglfs.py @@ -32,10 +32,12 @@ TAG_NAMELIMIT = 0x003a # 0x003a v--- ---- --11 1-1- TAG_GDELTA = 0x0100 ## 0x01tt v--- ---1 -ttt ttrr TAG_GRMDELTA = 0x0100 # 0x0100 v--- ---1 ---- ---- TAG_NAME = 0x0200 ## 0x02tt v--- --1- -ttt tttt +TAG_BNAME = 0x0200 # 0x0200 v--- --1- ---- ---- TAG_REG = 0x0201 # 0x0201 v--- --1- ---- ---1 TAG_DIR = 0x0202 # 0x0202 v--- --1- ---- --1- TAG_STICKYNOTE = 0x0203 # 0x0203 v--- --1- ---- --11 TAG_BOOKMARK = 0x0204 # 0x0204 v--- --1- ---- -1-- +TAG_MNAME = 0x0220 # 0x0220 v--- --1- --1- ---- TAG_STRUCT = 0x0300 ## 0x03tt v--- --11 -ttt ttrr TAG_BRANCH = 0x0300 # 0x030r v--- --11 ---- --rr TAG_DATA = 0x0304 # 0x0304 v--- --11 ---- -1-- @@ -271,11 +273,12 @@ def tagrepr(tag, weight=None, size=None, *, elif (tag & 0x6f00) == TAG_NAME: return '%s%s%s%s' % ( 'shrub' if tag & TAG_SHRUB else '', - 'name' if (tag & 0xfff) == TAG_NAME + 'bname' if (tag & 0xfff) == TAG_BNAME else 'reg' if (tag & 0xfff) == TAG_REG else 'dir' if (tag & 0xfff) == TAG_DIR else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK + else 'mname' if (tag & 0xfff) == TAG_MNAME else 'name 0x%02x' % (tag & 0xff), ' w%d' % weight if weight else '', ' %s' % size if size is not None else '') diff --git a/scripts/dbgmtree.py b/scripts/dbgmtree.py index 44576205..c7bcfce7 100755 --- a/scripts/dbgmtree.py +++ b/scripts/dbgmtree.py @@ -31,10 +31,12 @@ TAG_NAMELIMIT = 0x003a # 0x003a v--- ---- --11 1-1- TAG_GDELTA = 0x0100 ## 0x01tt v--- ---1 -ttt ttrr TAG_GRMDELTA = 0x0100 # 0x0100 v--- ---1 ---- ---- TAG_NAME = 0x0200 ## 0x02tt v--- --1- -ttt tttt +TAG_BNAME = 0x0200 # 0x0200 v--- --1- ---- ---- TAG_REG = 0x0201 # 0x0201 v--- --1- ---- ---1 TAG_DIR = 0x0202 # 0x0202 v--- --1- ---- --1- TAG_STICKYNOTE = 0x0203 # 0x0203 v--- --1- ---- --11 TAG_BOOKMARK = 0x0204 # 0x0204 v--- --1- ---- -1-- +TAG_MNAME = 0x0220 # 0x0220 v--- --1- --1- ---- TAG_STRUCT = 0x0300 ## 0x03tt v--- --11 -ttt ttrr TAG_BRANCH = 0x0300 # 0x030r v--- --11 ---- --rr TAG_DATA = 0x0304 # 0x0304 v--- --11 ---- -1-- @@ -237,11 +239,12 @@ def tagrepr(tag, weight=None, size=None, *, elif (tag & 0x6f00) == TAG_NAME: return '%s%s%s%s' % ( 'shrub' if tag & TAG_SHRUB else '', - 'name' if (tag & 0xfff) == TAG_NAME + 'bname' if (tag & 0xfff) == TAG_BNAME else 'reg' if (tag & 0xfff) == TAG_REG else 'dir' if (tag & 0xfff) == TAG_DIR else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK + else 'mname' if (tag & 0xfff) == TAG_MNAME else 'name 0x%02x' % (tag & 0xff), ' w%d' % weight if weight else '', ' %s' % size if size is not None else '') diff --git a/scripts/dbgrbyd.py b/scripts/dbgrbyd.py index a5a671ac..e7379c3b 100755 --- a/scripts/dbgrbyd.py +++ b/scripts/dbgrbyd.py @@ -41,10 +41,12 @@ TAG_NAMELIMIT = 0x003a # 0x003a v--- ---- --11 1-1- TAG_GDELTA = 0x0100 ## 0x01tt v--- ---1 -ttt ttrr TAG_GRMDELTA = 0x0100 # 0x0100 v--- ---1 ---- ---- TAG_NAME = 0x0200 ## 0x02tt v--- --1- -ttt tttt +TAG_BNAME = 0x0200 # 0x0200 v--- --1- ---- ---- TAG_REG = 0x0201 # 0x0201 v--- --1- ---- ---1 TAG_DIR = 0x0202 # 0x0202 v--- --1- ---- --1- TAG_STICKYNOTE = 0x0203 # 0x0203 v--- --1- ---- --11 TAG_BOOKMARK = 0x0204 # 0x0204 v--- --1- ---- -1-- +TAG_MNAME = 0x0220 # 0x0220 v--- --1- --1- ---- TAG_STRUCT = 0x0300 ## 0x03tt v--- --11 -ttt ttrr TAG_BRANCH = 0x0300 # 0x030r v--- --11 ---- --rr TAG_DATA = 0x0304 # 0x0304 v--- --11 ---- -1-- @@ -225,11 +227,12 @@ def tagrepr(tag, weight=None, size=None, *, elif (tag & 0x6f00) == TAG_NAME: return '%s%s%s%s' % ( 'shrub' if tag & TAG_SHRUB else '', - 'name' if (tag & 0xfff) == TAG_NAME + 'bname' if (tag & 0xfff) == TAG_BNAME else 'reg' if (tag & 0xfff) == TAG_REG else 'dir' if (tag & 0xfff) == TAG_DIR else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK + else 'mname' if (tag & 0xfff) == TAG_MNAME else 'name 0x%02x' % (tag & 0xff), ' w%d' % weight if weight else '', ' %s' % size if size is not None else '') diff --git a/scripts/dbgtag.py b/scripts/dbgtag.py index 8ebeedaa..37e10207 100755 --- a/scripts/dbgtag.py +++ b/scripts/dbgtag.py @@ -24,10 +24,12 @@ TAG_NAMELIMIT = 0x003a # 0x003a v--- ---- --11 1-1- TAG_GDELTA = 0x0100 ## 0x01tt v--- ---1 -ttt ttrr TAG_GRMDELTA = 0x0100 # 0x0100 v--- ---1 ---- ---- TAG_NAME = 0x0200 ## 0x02tt v--- --1- -ttt tttt +TAG_BNAME = 0x0200 # 0x0200 v--- --1- ---- ---- TAG_REG = 0x0201 # 0x0201 v--- --1- ---- ---1 TAG_DIR = 0x0202 # 0x0202 v--- --1- ---- --1- TAG_STICKYNOTE = 0x0203 # 0x0203 v--- --1- ---- --11 TAG_BOOKMARK = 0x0204 # 0x0204 v--- --1- ---- -1-- +TAG_MNAME = 0x0220 # 0x0220 v--- --1- --1- ---- TAG_STRUCT = 0x0300 ## 0x03tt v--- --11 -ttt ttrr TAG_BRANCH = 0x0300 # 0x030r v--- --11 ---- --rr TAG_DATA = 0x0304 # 0x0304 v--- --11 ---- -1-- @@ -129,11 +131,12 @@ def tagrepr(tag, weight=None, size=None, *, elif (tag & 0x6f00) == TAG_NAME: return '%s%s%s%s' % ( 'shrub' if tag & TAG_SHRUB else '', - 'name' if (tag & 0xfff) == TAG_NAME + 'bname' if (tag & 0xfff) == TAG_BNAME else 'reg' if (tag & 0xfff) == TAG_REG else 'dir' if (tag & 0xfff) == TAG_DIR else 'stickynote' if (tag & 0xfff) == TAG_STICKYNOTE else 'bookmark' if (tag & 0xfff) == TAG_BOOKMARK + else 'mname' if (tag & 0xfff) == TAG_MNAME else 'name 0x%02x' % (tag & 0xff), ' w%d' % weight if weight else '', ' %s' % size if size is not None else '') diff --git a/tests/test_btree.toml b/tests/test_btree.toml index 26c7f45b..ee20966f 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -3044,12 +3044,12 @@ code = ''' // try to find tags lfsr_bid_t bid_; - lfsr_tag_t tag_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfs_size_t weight_; - lfsr_data_t data_; - lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3, - &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; + lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_ERR_NOENT; ''' [cases.test_btree_find_one] @@ -3072,7 +3072,7 @@ code = ''' lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, "aaa", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0; printf("btree: w%d 0x%x.%x\n", @@ -3084,20 +3084,26 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); - lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT; + lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); @@ -3125,13 +3131,13 @@ code = ''' lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, "aaa", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, "aab", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0; printf("btree: w%d 0x%x.%x\n", @@ -3143,28 +3149,36 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); - lfsr_btree_namelookup(&lfs, &btree, 0, "aab", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aab", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); - lfsr_btree_namelookup(&lfs, &btree, 0, "aac", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT; + lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aac", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); @@ -3192,19 +3206,19 @@ code = ''' lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, "aaa", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 1*DID, "aab", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 2*DID, "aac", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "2", 1))) => 0; printf("btree: w%d 0x%x.%x\n", @@ -3216,36 +3230,46 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); - lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); - lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); - lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT; + lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); @@ -3273,19 +3297,19 @@ code = ''' lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, "aaa", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 2*DID, "aac", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "2", 1))) => 0; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 1*DID, "aab", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0; printf("btree: w%d 0x%x.%x\n", @@ -3297,36 +3321,46 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; - lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(memcmp(buffer, "0", 1) == 0); - lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(memcmp(buffer, "1", 1) == 0); - lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; assert(memcmp(buffer, "2", 1) == 0); - lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT; + lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); @@ -3358,7 +3392,7 @@ code = ''' }; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, name, 3), LFSR_RATTR_BUF( LFSR_TAG_DATA, 0, @@ -3373,7 +3407,7 @@ code = ''' LFSR_TAG_DATA, 0, &(uint8_t){'0'+((i-1) % 10)}, 1), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, i*DID, name, 3), LFSR_RATTR_BUF( LFSR_TAG_DATA, 0, @@ -3389,6 +3423,8 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -3398,8 +3434,10 @@ code = ''' 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; - lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i); assert(weight_ == 1); @@ -3429,7 +3467,7 @@ code = ''' lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, "___", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0; @@ -3469,7 +3507,7 @@ code = ''' LFSR_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, name, 3), LFSR_RATTR_BUF( LFSR_TAG_DATA, 0, @@ -3503,12 +3541,16 @@ code = ''' uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i); assert(weight_ == 1); @@ -3547,7 +3589,7 @@ code = ''' }; lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +W, + LFSR_TAG_REG, +W, 0, name, 3), LFSR_RATTR_BUF( LFSR_TAG_DATA, 0, @@ -3562,7 +3604,7 @@ code = ''' LFSR_TAG_DATA, 0, &(uint8_t){'0'+((i-1) % 10)}, 1), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +W, + LFSR_TAG_REG, +W, i*DID, name, 3), LFSR_RATTR_BUF( LFSR_TAG_DATA, 0, @@ -3578,6 +3620,8 @@ code = ''' // try to find tags uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -3587,8 +3631,10 @@ code = ''' 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) }; - lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i*W+W-1); assert(weight_ == W); @@ -3619,7 +3665,7 @@ code = ''' lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +W, + LFSR_TAG_REG, +W, 0, "___", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0; @@ -3674,7 +3720,7 @@ code = ''' LFSR_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +weight2, + LFSR_TAG_REG, +weight2, 0, name, 3), LFSR_RATTR_BUF( LFSR_TAG_DATA, 0, @@ -3727,6 +3773,8 @@ code = ''' uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -3737,8 +3785,10 @@ code = ''' weighted_bid += sim_weights[j]; } - lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(weight_ == sim_weights[i]); @@ -3775,7 +3825,7 @@ code = ''' lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, "___", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0; @@ -3816,28 +3866,28 @@ code = ''' } // split btree - lfs_size_t split_bid; - lfsr_data_t split_data; - lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3, - &split_bid, NULL, NULL, &split_data); + lfsr_bid_t split_bid; + lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree, + 0, name, 3, + &split_bid, NULL, NULL, NULL, NULL, NULL); assert(cmp >= 0); assert(cmp != LFS_CMP_EQ); if (cmp > LFS_CMP_EQ) { - lfsr_btree_commit(&lfs, &btree, - split_bid, LFSR_RATTRS( - LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, - 0, name, 3), - LFSR_RATTR_BUF( - LFSR_TAG_DATA, 0, - &(uint8_t){'0'+(i % 10)}, 1))) => 0; + lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( + LFSR_RATTR_NAME( + LFSR_TAG_REG, +1, + 0, name, 3), + LFSR_RATTR_BUF( + LFSR_TAG_DATA, 0, + &(uint8_t){'0'+(i % 10)}, 1))) => 0; } else { lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( - LFSR_RATTR_DATA( - LFSR_TAG_DATA, 0, - &split_data), + // TODO can we avoid this noop? the problem is we need + // some way to differentiate inserting before vs after + // the requested bid + LFSR_RATTR_NOOP(), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +1, + LFSR_TAG_REG, +1, 0, name, 3), LFSR_RATTR_BUF( LFSR_TAG_DATA, 0, @@ -3892,12 +3942,16 @@ code = ''' uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; for (lfs_size_t i = 0; i < sim_size; i++) { - lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i); assert(weight_ == 1); @@ -3932,7 +3986,7 @@ code = ''' lfsr_btree_init(&btree); lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +W, + LFSR_TAG_REG, +W, 0, "___", 3), LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0; @@ -3984,29 +4038,30 @@ code = ''' } // split btree - lfs_size_t split_bid; - lfs_size_t split_weight; - lfsr_data_t split_data; - lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3, - &split_bid, NULL, &split_weight, &split_data); + lfsr_bid_t split_bid; + lfsr_bid_t split_weight; + lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree, + 0, name, 3, + &split_bid, NULL, NULL, NULL, &split_weight, NULL); assert(cmp >= 0); assert(cmp != LFS_CMP_EQ); if (cmp > LFS_CMP_EQ) { lfsr_btree_commit(&lfs, &btree, split_bid-(split_weight-1), LFSR_RATTRS( LFSR_RATTR_NAME( - LFSR_TAG_NAME, +weight, + LFSR_TAG_REG, +weight, 0, name, 3), LFSR_RATTR_BUF( LFSR_TAG_DATA, 0, &(uint8_t){'0'+(i % 10)}, 1))) => 0; } else { lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS( - LFSR_RATTR_DATA( - LFSR_TAG_DATA, 0, - &split_data), + // TODO can we avoid this noop? the problem is we need + // some way to differentiate inserting before vs after + // the requested bid + LFSR_RATTR_NOOP(), LFSR_RATTR_NAME( - LFSR_TAG_NAME, +weight, + LFSR_TAG_REG, +weight, 0, name, 3), LFSR_RATTR_BUF( LFSR_TAG_DATA, 0, @@ -4087,6 +4142,8 @@ code = ''' uint8_t buffer[4]; lfsr_bid_t bid_; + lfsr_rbyd_t rbyd_; + lfsr_srid_t rid_; lfsr_tag_t tag_; lfs_size_t weight_; lfsr_data_t data_; @@ -4097,8 +4154,10 @@ code = ''' weighted_bid += sim_weights[j]; } - lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, - &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; + lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3, + &bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ; + lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT, + &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(weight_ == sim_weights[i]); diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 06ce8ca2..ecc1f1bf 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -4480,8 +4480,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, - j, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } @@ -6219,7 +6218,8 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -6247,7 +6247,8 @@ code = ''' assert(rid_ == k); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); } @@ -6263,7 +6264,8 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); @@ -6276,7 +6278,8 @@ code = ''' assert(rid_ == k); assert(lfsr_data_size(data_) == 3); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 3; assert(memcmp(buffer, names[k % 6], 3) == 0); } else { @@ -6284,7 +6287,8 @@ code = ''' assert(rid_ == k); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); } @@ -6627,14 +6631,13 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, - -1, LFSR_TAG_ATTR(j+1), NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1), + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, - j, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } @@ -6779,8 +6782,8 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == N); for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookup(&lfs, &rbyd, - -1, LFSR_TAG_ATTR(j+1), NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1), + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 1; assert(memcmp(buffer, names[j % 6], 1) == 0); } @@ -10614,7 +10617,8 @@ code = ''' 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_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); @@ -10637,11 +10641,13 @@ code = ''' assert(rbyd.weight == N); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); } @@ -10783,7 +10789,8 @@ code = ''' 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_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); @@ -10792,8 +10799,8 @@ code = ''' } for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, - k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_ATTR(u+1), + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 2; if (k >= j) { assert(memcmp(buffer, names[(k+1) % 6], 2) == 0); @@ -10825,24 +10832,26 @@ code = ''' assert(rbyd.weight == N); for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 6) => 6; assert(memcmp(buffer, names[k % 6], 6) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, - k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_ATTR(u+1), + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 6) => 3; assert(memcmp(buffer, names[k % 6], 3) == 0); } } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 6) => 4; assert(memcmp(buffer, names[k % 6], 4) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, - k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_ATTR(u+1), + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 6) => 2; assert(memcmp(buffer, names[k % 6], 2) == 0); } @@ -11573,8 +11582,7 @@ code = ''' // check that all tags are now removed lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, - LFSR_TAG_DATA, 0, + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_DATA, 0, NULL, &data) => LFS_ERR_NOENT; // try resuming from all tags being removed @@ -11586,12 +11594,10 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, - 0, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 6) => 6; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, - 1, LFSR_TAG_DATA, + lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => LFS_ERR_NOENT; // keep track of the worst size @@ -11729,8 +11735,7 @@ code = ''' // check that all tags are now removed lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 0); - lfsr_rbyd_lookup(&lfs, &rbyd, - 0, LFSR_TAG_DATA, + lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => LFS_ERR_NOENT; // try resuming from all tags being removed @@ -11748,21 +11753,18 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; assert(rbyd.weight == 1); - lfsr_rbyd_lookup(&lfs, &rbyd, - 0, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 6) => 6; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0); for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookup(&lfs, &rbyd, - 0, LFSR_TAG_ATTR(u+1), NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(u+1), + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 6) => 3; assert(memcmp(buffer, "\xaa\xaa\xaa", 3) == 0); } - lfsr_rbyd_lookup(&lfs, &rbyd, - 1, LFSR_TAG_DATA, + lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA, NULL, &data) => LFS_ERR_NOENT; - lfsr_rbyd_lookup(&lfs, &rbyd, - 1, LFSR_TAG_ATTR(1), + lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1), NULL, &data) => LFS_ERR_NOENT; // keep track of the worst size @@ -12349,7 +12351,8 @@ code = ''' assert(weight_ == W); assert(lfsr_data_size(data_) == 4); - lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } @@ -13559,7 +13562,8 @@ code = ''' assert(weight_ == 0); assert(lfsr_data_size(data_) == 2); - lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, NULL, &data) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, + NULL, &data) => 0; lfsr_data_read(&lfs, &data, buffer, 4) => 4; assert(memcmp(buffer, names[j % 6], 4) == 0); } @@ -16267,10 +16271,12 @@ code = ''' // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfsr_rbyd_lookup(&lfs, &rbyd, k, + LFSR_TAG_MASK8 | LFSR_TAG_ATTR, &tag_, &data_) => LFS_ERR_NOENT; } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfsr_rbyd_lookup(&lfs, &rbyd, k, + LFSR_TAG_MASK8 | LFSR_TAG_ATTR, &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); assert(lfsr_data_size(data_) == 4); @@ -16638,10 +16644,12 @@ code = ''' // also test that we can lookup each tag with a wide lookup for (unsigned k = 0; k < N; k++) { if (k == j) { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfsr_rbyd_lookup(&lfs, &rbyd, k, + LFSR_TAG_MASK8 | LFSR_TAG_ATTR, &tag_, &data_) => LFS_ERR_NOENT; } else { - lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR, + lfsr_rbyd_lookup(&lfs, &rbyd, k, + LFSR_TAG_MASK8 | LFSR_TAG_ATTR, &tag_, &data_) => 0; assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f)); assert(lfsr_data_size(data_) == 2);