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);