Github/littlefs
1
Fork 0
Code Actions Activity

rbyd-rr: Tweaked diverging machine for a bit better code reuse

Browse Source 
Mainly deduplicating the pruning of pre-diverged-lower alts and the
diverging alt itself.

This saves some code:

           code          stack
  before: 34308           2864
  after:  34236 (-0.2%)   2864 (+0.0%)
This commit is contained in:
Christopher Haster
2024-03-29 15:22:41 -05:00
parent 120f0a2e17
commit 115fad0c80
1 changed files with 53 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+24 -29
View File
@@ -2910,21 +2910,23 @@ again:;
jump = branch - jump; jump = branch - jump;
lfs_size_t branch_ = branch + d; lfs_size_t branch_ = branch + d;
// progress diverging state machine?
if (!lfsr_d_isdiverged(d_state)) {
// do bounds want to take different paths? begin diverging // do bounds want to take different paths? begin diverging
if (!lfsr_d_isdiverged(d_state) bool diverge
&& 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, lower_rid, upper_rid,
a_rid, a_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, lower_rid, upper_rid,
b_rid, b_tag)) { b_rid, b_tag);
LFS_ASSERT(d_state != LFSR_D_NOTDIVERGING);
// note that if red alt diverged if would have been caught // skip common alts on lower pass and the diverging alt
// on the previous pass // itself on both paths
d_state = lfsr_d_diverge(d_state); if (d_state == LFSR_D_DIVERGINGLOWER || diverge) {
LFS_ASSERT(d_state != LFSR_D_NOTDIVERGING);
if (lfsr_tag_follow2( if (lfsr_tag_follow2(
alt, weight, alt, weight,
@@ -2943,43 +2945,36 @@ again:;
&lower_rid, &upper_rid, &lower_rid, &upper_rid,
&lower_tag, &upper_tag); &lower_tag, &upper_tag);
// transition to the diverged state
//
// note that if red alt diverged if would have been
// caught on the previous pass
if (diverge) {
d_state = lfsr_d_diverge(d_state);
// stitch together diverged branches // stitch together diverged branches
if (d_state == LFSR_D_DIVERGEDUPPER) { if (d_state == LFSR_D_DIVERGEDUPPER) {
err = lfsr_rbyd_p_push(lfs, rbyd, err = lfsr_rbyd_p_push(lfs, rbyd,
p_alts, p_weights, p_jumps, p_alts, p_weights, p_jumps,
LFSR_TAG_ALT(LFSR_TAG_LE, LFSR_TAG_B, d_tag), LFSR_TAG_ALT(
LFSR_TAG_LE,
LFSR_TAG_B,
d_tag),
d_rid - lower_rid + weight, d_rid - lower_rid + weight,
d_branch); d_branch);
if (err) { if (err) {
return err; return err;
} }
} }
branch = branch_;
continue;
// don't write diverging lower alts
} else if (d_state == LFSR_D_DIVERGINGLOWER) {
if (lfsr_tag_follow(
alt, weight,
lower_rid, upper_rid,
a_rid, a_tag)) {
lfsr_tag_flip(
&alt, &weight,
lower_rid, upper_rid);
lfs_swap32(&jump, &branch_);
} }
lfsr_tag_trim(
alt, weight,
&lower_rid, &upper_rid,
&lower_tag, &upper_tag);
branch = branch_; branch = branch_;
continue; continue;
}
}
// trim unreachable alts created by diverged paths so they // trim unreachable diverged alts so they end up pruned
// will be pruned if (lfsr_d_isdiverged(d_state)
} else if (lfsr_d_isdiverged(d_state)
&& (d_state == LFSR_D_DIVERGEDUPPER) && (d_state == LFSR_D_DIVERGEDUPPER)
^ lfsr_tag_isgt(alt) ^ lfsr_tag_isgt(alt)
^ lfsr_tag_follow2( ^ lfsr_tag_follow2(