Github/littlefs
1
Fork 0
Code Actions Activity

Rbyd tests are now passing again, however range removal needs a review

Browse Source
This commit is contained in:
Christopher Haster
2023-01-27 16:10:07 -06:00
parent 56fbf4155b
commit 2a4b6fcad9
2 changed files with 587 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+452 -192
View File
@@ -767,7 +767,6 @@ static inline bool lfsr_tag_follow(lfsr_tag_t alt, lfs_size_t weight,
lfsr_sid_t lower, lfsr_sid_t upper, lfsr_sid_t lower, lfsr_sid_t upper,
lfsr_tag_t tag, lfsr_sid_t id) { lfsr_tag_t tag, lfsr_sid_t id) {
// TODO do we actually need lfsr_tag_key? // TODO do we actually need lfsr_tag_key?
// TODO hmm, are key and weight entirely exclusive?
if (lfsr_tag_isgt(alt)) { if (lfsr_tag_isgt(alt)) {
return id >= upper - (lfs_ssize_t)weight return id >= upper - (lfs_ssize_t)weight
|| (/*lfsr_tag_key(alt) || (/*lfsr_tag_key(alt)
@@ -781,6 +780,20 @@ static inline bool lfsr_tag_follow(lfsr_tag_t alt, lfs_size_t weight,
} }
} }
static inline bool lfsr_tag_follow2(
lfsr_tag_t alt, lfs_size_t weight,
lfsr_tag_t alt2, lfs_size_t weight2,
lfsr_sid_t lower, lfsr_sid_t upper,
lfsr_tag_t tag, lfsr_sid_t id) {
if (alt2
&& lfsr_tag_isred(alt2)
&& lfsr_tag_isparallel(alt, alt2)) {
return lfsr_tag_follow(alt, weight+weight2, lower, upper, tag, id);
} else {
return lfsr_tag_follow(alt, weight, lower, upper, tag, id);
}
}
static inline lfsr_tag_t lfsr_tag_flipalt(lfsr_tag_t alt) { static inline lfsr_tag_t lfsr_tag_flipalt(lfsr_tag_t alt) {
return alt ^ 0x4; return alt ^ 0x4;
} }
@@ -790,6 +803,16 @@ static inline lfs_size_t lfsr_tag_flipweight(lfs_size_t weight,
return (upper-lower) - weight - 1; return (upper-lower) - weight - 1;
} }
static inline lfs_size_t lfsr_tag_flipweight2(lfs_size_t weight,
lfsr_tag_t alt2, lfs_size_t weight2,
lfsr_sid_t lower, lfsr_sid_t upper) {
if (alt2 && lfsr_tag_isred(alt2)) {
return lfsr_tag_flipweight(weight+weight2, lower, upper);
} else {
return lfsr_tag_flipweight(weight, lower, upper);
}
}
static inline void lfsr_tag_trimweight(lfsr_tag_t alt, lfs_size_t weight, static inline void lfsr_tag_trimweight(lfsr_tag_t alt, lfs_size_t weight,
lfsr_sid_t *lower, lfsr_sid_t *upper) { lfsr_sid_t *lower, lfsr_sid_t *upper) {
if (lfsr_tag_isgt(alt)) { if (lfsr_tag_isgt(alt)) {
@@ -846,6 +869,42 @@ static inline void lfsr_tag_trim_(lfsr_tag_t alt,
} }
} }
static inline void lfsr_tag_trim__(
lfsr_tag_t alt, lfs_size_t weight,
lfsr_sid_t *lower_id, lfsr_sid_t *upper_id,
lfsr_tag_t *lower_tag, lfsr_tag_t *upper_tag) {
if (lfsr_tag_isgt(alt)) {
*upper_id -= weight;
// TODO need min/max? can this be better?
if (weight) {
*upper_tag = 0xffff;
}
*upper_tag = lfs_min(*upper_tag, alt + 0x10);
} else {
*lower_id += weight;
// TODO need min/max? can this be better?
if (weight) {
*lower_tag = 0;
}
*lower_tag = lfs_max(*lower_tag, alt + 0x10);
}
}
static inline void lfsr_tag_trim2(
lfsr_tag_t alt, lfs_size_t weight,
lfsr_tag_t alt2, lfs_size_t weight2,
lfsr_sid_t *lower_id, lfsr_sid_t *upper_id,
lfsr_tag_t *lower_tag, lfsr_tag_t *upper_tag) {
if (alt2 && lfsr_tag_isred(alt2)) {
lfsr_tag_trim__(alt2, weight2,
lower_id, upper_id, lower_tag, upper_tag);
}
lfsr_tag_trim__(alt, weight,
lower_id, upper_id, lower_tag, upper_tag);
}
// operations on attribute lists // operations on attribute lists
struct lfs_mattr { struct lfs_mattr {
lfs_tag_t tag; lfs_tag_t tag;
@@ -2025,12 +2084,8 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
// TODO bool flipped? bool found? // TODO bool flipped? bool found?
lfsr_sid_t lower_lower_id = -1; lfsr_sid_t lower_lower_id = -1;
lfsr_sid_t lower_upper_id = rbyd_->weight; lfsr_sid_t lower_upper_id = rbyd_->weight;
lfsr_sid_t upper_lower_id = lower_lower_id; lfsr_sid_t upper_lower_id = upper_lower_id;
lfsr_sid_t upper_upper_id = lower_upper_id; lfsr_sid_t upper_upper_id = upper_upper_id;
lfsr_sid_t lower_lower_id_ = lower_lower_id;
lfsr_sid_t lower_upper_id_ = lower_upper_id;
lfsr_sid_t upper_lower_id_ = upper_lower_id;
lfsr_sid_t upper_upper_id_ = upper_upper_id;
lfsr_tag_t lower_lower_tag = 0; lfsr_tag_t lower_lower_tag = 0;
lfsr_tag_t lower_upper_tag = 0xffff; lfsr_tag_t lower_upper_tag = 0xffff;
lfsr_tag_t upper_lower_tag = upper_lower_tag; lfsr_tag_t upper_lower_tag = upper_lower_tag;
@@ -2041,6 +2096,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
lfs_size_t p_weights[3] = {0, 0, 0}; lfs_size_t p_weights[3] = {0, 0, 0};
lfs_off_t p_jumps[3] = {0, 0, 0}; lfs_off_t p_jumps[3] = {0, 0, 0};
lfs_off_t graft = 0; lfs_off_t graft = 0;
graft = lower_branch; // TODO need?
// descend down tree, building alt pointers // descend down tree, building alt pointers
while (true) { while (true) {
@@ -2053,8 +2109,6 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
lfs_swap32(&lower_branch, &upper_branch); lfs_swap32(&lower_branch, &upper_branch);
lfs_swaps32(&lower_lower_id, &upper_lower_id); lfs_swaps32(&lower_lower_id, &upper_lower_id);
lfs_swaps32(&lower_upper_id, &upper_upper_id); lfs_swaps32(&lower_upper_id, &upper_upper_id);
lfs_swaps32(&lower_lower_id_, &upper_lower_id_);
lfs_swaps32(&lower_upper_id_, &upper_upper_id_);
lfs_swap16(&lower_lower_tag, &upper_lower_tag); lfs_swap16(&lower_lower_tag, &upper_lower_tag);
lfs_swap16(&lower_upper_tag, &upper_upper_tag); lfs_swap16(&lower_upper_tag, &upper_upper_tag);
} }
@@ -2079,21 +2133,45 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
// do bounds want to take different paths? begin cutting // do bounds want to take different paths? begin cutting
if (!diverged if (!diverged
&& lfsr_tag_follow(alt, weight_, && lfsr_tag_follow2(alt, weight_,
p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id, lower_lower_id, lower_upper_id,
lower_tag_, lower_id_) lower_tag_, lower_id_)
!= lfsr_tag_follow(alt, weight_, != lfsr_tag_follow2(alt, weight_,
p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id, lower_lower_id, lower_upper_id,
upper_tag_, upper_id_)) { upper_tag_, upper_id_)) {
// first handle any lingering red alts
if (lfsr_tag_isred(p_alts[0])) {
printf("diverging red!\n");
alt = lfsr_tag_mkblack(p_alts[0]);
weight_ = p_weights[0];
jump = p_jumps[0];
branch_ = lower_branch;
lower_branch = graft; // TODO need this?
lfsr_rbyd_p_pop(p_alts, p_weights, p_jumps);
goto diverging_red;
}
diverged = true; diverged = true;
upper_branch = lower_branch; upper_branch = lower_branch;
upper_lower_id = lower_lower_id; upper_lower_id = lower_lower_id;
upper_upper_id = lower_upper_id; upper_upper_id = lower_upper_id;
upper_lower_id_ = lower_lower_id_; upper_lower_id = lower_lower_id;
upper_upper_id_ = lower_upper_id_; upper_upper_id = lower_upper_id;
upper_lower_tag = lower_lower_tag; upper_lower_tag = lower_lower_tag;
upper_upper_tag = lower_upper_tag; upper_upper_tag = lower_upper_tag;
// // make sure upper path is in sync with red alts!
// if (lfsr_tag_isred(p_alts[0])) {
//// lfsr_tag_trim__(p_alts[0], p_weights[0],
//// &upper_lower_id, &upper_upper_id,
//// &upper_lower_tag, &upper_upper_tag);
// }
// // TODO ??? // // TODO ???
// // handle red edge before diverging // // handle red edge before diverging
// if (p_alts[0] && lfsr_tag_isred(p_alts[0])) { // if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
@@ -2118,13 +2196,30 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
// lfs_swap32(&lower_branch, &upper_branch); // lfs_swap32(&lower_branch, &upper_branch);
// lfs_swaps32(&lower_lower_id, &upper_lower_id); // lfs_swaps32(&lower_lower_id, &upper_lower_id);
// lfs_swaps32(&lower_upper_id, &upper_upper_id); // lfs_swaps32(&lower_upper_id, &upper_upper_id);
// lfs_swaps32(&lower_lower_id_, &upper_lower_id_); // lfs_swaps32(&lower_lower_id, &upper_lower_id);
// lfs_swaps32(&lower_upper_id_, &upper_upper_id_); // lfs_swaps32(&lower_upper_id, &upper_upper_id);
// lfs_swap16(&lower_lower_tag, &upper_lower_tag); // lfs_swap16(&lower_lower_tag, &upper_lower_tag);
// lfs_swap16(&lower_upper_tag, &upper_upper_tag); // lfs_swap16(&lower_upper_tag, &upper_upper_tag);
// } // }
} }
diverging_red:
printf("%c alt%c%s 0x%x w%d 0x%x (0x%x %d, 0x%x %d)\n",
!diverged
? '='
: (lower_id_ < upper_id_
|| (lower_id_ == upper_id_
&& lower_tag_ < upper_tag_))
? '['
: ']',
lfsr_tag_isred(alt) ? 'r' : 'b',
lfsr_tag_isgt(alt) ? "gt" : "le",
lfsr_tag_key(alt),
weight_,
jump,
lower_lower_tag, lower_lower_id,
lower_upper_tag, lower_upper_id);
// prune? // prune?
// <b >b // <b >b
// .-'| .-'| // .-'| .-'|
@@ -2135,54 +2230,21 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
// | | <b | <b | // | | <b | <b |
// | | .----'| | .----'| | // | | .----'| | .----'| |
// 1 2 3 4 4 1 2 3 4 4 2 // 1 2 3 4 4 1 2 3 4 4 2
// bool prune = false;
printf("%c alt%c%s 0x%x w%d 0x%x (0x%x %d (%d), 0x%x %d (%d)) f=%d (0x%x %d)\n",
!diverged
? '='
: (lower_id_ < upper_id_
|| (lower_id_ == upper_id_
&& lower_tag_ < upper_tag_))
? '['
: ']',
lfsr_tag_isred(alt) ? 'r' : 'b',
lfsr_tag_isgt(alt) ? "gt" : "lt",
lfsr_tag_key(alt),
weight_, jump, lower_lower_tag, lower_lower_id_, lower_lower_id, lower_upper_tag, lower_upper_id_, lower_upper_id,
lfsr_tag_follow(alt, weight_,
lower_lower_id, lower_upper_id,
lower_tag_, lower_id_),
lower_tag_, lower_id_);
LFS_ASSERT(lower_upper_id - lower_lower_id >= 1);
// TODO something better than this
lfsr_tag_t predicted_lower_tag = lower_lower_tag;
lfsr_tag_t predicted_upper_tag = lower_upper_tag;
// if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
// // TODO need this?
// lfsr_tag_trimtag(p_alts[0],
// lower_lower_id, lower_upper_id,
// &predicted_lower_tag, &predicted_upper_tag,
// lower_id_);
// }
// TODO can this be rewritten in terms of lfsr_tag_follow? // TODO can this be rewritten in terms of lfsr_tag_follow?
if (weight_ > (lfs_size_t)(lower_upper_id_-lower_lower_id_-1) if (weight_+(lfsr_tag_isred(p_alts[0]) ? p_weights[0] : 0) > (lfs_size_t)(lower_upper_id-lower_lower_id-1)
|| (weight_ == (lfs_size_t)(lower_upper_id_-lower_lower_id_-1) || (weight_+(lfsr_tag_isred(p_alts[0]) ? p_weights[0] : 0) == (lfs_size_t)(lower_upper_id-lower_lower_id-1)
// TODO need key? // TODO need key?
&& (lfsr_tag_isgt(alt) && (lfsr_tag_isgt(alt)
? lfsr_tag_key(predicted_lower_tag) > lfsr_tag_key(alt) ? lfsr_tag_key(lower_lower_tag) > lfsr_tag_key(alt)
: lfsr_tag_key(predicted_upper_tag-0x10) <= lfsr_tag_key(alt)))) { && !(lfsr_tag_isred(p_alts[0]) && lfsr_tag_isle(p_alts[0]) && p_weights[0])
// && (lfsr_tag_key(alt) : lfsr_tag_key(lower_upper_tag-0x10) <= lfsr_tag_key(alt)
// < lfsr_tag_key(lower_lower_tag) && !(lfsr_tag_isred(p_alts[0]) && lfsr_tag_isgt(p_alts[0]) && p_weights[0])))) {
// || lfsr_tag_key(alt)
// >= lfsr_tag_key(lower_upper_tag)))) {
printf("PRUUUUUUUUUUUUUUUUUUUUUUUNE\n"); printf("PRUUUUUUUUUUUUUUUUUUUUUUUNE\n");
printf("%d > %d-%d-1 => %d\n", weight_, lower_upper_id, lower_lower_id, weight_ > (lfs_size_t)(lower_upper_id-lower_lower_id-1)); printf("w%d+w%d > id%d-id%d-1\n", weight_, (lfsr_tag_isred(p_alts[0]) ? p_weights[0] : 0), lower_upper_id, lower_lower_id);
printf("%d == %d-%d-1 => %d\n", weight_, lower_upper_id, lower_lower_id, weight_ == (lfs_size_t)(lower_upper_id-lower_lower_id-1)); printf("isgt=%d ? 0x%x > 0x%x : 0x%x <= 0x%x\n",
printf("isgt = %d\n", lfsr_tag_isgt(alt)); lfsr_tag_isgt(alt),
printf("0x%x > 0x%x => %d\n", lfsr_tag_key(predicted_lower_tag), lfsr_tag_key(alt), lfsr_tag_key(predicted_lower_tag) > lfsr_tag_key(alt)); lfsr_tag_key(lower_lower_tag), lfsr_tag_key(alt),
printf("0x%x <= 0x%x => %d\n", lfsr_tag_key(predicted_upper_tag-0x10), lfsr_tag_key(alt), lfsr_tag_key(predicted_upper_tag-0x10) <= lfsr_tag_key(alt)); lfsr_tag_key(lower_upper_tag-0x10), lfsr_tag_key(alt));
// prune = true;
// lower_lower_tag = predicted_lower_tag;
// lower_upper_tag = predicted_upper_tag;
if (p_alts[0] && lfsr_tag_isred(p_alts[0])) { if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
alt = lfsr_tag_mkblack(p_alts[0]); alt = lfsr_tag_mkblack(p_alts[0]);
@@ -2191,23 +2253,28 @@ static int lfsr_rbyd_append(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);
lfsr_tag_untrimweight(alt, weight_, // lfsr_tag_untrimweight(alt, weight_,
&lower_lower_id, &lower_upper_id); // &lower_lower_id, &lower_upper_id);
//
printf("pruned into alt%c%s 0x%x w%d 0x%x (0x%x)\n", // printf("pruned into alt%c%s 0x%x w%d 0x%x (0x%x)\n",
lfsr_tag_isred(alt) ? 'r' : 'b', // lfsr_tag_isred(alt) ? 'r' : 'b',
lfsr_tag_isgt(alt) ? "gt" : "lt", // lfsr_tag_isgt(alt) ? "gt" : "lt",
lfsr_tag_key(alt), // lfsr_tag_key(alt),
weight_, // weight_,
jump, // jump,
branch_); // branch_);
} else { } else {
// TODO does this ever happen with normal prunes?
//LFS_ASSERT(false);
graft = lower_branch; // TODO need?
lower_branch = jump; lower_branch = jump;
continue; continue;
} }
// cut while following // cut while following
} else if (diverged } else if (diverged
&& lfsr_tag_follow(alt, weight_, && lfsr_tag_follow2(alt, weight_,
p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id, lower_lower_id, lower_upper_id,
lower_tag_, lower_id_) lower_tag_, lower_id_)
&& (lower_id_ < upper_id_ && (lower_id_ < upper_id_
@@ -2217,49 +2284,45 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
// lower_lower_id, lower_upper_id, // lower_lower_id, lower_upper_id,
// &lower_lower_tag, &lower_upper_tag, // &lower_lower_tag, &lower_upper_tag,
// lower_id_); // lower_id_);
printf("trim-f\n");
// prune = true; // prune = true;
if (p_alts[0] && lfsr_tag_isred(p_alts[0])) { if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
lfsr_tag_trimweight( printf("trimfb\n");
lfsr_tag_flipalt(alt), // if (!lfsr_tag_isparallel(alt, p_alts[0])) {
lfsr_tag_flipweight(weight_, //// p_weights[0] += weight_;
lower_lower_id, lower_upper_id), // } else {
&lower_lower_id, &lower_upper_id); lfsr_tag_trim__(
lfsr_tag_flipalt(alt),
lfsr_tag_flipweight2(weight_,
p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id),
&lower_lower_id, &lower_upper_id,
&lower_lower_tag, &lower_upper_tag);
//}
alt = lfsr_tag_mkblack(p_alts[0]); alt = lfsr_tag_mkblack(p_alts[0]);
weight_ = p_weights[0]; weight_ = p_weights[0];
branch_ = jump; branch_ = jump;
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);
lfsr_tag_untrimweight(alt, weight_,
&lower_lower_id, &lower_upper_id);
printf("pruned into alt%c%s 0x%x w%d 0x%x (0x%x)\n",
lfsr_tag_isred(alt) ? 'r' : 'b',
lfsr_tag_isgt(alt) ? "gt" : "lt",
lfsr_tag_key(alt),
weight_,
jump,
branch_);
} else { } else {
lfsr_tag_trimweight( printf("trimfr\n");
lfsr_tag_trim__(
lfsr_tag_flipalt(alt), lfsr_tag_flipalt(alt),
lfsr_tag_flipweight(weight_, lfsr_tag_flipweight2(weight_,
p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id), lower_lower_id, lower_upper_id),
&lower_lower_id, &lower_upper_id); &lower_lower_id, &lower_upper_id,
if (p_alts[0]) { &lower_lower_tag, &lower_upper_tag);
lfsr_tag_trim_(p_alts[0],
lower_lower_id, lower_upper_id, graft = lower_branch; // TODO need?
&lower_lower_id_, &lower_upper_id_,
&lower_lower_tag, &lower_upper_tag);
}
lower_branch = jump; lower_branch = jump;
continue; continue;
} }
// cut while not following // cut while not following
} else if (diverged } else if (diverged
&& !lfsr_tag_follow(alt, weight_, && !lfsr_tag_follow2(alt, weight_,
p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id, lower_lower_id, lower_upper_id,
lower_tag_, lower_id_) lower_tag_, lower_id_)
&& (lower_id_ < upper_id_ && (lower_id_ < upper_id_
@@ -2270,75 +2333,243 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_,
// &lower_lower_tag, &lower_upper_tag, // &lower_lower_tag, &lower_upper_tag,
// lower_id_); // lower_id_);
// lfs_swap32(&jump, &branch_); // lfs_swap32(&jump, &branch_);
printf("trim-nf\n");
// prune = true; // prune = true;
if (p_alts[0] && lfsr_tag_isred(p_alts[0])) { if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
printf("trimnfr\n");
// if (lfsr_tag_isparallel(alt, p_alts[0])) { // if (lfsr_tag_isparallel(alt, p_alts[0])) {
// p_weights[0] += weight_; // //p_weights[0] += weight_;
// } else {
lfsr_tag_trim__(
alt, weight_,
&lower_lower_id, &lower_upper_id,
&lower_lower_tag, &lower_upper_tag);
// } // }
lfsr_tag_trimweight(alt, weight_,
&lower_lower_id, &lower_upper_id);
alt = lfsr_tag_mkblack(p_alts[0]); alt = lfsr_tag_mkblack(p_alts[0]);
weight_ = p_weights[0]; weight_ = p_weights[0];
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);
lfsr_tag_untrimweight(alt, weight_,
&lower_lower_id, &lower_upper_id);
printf("pruned into alt%c%s 0x%x w%d 0x%x (0x%x)\n",
lfsr_tag_isred(alt) ? 'r' : 'b',
lfsr_tag_isgt(alt) ? "gt" : "lt",
lfsr_tag_key(alt),
weight_,
jump,
branch_);
printf("p alt%c%s 0x%x w%d 0x%x (0x%x %d (%d), 0x%x %d (%d)) f=%d (0x%x %d)\n",
!diverged
? '='
: (lower_id_ < upper_id_
|| (lower_id_ == upper_id_
&& lower_tag_ < upper_tag_))
? '['
: ']',
lfsr_tag_isred(alt) ? 'r' : 'b',
lfsr_tag_isgt(alt) ? "gt" : "lt",
lfsr_tag_key(alt),
weight_, jump, lower_lower_tag, lower_lower_id_, lower_lower_id, lower_upper_tag, lower_upper_id_, lower_upper_id,
lfsr_tag_follow(alt, weight_,
lower_lower_id, lower_upper_id,
lower_tag_, lower_id_),
lower_tag_, lower_id_);
} else { } else {
lfsr_tag_trimweight(alt, weight_, printf("trimnfb\n");
&lower_lower_id, &lower_upper_id); lfsr_tag_trim__(
if (p_alts[0]) { alt, weight_,
lfsr_tag_trim_(p_alts[0], &lower_lower_id, &lower_upper_id,
lower_lower_id, lower_upper_id, &lower_lower_tag, &lower_upper_tag);
&lower_lower_id_, &lower_upper_id_,
&lower_lower_tag, &lower_upper_tag); graft = lower_branch; // TODO need?
}
lower_branch = branch_; lower_branch = branch_;
continue; continue;
} }
} }
// if (diverged
// bool prune = false;
// printf("%c alt%c%s 0x%x w%d 0x%x (0x%x %d (%d), 0x%x %d (%d)) f=%d (0x%x %d)\n",
// !diverged
// ? '='
// : (lower_id_ < upper_id_
// || (lower_id_ == upper_id_
// && lower_tag_ < upper_tag_))
// ? '['
// : ']',
// lfsr_tag_isred(alt) ? 'r' : 'b',
// lfsr_tag_isgt(alt) ? "gt" : "lt",
// lfsr_tag_key(alt),
// weight_, jump, lower_lower_tag, lower_lower_id, lower_lower_id, lower_upper_tag, lower_upper_id, lower_upper_id,
// lfsr_tag_follow(alt, weight_,
// lower_lower_id, lower_upper_id,
// lower_tag_, lower_id_),
// lower_tag_, lower_id_);
// LFS_ASSERT(lower_upper_id - lower_lower_id >= 1);
// // TODO something better than this
// lfsr_tag_t predicted_lower_tag = lower_lower_tag;
// lfsr_tag_t predicted_upper_tag = lower_upper_tag;
//// if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
//// // TODO need this?
//// lfsr_tag_trimtag(p_alts[0],
//// lower_lower_id, lower_upper_id,
//// &predicted_lower_tag, &predicted_upper_tag,
//// lower_id_);
//// }
// // TODO can this be rewritten in terms of lfsr_tag_follow?
// if (weight_ > (lfs_size_t)(lower_upper_id-lower_lower_id-1)
// || (weight_ == (lfs_size_t)(lower_upper_id-lower_lower_id-1)
// // TODO need key?
// && (lfsr_tag_isgt(alt)
// ? lfsr_tag_key(predicted_lower_tag) > lfsr_tag_key(alt)
// : lfsr_tag_key(predicted_upper_tag-0x10) <= lfsr_tag_key(alt)))) {
//// && (lfsr_tag_key(alt)
//// < lfsr_tag_key(lower_lower_tag)
//// || lfsr_tag_key(alt)
//// >= lfsr_tag_key(lower_upper_tag)))) {
// printf("PRUUUUUUUUUUUUUUUUUUUUUUUNE\n");
// printf("%d > %d-%d-1 => %d\n", weight_, lower_upper_id, lower_lower_id, weight_ > (lfs_size_t)(lower_upper_id-lower_lower_id-1));
// printf("%d == %d-%d-1 => %d\n", weight_, lower_upper_id, lower_lower_id, weight_ == (lfs_size_t)(lower_upper_id-lower_lower_id-1));
// printf("isgt = %d\n", lfsr_tag_isgt(alt));
// printf("0x%x > 0x%x => %d\n", lfsr_tag_key(predicted_lower_tag), lfsr_tag_key(alt), lfsr_tag_key(predicted_lower_tag) > lfsr_tag_key(alt));
// printf("0x%x <= 0x%x => %d\n", lfsr_tag_key(predicted_upper_tag-0x10), lfsr_tag_key(alt), lfsr_tag_key(predicted_upper_tag-0x10) <= lfsr_tag_key(alt));
//// prune = true;
//// lower_lower_tag = predicted_lower_tag;
//// lower_upper_tag = predicted_upper_tag;
//
// if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
// alt = lfsr_tag_mkblack(p_alts[0]);
// weight_ = p_weights[0];
// branch_ = jump;
// jump = p_jumps[0];
// lfsr_rbyd_p_pop(p_alts, p_weights, p_jumps);
//
// lfsr_tag_untrimweight(alt, weight_,
// &lower_lower_id, &lower_upper_id);
//
// printf("pruned into alt%c%s 0x%x w%d 0x%x (0x%x)\n",
// lfsr_tag_isred(alt) ? 'r' : 'b',
// lfsr_tag_isgt(alt) ? "gt" : "lt",
// lfsr_tag_key(alt),
// weight_,
// jump,
// branch_);
// } else {
// lower_branch = jump;
// continue;
// }
// // cut while following
// } else if (diverged
// && lfsr_tag_follow(alt, weight_, // && lfsr_tag_follow(alt, weight_,
// lower_lower_id, lower_upper_id, // lower_lower_id, lower_upper_id,
// lower_tag_, lower_id_)) { // lower_tag_, lower_id_)
// printf("? %d || %d == %d\n", // && (lower_id_ < upper_id_
// (lower_id_ < upper_id_), // || (lower_id_ == upper_id_ && lower_tag_ < upper_tag_))
// (lower_id_ == upper_id_ && lower_tag_ < upper_tag_), // == lfsr_tag_isle(alt)) {
// lfsr_tag_isle(alt)); //// lfsr_tag_trimtag(lfsr_tag_flipalt(alt),
// printf("(0x%x %d) (0x%x %d)\n", lower_tag_, lower_id_, upper_tag_, upper_id_); //// lower_lower_id, lower_upper_id,
//// &lower_lower_tag, &lower_upper_tag,
//// lower_id_);
// printf("trim-f\n");
//// prune = true;
//
// if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
// lfsr_tag_trimweight(
// lfsr_tag_flipalt(alt),
// lfsr_tag_flipweight(weight_,
// lower_lower_id, lower_upper_id),
// &lower_lower_id, &lower_upper_id);
// alt = lfsr_tag_mkblack(p_alts[0]);
// weight_ = p_weights[0];
// branch_ = jump;
// jump = p_jumps[0];
// lfsr_rbyd_p_pop(p_alts, p_weights, p_jumps);
//
// lfsr_tag_untrimweight(alt, weight_,
// &lower_lower_id, &lower_upper_id);
//
// printf("pruned into alt%c%s 0x%x w%d 0x%x (0x%x)\n",
// lfsr_tag_isred(alt) ? 'r' : 'b',
// lfsr_tag_isgt(alt) ? "gt" : "lt",
// lfsr_tag_key(alt),
// weight_,
// jump,
// branch_);
// } else {
// lfsr_tag_trimweight(
// lfsr_tag_flipalt(alt),
// lfsr_tag_flipweight(weight_,
// lower_lower_id, lower_upper_id),
// &lower_lower_id, &lower_upper_id);
// if (p_alts[0]) {
// lfsr_tag_trim_(p_alts[0],
// lower_lower_id, lower_upper_id,
// &lower_lower_id, &lower_upper_id,
// &lower_lower_tag, &lower_upper_tag);
// }
// lower_branch = jump;
// continue;
// }
// // cut while not following
// } else if (diverged
// && !lfsr_tag_follow(alt, weight_,
// lower_lower_id, lower_upper_id,
// lower_tag_, lower_id_)
// && (lower_id_ < upper_id_
// || (lower_id_ == upper_id_ && lower_tag_ < upper_tag_))
// != lfsr_tag_isle(alt)) {
//// lfsr_tag_trimtag(alt,
//// lower_lower_id, lower_upper_id,
//// &lower_lower_tag, &lower_upper_tag,
//// lower_id_);
//// lfs_swap32(&jump, &branch_);
// printf("trim-nf\n");
//// prune = true;
//
// if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
//// if (lfsr_tag_isparallel(alt, p_alts[0])) {
//// p_weights[0] += weight_;
//// }
// lfsr_tag_trimweight(alt, weight_,
// &lower_lower_id, &lower_upper_id);
// alt = lfsr_tag_mkblack(p_alts[0]);
// weight_ = p_weights[0];
// jump = p_jumps[0];
// lfsr_rbyd_p_pop(p_alts, p_weights, p_jumps);
//
// lfsr_tag_untrimweight(alt, weight_,
// &lower_lower_id, &lower_upper_id);
//
// printf("pruned into alt%c%s 0x%x w%d 0x%x (0x%x)\n",
// lfsr_tag_isred(alt) ? 'r' : 'b',
// lfsr_tag_isgt(alt) ? "gt" : "lt",
// lfsr_tag_key(alt),
// weight_,
// jump,
// branch_);
// printf("p alt%c%s 0x%x w%d 0x%x (0x%x %d (%d), 0x%x %d (%d)) f=%d (0x%x %d)\n",
// !diverged
// ? '='
// : (lower_id_ < upper_id_
// || (lower_id_ == upper_id_
// && lower_tag_ < upper_tag_))
// ? '['
// : ']',
// lfsr_tag_isred(alt) ? 'r' : 'b',
// lfsr_tag_isgt(alt) ? "gt" : "lt",
// lfsr_tag_key(alt),
// weight_, jump, lower_lower_tag, lower_lower_id, lower_lower_id, lower_upper_tag, lower_upper_id, lower_upper_id,
// lfsr_tag_follow(alt, weight_,
// lower_lower_id, lower_upper_id,
// lower_tag_, lower_id_),
// lower_tag_, lower_id_);
// } else {
// lfsr_tag_trimweight(alt, weight_,
// &lower_lower_id, &lower_upper_id);
// if (p_alts[0]) {
// lfsr_tag_trim_(p_alts[0],
// lower_lower_id, lower_upper_id,
// &lower_lower_id, &lower_upper_id,
// &lower_lower_tag, &lower_upper_tag);
// }
// lower_branch = branch_;
// continue;
// }
// } // }
//
//// if (diverged
//// && lfsr_tag_follow(alt, weight_,
//// lower_lower_id, lower_upper_id,
//// lower_tag_, lower_id_)) {
//// printf("? %d || %d == %d\n",
//// (lower_id_ < upper_id_),
//// (lower_id_ == upper_id_ && lower_tag_ < upper_tag_),
//// lfsr_tag_isle(alt));
//// printf("(0x%x %d) (0x%x %d)\n", lower_tag_, lower_id_, upper_tag_, upper_id_);
//// }
//
//// if (prune) {
//// }
//
// if (prune) {
// }
redo_red:
// two reds makes a yellow, split? // two reds makes a yellow, split?
if (lfsr_tag_isred(alt) if (lfsr_tag_isred(alt)
&& p_alts[0] && p_alts[0]
@@ -2354,24 +2585,36 @@ redo_red:
// | | <b | <b | // | | <b | <b |
// | | .-'| | .-'| | // | | .-'| | .-'| |
// 1 2 3 4 1 2 3 4 1 // 1 2 3 4 1 2 3 4 1
if (lfsr_tag_follow(alt, weight_, if (lfsr_tag_follow2(
alt, weight_,
p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id, lower_lower_id, lower_upper_id,
lower_tag_, lower_id_)) { lower_tag_, lower_id_)) {
printf("ysplitf\n");
lfs_swap16(&alt, &p_alts[0]); lfs_swap16(&alt, &p_alts[0]);
lfs_swap32(&weight_, &p_weights[0]); lfs_swap32(&weight_, &p_weights[0]);
lfs_swap32(&jump, &branch_); lfs_swap32(&jump, &branch_);
lfs_swap32(&jump, &p_jumps[0]); lfs_swap32(&jump, &p_jumps[0]);
// TODO move these? combine these flips?
p_weights[0] = lfsr_tag_flipweight2(p_weights[0],
alt, weight_,
lower_lower_id, lower_upper_id);
p_alts[0] = lfsr_tag_mkblack( p_alts[0] = lfsr_tag_mkblack(
lfsr_tag_flipalt(p_alts[0])); lfsr_tag_flipalt(p_alts[0]));
p_weights[0] = lfsr_tag_flipweight(p_weights[0],
lower_lower_id, lower_upper_id);
alt = lfsr_tag_mkblack(alt); alt = lfsr_tag_mkblack(alt);
lfsr_tag_untrimweight(alt, weight_, // lfsr_tag_untrimweight(alt, weight_,
&lower_lower_id, &lower_upper_id); // &lower_lower_id, &lower_upper_id);
lfsr_tag_trimweight(p_alts[0], p_weights[0], // lfsr_tag_trimweight(p_alts[0], p_weights[0],
&lower_lower_id, &lower_upper_id); // &lower_lower_id, &lower_upper_id);
lfsr_rbyd_p_red(p_alts, p_weights, p_jumps);
lfsr_tag_trim__(
p_alts[0], p_weights[0],
&lower_lower_id, &lower_upper_id,
&lower_lower_tag, &lower_upper_tag);
if (!diverged) { // TODO can we not do this while diverging?
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
// prune later // prune later
@@ -2385,24 +2628,28 @@ redo_red:
// | | .-'| | | .----'| // | | .-'| | | .----'|
// 1 2 3 4 1 2 3 4 4 // 1 2 3 4 1 2 3 4 4
} else { } else {
printf("ysplitnf\n");
LFS_ASSERT(graft != 0); LFS_ASSERT(graft != 0);
p_alts[0] = lfsr_tag_mkblack(alt); p_alts[0] = lfsr_tag_mkblack(alt);
p_weights[0] += weight_; p_weights[0] += weight_;
p_jumps[0] = graft; p_jumps[0] = graft;
lfsr_tag_trimweight(alt, weight_, // lfsr_tag_trimweight(alt, weight_,
&lower_lower_id, &lower_upper_id); // &lower_lower_id, &lower_upper_id);
// lfsr_tag_trimtag(alt, // lfsr_tag_trimtag(alt,
// lower_lower_id, lower_upper_id, // lower_lower_id, lower_upper_id,
// &lower_lower_tag, &lower_upper_tag, // &lower_lower_tag, &lower_upper_tag,
// lower_id_); // lower_id_);
lfsr_rbyd_p_red(p_alts, p_weights, p_jumps);
lfsr_tag_trim_(alt, lfsr_tag_trim__(
lower_lower_id, lower_upper_id, p_alts[0], p_weights[0],
&lower_lower_id_, &lower_upper_id_, &lower_lower_id, &lower_upper_id,
&lower_lower_tag, &lower_upper_tag); &lower_lower_tag, &lower_upper_tag);
if (!diverged) { // TODO can we not do this while diverging?
lfsr_rbyd_p_red(p_alts, p_weights, p_jumps);
}
graft = lower_branch; // TODO need?
lower_branch = branch_; lower_branch = branch_;
continue; continue;
} }
@@ -2413,13 +2660,20 @@ redo_red:
// .-'| => .-'| // .-'| => .-'|
// 1 2 1 2 1 // 1 2 1 2 1
if (lfsr_tag_isblack(alt) if (lfsr_tag_isblack(alt)
&& lfsr_tag_follow(alt, weight_, && lfsr_tag_follow2(
alt, weight_,
p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id, lower_lower_id, lower_upper_id,
lower_tag_, lower_id_)) { lower_tag_, lower_id_)) {
printf("bflip\n"); printf("bflip\n");
alt = lfsr_tag_flipalt(alt); weight_ = lfsr_tag_flipweight2(weight_,
weight_ = lfsr_tag_flipweight(weight_, p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id); lower_lower_id, lower_upper_id);
alt = lfsr_tag_flipalt(alt);
// weight_ = lfsr_tag_flipweight2(
// alt, weight_,
// p_alts[0], p_weights[0],
// lower_lower_id, lower_upper_id);
lfs_swap32(&jump, &branch_); lfs_swap32(&jump, &branch_);
} }
@@ -2430,10 +2684,12 @@ redo_red:
// | .-'| .--|-'| // | .-'| .--|-'|
// 1 2 3 1 2 3 1 // 1 2 3 1 2 3 1
if (p_alts[0] if (p_alts[0]
&& lfsr_tag_follow(p_alts[0], 0, && lfsr_tag_isred(p_alts[0])
&& lfsr_tag_follow(p_alts[0], p_weights[0],
lower_lower_id, lower_upper_id, lower_lower_id, lower_upper_id,
lower_tag_, lower_id_)) { lower_tag_, lower_id_)) {
LFS_ASSERT(lfsr_tag_isred(p_alts[0])); printf("rflop\n");
// LFS_ASSERT(lfsr_tag_isred(p_alts[0]));
LFS_ASSERT(lfsr_tag_isblack(alt)); LFS_ASSERT(lfsr_tag_isblack(alt));
lfs_swap16(&alt, &p_alts[0]); lfs_swap16(&alt, &p_alts[0]);
@@ -2443,25 +2699,23 @@ redo_red:
p_alts[0] = lfsr_tag_mkred(p_alts[0]); p_alts[0] = lfsr_tag_mkred(p_alts[0]);
alt = lfsr_tag_mkblack(alt); alt = lfsr_tag_mkblack(alt);
lfsr_tag_untrimweight(alt, weight_, // lfsr_tag_untrimweight(alt, weight_,
&lower_lower_id, &lower_upper_id); // &lower_lower_id, &lower_upper_id);
lfsr_tag_trimweight(p_alts[0], p_weights[0], // lfsr_tag_trimweight(p_alts[0], p_weights[0],
&lower_lower_id, &lower_upper_id); // &lower_lower_id, &lower_upper_id);
printf("whh? 0x%x w%d 0x%x\n", alt, weight_, jump); weight_ = lfsr_tag_flipweight2(weight_,
printf("www? (0x%x w%d, 0x%x w%d)\n", 0, lower_lower_id, 0, upper_upper_id); p_alts[0], p_weights[0],
alt = lfsr_tag_flipalt(alt);
weight_ = lfsr_tag_flipweight(weight_,
lower_lower_id, lower_upper_id); lower_lower_id, lower_upper_id);
alt = lfsr_tag_flipalt(alt);
lfs_swap32(&jump, &branch_); lfs_swap32(&jump, &branch_);
printf("waa? 0x%x w%d 0x%x\n", alt, weight_, jump);
} }
// push alt onto queue // push alt onto queue
LFS_ASSERT((lfs_ssize_t)weight_ >= 0); LFS_ASSERT((lfs_ssize_t)weight_ >= 0);
printf("pushed alt%c%s 0x%x w%d 0x%x\n", printf("pushed alt%c%s 0x%x w%d 0x%x\n",
lfsr_tag_isred(alt) ? 'r' : 'b', lfsr_tag_isred(alt) ? 'r' : 'b',
lfsr_tag_isgt(alt) ? "gt" : "lt", lfsr_tag_isgt(alt) ? "gt" : "le",
lfsr_tag_key(alt), lfsr_tag_key(alt),
weight_, weight_,
jump); jump);
@@ -2473,19 +2727,30 @@ redo_red:
} }
// continue to next alt // continue to next alt
lfsr_tag_trimweight(alt, weight_, &lower_lower_id, &lower_upper_id); // TODO move this up?
if (lfsr_tag_isblack(alt)) { if (lfsr_tag_isblack(alt)) {
lfsr_tag_trim_(alt, lfsr_tag_trim2(
lower_lower_id, lower_upper_id, p_alts[0], p_weights[0],
&lower_lower_id_, &lower_upper_id_, p_alts[1], p_weights[1],
&lower_lower_id, &lower_upper_id,
&lower_lower_tag, &lower_upper_tag); &lower_lower_tag, &lower_upper_tag);
// if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
// lfsr_tag_trimtag(p_alts[0],
// lower_lower_id, lower_upper_id,
// &lower_lower_tag, &lower_upper_tag,
// lower_id_);
// }
} }
graft = lower_branch;
lower_branch = branch_;
// lfsr_tag_trimweight(alt, weight_, &lower_lower_id, &lower_upper_id);
// if (lfsr_tag_isblack(alt)) {
// lfsr_tag_trim_(alt,
// lower_lower_id, lower_upper_id,
// &lower_lower_id, &lower_upper_id,
// &lower_lower_tag, &lower_upper_tag);
//// if (p_alts[0] && lfsr_tag_isred(p_alts[0])) {
//// lfsr_tag_trimtag(p_alts[0],
//// lower_lower_id, lower_upper_id,
//// &lower_lower_tag, &lower_upper_tag,
//// lower_id_);
//// }
// }
// // TODO need key? // // TODO need key?
// if (lfsr_tag_key(alt) >= lfsr_tag_key(lower_tag_)) { // if (lfsr_tag_key(alt) >= lfsr_tag_key(lower_tag_)) {
// // TODO always max? // // TODO always max?
@@ -2495,11 +2760,10 @@ redo_red:
// // TODO always min? // // TODO always min?
// lower_upper_tag = lfs_min(lfsr_tag_key(alt), lower_upper_tag); // lower_upper_tag = lfs_min(lfsr_tag_key(alt), lower_upper_tag);
// } // }
graft = lower_branch;
lower_branch = branch_;
// found end of tree? // found end of tree?
} else { } else {
LFS_ASSERT(!p_alts[0] || lfsr_tag_isblack(p_alts[0]));
// update the tag id, marking as found // update the tag id, marking as found
lower_tag_ = lfsr_tag_mkfound(alt); lower_tag_ = lfsr_tag_mkfound(alt);
lower_id_ = lower_upper_id-1; lower_id_ = lower_upper_id-1;
@@ -2523,8 +2787,6 @@ stem:;
upper_branch = lower_branch; upper_branch = lower_branch;
upper_lower_id = lower_lower_id; upper_lower_id = lower_lower_id;
upper_upper_id = lower_upper_id; upper_upper_id = lower_upper_id;
upper_lower_id_ = lower_lower_id_;
upper_upper_id_ = lower_upper_id_;
upper_lower_tag = lower_lower_tag; upper_lower_tag = lower_lower_tag;
upper_upper_tag = lower_upper_tag; upper_upper_tag = lower_upper_tag;
} else if (lower_id_ > upper_id_ } else if (lower_id_ > upper_id_
@@ -2534,8 +2796,6 @@ stem:;
lfs_swap32(&lower_branch, &upper_branch); lfs_swap32(&lower_branch, &upper_branch);
lfs_swaps32(&lower_lower_id, &upper_lower_id); lfs_swaps32(&lower_lower_id, &upper_lower_id);
lfs_swaps32(&lower_upper_id, &upper_upper_id); lfs_swaps32(&lower_upper_id, &upper_upper_id);
lfs_swaps32(&lower_lower_id_, &upper_lower_id_);
lfs_swaps32(&lower_upper_id_, &upper_upper_id_);
lfs_swap16(&lower_lower_tag, &upper_lower_tag); lfs_swap16(&lower_lower_tag, &upper_lower_tag);
lfs_swap16(&lower_upper_tag, &upper_upper_tag); lfs_swap16(&lower_upper_tag, &upper_upper_tag);
} }
tests/test_rbyd.toml
+135 -135
View File
@@ -6535,7 +6535,7 @@ code = '''
// test that tree is self-balancing, we should be strictly bounded // test that tree is self-balancing, we should be strictly bounded
// by height <= 2*log(n)+1, assume tags are strictly <=12 bytes // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes
lfs_size_t n = 1 + N + N; lfs_size_t n = 1 + N+N*M + 2;
printf("worst size: %u B (N=%u, estimate=%u)\n", printf("worst size: %u B (N=%u, estimate=%u)\n",
worst_size, n, 12*n*(2*lfs_nlog2(n)+1)); worst_size, n, 12*n*(2*lfs_nlog2(n)+1));
printf("avg height: %u B (N=%u, estimate=%u)\n", printf("avg height: %u B (N=%u, estimate=%u)\n",
@@ -6546,140 +6546,140 @@ code = '''
} }
''' '''
#[cases.test_rbyd_mixed_remove_all_permutations] [cases.test_rbyd_mixed_remove_all_permutations]
#defines.N = 'range(1, 4)' defines.N = 'range(1, 4)'
#defines.M = 'range(1, 3)' defines.M = 'range(1, 3)'
#in = 'lfs.c' in = 'lfs.c'
#if = 'BLOCK_SIZE/PROG_SIZE >= N' if = 'BLOCK_SIZE/PROG_SIZE >= N'
#code = ''' code = '''
# lfs_t lfs; lfs_t lfs;
# lfs_init(&lfs, cfg) => 0; lfs_init(&lfs, cfg) => 0;
#
# lfsr_rbyd_t init_rbyd = { lfsr_rbyd_t init_rbyd = {
# .block = 0, .block = 0,
# .rev = 1, .rev = 1,
# .off = 0, .off = 0,
# .crc = 0, .crc = 0,
# .trunk = 0, .trunk = 0,
# .weight = 0, .weight = 0,
# .erased = true, .erased = true,
# }; };
# const uint8_t names[6][4] = { const uint8_t names[6][4] = {
# "\xaa\xaa\xaa\xaa", "\xaa\xaa\xaa\xaa",
# "\xbb\xbb\xbb\xbb", "\xbb\xbb\xbb\xbb",
# "\xcc\xcc\xcc\xcc", "\xcc\xcc\xcc\xcc",
# "\xdd\xdd\xdd\xdd", "\xdd\xdd\xdd\xdd",
# "\xee\xee\xee\xee", "\xee\xee\xee\xee",
# "\xff\xff\xff\xff", "\xff\xff\xff\xff",
# }; };
# lfsr_rbyd_t rbyd; lfsr_rbyd_t rbyd;
# uint8_t buffer[4]; uint8_t buffer[4];
#
# // keep track of the worst case log size // keep track of the worst case log size
# lfs_size_t worst_size = 0; lfs_size_t worst_size = 0;
#
# // create one consistent block // create one consistent block
# rbyd = init_rbyd; rbyd = init_rbyd;
# lfs_bd_erase(&lfs, rbyd.block) => 0; lfs_bd_erase(&lfs, rbyd.block) => 0;
#
# for (unsigned j = 0; j < N; j++) { for (unsigned j = 0; j < N; j++) {
# lfsr_rbyd_commit(&lfs, &rbyd, lfsr_rbyd_commit(&lfs, &rbyd,
# LFSR_ATTR(MKREG, j, names[j % 6], 4, LFSR_ATTR(MKREG, j, names[j % 6], 4,
# NULL)) => 0; NULL)) => 0;
# // note uattrs have a smaller size to help debugging // note uattrs have a smaller size to help debugging
# for (unsigned u = 0; u < M; u++) { for (unsigned u = 0; u < M; u++) {
# lfsr_rbyd_commit(&lfs, &rbyd, lfsr_rbyd_commit(&lfs, &rbyd,
# LFSR_ATTR(UATTR(u+1), j, names[j % 6], 2, LFSR_ATTR(UATTR(u+1), j, names[j % 6], 2,
# NULL)) => 0; NULL)) => 0;
# } }
# } }
#
# // copy block so we can reset after each remove // copy block so we can reset after each remove
# lfsr_rbyd_t backup_rbyd = rbyd; lfsr_rbyd_t backup_rbyd = rbyd;
# uint8_t backup_block[BLOCK_SIZE]; uint8_t backup_block[BLOCK_SIZE];
# lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off,
# rbyd.block, 0, backup_block, rbyd.off) => 0; rbyd.block, 0, backup_block, rbyd.off) => 0;
#
# // test all permutations of a given size // test all permutations of a given size
# uint8_t perm[N*M]; uint8_t perm[N*M];
# unsigned stack[N*M]; unsigned stack[N*M];
# for (uint8_t i = 0; i < N*M; i++) { for (uint8_t i = 0; i < N*M; i++) {
# perm[i] = i; perm[i] = i;
# stack[i] = 0; stack[i] = 0;
# } }
#
# unsigned i = 1; unsigned i = 1;
# while (i < N*M) { while (i < N*M) {
# // print permutation to help debugging // print permutation to help debugging
# printf("--- permutation: ["); printf("--- permutation: [");
# for (unsigned j = 0; j < N*M; j++) { for (unsigned j = 0; j < N*M; j++) {
# if (j > 0) { if (j > 0) {
# printf(", "); printf(", ");
# } }
# printf("%d", perm[j]+1); printf("%d", perm[j]+1);
# } }
# printf("] ---\n"); printf("] ---\n");
#
# // restore backup // restore backup
# rbyd = backup_rbyd; rbyd = backup_rbyd;
# lfs_bd_erase(&lfs, rbyd.block) => 0; lfs_bd_erase(&lfs, rbyd.block) => 0;
# lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false,
# rbyd.block, 0, backup_block, rbyd.off) => 0; rbyd.block, 0, backup_block, rbyd.off) => 0;
# lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0;
#
# // remove each tag in permutation order // remove each tag in permutation order
# for (unsigned j = 0; j < N*M; j++) { for (unsigned j = 0; j < N*M; j++) {
# lfsr_rbyd_commit(&lfs, &rbyd, lfsr_rbyd_commit(&lfs, &rbyd,
# LFSR_ATTR(RMUATTR(perm[j]%M+1), perm[j]/M, NULL, 0, LFSR_ATTR(RMUATTR(perm[j]%M+1), perm[j]/M, NULL, 0,
# NULL)) => 0; NULL)) => 0;
# } }
#
# // check that all tags have been removed // check that all tags have been removed
# lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0;
# for (unsigned j = 0; j < N; j++) { for (unsigned j = 0; j < N; j++) {
# lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j, buffer, 4) => 4; lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j, buffer, 4) => 4;
# assert(memcmp(buffer, names[j % 6], 4) == 0); assert(memcmp(buffer, names[j % 6], 4) == 0);
#
# for (unsigned u = 0; u < M; u++) { for (unsigned u = 0; u < M; u++) {
# lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(u+1), j, buffer, 4) lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(u+1), j, buffer, 4)
# => LFS_ERR_NOENT; => LFS_ERR_NOENT;
# } }
# } }
#
# // keep track of the worst size // keep track of the worst size
# worst_size = lfs_max(worst_size, rbyd.off); worst_size = lfs_max(worst_size, rbyd.off);
#
# // next permutation using Heap's algorithm // next permutation using Heap's algorithm
# if (stack[i] < i) { if (stack[i] < i) {
# if (i % 2 == 0) { if (i % 2 == 0) {
# uint8_t t = perm[0]; uint8_t t = perm[0];
# perm[0] = perm[i]; perm[0] = perm[i];
# perm[i] = t; perm[i] = t;
# } else { } else {
# uint8_t t = perm[stack[i]]; uint8_t t = perm[stack[i]];
# perm[stack[i]] = perm[i]; perm[stack[i]] = perm[i];
# perm[i] = t; perm[i] = t;
# } }
# stack[i] += 1; stack[i] += 1;
# i = 1; i = 1;
# } else { } else {
# stack[i] = 0; stack[i] = 0;
# i += 1; i += 1;
# } }
# } }
#
# // test that tree is self-balancing, we should be strictly bounded // test that tree is self-balancing, we should be strictly bounded
# // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes
# lfs_size_t n = 1 + N + N*M + N*M; lfs_size_t n = 1 + N + N*M + N*M;
# printf("worst size: %u B (N=%u, estimate=%u)\n", printf("worst size: %u B (N=%u, estimate=%u)\n",
# worst_size, n, 12*n*(2*lfs_nlog2(n)+1)); worst_size, n, 12*n*(2*lfs_nlog2(n)+1));
# printf("avg height: %u B (N=%u, estimate=%u)\n", printf("avg height: %u B (N=%u, estimate=%u)\n",
# worst_size / n, n, 12*(2*lfs_nlog2(n)+1)); worst_size / n, n, 12*(2*lfs_nlog2(n)+1));
# // note this only holds true with byte-level progs // note this only holds true with byte-level progs
# if (PROG_SIZE == 1) { if (PROG_SIZE == 1) {
# assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)); assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1));
# } }
#''' '''
[cases.test_rbyd_mixed_large] [cases.test_rbyd_mixed_large]
in = 'lfs.c' in = 'lfs.c'