From 94f7d2549fbb9437dc8b41d07a2d07232c806e77 Mon Sep 17 00:00:00 2001
From: Christopher Haster <geky@geky.net>
Date: Fri, 23 Feb 2024 15:50:21 -0600
Subject: [PATCH] Changed rbyd/btree namelookups to only compare raw bytes

This is a simplification of the rbyd/btree layers, but implies
behavioral changes to the mtree/mdir layers.

Instead of ordering by leb128 did + name:

  82 02 61 61 61  <  81 04 62 62 62
  (0x102, "aaa")     (0x201, "bbb")

We now order by the raw encoding, lexicographically:

  82 02 61 61 61  >  81 04 62 62 62
  (0x102, "aaa")     (0x201, "bbb")

This may be unintuitive, but note:

1. Files _within_ a directory are still ordered, since they share a did
   prefix.

2. We don't really care about the relative ordering of dids, just
   that they are unique. Changing the ordering at this level does not
   interfere with any of our did-related functions.

3. The only thing we may care about is that the root, did=0, is the
   first mtree entry. This is still true. No leb128 encoding is < 0x00
   even after encoding.

The motivation for this change is to allow for other named-btrees in the
system that may used non-did-prefixed names. At least one of these makes
sense for a sort of "content-tree" (cksum -> data block mapping).

As a plus, this change makes it possible to compare names and do btree
namelookups without needing to decode the leb128 prefix. Although I'm
struggling a bit to figure out exactly where this is useful...

One downside, this ordering only works if dids are always stored in
their canonical encoding, that is, the smallest leb128 encoding possible
for a given did. I think this is a reasonable requirement for just our
dids.

Another downside is this did add a decent chunk of code.

I did try limiting the changes to lfsr_data_namecmp, but it didn't have
much impact. I guess most of the cost comes from the reworked
lfsr_data_cmp function, which, to be fair, is quite a bit more
complicated now (it now supports limited data<=>data comparisons):

            code          stack
  before:  34148           2896
  namecmp: 34324 (+0.5%)   2896 (+0.0%)
  after:   34340 (+0.6%)   2896 (+0.0%)
---
 lfs.c                 | 131 ++++++++++++++++-----------------
 scripts/dbgbmap.py    | 128 --------------------------------
 scripts/dbglfs.py     |  33 ++++++---
 tests/test_btree.toml | 165 ++++++++++++------------------------------
 4 files changed, 136 insertions(+), 321 deletions(-)

diff --git a/lfs.c b/lfs.c
index 0142ec67..d0921657 100644
--- a/lfs.c
+++ b/lfs.c
@@ -1357,73 +1357,73 @@ static inline int lfsr_data_readlleb128(lfs_t *lfs, lfsr_data_t *data,
     return 0;
 }
 
