Github/littlefs
1
Fork 0
Code Actions Activity

Added LFSR_TAG_BNAME/MNAME, stop btree lookups at first tag

Browse Source 
Now that we don't have to worry about name tag conflicts as much, we
can add name tags for things that aren't files.

This adds LFSR_TAG_BNAME for branch names, and LFSR_TAG_MNAME for mtree
names. Note that the upper 4 bits of the subtype match LFSR_TAG_BRANCH
and LFSR_TAG_MDIR respectively:

  LFSR_TAG_BNAME        0x0200  v--- --1- ---- ----
  LFSR_TAG_MNAME        0x0220  v--- --1- --1- ----

  LFSR_TAG_BRANCH       0x030r  v--- --11 ---- --rr
  LFSR_TAG_MDIR         0x0324  v--- --11 --1- -1rr

The encoding is somewhat arbitrary, but I figured reserving ~31 types
for files is probably going to be plenty for littlefs. POSIX seems to
do just fine with only ~7 all these years, and I think custom attributes
will be more enticing for "niche" file types (symlinks, compressed
files, etc), given the easy backwards compatibility.

---

In addition to the debugging benefits, the new name tags let us stop
btree lookups on the first non-bname/branch tag. Previously we always
had to fetch the first struct tag as well to check if it was a branch.

In theory this saves one rbyd lookup, but in practice it's a bit muddy.

The problem is that there's two ways to use named btrees:

1. As buckets: mtree -> mdir -> mid
2. As a table: ddtree -> ddid

The only named btree we _currently_ have is the mtree. And the mtree
operates in bucket mode, with each mdir acting more-or-less as an
extension to the btree. So we end up needing to do the second tag lookup
anyways, and all we've done is complicated up the code.

But we will _eventually_ need the table mode for the ddtree, where we
care if the ddname is an exact match.

And returning the first tag is arguably the more "correct" internal API,
vs arbitrarily the first struct tag.

But then again this change is pretty pricey...

           code          stack          ctx
  before: 35732           2440          640
  after:  35888 (+0.4%)   2480 (+1.6%)  640 (+0.0%)

---

It's worth noting the new BNAME/MNAME tags don't _require_ the btree
lookup changes (which is why we can get away with not touching the dbg
scripts). The previous algorithm of always checking for branch tags
still works.

