Github/littlefs
1
Fork 0
Code Actions Activity

Reverted raw-byte comparisons for rbyd/btree namelookups

Browse Source 
Implementing raw-byte name comparisons ended up having more negative
effects on implementation requirements than I thought it would:

1. We would never actually concatenate the did + name, as that would
   require dynamic memory. Instead we need to express the concatenated
   relationship using our internal lfsr_data_t representation.

   I thought this wouldn't be too bad since we already have a
   concatenated lfsr_data_t representation, but:

   1. It was limited in scope, specifically only lfsr_data_prog was
      supported. It's actually not even possible to implement
      lfsr_data_read (I think) since we can't mutate the indirect
      lfsr_data_ts.

   2. It's not actually required. We really only use our concatenated
      representation to coalesce file fragments. You could in theory
      omit this representation at the cost of not being able to limit
      inlined shrub overhead.

   Asking all future littlefs implementations to implement a
   concatenated data representation (or dynamically allocate D:) for the
   basic task of file-name lookup is sort of a big ask.

2. A readonly implementation suddenly needs a toleb128 function.

   Which is an unexpected implication of requiring raw-byte leb128
   comparisons for file-name lookup.

3. Raw-byte comparisons require that dids are always stored in their
   canonical encoding (smallest leb128), though this is probably a good
   idea anyways.

And for what? A theoretical future-planned feature (content-tree)?

Let's think about the hypothetical content-tree for a second:

1. It's an advanced, opt-in feature. Which means higher code/storage-cost
   should be expected.

2. Basicall all littlefs implementations need file-name lookup, so
   keeping file-name lookup cheap is a much higher priority than the
   opt-int content-tree.

3. Worst case, the content-tree, and any future named trees, can just
   set did=0. This will cost one byte per name (and may leave room for
   future extensions).

So I'm reverting this for now.

There is still time before stabilization, so if it becomes clear there
is a better way to implement name lookups, we can still change this.
(Optimistically, the content-tree may be implemented before
stabilization, since it currently looks like it's required for data
redundancy).

Code changes:

           code          stack
  before: 34292           2896
  after:  34028 (-0.8%)   2896 (+0.0%)