-static lfs_scmp_t lfsr_data_cmp(lfs_t *lfs, const lfsr_data_t *data,
-        const void *buffer, lfs_size_t size) {
-    // limit our size to data range
-    lfs_size_t d = lfs_min32(size, lfsr_data_size(data));
+static lfs_scmp_t lfsr_data_cmp_(lfs_t *lfs,
+        const lfsr_data_t *a,
+        const lfsr_data_t *b,
+        lfs_size_t size) {
+    // on-disk cmp buffer?
+    if (lfsr_data_ondisk(a) && lfsr_data_isbuf(b)) {
+        return lfsr_bd_cmp(lfs, a->u.disk.block, a->u.disk.off, 0,
+                b->u.buf.buffer, size);
 
-    // on-disk?
-    if (lfsr_data_ondisk(data)) {
-        int cmp = lfsr_bd_cmp(lfs, data->u.disk.block, data->u.disk.off, 0,
-                buffer, d);
+    // on-disk cmp inlined?
+    } else if (lfsr_data_ondisk(a) && lfsr_data_isimm(b)) {
+        return lfsr_bd_cmp(lfs, a->u.disk.block, a->u.disk.off, 0,
+                b->u.imm.buf, size);
+
+    // not supported
+    } else {
+        LFS_UNREACHABLE();
+    }
+}
+
+static lfs_scmp_t lfsr_data_cmp(lfs_t *lfs,
+        const lfsr_data_t *a,
+        const lfsr_data_t *b) {
+    // simple data?
+    if (!lfsr_data_iscat(b)) {
+        // compare common prefix
+        lfs_scmp_t cmp = lfsr_data_cmp_(lfs, a, b,
+                lfs_min32(
+                    lfsr_data_size(a),
+                    lfsr_data_size(b)));
         if (cmp != LFS_CMP_EQ) {
             return cmp;
         }
 
-    // buffer?
-    } else if (lfsr_data_isbuf(data)) {
-        int cmp = memcmp(data->u.buf.buffer, buffer, d);
-        if (cmp < 0) {
-            return LFS_CMP_LT;
-        } else if (cmp > 0) {
-            return LFS_CMP_GT;
-        }
-
-    // inlined?
-    } else if (lfsr_data_isimm(data)) {
-        int cmp = memcmp(data->u.imm.buf, buffer, d);
-        if (cmp < 0) {
-            return LFS_CMP_LT;
-        } else if (cmp > 0) {
-            return LFS_CMP_GT;
-        }
-
-    // concatenated? not supported
+    // concatenated data? handle specially to avoid recursion
     } else {
-        LFS_UNREACHABLE();
+        // compare common prefix
+        lfs_size_t size = lfs_min32(
+                lfsr_data_size(a),
+                lfsr_data_size(b));
+        lfsr_data_t a_ = *a;
+        const lfsr_data_t *b_ = b->u.cat.datas;
+        while (size > 0) {
+            lfs_size_t d = lfs_min32(
+                    size,
+                    lfsr_data_size(b_));
+            lfs_scmp_t cmp = lfsr_data_cmp_(lfs, &a_, b_, d);
+            if (cmp != LFS_CMP_EQ) {
+                return cmp;
+            }
+
+            a_ = lfsr_data_slice(a_, d, -1);
+            size -= d;
+            b_ += 1;
+        }
     }
 
     // if data is equal, check for size mismatch
-    if (lfsr_data_size(data) < size) {
+    if (lfsr_data_size(a) < lfsr_data_size(b)) {
         return LFS_CMP_LT;
-    } else if (lfsr_data_size(data) > size) {
+    } else if (lfsr_data_size(a) > lfsr_data_size(b)) {
         return LFS_CMP_GT;
     } else {
         return LFS_CMP_EQ;
     }
 }
 
-static lfs_scmp_t lfsr_data_namecmp(lfs_t *lfs, const lfsr_data_t *data,
-        lfsr_did_t did, const char *name, lfs_size_t name_size) {
-    // first compare the did
-    lfsr_data_t data_ = *data;
-    lfsr_did_t did_;
-    int err = lfsr_data_readleb128(lfs, &data_, &did_);
-    if (err) {
-        LFS_ASSERT(err < 0);
-        return err;
-    }
-
-    if (did_ < did) {
-        return LFS_CMP_LT;
-    } else if (did_ > did) {
-        return LFS_CMP_GT;
-    }
-
-    // then compare the actual name
-    return lfsr_data_cmp(lfs, &data_, name, name_size);
-}
-
 static int lfsr_bd_progdata_(lfs_t *lfs,
         lfs_block_t block, lfs_size_t off, lfsr_data_t data,
         uint32_t *cksum_, uint32_t *flcksum_) {
@@ -1468,11 +1468,8 @@ static int lfsr_bd_progdata(lfs_t *lfs,
         uint32_t *cksum_, uint32_t *flcksum_) {
     // simple data?
     if (!lfsr_data_iscat(&data)) {
-        int err = lfsr_bd_progdata_(lfs, block, off, data,
+        return lfsr_bd_progdata_(lfs, block, off, data,
                 cksum_, flcksum_);
-        if (err) {
-            return err;
-        }
 
     // concatenated data? handle specially to avoid recursion
     } else {
@@ -1489,9 +1486,9 @@ static int lfsr_bd_progdata(lfs_t *lfs,
             size -= lfsr_data_size(datas);
             datas += 1;
         }
-    }
 
-    return 0;
+        return 0;
+    }
 }
 
 
@@ -3741,7 +3738,7 @@ static int lfsr_rbyd_appendshrub(lfs_t *lfs, lfsr_rbyd_t *rbyd,
 // binary search an rbyd for a name, leaving the rid_/tag_/weight_/data_
 // with the best matching name if not found
 static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
-        lfsr_did_t did, const char *name, lfs_size_t name_size,
+        const lfsr_data_t *name,
         lfsr_srid_t *rid_,
         lfsr_tag_t *tag_, lfsr_rid_t *weight_, lfsr_data_t *data_) {
     // empty rbyd? leave it up to upper layers to handle this
@@ -3775,7 +3772,7 @@ static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
 
         // compare names
         } else {
-            cmp = lfsr_data_namecmp(lfs, &data__, did, name, name_size);
+            cmp = lfsr_data_cmp(lfs, &data__, name);
             if (cmp < 0) {
                 return cmp;
             }
@@ -4701,7 +4698,7 @@ static int lfsr_btree_commit(lfs_t *lfs, lfsr_btree_t *btree, lfsr_bid_t bid,
 
 // lookup in a btree by name
 static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree,
-        lfsr_did_t did, const char *name, lfs_size_t name_size,
+        const lfsr_data_t *name,
         lfsr_bid_t *bid_,
         lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) {
     // an empty tree?
@@ -4716,8 +4713,7 @@ static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree,
         // lookup our name in the rbyd via binary search
         lfsr_srid_t rid__;
         lfsr_rid_t weight__;
-        lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &branch,
-                did, name, name_size,
+        lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &branch, name,
                 &rid__, NULL, &weight__, NULL);
         if (cmp < 0) {
             LFS_ASSERT(cmp != LFS_ERR_NOENT);
@@ -6926,7 +6922,9 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
     lfsr_srid_t rid;
     lfsr_tag_t tag;
     lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->rbyd,
-            did, name, name_size,
+            &LFSR_DATA_CAT(
+                LFSR_DATA_LEB128(did),
+                LFSR_DATA_BUF(name, name_size)),
             &rid, &tag, NULL, data_);
     if (cmp < 0) {
         LFS_ASSERT(cmp != LFS_ERR_NOENT);
@@ -6985,7 +6983,9 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, const lfsr_mtree_t *mtree,
         lfsr_bid_t weight;
         lfsr_data_t data;
         lfs_scmp_t cmp = lfsr_btree_namelookup(lfs, &mtree->u.btree,
-                did, name, name_size,
+                &LFSR_DATA_CAT(
+                    LFSR_DATA_LEB128(did),
+                    LFSR_DATA_BUF(name, name_size)),
                 &bid, &tag, &weight, &data);
         if (cmp < 0) {
             LFS_ASSERT(cmp != LFS_ERR_NOENT);
@@ -7746,7 +7746,8 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
         return err;
     }
 
-    lfs_scmp_t cmp = lfsr_data_cmp(lfs, &data, "littlefs", 8);
+    lfs_scmp_t cmp = lfsr_data_cmp(lfs, &data,
+            &LFSR_DATA_BUF("littlefs", 8));
     if (cmp < 0) {
         return cmp;
     }
diff --git a/scripts/dbgbmap.py b/scripts/dbgbmap.py
index c9e41658..83f6bbd5 100755
--- a/scripts/dbgbmap.py
+++ b/scripts/dbgbmap.py
@@ -1175,134 +1175,6 @@ class Rbyd:
                 else:
                     return True, -1, 0, None
 
-    # lookup by name
-    def namelookup(self, did, name):
-        # binary search
-        best = (False, -1, 0, 0)
-        lower = 0
-        upper = self.weight
-        while lower < upper:
-            done, rid, tag, w, j, d, data, _ = self.lookup(
-                lower + (upper-1-lower)//2, TAG_NAME)
-            if done:
-                break
-
-            # treat vestigial names as a catch-all
-            if ((tag == TAG_NAME and rid-(w-1) == 0)
-                    or (tag & 0xff00) != TAG_NAME):
-                did_ = 0
-                name_ = b''
-            else:
-                did_, d = fromleb128(data)
-                name_ = data[d:]
-
-            # bisect search space
-            if (did_, name_) > (did, name):
-                upper = rid-(w-1)
-            elif (did_, name_) < (did, name):
-                lower = rid + 1
-
-                # keep track of best match
-                best = (False, rid, tag, w)
-            else:
-                # found a match
-                return True, rid, tag, w
-
-        return best
-
-    # lookup by name with this rbyd as the btree root
-    def btree_namelookup(self, f, block_size, did, name):
-        rbyd = self
-        bid = 0
-
-        while True:
-            found, rid, tag, w = rbyd.namelookup(did, name)
-            done, rid_, tag_, w_, j, d, data, _ = rbyd.lookup(rid, TAG_STRUCT)
-
-            # found another branch
-            if tag_ & 0xfff == TAG_BRANCH:
-                # update our bid
-                bid += rid - (w-1)
-
-                block, trunk, cksum = frombranch(data)
-                rbyd = Rbyd.fetch(f, block_size, block, trunk)
-
-            # found best match
-            else:
-                return bid + rid, tag_, w, data
-
-    # lookup by name with this rbyd as the mroot
-    def mtree_namelookup(self, f, block_size, did, name):
-        # have mtree?
-        done, rid, tag, w, j, d, data, _ = self.lookup(-1, TAG_MTREE)
-        if not done and rid == -1 and tag == TAG_MTREE:
-            w, block, trunk, cksum = frombtree(data)
-            mtree = Rbyd.fetch(f, block_size, block, trunk)
-            # corrupted?
-            if not mtree:
-                return False, -1, 0, None, -1, 0, 0
-
-            # lookup our name in the mtree
-            mbid, tag_, mw, data = mtree.btree_namelookup(
-                f, block_size, did, name)
-            if tag_ != TAG_MDIR:
-                return False, -1, 0, None, -1, 0, 0
-
-            # fetch the mdir
-            blocks = frommdir(data)
-            mdir = Rbyd.fetch(f, block_size, blocks)
-
-        else:
-            # have mdir?
-            done, rid, tag, w, j, _, data, _ = self.lookup(-1, TAG_MDIR)
-            if not done and rid == -1 and tag == TAG_MDIR:
-                blocks = frommdir(data)
-                mbid = 0
-                mw = 0
-                mdir = Rbyd.fetch(f, block_size, blocks)
-
-            else:
-                # I guess we're inlined?
-                mbid = -1
-                mw = 0
-                mdir = self
-
-        # lookup name in our mdir
-        found, rid, tag, w = mdir.namelookup(did, name)
-        return found, mbid, mw, mdir, rid, tag, w
-
-    # iterate through a directory assuming this is the mtree root
-    def mtree_dir(self, f, block_size, did):
-        # lookup the bookmark
-        found, mbid, mw, mdir, rid, tag, w = self.mtree_namelookup(
-            f, block_size, did, b'')
-        # iterate through all files until the next bookmark
-        while found:
-            # lookup each rid
-            done, rid, tag, w, j, d, data, _ = mdir.lookup(rid, TAG_NAME)
-            if done:
-                break
-
-            # parse out each name
-            did_, d_ = fromleb128(data)
-            name_ = data[d_:]
-
-            # end if we see another did
-            if did_ != did:
-                break
-
-            # yield what we've found
-            yield name_, mbid, mw, mdir, rid, tag, w
-
-            rid += w
-            if rid >= mdir.weight:
-                rid -= mdir.weight
-                mbid += 1
-
-                done, mbid, mw, mdir = self.mtree_lookup(f, block_size, mbid)
-                if done:
-                    break
-
 
 def main(disk, mroots=None, *,
         block_size=None,
diff --git a/scripts/dbglfs.py b/scripts/dbglfs.py
index 31e16da8..5645a49b 100755
--- a/scripts/dbglfs.py
+++ b/scripts/dbglfs.py
@@ -131,6 +131,18 @@ def fromleb128(data):
             return word, i+1
     return word, len(data)
 
+def toleb128(word):
+    data = []
+    word &= 0xffffffff
+    while True:
+        b, word = word & 0x7f, word >> 7
+        if word:
+            data.append(b | 0x80)
+        else:
+            data.append(b | 0x00)
+            break
+    return bytes(data)
+
 def fromtag(data):
     data = data.ljust(4, b'\0')
     tag = (data[0] << 8) | data[1]
@@ -868,7 +880,7 @@ class Rbyd:
                     return True, -1, 0, None
 
     # lookup by name
-    def namelookup(self, did, name):
+    def namelookup(self, name):
         # binary search
         best = (False, -1, 0, 0)
         lower = 0
@@ -882,16 +894,14 @@ class Rbyd:
             # treat vestigial names as a catch-all
             if ((tag == TAG_NAME and rid-(w-1) == 0)
                     or (tag & 0xff00) != TAG_NAME):
-                did_ = 0
                 name_ = b''
             else:
-                did_, d = fromleb128(data)
-                name_ = data[d:]
+                name_ = data
 
             # bisect search space
-            if (did_, name_) > (did, name):
+            if name_ > name:
                 upper = rid-(w-1)
-            elif (did_, name_) < (did, name):
+            elif name_ < name:
                 lower = rid + 1
 
                 # keep track of best match
@@ -903,12 +913,12 @@ class Rbyd:
         return best
 
     # lookup by name with this rbyd as the btree root
-    def btree_namelookup(self, f, block_size, did, name):
+    def btree_namelookup(self, f, block_size, name):
         rbyd = self
         bid = 0
 
         while True:
-            found, rid, tag, w = rbyd.namelookup(did, name)
+            found, rid, tag, w = rbyd.namelookup(name)
             done, rid_, tag_, w_, j, d, data, _ = rbyd.lookup(rid, TAG_STRUCT)
 
             # found another branch
@@ -925,6 +935,9 @@ class Rbyd:
 
     # lookup by name with this rbyd as the mroot
     def mtree_namelookup(self, f, block_size, did, name):
+        # concatenate did + name
+        name = toleb128(did) + name
+
         # have mtree?
         done, rid, tag, w, j, d, data, _ = self.lookup(-1, TAG_MTREE)
         if not done and rid == -1 and tag == TAG_MTREE:
@@ -936,7 +949,7 @@ class Rbyd:
 
             # lookup our name in the mtree
             mbid, tag_, mw, data = mtree.btree_namelookup(
-                f, block_size, did, name)
+                f, block_size, name)
             if tag_ != TAG_MDIR:
                 return False, -1, 0, None, -1, 0, 0
 
@@ -960,7 +973,7 @@ class Rbyd:
                 mdir = self
 
         # lookup name in our mdir
-        found, rid, tag, w = mdir.namelookup(did, name)
+        found, rid, tag, w = mdir.namelookup(name)
         return found, mbid, mw, mdir, rid, tag, w
 
     # iterate through a directory assuming this is the mtree root
diff --git a/tests/test_btree.toml b/tests/test_btree.toml
index a3cf8c21..784ea71a 100644
--- a/tests/test_btree.toml
+++ b/tests/test_btree.toml
@@ -3226,13 +3226,11 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT;
 '''
 
 [cases.test_btree_find_one]
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3249,9 +3247,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -3266,7 +3262,7 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3274,7 +3270,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aab", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3284,8 +3280,6 @@ code = '''
 '''
 
 [cases.test_btree_find_two]
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3302,15 +3296,11 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aab", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aab", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -3325,7 +3315,7 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3333,7 +3323,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aab", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aab", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3341,7 +3331,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 0, "aac", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aac", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3352,8 +3342,6 @@ code = '''
 
 [cases.test_btree_find_three]
 in = 'lfs.c'
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 code = '''
     lfs_t lfs;
     lfs_init(&lfs, CFG) => 0;
@@ -3369,27 +3357,15 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(0),
-                    LFSR_DATA_BUF("aaa", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(1*DID),
-                    LFSR_DATA_BUF("aab", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aab", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(2*DID),
-                    LFSR_DATA_BUF("aac", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aac", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -3404,7 +3380,7 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3412,7 +3388,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aab", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3420,7 +3396,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aac", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3428,7 +3404,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "2", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aad", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3438,8 +3414,6 @@ code = '''
 '''
 
 [cases.test_btree_find_three_backwards]
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3456,27 +3430,15 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(0),
-                    LFSR_DATA_BUF("aaa", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(2*DID),
-                    LFSR_DATA_BUF("aac", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aac", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(
-                    LFSR_DATA_LEB128(1*DID),
-                    LFSR_DATA_BUF("aab", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aab", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
     printf("btree: w%d 0x%x.%x\n",
             btree.weight,
@@ -3491,7 +3453,7 @@ code = '''
     lfs_size_t weight_;
     lfsr_data_t data_;
 
-    lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aaa", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 0);
@@ -3499,7 +3461,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "0", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aab", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 1);
@@ -3507,7 +3469,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "1", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aac", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3515,7 +3477,7 @@ code = '''
     lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
     assert(memcmp(buffer, "2", 1) == 0);
 
-    lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
+    lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF("aad", 3),
             &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
     assert(tag_ == LFSR_TAG_DATA);
     assert(bid_ == 2);
@@ -3526,8 +3488,6 @@ code = '''
 
 [cases.test_btree_find]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3547,9 +3507,7 @@ code = '''
         'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26)
     };
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF(name, 3)),
             LFSR_ATTR(
                 LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
@@ -3562,10 +3520,7 @@ code = '''
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
-                LFSR_ATTR(
-                    LFSR_TAG_NAME, +1, LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(i*DID),
-                        LFSR_DATA_BUF(name, 3))),
+                LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF(name, 3)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
@@ -3594,7 +3549,7 @@ code = '''
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
 
-        lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(name, 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
@@ -3623,9 +3578,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("___", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
@@ -3665,9 +3618,7 @@ code = '''
                     LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
                 LFSR_ATTR(
                     LFSR_TAG_NAME, +1,
-                    LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(0),
-                        LFSR_DATA_BUF(name, 3))),
+                    LFSR_DATA_BUF(name, 3)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -3709,7 +3660,7 @@ code = '''
     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,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(sim_names[i], 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
@@ -3727,8 +3678,6 @@ code = '''
 [cases.test_btree_find_sparse]
 defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
 defines.W = 5
-# true or false for if we should use dids vs names
-defines.DID = [false, true]
 in = 'lfs.c'
 code = '''
     lfs_t lfs;
@@ -3748,9 +3697,7 @@ code = '''
         'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26)
     };
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +W,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +W, LFSR_DATA_BUF(name, 3)),
             LFSR_ATTR(
                 LFSR_TAG_DATA, 0,
                 LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
@@ -3763,11 +3710,7 @@ code = '''
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
-                LFSR_ATTR(
-                    LFSR_TAG_NAME, +W,
-                    LFSR_DATA_CAT(
-                        LFSR_DATA_LEB128(i*DID),
-                        LFSR_DATA_BUF(name, 3))),
+                LFSR_ATTR(LFSR_TAG_NAME, +W, LFSR_DATA_BUF(name, 3)),
                 LFSR_ATTR(
                     LFSR_TAG_DATA, 0,
                     LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
@@ -3796,7 +3739,7 @@ code = '''
             'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
         };
 
-        lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(name, 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i*W+W-1);
@@ -3826,9 +3769,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +W,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +W, LFSR_DATA_BUF("___", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
@@ -3884,9 +3825,7 @@ code = '''
                         LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
                     LFSR_ATTR(
                         LFSR_TAG_NAME, +weight2,
-                        LFSR_DATA_CAT(
-                            LFSR_DATA_LEB128(0),
-                            LFSR_DATA_BUF(name, 3))),
+                        LFSR_DATA_BUF(name, 3)),
                     LFSR_ATTR(
                         LFSR_TAG_DATA, 0,
                         LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -3953,7 +3892,7 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(sim_names[i], 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == weighted_bid+sim_weights[i]-1);
@@ -3989,9 +3928,7 @@ code = '''
     lfsr_btree_t btree;
     lfsr_btree_alloc(&lfs, &btree) => 0;
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
-            LFSR_ATTR(
-                LFSR_TAG_NAME, +1,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
+            LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("___", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
@@ -4033,7 +3970,8 @@ 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,
+            lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree,
+                    &LFSR_DATA_BUF(name, 3),
                     &split_bid, NULL, NULL, &split_data);
             assert(cmp >= 0);
             assert(cmp != LFS_CMP_EQ);
@@ -4042,9 +3980,7 @@ code = '''
                         split_bid, LFSR_ATTRS(
                             LFSR_ATTR(
                                 LFSR_TAG_NAME, +1,
-                                LFSR_DATA_CAT(
-                                    LFSR_DATA_LEB128(0),
-                                    LFSR_DATA_BUF(name, 3))),
+                                LFSR_DATA_BUF(name, 3)),
                             LFSR_ATTR(
                                 LFSR_TAG_DATA, 0,
                                 LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4056,11 +3992,7 @@ code = '''
             } else {
                 int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS(
                         LFSR_ATTR(LFSR_TAG_DATA, 0, split_data),
-                        LFSR_ATTR(
-                            LFSR_TAG_NAME, +1,
-                            LFSR_DATA_CAT(
-                                LFSR_DATA_LEB128(0),
-                                LFSR_DATA_BUF(name, 3))),
+                        LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF(name, 3)),
                         LFSR_ATTR(
                             LFSR_TAG_DATA, 0,
                             LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4133,7 +4065,7 @@ code = '''
     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,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(sim_names[i], 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == i);
@@ -4169,7 +4101,7 @@ code = '''
     lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
             LFSR_ATTR(
                 LFSR_TAG_NAME, +W,
-                LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
+                LFSR_DATA_BUF("___", 3)),
             LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
 
     // set up a simulation to compare against
@@ -4223,7 +4155,8 @@ code = '''
             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,
+            lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree,
+                    &LFSR_DATA_BUF(name, 3),
                     &split_bid, NULL, &split_weight, &split_data);
             assert(cmp >= 0);
             assert(cmp != LFS_CMP_EQ);
@@ -4232,9 +4165,7 @@ code = '''
                         split_bid-(split_weight-1), LFSR_ATTRS(
                             LFSR_ATTR(
                                 LFSR_TAG_NAME, +weight,
-                                LFSR_DATA_CAT(
-                                    LFSR_DATA_LEB128(0),
-                                    LFSR_DATA_BUF(name, 3))),
+                                LFSR_DATA_BUF(name, 3)),
                             LFSR_ATTR(
                                 LFSR_TAG_DATA, 0,
                                 LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4248,9 +4179,7 @@ code = '''
                         LFSR_ATTR(LFSR_TAG_DATA, 0, split_data),
                         LFSR_ATTR(
                             LFSR_TAG_NAME, +weight,
-                            LFSR_DATA_CAT(
-                                LFSR_DATA_LEB128(0),
-                                LFSR_DATA_BUF(name, 3))),
+                            LFSR_DATA_BUF(name, 3)),
                         LFSR_ATTR(
                             LFSR_TAG_DATA, 0,
                             LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4357,7 +4286,7 @@ code = '''
             weighted_bid += sim_weights[j];
         }
 
-        lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
+        lfsr_btree_namelookup(&lfs, &btree, &LFSR_DATA_BUF(sim_names[i], 3),
                 &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
         assert(tag_ == LFSR_TAG_DATA);
         assert(bid_ == weighted_bid+sim_weights[i]-1);