Maybe there's an argument for conditionally using the previous API when
compiling without the ddtree, but that sounds horrendously messy...
This commit is contained in:
Christopher Haster
2025-04-28 13:59:10 -05:00
parent 5eb194c215
commit 677c078b50
10 changed files with 315 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_btree.toml
+146 -87
View File
@@ -3044,12 +3044,12 @@ code = '''
// try to find tags
lfsr_bid_t bid_;
lfsr_tag_t tag_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfs_size_t weight_;
lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_ERR_NOENT;
lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_ERR_NOENT;
'''
[cases.test_btree_find_one]
@@ -3072,7 +3072,7 @@ code = '''
lfsr_btree_init(&btree);
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, "aaa", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0;
printf("btree: w%d 0x%x.%x\n",
@@ -3084,20 +3084,26 @@ code = '''
// try to find tags
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0);
assert(weight_ == 1);
lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "0", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0);
assert(weight_ == 1);
@@ -3125,13 +3131,13 @@ code = '''
lfsr_btree_init(&btree);
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, "aaa", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, "aab", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0;
printf("btree: w%d 0x%x.%x\n",
@@ -3143,28 +3149,36 @@ code = '''
// try to find tags
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aaa", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0);
assert(weight_ == 1);
lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "0", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, 0, "aab", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aab", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 1);
assert(weight_ == 1);
lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "1", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, 0, "aac", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
lfsr_btree_namelookupleaf(&lfs, &btree, 0, "aac", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 1);
assert(weight_ == 1);
@@ -3192,19 +3206,19 @@ code = '''
lfsr_btree_init(&btree);
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, "aaa", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
1*DID, "aab", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0;
lfsr_btree_commit(&lfs, &btree, 1, LFSR_RATTRS(
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
2*DID, "aac", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "2", 1))) => 0;
printf("btree: w%d 0x%x.%x\n",
@@ -3216,36 +3230,46 @@ code = '''
// try to find tags
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0);
assert(weight_ == 1);
lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "0", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 1);
assert(weight_ == 1);
lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "1", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 2);
assert(weight_ == 1);
lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "2", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 2);
assert(weight_ == 1);
@@ -3273,19 +3297,19 @@ code = '''
lfsr_btree_init(&btree);
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, "aaa", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1))) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
2*DID, "aac", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "2", 1))) => 0;
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "0", 1),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
1*DID, "aab", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "1", 1))) => 0;
printf("btree: w%d 0x%x.%x\n",
@@ -3297,36 +3321,46 @@ code = '''
// try to find tags
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 0*DID, "aaa", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 0);
assert(weight_ == 1);
lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "0", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 1*DID, "aab", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 1);
assert(weight_ == 1);
lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "1", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 2*DID, "aac", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 2);
assert(weight_ == 1);
lfsr_data_read(&lfs, &data_, buffer, 4) => 1;
assert(memcmp(buffer, "2", 1) == 0);
lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_LT;
lfsr_btree_namelookupleaf(&lfs, &btree, 3*DID, "aad", 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_LT;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == 2);
assert(weight_ == 1);
@@ -3358,7 +3392,7 @@ code = '''
};
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
@@ -3373,7 +3407,7 @@ code = '''
LFSR_TAG_DATA, 0,
&(uint8_t){'0'+((i-1) % 10)}, 1),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
i*DID, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
@@ -3389,6 +3423,8 @@ code = '''
// try to find tags
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
@@ -3398,8 +3434,10 @@ code = '''
'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
};
lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == i);
assert(weight_ == 1);
@@ -3429,7 +3467,7 @@ code = '''
lfsr_btree_init(&btree);
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, "___", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0;
@@ -3469,7 +3507,7 @@ code = '''
LFSR_TAG_DATA, 0,
&(uint8_t){'0'+(i % 10)}, 1),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
@@ -3503,12 +3541,16 @@ code = '''
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
for (lfs_size_t i = 0; i < sim_size; i++) {
lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == i);
assert(weight_ == 1);
@@ -3547,7 +3589,7 @@ code = '''
};
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +W,
LFSR_TAG_REG, +W,
0, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
@@ -3562,7 +3604,7 @@ code = '''
LFSR_TAG_DATA, 0,
&(uint8_t){'0'+((i-1) % 10)}, 1),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +W,
LFSR_TAG_REG, +W,
i*DID, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
@@ -3578,6 +3620,8 @@ code = '''
// try to find tags
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
@@ -3587,8 +3631,10 @@ code = '''
'a'+((i/26/26) % 26), 'a'+((i/26) % 26), 'a'+(i % 26)
};
lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, i*DID, name, 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == i*W+W-1);
assert(weight_ == W);
@@ -3619,7 +3665,7 @@ code = '''
lfsr_btree_init(&btree);
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +W,
LFSR_TAG_REG, +W,
0, "___", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0;
@@ -3674,7 +3720,7 @@ code = '''
LFSR_TAG_DATA, 0,
&(uint8_t){'0'+(i % 10)}, 1),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +weight2,
LFSR_TAG_REG, +weight2,
0, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
@@ -3727,6 +3773,8 @@ code = '''
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
@@ -3737,8 +3785,10 @@ code = '''
weighted_bid += sim_weights[j];
}
lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == weighted_bid+sim_weights[i]-1);
assert(weight_ == sim_weights[i]);
@@ -3775,7 +3825,7 @@ code = '''
lfsr_btree_init(&btree);
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, "___", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0;
@@ -3816,28 +3866,28 @@ code = '''
}
// split btree
lfs_size_t split_bid;
lfsr_data_t split_data;
lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3,
&split_bid, NULL, NULL, &split_data);
lfsr_bid_t split_bid;
lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree,
0, name, 3,
&split_bid, NULL, NULL, NULL, NULL, NULL);
assert(cmp >= 0);
assert(cmp != LFS_CMP_EQ);
if (cmp > LFS_CMP_EQ) {
lfsr_btree_commit(&lfs, &btree,
split_bid, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
0, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
&(uint8_t){'0'+(i % 10)}, 1))) => 0;
lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_REG, +1,
0, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
&(uint8_t){'0'+(i % 10)}, 1))) => 0;
} else {
lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS(
LFSR_RATTR_DATA(
LFSR_TAG_DATA, 0,
&split_data),
// TODO can we avoid this noop? the problem is we need
// some way to differentiate inserting before vs after
// the requested bid
LFSR_RATTR_NOOP(),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +1,
LFSR_TAG_REG, +1,
0, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
@@ -3892,12 +3942,16 @@ code = '''
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
for (lfs_size_t i = 0; i < sim_size; i++) {
lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == i);
assert(weight_ == 1);
@@ -3932,7 +3986,7 @@ code = '''
lfsr_btree_init(&btree);
lfsr_btree_commit(&lfs, &btree, 0, LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +W,
LFSR_TAG_REG, +W,
0, "___", 3),
LFSR_RATTR_BUF(LFSR_TAG_DATA, 0, "_", 1))) => 0;
@@ -3984,29 +4038,30 @@ code = '''
}
// split btree
lfs_size_t split_bid;
lfs_size_t split_weight;
lfsr_data_t split_data;
lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3,
&split_bid, NULL, &split_weight, &split_data);
lfsr_bid_t split_bid;
lfsr_bid_t split_weight;
lfs_scmp_t cmp = lfsr_btree_namelookupleaf(&lfs, &btree,
0, name, 3,
&split_bid, NULL, NULL, NULL, &split_weight, NULL);
assert(cmp >= 0);
assert(cmp != LFS_CMP_EQ);
if (cmp > LFS_CMP_EQ) {
lfsr_btree_commit(&lfs, &btree,
split_bid-(split_weight-1), LFSR_RATTRS(
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +weight,
LFSR_TAG_REG, +weight,
0, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
&(uint8_t){'0'+(i % 10)}, 1))) => 0;
} else {
lfsr_btree_commit(&lfs, &btree, split_bid, LFSR_RATTRS(
LFSR_RATTR_DATA(
LFSR_TAG_DATA, 0,
&split_data),
// TODO can we avoid this noop? the problem is we need
// some way to differentiate inserting before vs after
// the requested bid
LFSR_RATTR_NOOP(),
LFSR_RATTR_NAME(
LFSR_TAG_NAME, +weight,
LFSR_TAG_REG, +weight,
0, name, 3),
LFSR_RATTR_BUF(
LFSR_TAG_DATA, 0,
@@ -4087,6 +4142,8 @@ code = '''
uint8_t buffer[4];
lfsr_bid_t bid_;
lfsr_rbyd_t rbyd_;
lfsr_srid_t rid_;
lfsr_tag_t tag_;
lfs_size_t weight_;
lfsr_data_t data_;
@@ -4097,8 +4154,10 @@ code = '''
weighted_bid += sim_weights[j];
}
lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ;
lfsr_btree_namelookupleaf(&lfs, &btree, 0, sim_names[i], 3,
&bid_, &rbyd_, &rid_, NULL, &weight_, NULL) => LFS_CMP_EQ;
lfsr_rbyd_lookup(&lfs, &rbyd_, rid_, LFSR_TAG_MASK8 | LFSR_TAG_STRUCT,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_DATA);
assert(bid_ == weighted_bid+sim_weights[i]-1);
assert(weight_ == sim_weights[i]);
tests/test_rbyd.toml
+55 -47
View File
@@ -4480,8 +4480,7 @@ code = '''
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
assert(rbyd.weight == N);
for (unsigned j = 0; j < N; j++) {
lfsr_rbyd_lookup(&lfs, &rbyd,
j, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 4;
assert(memcmp(buffer, names[j % 6], 4) == 0);
}
@@ -6219,7 +6218,8 @@ code = '''
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
for (unsigned k = 0; k < N; k++) {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 4;
assert(memcmp(buffer, names[k % 6], 4) == 0);
@@ -6247,7 +6247,8 @@ code = '''
assert(rid_ == k);
assert(lfsr_data_size(data_) == 2);
lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 2;
assert(memcmp(buffer, names[k % 6], 2) == 0);
}
@@ -6263,7 +6264,8 @@ code = '''
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
for (unsigned k = 0; k < N; k++) {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 4;
assert(memcmp(buffer, names[k % 6], 4) == 0);
@@ -6276,7 +6278,8 @@ code = '''
assert(rid_ == k);
assert(lfsr_data_size(data_) == 3);
lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 3;
assert(memcmp(buffer, names[k % 6], 3) == 0);
} else {
@@ -6284,7 +6287,8 @@ code = '''
assert(rid_ == k);
assert(lfsr_data_size(data_) == 2);
lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, rid_, tag_,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 2;
assert(memcmp(buffer, names[k % 6], 2) == 0);
}
@@ -6627,14 +6631,13 @@ code = '''
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
assert(rbyd.weight == N);
for (unsigned j = 0; j < N; j++) {
lfsr_rbyd_lookup(&lfs, &rbyd,
-1, LFSR_TAG_ATTR(j+1), NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1),
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 1;
assert(memcmp(buffer, names[j % 6], 1) == 0);
}
for (unsigned j = 0; j < N; j++) {
lfsr_rbyd_lookup(&lfs, &rbyd,
j, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, j, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 4;
assert(memcmp(buffer, names[j % 6], 4) == 0);
}
@@ -6779,8 +6782,8 @@ code = '''
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
assert(rbyd.weight == N);
for (unsigned j = 0; j < N; j++) {
lfsr_rbyd_lookup(&lfs, &rbyd,
-1, LFSR_TAG_ATTR(j+1), NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, -1, LFSR_TAG_ATTR(j+1),
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 1;
assert(memcmp(buffer, names[j % 6], 1) == 0);
}
@@ -10614,7 +10617,8 @@ code = '''
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
assert(rbyd.weight == N-1);
for (unsigned k = 0; k < N-1; k++) {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 4;
if (k >= j) {
assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
@@ -10637,11 +10641,13 @@ code = '''
assert(rbyd.weight == N);
for (unsigned k = 0; k < N; k++) {
if (k == j) {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 6) => 6;
assert(memcmp(buffer, names[k % 6], 6) == 0);
} else {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 6) => 4;
assert(memcmp(buffer, names[k % 6], 4) == 0);
}
@@ -10783,7 +10789,8 @@ code = '''
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0;
assert(rbyd.weight == N-1);
for (unsigned k = 0; k < N-1; k++) {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 4;
if (k >= j) {
assert(memcmp(buffer, names[(k+1) % 6], 4) == 0);
@@ -10792,8 +10799,8 @@ code = '''
}
for (unsigned u = 0; u < M; u++) {
lfsr_rbyd_lookup(&lfs, &rbyd,
k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_ATTR(u+1),
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 2;
if (k >= j) {
assert(memcmp(buffer, names[(k+1) % 6], 2) == 0);
@@ -10825,24 +10832,26 @@ code = '''
assert(rbyd.weight == N);
for (unsigned k = 0; k < N; k++) {
if (k == j) {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 6) => 6;
assert(memcmp(buffer, names[k % 6], 6) == 0);
for (unsigned u = 0; u < M; u++) {
lfsr_rbyd_lookup(&lfs, &rbyd,
k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_ATTR(u+1),
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 6) => 3;
assert(memcmp(buffer, names[k % 6], 3) == 0);
}
} else {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 6) => 4;
assert(memcmp(buffer, names[k % 6], 4) == 0);
for (unsigned u = 0; u < M; u++) {
lfsr_rbyd_lookup(&lfs, &rbyd,
k, LFSR_TAG_ATTR(u+1), NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_ATTR(u+1),
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 6) => 2;
assert(memcmp(buffer, names[k % 6], 2) == 0);
}
@@ -11573,8 +11582,7 @@ code = '''
// check that all tags are now removed
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
assert(rbyd.weight == 0);
lfsr_rbyd_lookup(&lfs, &rbyd,
LFSR_TAG_DATA, 0,
lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_DATA, 0,
NULL, &data) => LFS_ERR_NOENT;
// try resuming from all tags being removed
@@ -11586,12 +11594,10 @@ code = '''
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
assert(rbyd.weight == 1);
lfsr_rbyd_lookup(&lfs, &rbyd,
0, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 6) => 6;
assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0);
lfsr_rbyd_lookup(&lfs, &rbyd,
1, LFSR_TAG_DATA,
lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
NULL, &data) => LFS_ERR_NOENT;
// keep track of the worst size
@@ -11729,8 +11735,7 @@ code = '''
// check that all tags are now removed
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
assert(rbyd.weight == 0);
lfsr_rbyd_lookup(&lfs, &rbyd,
0, LFSR_TAG_DATA,
lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA,
NULL, &data) => LFS_ERR_NOENT;
// try resuming from all tags being removed
@@ -11748,21 +11753,18 @@ code = '''
lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0;
assert(rbyd.weight == 1);
lfsr_rbyd_lookup(&lfs, &rbyd,
0, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 6) => 6;
assert(memcmp(buffer, "\xaa\xaa\xaa\xaa\xaa\xaa", 6) == 0);
for (unsigned u = 0; u < M; u++) {
lfsr_rbyd_lookup(&lfs, &rbyd,
0, LFSR_TAG_ATTR(u+1), NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, 0, LFSR_TAG_ATTR(u+1),
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 6) => 3;
assert(memcmp(buffer, "\xaa\xaa\xaa", 3) == 0);
}
lfsr_rbyd_lookup(&lfs, &rbyd,
1, LFSR_TAG_DATA,
lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_DATA,
NULL, &data) => LFS_ERR_NOENT;
lfsr_rbyd_lookup(&lfs, &rbyd,
1, LFSR_TAG_ATTR(1),
lfsr_rbyd_lookup(&lfs, &rbyd, 1, LFSR_TAG_ATTR(1),
NULL, &data) => LFS_ERR_NOENT;
// keep track of the worst size
@@ -12349,7 +12351,8 @@ code = '''
assert(weight_ == W);
assert(lfsr_data_size(data_) == 4);
lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 4;
assert(memcmp(buffer, names[j % 6], 4) == 0);
}
@@ -13559,7 +13562,8 @@ code = '''
assert(weight_ == 0);
assert(lfsr_data_size(data_) == 2);
lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA, NULL, &data) => 0;
lfsr_rbyd_lookup(&lfs, &rbyd, j*W+W-1, LFSR_TAG_DATA,
NULL, &data) => 0;
lfsr_data_read(&lfs, &data, buffer, 4) => 4;
assert(memcmp(buffer, names[j % 6], 4) == 0);
}
@@ -16267,10 +16271,12 @@ code = '''
// also test that we can lookup each tag with a wide lookup
for (unsigned k = 0; k < N; k++) {
if (k == j) {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
lfsr_rbyd_lookup(&lfs, &rbyd, k,
LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
&tag_, &data_) => LFS_ERR_NOENT;
} else {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
lfsr_rbyd_lookup(&lfs, &rbyd, k,
LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f));
assert(lfsr_data_size(data_) == 4);
@@ -16638,10 +16644,12 @@ code = '''
// also test that we can lookup each tag with a wide lookup
for (unsigned k = 0; k < N; k++) {
if (k == j) {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
lfsr_rbyd_lookup(&lfs, &rbyd, k,
LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
&tag_, &data_) => LFS_ERR_NOENT;
} else {
lfsr_rbyd_lookup(&lfs, &rbyd, k, LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
lfsr_rbyd_lookup(&lfs, &rbyd, k,
LFSR_TAG_MASK8 | LFSR_TAG_ATTR,
&tag_, &data_) => 0;
assert(tag_ == LFSR_TAG_ATTR((k + SHIFT) & 0x7f));
assert(lfsr_data_size(data_) == 2);