Github/littlefs
1
Fork 0
Code Actions Activity

Renamed */other_* -> a_*/b_*

Browse Source 
I think this does a better job of indicating that we're operating on two
different paths simultaneously. At the very least the prefix other_* was
kind of ambiguous...
This commit is contained in:
Christopher Haster
2024-03-07 01:42:30 -06:00
parent 5c45f07f1b
commit 3942d643e5
1 changed files with 174 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+174 -174
View File
@@ -2689,10 +2689,10 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// //
// several lower bits are reserved, so we repurpose these // several lower bits are reserved, so we repurpose these
// to keep track of some append state // to keep track of some append state
lfsr_srid_t rid_; lfsr_srid_t a_rid;
lfsr_srid_t other_rid_; lfsr_srid_t b_rid;
lfsr_tag_t tag_; lfsr_tag_t a_tag;
lfsr_tag_t other_tag_; lfsr_tag_t b_tag;
if (!lfsr_tag_isgrow(tag) && delta != 0) { if (!lfsr_tag_isgrow(tag) && delta != 0) {
if (delta > 0) { if (delta > 0) {
LFS_ASSERT(rid <= (lfsr_srid_t)rbyd->weight); LFS_ASSERT(rid <= (lfsr_srid_t)rbyd->weight);
@@ -2700,41 +2700,41 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// it's a bit ugly, but adjusting the rid here makes the following // it's a bit ugly, but adjusting the rid here makes the following
// logic work out more consistently // logic work out more consistently
rid -= 1; rid -= 1;
rid_ = rid + 1; a_rid = rid + 1;
other_rid_ = rid + 1; b_rid = rid + 1;
} else { } else {
LFS_ASSERT(rid < (lfsr_srid_t)rbyd->weight); LFS_ASSERT(rid < (lfsr_srid_t)rbyd->weight);
// it's a bit ugly, but adjusting the rid here makes the following // it's a bit ugly, but adjusting the rid here makes the following
// logic work out more consistently // logic work out more consistently
rid += 1; rid += 1;
rid_ = rid - lfs_smax32(-delta, 0); a_rid = rid - lfs_smax32(-delta, 0);
other_rid_ = rid; b_rid = rid;
} }
tag_ = 0; a_tag = 0;
other_tag_ = tag_; b_tag = a_tag;
} else { } else {
LFS_ASSERT(rid < (lfsr_srid_t)rbyd->weight); LFS_ASSERT(rid < (lfsr_srid_t)rbyd->weight);
rid_ = rid - lfs_smax32(-delta, 0); a_rid = rid - lfs_smax32(-delta, 0);
other_rid_ = rid; b_rid = rid;
// note both normal and rm wide-tags have the same bounds, really it's // note both normal and rm wide-tags have the same bounds, really it's
// the normal non-wide-tags that are an outlier here // the normal non-wide-tags that are an outlier here
if (lfsr_tag_issup(tag)) { if (lfsr_tag_issup(tag)) {
tag_ = 0; a_tag = 0;
other_tag_ = tag_ + 0x800; b_tag = a_tag + 0x800;
} else if (lfsr_tag_issub(tag)) { } else if (lfsr_tag_issub(tag)) {
tag_ = lfsr_tag_supkey(tag); a_tag = lfsr_tag_supkey(tag);
other_tag_ = tag_ + 0x100; b_tag = a_tag + 0x100;
} else if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) { } else if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) {
tag_ = lfsr_tag_key(tag); a_tag = lfsr_tag_key(tag);
other_tag_ = tag_ + 0x1; b_tag = a_tag + 0x1;
} else { } else {
tag_ = lfsr_tag_key(tag); a_tag = lfsr_tag_key(tag);
other_tag_ = tag_; b_tag = a_tag;
} }
} }
@@ -2743,11 +2743,11 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// this gets a bit confusing as we also may need to keep // this gets a bit confusing as we also may need to keep
// track of both the lower and upper bounds of diverging paths // track of both the lower and upper bounds of diverging paths
// in the case of range deletions // in the case of range deletions
lfs_size_t branch = lfsr_rbyd_trunk(rbyd); lfs_size_t a_branch = lfsr_rbyd_trunk(rbyd);
lfsr_srid_t lower_rid = 0; lfsr_srid_t a_lower_rid = 0;
lfsr_srid_t upper_rid = rbyd->weight; lfsr_srid_t a_upper_rid = rbyd->weight;
lfsr_tag_t lower_tag = 0; lfsr_tag_t a_lower_tag = 0;
lfsr_tag_t upper_tag = 0xffff; lfsr_tag_t a_upper_tag = 0xffff;
// diverged state in case we are removing a range from the tree // diverged state in case we are removing a range from the tree
// //
@@ -2756,11 +2756,11 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// //
// note we can't just perform two searches sequentially, or else our tree // note we can't just perform two searches sequentially, or else our tree
// will end up very unbalanced. // will end up very unbalanced.
lfs_size_t other_branch = 0; lfs_size_t b_branch = 0;
lfsr_srid_t other_lower_rid = 0; lfsr_srid_t b_lower_rid = 0;
lfsr_srid_t other_upper_rid = 0; lfsr_srid_t b_upper_rid = 0;
lfsr_tag_t other_lower_tag = 0; lfsr_tag_t b_lower_tag = 0;
lfsr_tag_t other_upper_tag = 0; lfsr_tag_t b_upper_tag = 0;
// go ahead and update the rbyd's weight, if an error occurs our // go ahead and update the rbyd's weight, if an error occurs our
// rbyd is no longer usable anyways // rbyd is no longer usable anyways
@@ -2771,7 +2771,7 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
rbyd->trunk = (rbyd->trunk & LFSR_RBYD_ISSHRUB) | rbyd->eoff; rbyd->trunk = (rbyd->trunk & LFSR_RBYD_ISSHRUB) | rbyd->eoff;
// no trunk yet? // no trunk yet?
if (!branch) { if (!a_branch) {
goto leaf; goto leaf;
} }
@@ -2788,7 +2788,7 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
lfsr_rid_t weight; lfsr_rid_t weight;
lfs_size_t jump; lfs_size_t jump;
lfs_ssize_t d = lfsr_bd_readtag(lfs, lfs_ssize_t d = lfsr_bd_readtag(lfs,
rbyd->blocks[0], branch, 0, rbyd->blocks[0], a_branch, 0,
&alt, &weight, &jump, NULL); &alt, &weight, &jump, NULL);
if (d < 0) { if (d < 0) {
return d; return d;
@@ -2797,69 +2797,69 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// found an alt? // found an alt?
if (lfsr_tag_isalt(alt)) { if (lfsr_tag_isalt(alt)) {
// make jump absolute // make jump absolute
jump = branch - jump; jump = a_branch - jump;
lfs_size_t branch_ = branch + d; lfs_size_t branch_ = a_branch + d;
// do bounds want to take different paths? begin diverging // do bounds want to take different paths? begin diverging
if (!lfsr_tag_hasdiverged(tag_) if (!lfsr_tag_hasdiverged(a_tag)
&& lfsr_tag_follow2(alt, weight, && lfsr_tag_follow2(alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid, a_lower_rid, a_upper_rid,
rid_, tag_) a_rid, a_tag)
^ lfsr_tag_follow2(alt, weight, ^ lfsr_tag_follow2(alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid, a_lower_rid, a_upper_rid,
other_rid_, other_tag_)) { b_rid, b_tag)) {
// take care of any lingering red alts before diverging // take care of any lingering red alts before diverging
if (lfsr_tag_isred(p_alts[0])) { if (lfsr_tag_isred(p_alts[0])) {
alt = p_alts[0] & ~LFSR_TAG_R; alt = p_alts[0] & ~LFSR_TAG_R;
weight = p_weights[0]; weight = p_weights[0];
jump = p_jumps[0]; jump = p_jumps[0];
branch_ = branch; branch_ = a_branch;
lfsr_rbyd_p_pop(p_alts, p_weights, p_jumps); lfsr_rbyd_p_pop(p_alts, p_weights, p_jumps);
// begin diverging // begin diverging
} else { } else {
tag_ |= LFSR_TAG_DIVERGED | LFSR_TAG_DIVERGEDLOWER; a_tag |= LFSR_TAG_DIVERGED | LFSR_TAG_DIVERGEDLOWER;
other_tag_ |= LFSR_TAG_DIVERGED | LFSR_TAG_DIVERGEDUPPER; b_tag |= LFSR_TAG_DIVERGED | LFSR_TAG_DIVERGEDUPPER;
other_branch = branch; b_branch = a_branch;
other_lower_rid = lower_rid; b_lower_rid = a_lower_rid;
other_upper_rid = upper_rid; b_upper_rid = a_upper_rid;
other_lower_tag = lower_tag; b_lower_tag = a_lower_tag;
other_upper_tag = upper_tag; b_upper_tag = a_upper_tag;
} }
} }
// if we diverged, paint alts black, this isn't perfect but // if we diverged, paint alts black, this isn't perfect but
// otherwise we run into recoloring issues // otherwise we run into recoloring issues
if (lfsr_tag_hasdiverged(tag_)) { if (lfsr_tag_hasdiverged(a_tag)) {
alt &= ~LFSR_TAG_R; alt &= ~LFSR_TAG_R;
// prune diverged? // prune diverged?
if (lfsr_tag_isdivergedupper(tag_) if (lfsr_tag_isdivergedupper(a_tag)
^ lfsr_tag_isgt(alt) ^ lfsr_tag_isgt(alt)
^ lfsr_tag_follow2( ^ lfsr_tag_follow2(
alt, weight, alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid, a_lower_rid, a_upper_rid,
rid_, tag_)) { a_rid, a_tag)) {
if (lfsr_tag_follow2( if (lfsr_tag_follow2(
alt, weight, alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid, a_lower_rid, a_upper_rid,
rid_, tag_)) { a_rid, a_tag)) {
lfsr_tag_flip2( lfsr_tag_flip2(
&alt, &weight, &alt, &weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid); a_lower_rid, a_upper_rid);
lfs_swap32(&jump, &branch_); lfs_swap32(&jump, &branch_);
} }
lfsr_tag_trim( lfsr_tag_trim(
alt, weight, alt, weight,
&lower_rid, &upper_rid, &a_lower_rid, &a_upper_rid,
&lower_tag, &upper_tag); &a_lower_tag, &a_upper_tag);
graft = branch; graft = a_branch;
branch = branch_; a_branch = branch_;
goto next; goto next;
} }
} }
@@ -2877,8 +2877,8 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
if (lfsr_tag_prune2( if (lfsr_tag_prune2(
alt, weight, alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid, a_lower_rid, a_upper_rid,
lower_tag, upper_tag)) { a_lower_tag, a_upper_tag)) {
if (lfsr_tag_isred(p_alts[0])) { if (lfsr_tag_isred(p_alts[0])) {
alt = p_alts[0] & ~LFSR_TAG_R; alt = p_alts[0] & ~LFSR_TAG_R;
weight = p_weights[0]; weight = p_weights[0];
@@ -2886,8 +2886,8 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
jump = p_jumps[0]; jump = p_jumps[0];
lfsr_rbyd_p_pop(p_alts, p_weights, p_jumps); lfsr_rbyd_p_pop(p_alts, p_weights, p_jumps);
} else { } else {
graft = branch; graft = a_branch;
branch = jump; a_branch = jump;
continue; continue;
} }
} }
@@ -2908,11 +2908,11 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
if (lfsr_tag_follow2( if (lfsr_tag_follow2(
alt, weight, alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid, a_lower_rid, a_upper_rid,
rid_, tag_)) { a_rid, a_tag)) {
lfsr_tag_flip2(&alt, &weight, lfsr_tag_flip2(&alt, &weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid); a_lower_rid, a_upper_rid);
lfs_swap32(&jump, &branch_); lfs_swap32(&jump, &branch_);
lfs_swap16(&p_alts[0], &alt); lfs_swap16(&p_alts[0], &alt);
@@ -2922,8 +2922,8 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
lfsr_tag_trim( lfsr_tag_trim(
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
&lower_rid, &upper_rid, &a_lower_rid, &a_upper_rid,
&lower_tag, &upper_tag); &a_lower_tag, &a_upper_tag);
lfsr_rbyd_p_red(p_alts, p_weights, p_jumps); lfsr_rbyd_p_red(p_alts, p_weights, p_jumps);
// otherwise we need to point to the yellow alt and // otherwise we need to point to the yellow alt and
@@ -2945,11 +2945,11 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
lfsr_tag_trim( lfsr_tag_trim(
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
&lower_rid, &upper_rid, &a_lower_rid, &a_upper_rid,
&lower_tag, &upper_tag); &a_lower_tag, &a_upper_tag);
lfsr_rbyd_p_red(p_alts, p_weights, p_jumps); lfsr_rbyd_p_red(p_alts, p_weights, p_jumps);
branch = branch_; a_branch = branch_;
continue; continue;
} }
} }
@@ -2962,11 +2962,11 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
&& lfsr_tag_follow2( && lfsr_tag_follow2(
alt, weight, alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid, a_lower_rid, a_upper_rid,
rid_, tag_)) { a_rid, a_tag)) {
lfsr_tag_flip2(&alt, &weight, lfsr_tag_flip2(&alt, &weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid); a_lower_rid, a_upper_rid);
lfs_swap32(&jump, &branch_); lfs_swap32(&jump, &branch_);
} }
@@ -2978,8 +2978,8 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// 1 2 3 1 2 3 1 // 1 2 3 1 2 3 1
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_rid, upper_rid, a_lower_rid, a_upper_rid,
rid_, tag_)) { a_rid, a_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);
@@ -2988,7 +2988,7 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
lfsr_tag_flip2(&alt, &weight, lfsr_tag_flip2(&alt, &weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
lower_rid, upper_rid); a_lower_rid, a_upper_rid);
lfs_swap32(&jump, &branch_); lfs_swap32(&jump, &branch_);
} }
@@ -2997,8 +2997,8 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
lfsr_tag_trim2( lfsr_tag_trim2(
alt, weight, alt, weight,
p_alts[0], p_weights[0], p_alts[0], p_weights[0],
&lower_rid, &upper_rid, &a_lower_rid, &a_upper_rid,
&lower_tag, &upper_tag); &a_lower_tag, &a_upper_tag);
} }
// push alt onto our queue // push alt onto our queue
@@ -3013,39 +3013,39 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// red alts, this gives us an optimal ternary tree if we // red alts, this gives us an optimal ternary tree if we
// started with a binary tree, but the above recoloring makes // started with a binary tree, but the above recoloring makes
// this not optimal // this not optimal
if (lfsr_tag_hasdiverged(tag_) && lfsr_tag_isblack(p_alts[2])) { if (lfsr_tag_hasdiverged(a_tag) && lfsr_tag_isblack(p_alts[2])) {
lfsr_rbyd_p_red(p_alts, p_weights, p_jumps); lfsr_rbyd_p_red(p_alts, p_weights, p_jumps);
} }
// continue to next alt // continue to next alt
graft = branch; graft = a_branch;
branch = branch_; a_branch = branch_;
// found end of tree? // found end of tree?
} else { } else {
// update the found tag/rid, marking as done while preserving // update the found tag/rid, marking as done while preserving
// any diverged state // any diverged state
tag_ = LFSR_TAG_DIVERGEDDONE a_tag = LFSR_TAG_DIVERGEDDONE
| lfsr_tag_mode(tag_) | lfsr_tag_mode(a_tag)
| alt; | alt;
// done? // done?
if (!lfsr_tag_hasdiverged(tag_) if (!lfsr_tag_hasdiverged(a_tag)
|| lfsr_tag_isdivergeddone(other_tag_)) { || lfsr_tag_isdivergeddone(b_tag)) {
break; break;
} }
} }
next:; next:;
// switch to the other path if we have diverged // switch to the other path if we have diverged
if (lfsr_tag_hasdiverged(tag_)) { if (lfsr_tag_hasdiverged(a_tag)) {
lfs_swap16(&tag_, &other_tag_); lfs_swap16(&a_tag, &b_tag);
lfs_sswap32(&rid_, &other_rid_); lfs_sswap32(&a_rid, &b_rid);
lfs_swap32(&branch, &other_branch); lfs_swap32(&a_branch, &b_branch);
lfs_sswap32(&lower_rid, &other_lower_rid); lfs_sswap32(&a_lower_rid, &b_lower_rid);
lfs_sswap32(&upper_rid, &other_upper_rid); lfs_sswap32(&a_upper_rid, &b_upper_rid);
lfs_swap16(&lower_tag, &other_lower_tag); lfs_swap16(&a_lower_tag, &b_lower_tag);
lfs_swap16(&upper_tag, &other_upper_tag); lfs_swap16(&a_upper_tag, &b_upper_tag);
} }
} }
@@ -3053,18 +3053,18 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
LFS_ASSERT(lfsr_tag_isblack(p_alts[0])); LFS_ASSERT(lfsr_tag_isblack(p_alts[0]));
// if we diverged, merge the bounds // if we diverged, merge the bounds
LFS_ASSERT(lfsr_tag_isdivergeddone(tag_)); LFS_ASSERT(lfsr_tag_isdivergeddone(a_tag));
LFS_ASSERT(!lfsr_tag_hasdiverged(tag_) LFS_ASSERT(!lfsr_tag_hasdiverged(a_tag)
|| lfsr_tag_isdivergeddone(other_tag_)); || lfsr_tag_isdivergeddone(b_tag));
if (lfsr_tag_hasdiverged(tag_)) { if (lfsr_tag_hasdiverged(a_tag)) {
if (lfsr_tag_isdivergedlower(tag_)) { if (lfsr_tag_isdivergedlower(a_tag)) {
// finished on lower path // finished on lower path
tag_ = other_tag_; a_tag = b_tag;
branch = other_branch; a_branch = b_branch;
upper_rid = other_upper_rid; a_upper_rid = b_upper_rid;
} else { } else {
// finished on upper path // finished on upper path
lower_rid = other_lower_rid; a_lower_rid = b_lower_rid;
} }
} }
@@ -3073,7 +3073,7 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// note we bias the weights here so that lfsr_rbyd_lookupnext // note we bias the weights here so that lfsr_rbyd_lookupnext
// always finds the next biggest tag // always finds the next biggest tag
// //
// note also if lfsr_tag_key(tag_) is null, we found a removed tag that // note also if lfsr_tag_key(a_tag) is null, we found a removed tag that
// we should just prune // we should just prune
// //
// this gets real messy because we have a lot of special behavior built in: // this gets real messy because we have a lot of special behavior built in:
@@ -3083,65 +3083,65 @@ static int lfsr_rbyd_appendattr(lfs_t *lfs, lfsr_rbyd_t *rbyd,
// - rm-bit set => never split, but emit alt-always tags, making our // - rm-bit set => never split, but emit alt-always tags, making our
// tag effectively unreachable // tag effectively unreachable
// //
lfsr_tag_t alt = 0; lfsr_tag_t a_alt = 0;
lfsr_rid_t weight = 0; lfsr_rid_t a_weight = 0;
if (lfsr_tag_key(tag_) if (lfsr_tag_key(a_tag)
&& (upper_rid-1 < rid-lfs_smax32(-delta, 0) && (a_upper_rid-1 < rid-lfs_smax32(-delta, 0)
|| (upper_rid-1 == rid-lfs_smax32(-delta, 0) || (a_upper_rid-1 == rid-lfs_smax32(-delta, 0)
&& ((!lfsr_tag_isgrow(tag) && delta > 0) && ((!lfsr_tag_isgrow(tag) && delta > 0)
|| (!lfsr_tag_issup(tag) || (!lfsr_tag_issup(tag)
&& lfsr_tag_supkey(tag_) < lfsr_tag_supkey(tag)) && lfsr_tag_supkey(a_tag) < lfsr_tag_supkey(tag))
|| (!lfsr_tag_issup(tag) || (!lfsr_tag_issup(tag)
&& !lfsr_tag_issub(tag) && !lfsr_tag_issub(tag)
&& lfsr_tag_key(tag_) < lfsr_tag_key(tag)))))) { && lfsr_tag_key(a_tag) < lfsr_tag_key(tag)))))) {
if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) { if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) {
// if removed, make our tag unreachable // if removed, make our tag unreachable
alt = LFSR_TAG_ALT(LFSR_TAG_GT, LFSR_TAG_B, 0); a_alt = LFSR_TAG_ALT(LFSR_TAG_GT, LFSR_TAG_B, 0);
weight = upper_rid - lower_rid + delta; a_weight = a_upper_rid - a_lower_rid + delta;
upper_rid -= weight; a_upper_rid -= a_weight;
} else { } else {
// split less than // split less than
alt = LFSR_TAG_ALT( a_alt = LFSR_TAG_ALT(
LFSR_TAG_LE, LFSR_TAG_LE,
(!lfsr_tag_hasdiverged(tag_)) (!lfsr_tag_hasdiverged(a_tag))
? LFSR_TAG_R ? LFSR_TAG_R
: LFSR_TAG_B, : LFSR_TAG_B,
tag_); a_tag);
weight = upper_rid - lower_rid; a_weight = a_upper_rid - a_lower_rid;
lower_rid += weight; a_lower_rid += a_weight;
} }
} else if (lfsr_tag_key(tag_) } else if (lfsr_tag_key(a_tag)
&& (upper_rid-1 > rid && (a_upper_rid-1 > rid
|| (upper_rid-1 == rid || (a_upper_rid-1 == rid
&& ((!lfsr_tag_isgrow(tag) && delta > 0) && ((!lfsr_tag_isgrow(tag) && delta > 0)
|| (!lfsr_tag_issup(tag) || (!lfsr_tag_issup(tag)
&& lfsr_tag_supkey(tag_) > lfsr_tag_supkey(tag)) && lfsr_tag_supkey(a_tag) > lfsr_tag_supkey(tag))
|| (!lfsr_tag_issup(tag) || (!lfsr_tag_issup(tag)
&& !lfsr_tag_issub(tag) && !lfsr_tag_issub(tag)
&& lfsr_tag_key(tag_) > lfsr_tag_key(tag)))))) { && lfsr_tag_key(a_tag) > lfsr_tag_key(tag)))))) {
if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) { if (lfsr_tag_isrm(tag) || !lfsr_tag_key(tag)) {
// if removed, make our tag unreachable // if removed, make our tag unreachable
alt = LFSR_TAG_ALT(LFSR_TAG_GT, LFSR_TAG_B, 0); a_alt = LFSR_TAG_ALT(LFSR_TAG_GT, LFSR_TAG_B, 0);
weight = upper_rid - lower_rid + delta; a_weight = a_upper_rid - a_lower_rid + delta;
upper_rid -= weight; a_upper_rid -= a_weight;
} else { } else {
// split greater than // split greater than
alt = LFSR_TAG_ALT( a_alt = LFSR_TAG_ALT(
LFSR_TAG_GT, LFSR_TAG_GT,
(!lfsr_tag_hasdiverged(tag_)) (!lfsr_tag_hasdiverged(a_tag))
? LFSR_TAG_R ? LFSR_TAG_R
: LFSR_TAG_B, : LFSR_TAG_B,
tag); tag);
weight = upper_rid - (rid+1); a_weight = a_upper_rid - (rid+1);
upper_rid -= weight; a_upper_rid -= a_weight;
} }
} }
if (alt) { if (a_alt) {
int err = lfsr_rbyd_p_push(lfs, rbyd, int err = lfsr_rbyd_p_push(lfs, rbyd,
p_alts, p_weights, p_jumps, p_alts, p_weights, p_jumps,
alt, weight, branch); a_alt, a_weight, a_branch);
if (err) { if (err) {
return err; return err;
} }
@@ -3171,7 +3171,7 @@ leaf:;
| ((lfsr_tag_isrm(tag)) | ((lfsr_tag_isrm(tag))
? LFSR_TAG_NULL ? LFSR_TAG_NULL
: lfsr_tag_key(tag)), : lfsr_tag_key(tag)),
upper_rid - lower_rid + delta, a_upper_rid - a_lower_rid + delta,
lfsr_data_size(data), lfsr_data_size(data),
&rbyd->cksum); &rbyd->cksum);
if (d < 0) { if (d < 0) {
@@ -3409,22 +3409,22 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
// this naturally gives us a split rid // this naturally gives us a split rid
// //
// TODO adopt this a/b naming scheme in lfsr_rbyd_appendattr? // TODO adopt this a/b naming scheme in lfsr_rbyd_appendattr?
lfsr_srid_t rid = start_rid; lfsr_srid_t a_rid = start_rid;
lfsr_srid_t other_rid = lfs_min32(rbyd->weight, end_rid); lfsr_srid_t b_rid = lfs_min32(rbyd->weight, end_rid);
lfs_size_t dsize = 0; lfs_size_t a_dsize = 0;
lfs_size_t other_dsize = 0; lfs_size_t b_dsize = 0;
lfs_size_t rbyd_dsize = 0; lfs_size_t rbyd_dsize = 0;
while (rid != other_rid) { while (a_rid != b_rid) {
if (dsize > other_dsize if (a_dsize > b_dsize
// bias so lower dsize >= upper dsize // bias so lower dsize >= upper dsize
|| (dsize == other_dsize && rid > other_rid)) { || (a_dsize == b_dsize && a_rid > b_rid)) {
lfs_sswap32(&rid, &other_rid); lfs_sswap32(&a_rid, &b_rid);
lfs_swap32(&dsize, &other_dsize); lfs_swap32(&a_dsize, &b_dsize);
} }
if (rid > other_rid) { if (a_rid > b_rid) {
rid -= 1; a_rid -= 1;
} }
lfsr_tag_t tag = 0; lfsr_tag_t tag = 0;
@@ -3435,7 +3435,7 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
lfsr_rid_t weight_; lfsr_rid_t weight_;
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_rbyd_lookupnext(lfs, rbyd, int err = lfsr_rbyd_lookupnext(lfs, rbyd,
rid, tag+1, a_rid, tag+1,
&rid_, &tag, &weight_, &data); &rid_, &tag, &weight_, &data);
if (err) { if (err) {
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
@@ -3444,36 +3444,36 @@ static lfs_ssize_t lfsr_rbyd_estimate(lfs_t *lfs, const lfsr_rbyd_t *rbyd,
LFS_ASSERT(err < 0); LFS_ASSERT(err < 0);
return err; return err;
} }
if (rid_ > rid+lfs_smax32(weight_-1, 0)) { if (rid_ > a_rid+lfs_smax32(weight_-1, 0)) {
break; break;
} }
// keep track of rid and weight // keep track of rid and weight
rid = rid_; a_rid = rid_;
weight += weight_; weight += weight_;
// include the cost of this tag // include the cost of this tag
dsize_ += lfs->attr_estimate + lfsr_data_size(data); dsize_ += lfs->attr_estimate + lfsr_data_size(data);
} }
if (rid == -1) { if (a_rid == -1) {
rbyd_dsize += dsize_; rbyd_dsize += dsize_;
} else { } else {
dsize += dsize_; a_dsize += dsize_;
} }
if (rid < other_rid) { if (a_rid < b_rid) {
rid += 1; a_rid += 1;
} else { } else {
rid -= lfs_smax32(weight-1, 0); a_rid -= lfs_smax32(weight-1, 0);
} }
} }
if (split_rid_) { if (split_rid_) {
*split_rid_ = rid; *split_rid_ = a_rid;
} }
return rbyd_dsize + dsize + other_dsize; return rbyd_dsize + a_dsize + b_dsize;
} }
// appends a raw tag as a part of compaction, note these must // appends a raw tag as a part of compaction, note these must
@@ -5986,22 +5986,22 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir,
// calculate dsize by starting from the outside ids and working inwards, // calculate dsize by starting from the outside ids and working inwards,
// this naturally gives us a split rid // this naturally gives us a split rid
lfsr_srid_t rid = start_rid; lfsr_srid_t a_rid = start_rid;
lfsr_srid_t other_rid = lfs_min32(mdir->rbyd.weight, end_rid); lfsr_srid_t b_rid = lfs_min32(mdir->rbyd.weight, end_rid);
lfs_size_t dsize = 0; lfs_size_t a_dsize = 0;
lfs_size_t other_dsize = 0; lfs_size_t b_dsize = 0;
lfs_size_t mdir_dsize = 0; lfs_size_t mdir_dsize = 0;
while (rid != other_rid) { while (a_rid != b_rid) {
if (dsize > other_dsize if (a_dsize > b_dsize
// bias so lower dsize >= upper dsize // bias so lower dsize >= upper dsize
|| (dsize == other_dsize && rid > other_rid)) { || (a_dsize == b_dsize && a_rid > b_rid)) {
lfs_sswap32(&rid, &other_rid); lfs_sswap32(&a_rid, &b_rid);
lfs_swap32(&dsize, &other_dsize); lfs_swap32(&a_dsize, &b_dsize);
} }
if (rid > other_rid) { if (a_rid > b_rid) {
rid -= 1; a_rid -= 1;
} }
lfsr_tag_t tag = 0; lfsr_tag_t tag = 0;
@@ -6010,7 +6010,7 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir,
lfsr_srid_t rid_; lfsr_srid_t rid_;
lfsr_data_t data; lfsr_data_t data;
int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd, int err = lfsr_rbyd_lookupnext(lfs, &mdir->rbyd,
rid, tag+1, a_rid, tag+1,
&rid_, &tag, NULL, &data); &rid_, &tag, NULL, &data);
if (err) { if (err) {
if (err == LFS_ERR_NOENT) { if (err == LFS_ERR_NOENT) {
@@ -6019,7 +6019,7 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir,
LFS_ASSERT(err < 0); LFS_ASSERT(err < 0);
return err; return err;
} }
if (rid_ != rid) { if (rid_ != a_rid) {
break; break;
} }
@@ -6070,7 +6070,7 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir,
// belongs to our mdir + rid? // belongs to our mdir + rid?
if (file->m.type != LFS_TYPE_REG if (file->m.type != LFS_TYPE_REG
|| lfsr_mdir_cmp(&file->m.mdir, mdir) != 0 || lfsr_mdir_cmp(&file->m.mdir, mdir) != 0
|| lfsr_mid_rid(lfs, file->m.mdir.mid) != rid) { || lfsr_mid_rid(lfs, file->m.mdir.mid) != a_rid) {
continue; continue;
} }
@@ -6094,22 +6094,22 @@ static lfs_ssize_t lfsr_mdir_estimate__(lfs_t *lfs, const lfsr_mdir_t *mdir,
} }
} }
if (rid == -1) { if (a_rid == -1) {
mdir_dsize += dsize_; mdir_dsize += dsize_;
} else { } else {
dsize += dsize_; a_dsize += dsize_;
} }
if (rid < other_rid) { if (a_rid < b_rid) {
rid += 1; a_rid += 1;
} }
} }
if (split_rid_) { if (split_rid_) {
*split_rid_ = rid; *split_rid_ = a_rid;
} }
return mdir_dsize + dsize + other_dsize; return mdir_dsize + a_dsize + b_dsize;
} }
static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_, static int lfsr_mdir_compact__(lfs_t *lfs, lfsr_mdir_t *mdir_,