From 6c9ce4e8f13485e2c5d6062e42c88dda5ad2adf7 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Sat, 24 Feb 2024 13:55:32 -0600 Subject: [PATCH] Reverted raw-byte comparisons for rbyd/btree namelookups 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%) --- lfs.c | 120 +++++++++++++++--------------- scripts/dbglfs.py | 33 +++------ tests/test_btree.toml | 165 ++++++++++++++++++++++++++++++------------ 3 files changed, 186 insertions(+), 132 deletions(-) diff --git a/lfs.c b/lfs.c index b4d56b25..eb382ad5 100644 --- a/lfs.c +++ b/lfs.c @@ -1353,73 +1353,72 @@ 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 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); +static lfs_scmp_t lfsr_data_cmp(lfs_t *lfs, lfsr_data_t data, + const void *buffer, lfs_size_t size) { + // compare common prefix + lfs_size_t d = lfs_min32(size, lfsr_data_size(data)); - // 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))); + // on-disk? + if (lfsr_data_ondisk(data)) { + int cmp = lfsr_bd_cmp(lfs, data.u.disk.block, data.u.disk.off, 0, + buffer, d); if (cmp != LFS_CMP_EQ) { return cmp; } - // concatenated data? handle specially to avoid recursion - } else { - // 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; + // 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 + } else { + LFS_UNREACHABLE(); } // 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; - } else if (lfsr_data_size(a) > lfsr_data_size(b)) { + } else if (lfsr_data_size(data) > size) { return LFS_CMP_GT; } else { 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, lfs_block_t block, lfs_size_t off, lfsr_data_t data, 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_ // with the best matching name if not found 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_tag_t *tag_, lfsr_rid_t *weight_, lfsr_data_t *data_) { // 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 } else { - cmp = lfsr_data_cmp(lfs, data__, name); + cmp = lfsr_data_namecmp(lfs, data__, did, name, name_size); if (cmp < 0) { 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 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_tag_t *tag_, lfsr_bid_t *weight_, lfsr_data_t *data_) { // 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 lfsr_srid_t rid__; 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); if (cmp < 0) { 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_tag_t tag; lfs_scmp_t cmp = lfsr_rbyd_namelookup(lfs, &mdir->rbyd, - LFSR_DATA_CAT( - LFSR_DATA_LEB128(did), - LFSR_DATA_BUF(name, name_size)), + did, name, name_size, &rid, &tag, NULL, data_); if (cmp < 0) { 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_data_t data; lfs_scmp_t cmp = lfsr_btree_namelookup(lfs, &mtree->u.btree, - LFSR_DATA_CAT( - LFSR_DATA_LEB128(did), - LFSR_DATA_BUF(name, name_size)), + did, name, name_size, &bid, &tag, &weight, &data); if (cmp < 0) { LFS_ASSERT(cmp != LFS_ERR_NOENT); @@ -7735,7 +7731,7 @@ static int lfsr_mountmroot(lfs_t *lfs, const lfsr_mdir_t *mroot) { 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) { return cmp; } diff --git a/scripts/dbglfs.py b/scripts/dbglfs.py index 5645a49b..31e16da8 100755 --- a/scripts/dbglfs.py +++ b/scripts/dbglfs.py @@ -131,18 +131,6 @@ 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] @@ -880,7 +868,7 @@ class Rbyd: return True, -1, 0, None # lookup by name - def namelookup(self, name): + def namelookup(self, did, name): # binary search best = (False, -1, 0, 0) lower = 0 @@ -894,14 +882,16 @@ 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: - name_ = data + did_, d = fromleb128(data) + name_ = data[d:] # bisect search space - if name_ > name: + if (did_, name_) > (did, name): upper = rid-(w-1) - elif name_ < name: + elif (did_, name_) < (did, name): lower = rid + 1 # keep track of best match @@ -913,12 +903,12 @@ class Rbyd: return best # 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 bid = 0 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) # found another branch @@ -935,9 +925,6 @@ 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: @@ -949,7 +936,7 @@ class Rbyd: # lookup our name in the mtree mbid, tag_, mw, data = mtree.btree_namelookup( - f, block_size, name) + f, block_size, did, name) if tag_ != TAG_MDIR: return False, -1, 0, None, -1, 0, 0 @@ -973,7 +960,7 @@ class Rbyd: mdir = self # 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 # iterate through a directory assuming this is the mtree root diff --git a/tests/test_btree.toml b/tests/test_btree.toml index 8f389fb5..bdd340b9 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -3226,11 +3226,13 @@ code = ''' lfs_size_t weight_; 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; ''' [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; @@ -3247,7 +3249,9 @@ 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_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; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -3262,7 +3266,7 @@ code = ''' lfs_size_t weight_; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); @@ -3270,7 +3274,7 @@ code = ''' lfsr_data_read(&lfs, &data_, buffer, 4) => 1; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); @@ -3280,6 +3284,8 @@ 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; @@ -3296,11 +3302,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_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_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_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; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -3315,7 +3325,7 @@ code = ''' lfs_size_t weight_; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); @@ -3323,7 +3333,7 @@ code = ''' lfsr_data_read(&lfs, &data_, buffer, 4) => 1; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); @@ -3331,7 +3341,7 @@ code = ''' lfsr_data_read(&lfs, &data_, buffer, 4) => 1; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); @@ -3342,6 +3352,8 @@ 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; @@ -3357,15 +3369,27 @@ 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_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_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_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_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_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; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -3380,7 +3404,7 @@ code = ''' lfs_size_t weight_; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); @@ -3388,7 +3412,7 @@ code = ''' lfsr_data_read(&lfs, &data_, buffer, 4) => 1; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); @@ -3396,7 +3420,7 @@ code = ''' lfsr_data_read(&lfs, &data_, buffer, 4) => 1; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); @@ -3404,7 +3428,7 @@ code = ''' lfsr_data_read(&lfs, &data_, buffer, 4) => 1; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); @@ -3414,6 +3438,8 @@ 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; @@ -3430,15 +3456,27 @@ 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_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_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_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_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_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; printf("btree: w%d 0x%x.%x\n", btree.weight, @@ -3453,7 +3491,7 @@ code = ''' lfs_size_t weight_; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); @@ -3461,7 +3499,7 @@ code = ''' lfsr_data_read(&lfs, &data_, buffer, 4) => 1; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); @@ -3469,7 +3507,7 @@ code = ''' lfsr_data_read(&lfs, &data_, buffer, 4) => 1; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); @@ -3477,7 +3515,7 @@ code = ''' lfsr_data_read(&lfs, &data_, buffer, 4) => 1; 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); @@ -3488,6 +3526,8 @@ 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; @@ -3507,7 +3547,9 @@ 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_BUF(name, 3)), + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), LFSR_ATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; @@ -3520,7 +3562,10 @@ 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_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_TAG_DATA, 0, 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) }; - 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i); @@ -3578,7 +3623,9 @@ 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_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; // set up a simulation to compare against @@ -3618,7 +3665,9 @@ code = ''' LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), LFSR_ATTR( LFSR_TAG_NAME, +1, - LFSR_DATA_BUF(name, 3)), + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), LFSR_ATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); @@ -3660,7 +3709,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, LFSR_DATA_BUF(sim_names[i], 3), + lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i); @@ -3678,6 +3727,8 @@ 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; @@ -3697,7 +3748,9 @@ 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_BUF(name, 3)), + LFSR_ATTR( + LFSR_TAG_NAME, +W, + LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), LFSR_ATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(0 % 10)}, 1)))) => 0; @@ -3710,7 +3763,11 @@ 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_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_TAG_DATA, 0, 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) }; - 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i*W+W-1); @@ -3769,7 +3826,9 @@ 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_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; // set up a simulation to compare against @@ -3825,7 +3884,9 @@ code = ''' LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)), LFSR_ATTR( LFSR_TAG_NAME, +weight2, - LFSR_DATA_BUF(name, 3)), + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), LFSR_ATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); @@ -3892,7 +3953,7 @@ code = ''' 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == weighted_bid+sim_weights[i]-1); @@ -3928,7 +3989,9 @@ 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_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; // set up a simulation to compare against @@ -3970,8 +4033,7 @@ code = ''' // split btree lfs_size_t split_bid; lfsr_data_t split_data; - lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, - LFSR_DATA_BUF(name, 3), + lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3, &split_bid, NULL, NULL, &split_data); assert(cmp >= 0); assert(cmp != LFS_CMP_EQ); @@ -3980,7 +4042,9 @@ code = ''' split_bid, LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_NAME, +1, - LFSR_DATA_BUF(name, 3)), + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), LFSR_ATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); @@ -3992,7 +4056,11 @@ 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_BUF(name, 3)), + LFSR_ATTR( + LFSR_TAG_NAME, +1, + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), LFSR_ATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); @@ -4065,7 +4133,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, LFSR_DATA_BUF(sim_names[i], 3), + lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, &bid_, &tag_, &weight_, &data_) => LFS_CMP_EQ; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i); @@ -4101,7 +4169,7 @@ code = ''' lfsr_btree_commit(&lfs, &btree, 0, LFSR_ATTRS( LFSR_ATTR( 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; // set up a simulation to compare against @@ -4155,8 +4223,7 @@ 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, - LFSR_DATA_BUF(name, 3), + lfs_scmp_t cmp = lfsr_btree_namelookup(&lfs, &btree, 0, name, 3, &split_bid, NULL, &split_weight, &split_data); assert(cmp >= 0); assert(cmp != LFS_CMP_EQ); @@ -4165,7 +4232,9 @@ code = ''' split_bid-(split_weight-1), LFSR_ATTRS( LFSR_ATTR( LFSR_TAG_NAME, +weight, - LFSR_DATA_BUF(name, 3)), + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), LFSR_ATTR( LFSR_TAG_DATA, 0, 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_NAME, +weight, - LFSR_DATA_BUF(name, 3)), + LFSR_DATA_CAT( + LFSR_DATA_LEB128(0), + LFSR_DATA_BUF(name, 3))), LFSR_ATTR( LFSR_TAG_DATA, 0, LFSR_DATA_BUF(&(uint8_t){'0'+(i % 10)}, 1)))); @@ -4286,7 +4357,7 @@ code = ''' 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; assert(tag_ == LFSR_TAG_DATA); assert(bid_ == weighted_bid+sim_weights[i]-1);