Github/littlefs
1
Fork 0
Code Actions Activity

Reversed LFSR_ATTR id/tag argument order

Browse Source 
I've been wanting to make this change for a while now (tag,id => id,tag).
The id,tag order matches the common lexicographic order used for sorting
tuples. Sorting tag,id tuples by their id first is less common.

The reason for this order in the codebase is because all attrs on disk
start with their tag first, since its decoding determines the purpose of
the id field (keep in mind this includes other non-tree tags such as
crcs, alts, etc). But with the move to storing weights instead of tags
on disk, this gives us a clear point to switch from tag,w to id,tag
ordering.

I may be thinking to much about this, but it does affect a significant
amount of the codebase.
This commit is contained in:
Christopher Haster
2023-04-07 13:03:03 -05:00
parent a463d6f106
commit 7eb0c4763a
5 changed files with 2534 additions and 2535 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+140 -141
View File
@@ -613,7 +613,7 @@ static inline lfsr_tag_t lfsr_tag_key(lfsr_tag_t tag) {
static inline bool lfsr_tag_follow(lfsr_tag_t alt, lfs_size_t weight, static inline bool lfsr_tag_follow(lfsr_tag_t alt, lfs_size_t weight,
lfs_ssize_t lower, lfs_ssize_t upper, lfs_ssize_t lower, lfs_ssize_t upper,
lfsr_tag_t tag, lfs_ssize_t id) { lfs_ssize_t id, lfsr_tag_t tag) {
if (lfsr_tag_isgt(alt)) { if (lfsr_tag_isgt(alt)) {
return id > upper - (lfs_ssize_t)weight - 1 return id > upper - (lfs_ssize_t)weight - 1
|| (id == upper - (lfs_ssize_t)weight - 1 || (id == upper - (lfs_ssize_t)weight - 1
@@ -629,12 +629,12 @@ static inline bool lfsr_tag_follow2(
lfsr_tag_t alt, lfs_size_t weight, lfsr_tag_t alt, lfs_size_t weight,
lfsr_tag_t alt2, lfs_size_t weight2, lfsr_tag_t alt2, lfs_size_t weight2,
lfs_ssize_t lower, lfs_ssize_t upper, lfs_ssize_t lower, lfs_ssize_t upper,
lfsr_tag_t tag, lfs_ssize_t id) { lfs_ssize_t id, lfsr_tag_t tag) {
if (lfsr_tag_isred(alt2) && lfsr_tag_isparallel(alt, alt2)) { if (lfsr_tag_isred(alt2) && lfsr_tag_isparallel(alt, alt2)) {
weight += weight2; weight += weight2;
} }
return lfsr_tag_follow(alt, weight, lower, upper, tag, id); return lfsr_tag_follow(alt, weight, lower, upper, id, tag);
} }
static inline bool lfsr_tag_prune2( static inline bool lfsr_tag_prune2(
@@ -647,13 +647,13 @@ static inline bool lfsr_tag_prune2(
alt, weight, alt, weight,
alt2, weight2, alt2, weight2,
lower_id, upper_id, lower_id, upper_id,
lower_tag, lower_id); lower_id, lower_tag);
} else { } else {
return lfsr_tag_follow2( return lfsr_tag_follow2(
alt, weight, alt, weight,
alt2, weight2, alt2, weight2,
lower_id, upper_id, lower_id, upper_id,
upper_tag-0x10, upper_id-1); upper_id-1, upper_tag-0x10);
} }
} }
@@ -766,29 +766,29 @@ struct lfs_diskoff {
sizeof((struct lfs_mattr[]){__VA_ARGS__}) / sizeof(struct lfs_mattr) sizeof((struct lfs_mattr[]){__VA_ARGS__}) / sizeof(struct lfs_mattr)
typedef struct lfsr_attr { typedef struct lfsr_attr {
lfsr_tag_t tag;
lfs_ssize_t id; lfs_ssize_t id;
lfsr_tag_t tag;
lfs_ssize_t delta; lfs_ssize_t delta;
lfsr_data_t data; lfsr_data_t data;
} lfsr_attr_t; } lfsr_attr_t;
#define LFSR_ATTR_(_tag, _id, _delta, _buf, _len) \ #define LFSR_ATTR_(_id, _tag, _delta, _buf, _len) \
((const lfsr_attr_t){ \ ((const lfsr_attr_t){ \
_tag, _id, _delta, \ _id, _tag, _delta, \
LFSR_DATA_BUF(_buf, _len)}) LFSR_DATA_BUF(_buf, _len)})
#define LFSR_ATTR(_type, _id, _delta, _buf, _len) \ #define LFSR_ATTR(_id, _type, _delta, _buf, _len) \
LFSR_ATTR_(LFSR_TAG_##_type, _id, _delta, _buf, _len) LFSR_ATTR_(_id, LFSR_TAG_##_type, _delta, _buf, _len)
#define LFSR_ATTR_DISK_(_tag, _id, _delta, _block, _off, _len) \ #define LFSR_ATTR_DISK_(_id, _tag, _delta, _block, _off, _len) \
((const lfsr_attr_t){ \ ((const lfsr_attr_t){ \
_tag, _id, _delta, \ _id, _tag, _delta, \
LFSR_DATA_DISK(_block, _off, _len)}) LFSR_DATA_DISK(_block, _off, _len)})
#define LFSR_ATTR_DISK(_type, _id, _delta, _block, _off, _len) \ #define LFSR_ATTR_DISK(_id, _type, _delta, _block, _off, _len) \
LFSR_ATTR_DISK_(LFSR_TAG_##_type, _id, _delta, _block, _off, _len) LFSR_ATTR_DISK_(_id, LFSR_TAG_##_type, _delta, _block, _off, _len)
#define LFSR_ATTR_NOOP LFSR_ATTR(UNR, 0, 0, NULL, 0) #define LFSR_ATTR_NOOP LFSR_ATTR(-1, UNR, 0, NULL, 0)
#define LFSR_ATTRS(...) \ #define LFSR_ATTRS(...) \
(lfsr_attr_t[]){__VA_ARGS__}, \ (lfsr_attr_t[]){__VA_ARGS__}, \
@@ -1524,8 +1524,8 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd,
} }
static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
lfsr_tag_t tag, lfs_ssize_t id, lfs_ssize_t id, lfsr_tag_t tag,
lfsr_tag_t *tag_, lfs_ssize_t *id_, lfs_size_t *weight_, lfs_ssize_t *id_, lfsr_tag_t *tag_, lfs_size_t *weight_,
// TODO should this take lfsr_data_t for consistency? // TODO should this take lfsr_data_t for consistency?
lfs_off_t *off_, lfs_size_t *size_) { lfs_off_t *off_, lfs_size_t *size_) {
// keep track of bounds as we descend down the tree // keep track of bounds as we descend down the tree
@@ -1556,7 +1556,7 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
// found an alt? // found an alt?
if (lfsr_tag_isalt(alt)) { if (lfsr_tag_isalt(alt)) {
if (lfsr_tag_follow(alt, weight, lower, upper, tag, id)) { if (lfsr_tag_follow(alt, weight, lower, upper, id, tag)) {
lfsr_tag_flip(&alt, &weight, lower, upper); lfsr_tag_flip(&alt, &weight, lower, upper);
lfsr_tag_trim(alt, weight, &lower, &upper, NULL, NULL); lfsr_tag_trim(alt, weight, &lower, &upper, NULL, NULL);
branch = branch - jump; branch = branch - jump;
@@ -1568,8 +1568,8 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
// found end of tree? // found end of tree?
} else { } else {
// update the tag id // update the tag id
lfsr_tag_t tag__ = alt;
lfs_ssize_t id__ = upper-1; lfs_ssize_t id__ = upper-1;
lfsr_tag_t tag__ = alt;
// not what we're looking for? // not what we're looking for?
if (id__ < id if (id__ < id
@@ -1580,12 +1580,12 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
// save what we found // save what we found
// TODO how many of these need to be conditional? // TODO how many of these need to be conditional?
if (tag_) {
*tag_ = tag__;
}
if (id_) { if (id_) {
*id_ = id__; *id_ = id__;
} }
if (tag_) {
*tag_ = tag__;
}
if (weight_) { if (weight_) {
*weight_ = id__ - lower; *weight_ = id__ - lower;
} }
@@ -1602,13 +1602,13 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
} }
static lfs_ssize_t lfsr_rbyd_get(lfs_t *lfs, const lfsr_rbyd_t *rbyd, static lfs_ssize_t lfsr_rbyd_get(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
lfsr_tag_t tag, lfs_ssize_t id, void *buffer, lfs_size_t size) { lfs_ssize_t id, lfsr_tag_t tag, void *buffer, lfs_size_t size) {
lfsr_tag_t tag_;
lfs_ssize_t id_; lfs_ssize_t id_;
lfsr_tag_t tag_;
lfs_off_t off_; lfs_off_t off_;
lfs_size_t size_; lfs_size_t size_;
int err = lfsr_rbyd_lookup(lfs, rbyd, tag, id, int err = lfsr_rbyd_lookup(lfs, rbyd, id, tag,
&tag_, &id_, NULL, &off_, &size_); &id_, &tag_, NULL, &off_, &size_);
if (err) { if (err) {
return err; return err;
} }
@@ -1648,8 +1648,8 @@ static lfs_ssize_t lfsr_rbyd_bisect(lfs_t *lfs, const lfsr_rbyd_t *rbyd) {
while (true) { while (true) {
lfs_size_t size; lfs_size_t size;
int err = lfsr_rbyd_lookup(lfs, rbyd, int err = lfsr_rbyd_lookup(lfs, rbyd,
lfsr_tag_next(tag), id, id, lfsr_tag_next(tag),
&tag, &id, NULL, NULL, &size); &id, &tag, NULL, NULL, &size);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -1668,8 +1668,8 @@ static lfs_ssize_t lfsr_rbyd_bisect(lfs_t *lfs, const lfsr_rbyd_t *rbyd) {
while (true) { while (true) {
lfs_size_t size; lfs_size_t size;
int err = lfsr_rbyd_lookup(lfs, rbyd, int err = lfsr_rbyd_lookup(lfs, rbyd,
lfsr_tag_next(tag), id, id, lfsr_tag_next(tag),
&tag, &id, NULL, NULL, &size); &id, &tag, NULL, NULL, &size);
if (err) { if (err) {
return err; return err;
} }
@@ -1922,7 +1922,7 @@ static void lfsr_rbyd_p_red(
// core rbyd algorithm // core rbyd algorithm
static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd,
lfsr_tag_t tag, lfs_ssize_t id, lfs_ssize_t delta, lfs_ssize_t id, lfsr_tag_t tag, lfs_ssize_t delta,
lfsr_data_t data) { lfsr_data_t data) {
// never write zero tags to disk, use unr if tag contains no data // never write zero tags to disk, use unr if tag contains no data
LFS_ASSERT(tag != 0); LFS_ASSERT(tag != 0);
@@ -2063,11 +2063,11 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd,
&& lfsr_tag_follow2(alt, weight, && lfsr_tag_follow2(alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_id, upper_id, lower_id, upper_id,
tag_, id_) id_, tag_)
!= lfsr_tag_follow2(alt, weight, != lfsr_tag_follow2(alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_id, upper_id, lower_id, upper_id,
other_tag_, other_id_)) { other_id_, other_tag_)) {
// first take care of any lingering red alts // first take care of any lingering red alts
if (lfsr_tag_isred(p_alts[0])) { if (lfsr_tag_isred(p_alts[0])) {
alt = lfsr_tag_setblack(p_alts[0]); alt = lfsr_tag_setblack(p_alts[0]);
@@ -2137,7 +2137,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd,
alt, weight, alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_id, upper_id, lower_id, upper_id,
tag_, id_)) { id_, tag_)) {
lfsr_tag_flip2(&alt, &weight, lfsr_tag_flip2(&alt, &weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_id, upper_id); lower_id, upper_id);
@@ -2191,7 +2191,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd,
alt, weight, alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_id, upper_id, lower_id, upper_id,
tag_, id_)) { id_, tag_)) {
lfsr_tag_flip2(&alt, &weight, lfsr_tag_flip2(&alt, &weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_id, upper_id); lower_id, upper_id);
@@ -2207,7 +2207,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd,
if (lfsr_tag_isred(p_alts[0]) if (lfsr_tag_isred(p_alts[0])
&& lfsr_tag_follow(p_alts[0], p_weights[0], && lfsr_tag_follow(p_alts[0], p_weights[0],
lower_id, upper_id, lower_id, upper_id,
tag_, id_)) { id_, tag_)) {
lfs_swap16(&p_alts[0], &alt); lfs_swap16(&p_alts[0], &alt);
lfs_swap32(&p_weights[0], &weight); lfs_swap32(&p_weights[0], &weight);
lfs_swap32(&p_jumps[0], &jump); lfs_swap32(&p_jumps[0], &jump);
@@ -2411,7 +2411,7 @@ static int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// append each tag to the tree // append each tag to the tree
for (lfs_size_t i = 0; i < attr_count; i++) { for (lfs_size_t i = 0; i < attr_count; i++) {
int err = lfsr_rbyd_append(lfs, &rbyd_, int err = lfsr_rbyd_append(lfs, &rbyd_,
attrs[i].tag, attrs[i].id, attrs[i].delta, attrs[i].data); attrs[i].id, attrs[i].tag, attrs[i].delta, attrs[i].data);
if (err) { if (err) {
return err; return err;
} }
@@ -2617,9 +2617,8 @@ static lfs_ssize_t lfsr_branch_fromdisk(
static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs, static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
const lfsr_btree_t *btree, lfs_size_t id, const lfsr_btree_t *btree, lfs_size_t id,
lfsr_tag_t *tag_, lfs_size_t *id_, lfs_size_t *id_, lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_,
lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_, lfsr_tag_t *tag_, lfs_size_t *weight_,
lfs_size_t *weight_,
void *buffer, lfs_size_t size) { void *buffer, lfs_size_t size) {
// in range? // in range?
if (id >= btree->weight) { if (id >= btree->weight) {
@@ -2632,13 +2631,13 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
if (id_) { if (id_) {
*id_ = btree->weight-1; *id_ = btree->weight-1;
} }
if (tag_) {
*tag_ = btree->tag;
}
// TODO need rid here? // TODO need rid here?
if (rid_) { if (rid_) {
*rid_ = -1; *rid_ = -1;
} }
if (tag_) {
*tag_ = btree->tag;
}
if (weight_) { if (weight_) {
*weight_ = btree->weight; *weight_ = btree->weight;
} }
@@ -2661,21 +2660,21 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
} }
// each branch is a pair of optional name + on-disk structure // each branch is a pair of optional name + on-disk structure
lfsr_tag_t tag__;
lfs_ssize_t rid__; lfs_ssize_t rid__;
lfsr_tag_t tag__;
lfs_size_t weight__; lfs_size_t weight__;
lfs_off_t off_; lfs_off_t off_;
lfs_size_t size_; lfs_size_t size_;
err = lfsr_rbyd_lookup(lfs, &rbyd, 0, rid, err = lfsr_rbyd_lookup(lfs, &rbyd, rid, 0,
&tag__, &rid__, &weight__, &off_, &size_); &rid__, &tag__, &weight__, &off_, &size_);
if (err) { if (err) {
return err; return err;
} }
if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
// TODO what if we don't find a struct? ENOENT? // TODO what if we don't find a struct? ENOENT?
err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_STRUCT, rid__, err = lfsr_rbyd_lookup(lfs, &rbyd, rid__, LFSR_TAG_STRUCT,
&tag__, NULL, NULL, &off_, &size_); NULL, &tag__, NULL, &off_, &size_);
if (err) { if (err) {
return err; return err;
} }
@@ -2707,15 +2706,15 @@ static lfs_ssize_t lfsr_btree_lookup(lfs_t *lfs,
if (id_) { if (id_) {
*id_ = id + (rid__ - rid); *id_ = id + (rid__ - rid);
} }
if (tag_) {
*tag_ = tag__;
}
if (rbyd_) { if (rbyd_) {
*rbyd_ = rbyd; *rbyd_ = rbyd;
} }
if (rid_) { if (rid_) {
*rid_ = rid__; *rid_ = rid__;
} }
if (tag_) {
*tag_ = tag__;
}
if (weight_) { if (weight_) {
*weight_ = weight__; *weight_ = weight__;
} }
@@ -2759,13 +2758,13 @@ static int lfsr_btree_parent(lfs_t *lfs,
} }
// each branch is a pair of optional name + on-disk structure // each branch is a pair of optional name + on-disk structure
lfsr_tag_t tag__;
lfs_ssize_t rid__; lfs_ssize_t rid__;
lfsr_tag_t tag__;
lfs_size_t weight__; lfs_size_t weight__;
lfs_off_t off_; lfs_off_t off_;
lfs_size_t size_; lfs_size_t size_;
err = lfsr_rbyd_lookup(lfs, &rbyd, 0, rid, err = lfsr_rbyd_lookup(lfs, &rbyd, rid, 0,
&tag__, &rid__, &weight__, &off_, &size_); &rid__, &tag__, &weight__, &off_, &size_);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_NOENT); LFS_ASSERT(err != LFS_ERR_NOENT);
return err; return err;
@@ -2773,8 +2772,8 @@ static int lfsr_btree_parent(lfs_t *lfs,
if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
// TODO what if we don't find a struct? ENOENT? // TODO what if we don't find a struct? ENOENT?
err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_STRUCT, rid__, err = lfsr_rbyd_lookup(lfs, &rbyd, rid__, LFSR_TAG_STRUCT,
&tag__, NULL, NULL, &off_, &size_); NULL, &tag__, NULL, &off_, &size_);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_NOENT); LFS_ASSERT(err != LFS_ERR_NOENT);
return err; return err;
@@ -2821,19 +2820,19 @@ static int lfsr_btree_parent(lfs_t *lfs,
// TODO do we really need this? // TODO do we really need this?
static lfs_ssize_t lfsr_btree_get(lfs_t *lfs, static lfs_ssize_t lfsr_btree_get(lfs_t *lfs,
const lfsr_btree_t *btree, lfs_size_t id, const lfsr_btree_t *btree, lfs_size_t id,
lfsr_tag_t *tag_, lfs_size_t *id_, lfs_size_t *weight_, lfs_size_t *id_, lfsr_tag_t *tag_, lfs_size_t *weight_,
void *buffer, lfs_size_t size) { void *buffer, lfs_size_t size) {
// note we need an allocated rbyd in btree lookup // note we need an allocated rbyd in btree lookup
return lfsr_btree_lookup(lfs, btree, id, return lfsr_btree_lookup(lfs, btree, id,
tag_, id_, NULL, NULL, weight_, id_, NULL, NULL, tag_, weight_,
buffer, size); buffer, size);
} }
static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs, static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
const lfsr_btree_t *btree, const char *name, lfs_size_t name_len, const lfsr_btree_t *btree, const char *name, lfs_size_t name_len,
lfsr_tag_t *tag_, lfs_size_t *id_, lfs_size_t *id_,
lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_, lfsr_rbyd_t *rbyd_, lfs_ssize_t *rid_,
lfs_size_t *weight_, lfsr_tag_t *tag_, lfs_size_t *weight_,
void *buffer, lfs_size_t size) { void *buffer, lfs_size_t size) {
// inlined? // inlined?
if (btree->tag) { if (btree->tag) {
@@ -2841,13 +2840,13 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
if (id_) { if (id_) {
*id_ = btree->weight-1; *id_ = btree->weight-1;
} }
if (tag_) {
*tag_ = btree->tag;
}
// TODO need rid here? // TODO need rid here?
if (rid_) { if (rid_) {
*rid_ = -1; *rid_ = -1;
} }
if (tag_) {
*tag_ = btree->tag;
}
if (weight_) { if (weight_) {
*weight_ = btree->weight; *weight_ = btree->weight;
} }
@@ -2888,16 +2887,16 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
lfs_size_t weight__; lfs_size_t weight__;
lfs_off_t off_; lfs_off_t off_;
lfs_size_t size_; lfs_size_t size_;
err = lfsr_rbyd_lookup(lfs, &rbyd, 0, find.found_id, err = lfsr_rbyd_lookup(lfs, &rbyd, find.found_id, 0,
&tag__, &rid__, &weight__, &off_, &size_); &rid__, &tag__, &weight__, &off_, &size_);
if (err) { if (err) {
return err; return err;
} }
if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) { if (lfsr_tag_suptype(tag__) == LFSR_TAG_NAME) {
// TODO what if we don't find a struct? ENOENT? // TODO what if we don't find a struct? ENOENT?
err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_STRUCT, rid__, err = lfsr_rbyd_lookup(lfs, &rbyd, rid__, LFSR_TAG_STRUCT,
&tag__, NULL, NULL, &off_, &size_); NULL, &tag__, NULL, &off_, &size_);
if (err) { if (err) {
return err; return err;
} }
@@ -2929,15 +2928,15 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
if (id_) { if (id_) {
*id_ = id + rid__; *id_ = id + rid__;
} }
if (tag_) {
*tag_ = tag__;
}
if (rbyd_) { if (rbyd_) {
*rbyd_ = rbyd; *rbyd_ = rbyd;
} }
if (rid_) { if (rid_) {
*rid_ = rid__; *rid_ = rid__;
} }
if (tag_) {
*tag_ = tag__;
}
if (weight_) { if (weight_) {
*weight_ = weight__; *weight_ = weight__;
} }
@@ -2958,10 +2957,10 @@ static lfs_ssize_t lfsr_btree_find_(lfs_t *lfs,
static lfs_ssize_t lfsr_btree_find(lfs_t *lfs, static lfs_ssize_t lfsr_btree_find(lfs_t *lfs,
const lfsr_btree_t *btree, const char *name, lfs_size_t name_len, const lfsr_btree_t *btree, const char *name, lfs_size_t name_len,
lfsr_tag_t *tag_, lfs_size_t *id_, lfs_size_t *weight_, lfs_size_t *id_, lfsr_tag_t *tag_, lfs_size_t *weight_,
void *buffer, lfs_size_t size) { void *buffer, lfs_size_t size) {
return lfsr_btree_find_(lfs, btree, name, name_len, return lfsr_btree_find_(lfs, btree, name, name_len,
tag_, id_, NULL, NULL, weight_, id_, NULL, NULL, tag_, weight_,
buffer, size); buffer, size);
} }
@@ -3022,15 +3021,15 @@ static int lfsr_btree_commit(lfs_t *lfs,
// end up removing an rbyd here // end up removing an rbyd here
if (rbyd->weight == 0) { if (rbyd->weight == 0) {
scratch_attrs[0] = LFSR_ATTR( scratch_attrs[0] = LFSR_ATTR(
MKUNR, rid, +rbyd->weight-rweight, scratch_buf1, delta); rid, MKUNR, +rbyd->weight-rweight, scratch_buf1, delta);
attrs = scratch_attrs; attrs = scratch_attrs;
attr_count = 1; attr_count = 1;
} else { } else {
scratch_attrs[0] = LFSR_ATTR( scratch_attrs[0] = LFSR_ATTR(
BRANCH, rid, 0, scratch_buf1, delta); rid, BRANCH, 0, scratch_buf1, delta);
scratch_attrs[1] = LFSR_ATTR( scratch_attrs[1] = LFSR_ATTR(
UNR, rid, +rbyd->weight-rweight, NULL, 0); rid, UNR, +rbyd->weight-rweight, NULL, 0);
attrs = scratch_attrs; attrs = scratch_attrs;
attr_count = 2; attr_count = 2;
@@ -3056,8 +3055,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
while (true) { while (true) {
lfs_off_t off; lfs_off_t off;
lfs_size_t size; lfs_size_t size;
err = lfsr_rbyd_lookup(lfs, rbyd, lfsr_tag_next(tag), id, err = lfsr_rbyd_lookup(lfs, rbyd, id, lfsr_tag_next(tag),
&tag, &id, NULL, &off, &size); &id, &tag, NULL, &off, &size);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -3084,8 +3083,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
// append the attr // append the attr
err = lfsr_rbyd_append(lfs, &rbyd_, err = lfsr_rbyd_append(lfs, &rbyd_,
lfsr_tag_setmk(tag), id-lfs_smax32(weight-1, 0),
id-lfs_smax32(weight-1, 0), +weight, lfsr_tag_setmk(tag), +weight,
LFSR_DATA_DISK(rbyd->block, off, size)); LFSR_DATA_DISK(rbyd->block, off, size));
if (err) { if (err) {
return err; return err;
@@ -3102,7 +3101,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
// layers to make sure these always fit // layers to make sure these always fit
for (lfs_size_t i = 0; i < attr_count; i++) { for (lfs_size_t i = 0; i < attr_count; i++) {
err = lfsr_rbyd_append(lfs, &rbyd_, err = lfsr_rbyd_append(lfs, &rbyd_,
attrs[i].tag, attrs[i].id, attrs[i].delta, attrs[i].data); attrs[i].id, attrs[i].tag, attrs[i].delta, attrs[i].data);
if (err) { if (err) {
return err; return err;
} }
@@ -3143,15 +3142,15 @@ static int lfsr_btree_commit(lfs_t *lfs,
// end up removing an rbyd here // end up removing an rbyd here
if (rbyd_.weight == 0) { if (rbyd_.weight == 0) {
scratch_attrs[0] = LFSR_ATTR( scratch_attrs[0] = LFSR_ATTR(
MKUNR, rid, +rbyd_.weight-rweight, scratch_buf1, delta); rid, MKUNR, +rbyd_.weight-rweight, scratch_buf1, delta);
attrs = scratch_attrs; attrs = scratch_attrs;
attr_count = 1; attr_count = 1;
} else { } else {
scratch_attrs[0] = LFSR_ATTR( scratch_attrs[0] = LFSR_ATTR(
BRANCH, rid, 0, scratch_buf1, delta); rid, BRANCH, 0, scratch_buf1, delta);
scratch_attrs[1] = LFSR_ATTR( scratch_attrs[1] = LFSR_ATTR(
UNR, rid, +rbyd_.weight-rweight, NULL, 0); rid, UNR, +rbyd_.weight-rweight, NULL, 0);
attrs = scratch_attrs; attrs = scratch_attrs;
attr_count = 2; attr_count = 2;
@@ -3173,7 +3172,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
// add an rbyd and btree test? // add an rbyd and btree test?
if ((lfs_size_t)bisect < rbyd_.weight) { if ((lfs_size_t)bisect < rbyd_.weight) {
err = lfsr_rbyd_append(lfs, &rbyd_, err = lfsr_rbyd_append(lfs, &rbyd_,
LFSR_TAG_MKUNR, rbyd_.weight-1, -(rbyd_.weight-bisect), rbyd_.weight-1, LFSR_TAG_MKUNR, -(rbyd_.weight-bisect),
LFSR_DATA_NULL); LFSR_DATA_NULL);
if (err) { if (err) {
return err; return err;
@@ -3188,7 +3187,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
for (lfs_size_t i = 0; i < attr_count; i++) { for (lfs_size_t i = 0; i < attr_count; i++) {
if (attrs[i].id < bisect_) { if (attrs[i].id < bisect_) {
err = lfsr_rbyd_append(lfs, &rbyd_, err = lfsr_rbyd_append(lfs, &rbyd_,
attrs[i].tag, attrs[i].id, attrs[i].delta, attrs[i].id, attrs[i].tag, attrs[i].delta,
attrs[i].data); attrs[i].data);
if (err) { if (err) {
return err; return err;
@@ -3223,8 +3222,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
lfs_off_t off; lfs_off_t off;
lfs_size_t size; lfs_size_t size;
lfs_size_t weight; lfs_size_t weight;
err = lfsr_rbyd_lookup(lfs, rbyd, lfsr_tag_next(tag), id, err = lfsr_rbyd_lookup(lfs, rbyd, id, lfsr_tag_next(tag),
&tag, &id, &weight, &off, &size); &id, &tag, &weight, &off, &size);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -3234,8 +3233,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
// append the attr // append the attr
err = lfsr_rbyd_append(lfs, &sibling, err = lfsr_rbyd_append(lfs, &sibling,
lfsr_tag_setmk(tag), id-bisect-lfs_smax32(weight-1, 0),
id-bisect-lfs_smax32(weight-1, 0), +weight, lfsr_tag_setmk(tag), +weight,
LFSR_DATA_DISK(rbyd->block, off, size)); LFSR_DATA_DISK(rbyd->block, off, size));
if (err) { if (err) {
return err; return err;
@@ -3249,7 +3248,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
for (lfs_size_t i = 0; i < attr_count; i++) { for (lfs_size_t i = 0; i < attr_count; i++) {
if (attrs[i].id >= bisect_) { if (attrs[i].id >= bisect_) {
err = lfsr_rbyd_append(lfs, &sibling, err = lfsr_rbyd_append(lfs, &sibling,
attrs[i].tag, attrs[i].id-bisect_, attrs[i].delta, attrs[i].id-bisect_, attrs[i].tag, attrs[i].delta,
attrs[i].data); attrs[i].data);
if (err) { if (err) {
return err; return err;
@@ -3276,8 +3275,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
lfs_ssize_t sid; lfs_ssize_t sid;
lfs_off_t soff; lfs_off_t soff;
lfs_size_t ssize; lfs_size_t ssize;
err = lfsr_rbyd_lookup(lfs, &sibling, LFSR_TAG_NAME, 0, err = lfsr_rbyd_lookup(lfs, &sibling, 0, LFSR_TAG_NAME,
&stag, &sid, NULL, &soff, &ssize); &sid, &stag, NULL, &soff, &ssize);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -3307,21 +3306,21 @@ static int lfsr_btree_commit(lfs_t *lfs,
} }
scratch_attrs[0] = LFSR_ATTR( scratch_attrs[0] = LFSR_ATTR(
MKBRANCH, 0, +rbyd_.weight, scratch_buf1, delta1); 0, MKBRANCH, +rbyd_.weight, scratch_buf1, delta1);
if (lfsr_tag_suptype(stag) == LFSR_TAG_NAME) { if (lfsr_tag_suptype(stag) == LFSR_TAG_NAME) {
scratch_attrs[1] = LFSR_ATTR_DISK( scratch_attrs[1] = LFSR_ATTR_DISK(
MKBNAME, rbyd_.weight, +sibling.weight, rbyd_.weight, MKBNAME, +sibling.weight,
sibling.block, soff, ssize); sibling.block, soff, ssize);
scratch_attrs[2] = LFSR_ATTR( scratch_attrs[2] = LFSR_ATTR(
BRANCH, 0+rbyd_.weight+sibling.weight-1, 0, 0+rbyd_.weight+sibling.weight-1, BRANCH, 0,
scratch_buf2, delta2); scratch_buf2, delta2);
attrs = scratch_attrs; attrs = scratch_attrs;
attr_count = 3; attr_count = 3;
} else { } else {
scratch_attrs[1] = LFSR_ATTR( scratch_attrs[1] = LFSR_ATTR(
MKBRANCH, 0+rbyd_.weight, +sibling.weight, 0+rbyd_.weight, MKBRANCH, +sibling.weight,
scratch_buf2, delta2); scratch_buf2, delta2);
attrs = scratch_attrs; attrs = scratch_attrs;
@@ -3347,18 +3346,18 @@ static int lfsr_btree_commit(lfs_t *lfs,
} }
scratch_attrs[0] = LFSR_ATTR( scratch_attrs[0] = LFSR_ATTR(
UNR, rid, +rbyd_.weight-rweight, NULL, 0); rid, UNR, +rbyd_.weight-rweight, NULL, 0);
scratch_attrs[1] = LFSR_ATTR( scratch_attrs[1] = LFSR_ATTR(
BRANCH, rid-(rweight-1)+rbyd_.weight-1, 0, rid-(rweight-1)+rbyd_.weight-1, BRANCH, 0,
scratch_buf1, delta1); scratch_buf1, delta1);
if (lfsr_tag_suptype(stag) == LFSR_TAG_NAME) { if (lfsr_tag_suptype(stag) == LFSR_TAG_NAME) {
scratch_attrs[2] = LFSR_ATTR_DISK( scratch_attrs[2] = LFSR_ATTR_DISK(
MKBNAME, rid-(rweight-1)+rbyd_.weight, rid-(rweight-1)+rbyd_.weight, MKBNAME,
+sibling.weight, +sibling.weight,
sibling.block, soff, ssize); sibling.block, soff, ssize);
scratch_attrs[3] = LFSR_ATTR( scratch_attrs[3] = LFSR_ATTR(
BRANCH, rid-(rweight-1)+rbyd_.weight+sibling.weight-1, rid-(rweight-1)+rbyd_.weight+sibling.weight-1, BRANCH,
0, 0,
scratch_buf2, delta2); scratch_buf2, delta2);
@@ -3366,7 +3365,7 @@ static int lfsr_btree_commit(lfs_t *lfs,
attr_count = 4; attr_count = 4;
} else { } else {
scratch_attrs[2] = LFSR_ATTR( scratch_attrs[2] = LFSR_ATTR(
MKBRANCH, rid-(rweight-1)+rbyd_.weight, rid-(rweight-1)+rbyd_.weight, MKBRANCH,
+sibling.weight, +sibling.weight,
scratch_buf2, delta2); scratch_buf2, delta2);
@@ -3393,8 +3392,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
// try looking up the sibling // try looking up the sibling
lfs_size_t sweight; lfs_size_t sweight;
err = lfsr_rbyd_lookup(lfs, &parent, LFSR_TAG_NAME, sid, err = lfsr_rbyd_lookup(lfs, &parent, sid, LFSR_TAG_NAME,
NULL, &sid, &sweight, NULL, NULL); &sid, NULL, &sweight, NULL, NULL);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -3407,8 +3406,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
// lfsr_tag_t stag; // lfsr_tag_t stag;
lfs_off_t off; lfs_off_t off;
lfs_size_t size; lfs_size_t size;
err = lfsr_rbyd_lookup(lfs, &parent, LFSR_TAG_BRANCH, sid, err = lfsr_rbyd_lookup(lfs, &parent, sid, LFSR_TAG_BRANCH,
&stag, NULL, NULL, &off, &size); NULL, &stag, NULL, &off, &size);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -3444,8 +3443,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
id = 0; id = 0;
while (true) { while (true) {
lfs_size_t weight; lfs_size_t weight;
err = lfsr_rbyd_lookup(lfs, &sibling, lfsr_tag_next(tag), id, err = lfsr_rbyd_lookup(lfs, &sibling, id, lfsr_tag_next(tag),
&tag, &id, &weight, &off, &size); &id, &tag, &weight, &off, &size);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -3455,8 +3454,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
// append the attr // append the attr
err = lfsr_rbyd_append(lfs, &rbyd_, err = lfsr_rbyd_append(lfs, &rbyd_,
lfsr_tag_setmk(tag), sdelta+id-lfs_smax32(weight-1, 0),
sdelta+id-lfs_smax32(weight-1, 0), +weight, lfsr_tag_setmk(tag), +weight,
LFSR_DATA_DISK(sibling.block, off, size)); LFSR_DATA_DISK(sibling.block, off, size));
if (err) { if (err) {
return err; return err;
@@ -3466,8 +3465,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
// failed, clean up ids and merge_abort // failed, clean up ids and merge_abort
if (rbyd_.off > lfs->cfg->block_size/2) { if (rbyd_.off > lfs->cfg->block_size/2) {
err = lfsr_rbyd_append(lfs, &rbyd_, err = lfsr_rbyd_append(lfs, &rbyd_,
LFSR_TAG_MKUNR, sdelta+(rbyd_.weight-rweight_)-1, sdelta+(rbyd_.weight-rweight_)-1,
-(rbyd_.weight-rweight_), LFSR_TAG_MKUNR, -(rbyd_.weight-rweight_),
LFSR_DATA_NULL); LFSR_DATA_NULL);
if (err) { if (err) {
return err; return err;
@@ -3482,8 +3481,8 @@ static int lfsr_btree_commit(lfs_t *lfs,
lfs_off_t split_off; lfs_off_t split_off;
lfs_size_t split_size; lfs_size_t split_size;
err = lfsr_rbyd_lookup(lfs, &parent, err = lfsr_rbyd_lookup(lfs, &parent,
LFSR_TAG_NAME, (sdelta == 0 ? rid : sid), (sdelta == 0 ? rid : sid), LFSR_TAG_NAME,
&split_tag, NULL, NULL, &split_off, &split_size); NULL, &split_tag, NULL, &split_off, &split_size);
if (err) { if (err) {
return err; return err;
} }
@@ -3493,14 +3492,14 @@ static int lfsr_btree_commit(lfs_t *lfs,
// lookup the id of the previously-split entry // lookup the id of the previously-split entry
lfs_ssize_t split_id; lfs_ssize_t split_id;
err = lfsr_rbyd_lookup(lfs, &rbyd_, err = lfsr_rbyd_lookup(lfs, &rbyd_,
LFSR_TAG_NAME, (sdelta == 0 ? sweight : rweight_), (sdelta == 0 ? sweight : rweight_), LFSR_TAG_NAME,
NULL, &split_id, NULL, NULL, NULL); &split_id, NULL, NULL, NULL, NULL);
if (err) { if (err) {
return err; return err;
} }
err = lfsr_rbyd_append(lfs, &rbyd_, err = lfsr_rbyd_append(lfs, &rbyd_,
LFSR_TAG_BNAME, split_id, 0, split_id, LFSR_TAG_BNAME, 0,
LFSR_DATA_DISK(parent.block, split_off, split_size)); LFSR_DATA_DISK(parent.block, split_off, split_size));
if (err) { if (err) {
return err; return err;
@@ -3539,11 +3538,11 @@ static int lfsr_btree_commit(lfs_t *lfs,
} }
scratch_attrs[0] = LFSR_ATTR( scratch_attrs[0] = LFSR_ATTR(
MKUNR, sid, -sweight, NULL, 0); sid, MKUNR, -sweight, NULL, 0);
scratch_attrs[1] = LFSR_ATTR( scratch_attrs[1] = LFSR_ATTR(
BRANCH, rid, 0, scratch_buf1, delta1); rid, BRANCH, 0, scratch_buf1, delta1);
scratch_attrs[2] = LFSR_ATTR( scratch_attrs[2] = LFSR_ATTR(
UNR, rid, +rbyd_.weight-rweight, NULL, 0); rid, UNR, +rbyd_.weight-rweight, NULL, 0);
attrs = scratch_attrs; attrs = scratch_attrs;
attr_count = 3; attr_count = 3;
@@ -3588,10 +3587,10 @@ static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree,
// commit our entries // commit our entries
err = lfsr_rbyd_commit(lfs, &rbyd, LFSR_ATTRS( err = lfsr_rbyd_commit(lfs, &rbyd, LFSR_ATTRS(
LFSR_ATTR_( LFSR_ATTR_(
lfsr_tag_setmk(btree->tag), 0, +btree->weight, 0, lfsr_tag_setmk(btree->tag), +btree->weight,
btree->u.inlined.buf, btree->u.inlined.size), btree->u.inlined.buf, btree->u.inlined.size),
LFSR_ATTR_( LFSR_ATTR_(
lfsr_tag_setmk(tag), id, +weight, id, lfsr_tag_setmk(tag), +weight,
buffer, size))); buffer, size)));
if (err) { if (err) {
return err; return err;
@@ -3611,7 +3610,7 @@ static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree,
lfs_size_t rweight; lfs_size_t rweight;
lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, lfs_ssize_t size = lfsr_btree_lookup(lfs, btree,
lfs_min32(id, btree->weight-1), lfs_min32(id, btree->weight-1),
NULL, NULL, &rbyd, &rid, &rweight, NULL, 0); NULL, &rbyd, &rid, NULL, &rweight, NULL, 0);
if (size < 0) { if (size < 0) {
return size; return size;
} }
@@ -3627,7 +3626,7 @@ static int lfsr_btree_push(lfs_t *lfs, lfsr_btree_t *btree,
// of the rest // of the rest
return lfsr_btree_commit(lfs, btree, return lfsr_btree_commit(lfs, btree,
lfs_min32(id, btree->weight-1), &rbyd, LFSR_ATTRS( lfs_min32(id, btree->weight-1), &rbyd, LFSR_ATTRS(
LFSR_ATTR_(lfsr_tag_setmk(tag), rid, +weight, LFSR_ATTR_(rid, lfsr_tag_setmk(tag), +weight,
buffer, size))); buffer, size)));
} }
} }
@@ -3657,7 +3656,7 @@ static int lfsr_btree_update(lfs_t *lfs, lfsr_btree_t *btree,
lfs_ssize_t rid; lfs_ssize_t rid;
lfs_size_t rweight; lfs_size_t rweight;
lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, id, lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, id,
&rtag, NULL, &rbyd, &rid, &rweight, NULL, 0); NULL, &rbyd, &rid, &rtag, &rweight, NULL, 0);
if (size < 0) { if (size < 0) {
return size; return size;
} }
@@ -3666,10 +3665,10 @@ static int lfsr_btree_update(lfs_t *lfs, lfsr_btree_t *btree,
// of the rest // of the rest
return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTRS( return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTRS(
(tag != rtag (tag != rtag
? LFSR_ATTR_(lfsr_tag_setrm(rtag), rid, 0, NULL, 0) ? LFSR_ATTR_(rid, lfsr_tag_setrm(rtag), 0, NULL, 0)
: LFSR_ATTR_NOOP), : LFSR_ATTR_NOOP),
LFSR_ATTR_(tag, rid, 0, buffer, size), LFSR_ATTR_(rid, tag, 0, buffer, size),
LFSR_ATTR(UNR, rid, +weight-rweight, NULL, 0))); LFSR_ATTR(rid, UNR, +weight-rweight, NULL, 0)));
} }
} }
@@ -3690,7 +3689,7 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) {
lfs_ssize_t rid; lfs_ssize_t rid;
lfs_size_t rweight; lfs_size_t rweight;
lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, id, lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, id,
&rtag, NULL, &rbyd, &rid, &rweight, NULL, 0); NULL, &rbyd, &rid, &rtag, &rweight, NULL, 0);
if (size < 0) { if (size < 0) {
return size; return size;
} }
@@ -3709,8 +3708,8 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) {
// try looking up the sibling // try looking up the sibling
lfs_size_t sweight; lfs_size_t sweight;
int err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_NAME, sid, int err = lfsr_rbyd_lookup(lfs, &rbyd, sid, LFSR_TAG_NAME,
NULL, &sid, &sweight, NULL, NULL); &sid, NULL, &sweight, NULL, NULL);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -3724,8 +3723,8 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) {
lfsr_tag_t stag; lfsr_tag_t stag;
lfs_off_t off; lfs_off_t off;
lfs_size_t size; lfs_size_t size;
err = lfsr_rbyd_lookup(lfs, &rbyd, LFSR_TAG_STRUCT, sid, err = lfsr_rbyd_lookup(lfs, &rbyd, sid, LFSR_TAG_STRUCT,
&stag, NULL, NULL, &off, &size); NULL, &stag, NULL, &off, &size);
if (err && err != LFS_ERR_NOENT) { if (err && err != LFS_ERR_NOENT) {
return err; return err;
} }
@@ -3756,7 +3755,7 @@ static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t id) {
// remove our id, letting lfsr_btree_commit take care // remove our id, letting lfsr_btree_commit take care
// of the rest // of the rest
return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTRS( return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTRS(
LFSR_ATTR(MKUNR, rid, -rweight, NULL, 0))); LFSR_ATTR(rid, MKUNR, -rweight, NULL, 0)));
} }
} }
@@ -3785,11 +3784,11 @@ static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree,
// commit our entries // commit our entries
err = lfsr_rbyd_commit(lfs, &rbyd, LFSR_ATTRS( err = lfsr_rbyd_commit(lfs, &rbyd, LFSR_ATTRS(
LFSR_ATTR_(lfsr_tag_setmk(tag1), 0, +weight1, LFSR_ATTR_(0, lfsr_tag_setmk(tag1), +weight1,
buffer1, size1), buffer1, size1),
LFSR_ATTR(MKBNAME, weight1, +weight2, LFSR_ATTR(weight1, MKBNAME, +weight2,
name, name_len), name, name_len),
LFSR_ATTR_(tag2, weight1+weight2-1, 0, LFSR_ATTR_(weight1+weight2-1, tag2, 0,
buffer2, size2))); buffer2, size2)));
if (err) { if (err) {
return err; return err;
@@ -3811,7 +3810,7 @@ static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree,
// // TODO should we bother with id splits if we usually split on names? // // TODO should we bother with id splits if we usually split on names?
// if (name_len == 0) { // if (name_len == 0) {
lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, id, lfs_ssize_t size = lfsr_btree_lookup(lfs, btree, id,
NULL, NULL, &rbyd, &rid, &rweight, NULL, 0); NULL, &rbyd, &rid, NULL, &rweight, NULL, 0);
if (size < 0) { if (size < 0) {
return size; return size;
} }
@@ -3826,13 +3825,13 @@ static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree,
// commit our id into the tree, letting lfsr_btree_commit take care // commit our id into the tree, letting lfsr_btree_commit take care
// of the rest // of the rest
return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTRS( return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTRS(
LFSR_ATTR(UNR, rid, +weight1-rweight, NULL, 0), LFSR_ATTR(rid, UNR, +weight1-rweight, NULL, 0),
LFSR_ATTR_(tag1, rid-(rweight-1)+weight1-1, 0, LFSR_ATTR_(rid-(rweight-1)+weight1-1, tag1, 0,
buffer1, size1), buffer1, size1),
// TODO should we always be making name entries? // TODO should we always be making name entries?
LFSR_ATTR(MKBNAME, rid-(rweight-1)+weight1, +weight2, LFSR_ATTR(rid-(rweight-1)+weight1, MKBNAME, +weight2,
name, name_len), name, name_len),
LFSR_ATTR_(tag2, rid-(rweight-1)+weight1+weight2-1, 0, LFSR_ATTR_(rid-(rweight-1)+weight1+weight2-1, tag2, 0,
buffer2, size2))); buffer2, size2)));
} }
} }
scripts/dbgbtree.py
+9 -9
View File
@@ -199,7 +199,7 @@ class Rbyd:
return Rbyd(block, limit, data, rev, off, trunk, weight) return Rbyd(block, limit, data, rev, off, trunk, weight)
def lookup(self, tag, id): def lookup(self, id, tag):
if not self: if not self:
return True, 0, -1, 0, 0, 0, b'' return True, 0, -1, 0, 0, 0, b''
@@ -227,13 +227,13 @@ class Rbyd:
j = j + delta j = j + delta
# found tag # found tag
else: else:
tag_ = alt
id_ = upper-1 id_ = upper-1
tag_ = alt
w_ = id_-lower w_ = id_-lower
done = (id_, tag_) < (id, tag) or tag_ & 2 done = (id_, tag_) < (id, tag) or tag_ & 2
return (done, tag_, id_, w_, return (done, id_, tag_, w_,
j, delta, self.data[j+delta:j+delta+jump]) j, delta, self.data[j+delta:j+delta+jump])
def __bool__(self): def __bool__(self):
@@ -250,11 +250,11 @@ class Rbyd:
id = 0 id = 0
while True: while True:
done, tag, id, w, j, d, data = self.lookup(tag+0x10, id) done, id, tag, w, j, d, data = self.lookup(id, tag+0x10)
if done: if done:
break break
yield tag, id, w, j, d, data yield id, tag, w, j, d, data
def main(disk, block_size=None, trunk=0, limit=None, *, def main(disk, block_size=None, trunk=0, limit=None, *,
@@ -306,8 +306,8 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
while True: while True:
# first lookup id/name # first lookup id/name
(done, name_tag, rid_, w, (done, rid_, name_tag, w,
name_j, name_d, name) = rbyd.lookup(0, rid) name_j, name_d, name) = rbyd.lookup(rid, 0)
if done: if done:
return (True, id, 0, rbyd, -1, return (True, id, 0, rbyd, -1,
(0, 0, 0, b''), (0, 0, 0, b''),
@@ -316,9 +316,9 @@ def main(disk, block_size=None, trunk=0, limit=None, *,
if name_tag & 0xf00f == TAG_NAME: if name_tag & 0xf00f == TAG_NAME:
# then lookup struct # then lookup struct
(done, struct_tag, _, _, (done, _, struct_tag, _,
struct_j, struct_d, struct_) = rbyd.lookup( struct_j, struct_d, struct_) = rbyd.lookup(
TAG_STRUCT, rid_) rid_, TAG_STRUCT)
if done: if done:
return (True, id, 0, rbyd, -1, return (True, id, 0, rbyd, -1,
(0, 0, 0, b''), (0, 0, 0, b''),
scripts/dbgrbyd.py
+7 -7
View File
@@ -493,7 +493,7 @@ def show_tree(block_size, data, rev, trunk, weight, *,
# lookup a tag, returning also the search path for decoration # lookup a tag, returning also the search path for decoration
# purposes # purposes
def lookup(tag, id): def lookup(id, tag):
lower = -1 lower = -1
upper = weight upper = weight
path = [] path = []
@@ -541,13 +541,13 @@ def show_tree(block_size, data, rev, trunk, weight, *,
path.append((j-delta, j, False, 'b')) path.append((j-delta, j, False, 'b'))
# found tag # found tag
else: else:
tag_ = alt
id_ = upper-1 id_ = upper-1
tag_ = alt
w_ = id_-lower w_ = id_-lower
done = (id_, tag_) < (id, tag) or tag_ & 2 done = (id_, tag_) < (id, tag) or tag_ & 2
return done, tag_, id_, w_, j, delta, jump, path return done, id_, tag_, w_, j, delta, jump, path
# precompute tree # precompute tree
tree_width = 0 tree_width = 0
@@ -555,9 +555,9 @@ def show_tree(block_size, data, rev, trunk, weight, *,
trunks = co.defaultdict(lambda: (-1, 0)) trunks = co.defaultdict(lambda: (-1, 0))
alts = co.defaultdict(lambda: {}) alts = co.defaultdict(lambda: {})
tag, id = 0, -1 id, tag = -1, 0
while True: while True:
done, tag, id, w, j, delta, size, path = lookup(tag+0x10, id) done, id, tag, w, j, delta, size, path = lookup(id, tag+0x10)
# found end of tree? # found end of tree?
if done: if done:
break break
@@ -690,9 +690,9 @@ def show_tree(block_size, data, rev, trunk, weight, *,
'data (truncated)' 'data (truncated)'
if not args.get('no_truncate') else '')) if not args.get('no_truncate') else ''))
tag, id = 0, -1 id, tag = -1, 0
while True: while True:
done, tag, id, w, j, delta, size, path = lookup(tag+0x10, id) done, id, tag, w, j, delta, size, path = lookup(id, tag+0x10)
# found end of tree? # found end of tree?
if done: if done:
break break
tests/test_btree.toml
+133 -133
View File
File diff suppressed because it is too large Load Diff
tests/test_rbyd.toml
+2245 -2245
View File
File diff suppressed because it is too large Load Diff