This commit is contained in:
Christopher Haster
2024-02-24 13:55:32 -06:00
parent 35a4934178
commit 6c9ce4e8f1
3 changed files with 186 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+58 -62
View File
@@ -1353,73 +1353,72 @@ static inline int lfsr_data_readlleb128(lfs_t *lfs, lfsr_data_t *data,
return 0; return 0;
} }
static lfs_scmp_t lfsr_data_cmp_(lfs_t *lfs, static lfs_scmp_t lfsr_data_cmp(lfs_t *lfs, lfsr_data_t data,
const lfsr_data_t a, const void *buffer, lfs_size_t size) {
const lfsr_data_t b, // compare common prefix
lfs_size_t size) { lfs_size_t d = lfs_min32(size, lfsr_data_size(data));
// 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 cmp inlined? // on-disk?
} else if (lfsr_data_ondisk(a) && lfsr_data_isimm(b)) { if (lfsr_data_ondisk(data)) {
return lfsr_bd_cmp(lfs, a.u.disk.block, a.u.disk.off, 0, int cmp = lfsr_bd_cmp(lfs, data.u.disk.block, data.u.disk.off, 0,
b.u.imm.buf, size); buffer, d);
// 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) { if (cmp != LFS_CMP_EQ) {
return cmp; return cmp;
} }
// concatenated data? handle specially to avoid recursion // buffer?
} else { } else if (lfsr_data_isbuf(data)) {
// compare common prefix int cmp = memcmp(data.u.buf.buffer, buffer, d);
lfs_size_t size = lfs_min32( if (cmp < 0) {
lfsr_data_size(a), return LFS_CMP_LT;
lfsr_data_size(b)); } else if (cmp > 0) {
lfsr_data_t a_ = a; return LFS_CMP_GT;
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;
} }
// 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
} else {
LFS_UNREACHABLE();
} }
// if data is equal, check for size mismatch // if data is equal, check for size mismatch
if (lfsr_data_size(a) < lfsr_data_size(b)) { if (lfsr_data_size(data) < size) {
return LFS_CMP_LT; return LFS_CMP_LT;
} else if (lfsr_data_size(a) > lfsr_data_size(b)) { } else if (lfsr_data_size(data) > size) {
return LFS_CMP_GT; return LFS_CMP_GT;
} else { } else {
return LFS_CMP_EQ; return LFS_CMP_EQ;
} }
} }
static lfs_scmp_t lfsr_data_namecmp(lfs_t *lfs, lfsr_data_t data,
lfsr_did_t did, const char *name, lfs_size_t name_size) {
// first compare the did
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, static int lfsr_bd_progdata_(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfsr_data_t data, lfs_block_t block, lfs_size_t off, lfsr_data_t data,
uint32_t *cksum_, uint32_t *flcksum_) { uint32_t *cksum_, uint32_t *flcksum_) {
@@ -3734,7 +3733,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_ // binary search an rbyd for a name, leaving the rid_/tag_/weight_/data_
// with the best matching name if not found // with the best matching name if not found
static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
lfsr_data_t name, lfsr_did_t did, const char *name, lfs_size_t name_size,
lfsr_srid_t *rid_, lfsr_srid_t *rid_,
lfsr_tag_t *tag_, lfsr_rid_t *weight_, lfsr_data_t *data_) { lfsr_tag_t *tag_, lfsr_rid_t *weight_, lfsr_data_t *data_) {
// empty rbyd? leave it up to upper layers to handle this // empty rbyd? leave it up to upper layers to handle this
@@ -3768,7 +3767,7 @@ static lfs_scmp_t lfsr_rbyd_namelookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
// compare names // compare names
} else { } else {
cmp = lfsr_data_cmp(lfs, data__, name); cmp = lfsr_data_namecmp(lfs, data__, did, name, name_size);
if (cmp < 0) { if (cmp < 0) {
return cmp; return cmp;
} }
@@ -4694,7 +4693,7 @@ static int lfsr_btree_commit(lfs_t *lfs, lfsr_btree_t *btree, lfsr_bid_t bid,
// lookup in a btree by name // lookup in a btree by name
static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree, static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree,
lfsr_data_t name, lfsr_did_t did, const char *name, lfs_size_t name_size,
lfsr_bid_t *bid_, lfsr_bid_t *bid_,
lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { lfsr_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) {
// an empty tree? // an empty tree?
@@ -4709,7 +4708,8 @@ static lfs_scmp_t lfsr_btree_namelookup(lfs_t *lfs, const lfsr_btree_t *btree,
// lookup our name in the rbyd via binary search // lookup our name in the rbyd via binary search
lfsr_srid_t rid__; lfsr_srid_t rid__;
lfsr_rid_t weight__; lfsr_rid_t weight__;
lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &branch, name, lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &branch,
did, name, name_size,
&rid__, NULL, &weight__, NULL); &rid__, NULL, &weight__, NULL);
if (cmp < 0) { if (cmp < 0) {
LFS_ASSERT(cmp != LFS_ERR_NOENT); LFS_ASSERT(cmp != LFS_ERR_NOENT);
@@ -6911,9 +6911,7 @@ static int lfsr_mdir_namelookup(lfs_t *lfs, const lfsr_mdir_t *mdir,
lfsr_srid_t rid; lfsr_srid_t rid;
lfsr_tag_t tag; lfsr_tag_t tag;
lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->rbyd, lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->rbyd,
LFSR_DATA_CAT( did, name, name_size,
LFSR_DATA_LEB128(did),
LFSR_DATA_BUF(name, name_size)),
&rid, &tag, NULL, data_); &rid, &tag, NULL, data_);
if (cmp < 0) { if (cmp < 0) {
LFS_ASSERT(cmp != LFS_ERR_NOENT); LFS_ASSERT(cmp != LFS_ERR_NOENT);
@@ -6972,9 +6970,7 @@ static int lfsr_mtree_namelookup(lfs_t *lfs, const lfsr_mtree_t *mtree,
lfsr_bid_t weight; lfsr_bid_t weight;
lfsr_data_t data; lfsr_data_t data;
lfs_scmp_t cmp = lfsr_btree_namelookup(lfs, &mtree->u.btree, lfs_scmp_t cmp = lfsr_btree_namelookup(lfs, &mtree->u.btree,
LFSR_DATA_CAT( did, name, name_size,
LFSR_DATA_LEB128(did),
LFSR_DATA_BUF(name, name_size)),
&bid, &tag, &weight, &data); &bid, &tag, &weight, &data);
if (cmp < 0) { if (cmp < 0) {
LFS_ASSERT(cmp != LFS_ERR_NOENT); LFS_ASSERT(cmp != LFS_ERR_NOENT);
@@ -7735,7 +7731,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) {
return err; return err;
} }
lfs_scmp_t cmp = lfsr_data_cmp(lfs, data, LFSR_DATA_BUF("littlefs", 8)); lfs_scmp_t cmp = lfsr_data_cmp(lfs, data, "littlefs", 8);
if (cmp < 0) { if (cmp < 0) {
return cmp; return cmp;
} }
scripts/dbglfs.py
+10 -23
View File
@@ -131,18 +131,6 @@ def fromleb128(data):
return word, i+1 return word, i+1
return word, len(data) 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): def fromtag(data):
data = data.ljust(4, b'\0') data = data.ljust(4, b'\0')
tag = (data[0] << 8) | data[1] tag = (data[0] << 8) | data[1]
@@ -880,7 +868,7 @@ class Rbyd:
return True, -1, 0, None return True, -1, 0, None
# lookup by name # lookup by name
def namelookup(self, name): def namelookup(self, did, name):
# binary search # binary search
best = (False, -1, 0, 0) best = (False, -1, 0, 0)
lower = 0 lower = 0
@@ -894,14 +882,16 @@ class Rbyd:
# treat vestigial names as a catch-all # treat vestigial names as a catch-all
if ((tag == TAG_NAME and rid-(w-1) == 0) if ((tag == TAG_NAME and rid-(w-1) == 0)
or (tag & 0xff00) != TAG_NAME): or (tag & 0xff00) != TAG_NAME):
did_ = 0
name_ = b'' name_ = b''
else: else:
name_ = data did_, d = fromleb128(data)
name_ = data[d:]
# bisect search space # bisect search space
if name_ > name: if (did_, name_) > (did, name):
upper = rid-(w-1) upper = rid-(w-1)
elif name_ < name: elif (did_, name_) < (did, name):
lower = rid + 1 lower = rid + 1
# keep track of best match # keep track of best match
@@ -913,12 +903,12 @@ class Rbyd:
return best return best
# lookup by name with this rbyd as the btree root # lookup by name with this rbyd as the btree root
def btree_namelookup(self, f, block_size, name): def btree_namelookup(self, f, block_size, did, name):
rbyd = self rbyd = self
bid = 0 bid = 0
while True: while True:
found, rid, tag, w = rbyd.namelookup(name) found, rid, tag, w = rbyd.namelookup(did, name)
done, rid_, tag_, w_, j, d, data, _ = rbyd.lookup(rid, TAG_STRUCT) done, rid_, tag_, w_, j, d, data, _ = rbyd.lookup(rid, TAG_STRUCT)
# found another branch # found another branch
@@ -935,9 +925,6 @@ class Rbyd:
# lookup by name with this rbyd as the mroot # lookup by name with this rbyd as the mroot
def mtree_namelookup(self, f, block_size, did, name): def mtree_namelookup(self, f, block_size, did, name):
# concatenate did + name
name = toleb128(did) + name
# have mtree? # have mtree?
done, rid, tag, w, j, d, data, _ = self.lookup(-1, TAG_MTREE) done, rid, tag, w, j, d, data, _ = self.lookup(-1, TAG_MTREE)
if not done and rid == -1 and tag == TAG_MTREE: if not done and rid == -1 and tag == TAG_MTREE:
@@ -949,7 +936,7 @@ class Rbyd:
# lookup our name in the mtree # lookup our name in the mtree
mbid, tag_, mw, data = mtree.btree_namelookup( mbid, tag_, mw, data = mtree.btree_namelookup(
f, block_size, name) f, block_size, did, name)
if tag_ != TAG_MDIR: if tag_ != TAG_MDIR:
return False, -1, 0, None, -1, 0, 0 return False, -1, 0, None, -1, 0, 0
@@ -973,7 +960,7 @@ class Rbyd:
mdir = self mdir = self
# lookup name in our mdir # lookup name in our mdir
found, rid, tag, w = mdir.namelookup(name) found, rid, tag, w = mdir.namelookup(did, name)
return found, mbid, mw, mdir, rid, tag, w return found, mbid, mw, mdir, rid, tag, w
# iterate through a directory assuming this is the mtree root # iterate through a directory assuming this is the mtree root
tests/test_btree.toml
+118 -47
View File
@@ -3226,11 +3226,13 @@ code = '''
lfs_size_t weight_; lfs_size_t weight_;
lfsr_data_t data_; lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aaa", 3), lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT; &bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT;
''' '''
[cases.test_btree_find_one] [cases.test_btree_find_one]
# true or false for if we should use dids vs names
defines.DID = [false, true]
in = 'lfs.c' in = 'lfs.c'
code = ''' code = '''
lfs_t lfs; lfs_t lfs;
@@ -3247,7 +3249,9 @@ code = '''
lfsr_btree_t btree; lfsr_btree_t btree;
lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_alloc(&lfs, &btree) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
printf("btree: w%d 0x%x.%x\n", printf("btree: w%d 0x%x.%x\n",
btree.weight, btree.weight,
@@ -3262,7 +3266,7 @@ code = '''
lfs_size_t weight_; lfs_size_t weight_;
lfsr_data_t data_; lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aaa", 3), lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0); assert(bid_ == 0);
@@ -3270,7 +3274,7 @@ code = '''
lfsr_data_read(&lfs, &data_, buffer, 4) => 1; lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "0", 1) == 0); assert(memcmp(buffer, "0", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aab", 3), lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_LT; &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0); assert(bid_ == 0);
@@ -3280,6 +3284,8 @@ code = '''
''' '''
[cases.test_btree_find_two] [cases.test_btree_find_two]
# true or false for if we should use dids vs names
defines.DID = [false, true]
in = 'lfs.c' in = 'lfs.c'
code = ''' code = '''
lfs_t lfs; lfs_t lfs;
@@ -3296,11 +3302,15 @@ code = '''
lfsr_btree_t btree; lfsr_btree_t btree;
lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_alloc(&lfs, &btree) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aab", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aab", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
printf("btree: w%d 0x%x.%x\n", printf("btree: w%d 0x%x.%x\n",
btree.weight, btree.weight,
@@ -3315,7 +3325,7 @@ code = '''
lfs_size_t weight_; lfs_size_t weight_;
lfsr_data_t data_; lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aaa", 3), lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0); assert(bid_ == 0);
@@ -3323,7 +3333,7 @@ code = '''
lfsr_data_read(&lfs, &data_, buffer, 4) => 1; lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "0", 1) == 0); assert(memcmp(buffer, "0", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aab", 3), lfsr_btree_namelookup(&lfs, &btree, 0, "aab", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 1); assert(bid_ == 1);
@@ -3331,7 +3341,7 @@ code = '''
lfsr_data_read(&lfs, &data_, buffer, 4) => 1; lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "1", 1) == 0); assert(memcmp(buffer, "1", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aac", 3), lfsr_btree_namelookup(&lfs, &btree, 0, "aac", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_LT; &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 1); assert(bid_ == 1);
@@ -3342,6 +3352,8 @@ code = '''
[cases.test_btree_find_three] [cases.test_btree_find_three]
in = 'lfs.c' in = 'lfs.c'
# true or false for if we should use dids vs names
defines.DID = [false, true]
code = ''' code = '''
lfs_t lfs; lfs_t lfs;
lfs_init(&lfs, CFG) => 0; lfs_init(&lfs, CFG) => 0;
@@ -3357,15 +3369,27 @@ code = '''
lfsr_btree_t btree; lfsr_btree_t btree;
lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_alloc(&lfs, &btree) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(
LFSR_DATA_LEB128(0),
LFSR_DATA_BUF("aaa", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aab", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(
LFSR_DATA_LEB128(1*DID),
LFSR_DATA_BUF("aab", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 1, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aac", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(
LFSR_DATA_LEB128(2*DID),
LFSR_DATA_BUF("aac", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
printf("btree: w%d 0x%x.%x\n", printf("btree: w%d 0x%x.%x\n",
btree.weight, btree.weight,
@@ -3380,7 +3404,7 @@ code = '''
lfs_size_t weight_; lfs_size_t weight_;
lfsr_data_t data_; lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aaa", 3), lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0); assert(bid_ == 0);
@@ -3388,7 +3412,7 @@ code = '''
lfsr_data_read(&lfs, &data_, buffer, 4) => 1; lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "0", 1) == 0); assert(memcmp(buffer, "0", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aab", 3), lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 1); assert(bid_ == 1);
@@ -3396,7 +3420,7 @@ code = '''
lfsr_data_read(&lfs, &data_, buffer, 4) => 1; lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "1", 1) == 0); assert(memcmp(buffer, "1", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aac", 3), lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 2); assert(bid_ == 2);
@@ -3404,7 +3428,7 @@ code = '''
lfsr_data_read(&lfs, &data_, buffer, 4) => 1; lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "2", 1) == 0); assert(memcmp(buffer, "2", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aad", 3), lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_LT; &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 2); assert(bid_ == 2);
@@ -3414,6 +3438,8 @@ code = '''
''' '''
[cases.test_btree_find_three_backwards] [cases.test_btree_find_three_backwards]
# true or false for if we should use dids vs names
defines.DID = [false, true]
in = 'lfs.c' in = 'lfs.c'
code = ''' code = '''
lfs_t lfs; lfs_t lfs;
@@ -3430,15 +3456,27 @@ code = '''
lfsr_btree_t btree; lfsr_btree_t btree;
lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_alloc(&lfs, &btree) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aaa", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(
LFSR_DATA_LEB128(0),
LFSR_DATA_BUF("aaa", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)))) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)), LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)),
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aac", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(
LFSR_DATA_LEB128(2*DID),
LFSR_DATA_BUF("aac", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("2", 1)))) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)), LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("0", 1)),
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("aab", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(
LFSR_DATA_LEB128(1*DID),
LFSR_DATA_BUF("aab", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("1", 1)))) => 0;
printf("btree: w%d 0x%x.%x\n", printf("btree: w%d 0x%x.%x\n",
btree.weight, btree.weight,
@@ -3453,7 +3491,7 @@ code = '''
lfs_size_t weight_; lfs_size_t weight_;
lfsr_data_t data_; lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aaa", 3), lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0); assert(bid_ == 0);
@@ -3461,7 +3499,7 @@ code = '''
lfsr_data_read(&lfs, &data_, buffer, 4) => 1; lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "0", 1) == 0); assert(memcmp(buffer, "0", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aab", 3), lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 1); assert(bid_ == 1);
@@ -3469,7 +3507,7 @@ code = '''
lfsr_data_read(&lfs, &data_, buffer, 4) => 1; lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "1", 1) == 0); assert(memcmp(buffer, "1", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aac", 3), lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 2); assert(bid_ == 2);
@@ -3477,7 +3515,7 @@ code = '''
lfsr_data_read(&lfs, &data_, buffer, 4) => 1; lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "2", 1) == 0); assert(memcmp(buffer, "2", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF("aad", 3), lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_LT; &bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 2); assert(bid_ == 2);
@@ -3488,6 +3526,8 @@ code = '''
[cases.test_btree_find] [cases.test_btree_find]
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] 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' in = 'lfs.c'
code = ''' code = '''
lfs_t lfs; lfs_t lfs;
@@ -3507,7 +3547,9 @@ code = '''
'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26)
}; };
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF(name, 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
@@ -3520,7 +3562,10 @@ code = '''
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF(name, 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1, LFSR_DATA_CAT(
LFSR_DATA_LEB128(i*DID),
LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
@@ -3549,7 +3594,7 @@ code = '''
'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
}; };
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF(name, 3), lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == i); assert(bid_ == i);
@@ -3578,7 +3623,9 @@ code = '''
lfsr_btree_t btree; lfsr_btree_t btree;
lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_alloc(&lfs, &btree) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("___", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
// set up a simulation to compare against // set up a simulation to compare against
@@ -3618,7 +3665,9 @@ code = '''
LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_NAME, +1, LFSR_TAG_NAME, +1,
LFSR_DATA_BUF(name, 3)), LFSR_DATA_CAT(
LFSR_DATA_LEB128(0),
LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -3660,7 +3709,7 @@ code = '''
lfs_size_t weight_; lfs_size_t weight_;
lfsr_data_t data_; lfsr_data_t data_;
for (lfs_size_t i = 0; i < sim_size; i++) { for (lfs_size_t i = 0; i < sim_size; i++) {
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF(sim_names[i], 3), lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == i); assert(bid_ == i);
@@ -3678,6 +3727,8 @@ code = '''
[cases.test_btree_find_sparse] [cases.test_btree_find_sparse]
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
defines.W = 5 defines.W = 5
# true or false for if we should use dids vs names
defines.DID = [false, true]
in = 'lfs.c' in = 'lfs.c'
code = ''' code = '''
lfs_t lfs; lfs_t lfs;
@@ -3697,7 +3748,9 @@ code = '''
'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26) 'a'+((0/26/26) % 26), 'a'+((0/26) % 26), 'a'+(0 % 26)
}; };
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_NAME, +W, LFSR_DATA_BUF(name, 3)), LFSR_ATTR(
LFSR_TAG_NAME, +W,
LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0;
@@ -3710,7 +3763,11 @@ code = '''
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)), LFSR_DATA_BUF(&(uint8_t){'0'+((i-1) % 10)}, 1)),
LFSR_ATTR(LFSR_TAG_NAME, +W, LFSR_DATA_BUF(name, 3)), LFSR_ATTR(
LFSR_TAG_NAME, +W,
LFSR_DATA_CAT(
LFSR_DATA_LEB128(i*DID),
LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1)))); LFSR_DATA_BUF(&(uint8_t){'0'+((i-0) % 10)}, 1))));
@@ -3739,7 +3796,7 @@ code = '''
'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26) 'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
}; };
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF(name, 3), lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == i*W+W-1); assert(bid_ == i*W+W-1);
@@ -3769,7 +3826,9 @@ code = '''
lfsr_btree_t btree; lfsr_btree_t btree;
lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_alloc(&lfs, &btree) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_NAME, +W, LFSR_DATA_BUF("___", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +W,
LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
// set up a simulation to compare against // set up a simulation to compare against
@@ -3825,7 +3884,9 @@ code = '''
LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_NAME, +weight2, LFSR_TAG_NAME, +weight2,
LFSR_DATA_BUF(name, 3)), LFSR_DATA_CAT(
LFSR_DATA_LEB128(0),
LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -3892,7 +3953,7 @@ code = '''
weighted_bid += sim_weights[j]; weighted_bid += sim_weights[j];
} }
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF(sim_names[i], 3), lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == weighted_bid+sim_weights[i]-1); assert(bid_ == weighted_bid+sim_weights[i]-1);
@@ -3928,7 +3989,9 @@ code = '''
lfsr_btree_t btree; lfsr_btree_t btree;
lfsr_btree_alloc(&lfs, &btree) => 0; lfsr_btree_alloc(&lfs, &btree) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF("___", 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
// set up a simulation to compare against // set up a simulation to compare against
@@ -3970,8 +4033,7 @@ code = '''
// split btree // split btree
lfs_size_t split_bid; lfs_size_t split_bid;
lfsr_data_t split_data; lfsr_data_t split_data;
lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3,
LFSR_DATA_BUF(name, 3),
&split_bid, NULL, NULL, &split_data); &split_bid, NULL, NULL, &split_data);
assert(cmp >= 0); assert(cmp >= 0);
assert(cmp != LFS_CMP_EQ); assert(cmp != LFS_CMP_EQ);
@@ -3980,7 +4042,9 @@ code = '''
split_bid, LFSR_ATTRS( split_bid, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_NAME, +1, LFSR_TAG_NAME, +1,
LFSR_DATA_BUF(name, 3)), LFSR_DATA_CAT(
LFSR_DATA_LEB128(0),
LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -3992,7 +4056,11 @@ code = '''
} else { } else {
int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS( int err = lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_DATA, 0, split_data), LFSR_ATTR(LFSR_TAG_DATA, 0, split_data),
LFSR_ATTR(LFSR_TAG_NAME, +1, LFSR_DATA_BUF(name, 3)), LFSR_ATTR(
LFSR_TAG_NAME, +1,
LFSR_DATA_CAT(
LFSR_DATA_LEB128(0),
LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4065,7 +4133,7 @@ code = '''
lfs_size_t weight_; lfs_size_t weight_;
lfsr_data_t data_; lfsr_data_t data_;
for (lfs_size_t i = 0; i < sim_size; i++) { for (lfs_size_t i = 0; i < sim_size; i++) {
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF(sim_names[i], 3), lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == i); assert(bid_ == i);
@@ -4101,7 +4169,7 @@ code = '''
lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_NAME, +W, LFSR_TAG_NAME, +W,
LFSR_DATA_BUF("___", 3)), LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))),
LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0; LFSR_ATTR(LFSR_TAG_DATA, 0, LFSR_DATA_BUF("_", 1)))) => 0;
// set up a simulation to compare against // set up a simulation to compare against
@@ -4155,8 +4223,7 @@ code = '''
lfs_size_t split_bid; lfs_size_t split_bid;
lfs_size_t split_weight; lfs_size_t split_weight;
lfsr_data_t split_data; lfsr_data_t split_data;
lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3,
LFSR_DATA_BUF(name, 3),
&split_bid, NULL, &split_weight, &split_data); &split_bid, NULL, &split_weight, &split_data);
assert(cmp >= 0); assert(cmp >= 0);
assert(cmp != LFS_CMP_EQ); assert(cmp != LFS_CMP_EQ);
@@ -4165,7 +4232,9 @@ code = '''
split_bid-(split_weight-1), LFSR_ATTRS( split_bid-(split_weight-1), LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_NAME, +weight, LFSR_TAG_NAME, +weight,
LFSR_DATA_BUF(name, 3)), LFSR_DATA_CAT(
LFSR_DATA_LEB128(0),
LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4179,7 +4248,9 @@ code = '''
LFSR_ATTR(LFSR_TAG_DATA, 0, split_data), LFSR_ATTR(LFSR_TAG_DATA, 0, split_data),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_NAME, +weight, LFSR_TAG_NAME, +weight,
LFSR_DATA_BUF(name, 3)), LFSR_DATA_CAT(
LFSR_DATA_LEB128(0),
LFSR_DATA_BUF(name, 3))),
LFSR_ATTR( LFSR_ATTR(
LFSR_TAG_DATA, 0, LFSR_TAG_DATA, 0,
LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1))));
@@ -4286,7 +4357,7 @@ code = '''
weighted_bid += sim_weights[j]; weighted_bid += sim_weights[j];
} }
lfsr_btree_namelookup(&lfs, &btree, LFSR_DATA_BUF(sim_names[i], 3), lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
assert(tag_ == LFSR_TAG_DATA); assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == weighted_bid+sim_weights[i]-1); assert(bid_ == weighted_bid+sim_weights[i]-1);