Github/littlefs
1
Fork 0
Code Actions Activity

Changed rbyd/btree namelookups to only compare raw bytes

Browse Source 
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%)
This commit is contained in:
Christopher Haster
2024-02-23 15:50:21 -06:00
parent 5eed6f40aa
commit 94f7d2549f
4 changed files with 136 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+66 -65
View File
@@ -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;
}
scripts/dbgbmap.py
-128
View File
@@ -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,
scripts/dbglfs.py
+23 -10
View File
@@ -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
tests/test_btree.toml
+47 -118
View File
@@ -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);