Github/littlefs
1
Fork 0
Code Actions Activity

Replaced lfsr_bd_unprog with an align flag in each prog function

Browse Source 
This sort of reverts the addition of lfsr_bd_unprog, but with a slightly
better API. lfsr_bd_unprog was too much of a hack, and isn't really
generalizable. The align flag isn't necessarily any better, but at least
it's the simplest/least-confusing solution available.

And it's net savings, code-wise:

           code          stack          lfs_t
  before: 33690           2608            164
  after:  33678 (-0.0%)   2600 (-0.3%)    160 (-2.4%)
This commit is contained in:
Christopher Haster
2024-05-30 01:46:58 -05:00
parent dd3faae48e
commit 50fc0ed680
3 changed files with 98 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lfs.c
+40 -80
View File
@@ -296,7 +296,7 @@ static lfs_scmp_t lfsr_bd_cmp(lfs_t *lfs,
// low-level prog stuff // low-level prog stuff
static int lfsr_bd_prog_(lfs_t *lfs, lfs_block_t block, lfs_size_t off, static int lfsr_bd_prog_(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
const void *buffer, lfs_size_t size, const void *buffer, lfs_size_t size,
uint32_t *cksum_) { uint32_t *cksum_, bool align) {
// prog to disk // prog to disk
int err = lfsr_bd_prog__(lfs, block, off, buffer, size); int err = lfsr_bd_prog__(lfs, block, off, buffer, size);
if (err) { if (err) {
@@ -337,16 +337,16 @@ static int lfsr_bd_prog_(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
lfs->rcache.size - (off-lfs->rcache.off)); lfs->rcache.size - (off-lfs->rcache.off));
} }
// keep track of the last flushed cksum // optional aligned checksum
if (cksum_) { if (cksum_ && align) {
lfs->pcksum = *cksum_; *cksum_ = lfs_crc32c(*cksum_, buffer, size);
} }
return 0; return 0;
} }
// flush the pcache // flush the pcache
static int lfsr_bd_flush(lfs_t *lfs, uint32_t *cksum_) { static int lfsr_bd_flush(lfs_t *lfs, uint32_t *cksum_, bool align) {
if (lfs->pcache.size != 0) { if (lfs->pcache.size != 0) {
// must be in-bounds // must be in-bounds
LFS_ASSERT(lfs->pcache.block < lfs->cfg->block_count); LFS_ASSERT(lfs->pcache.block < lfs->cfg->block_count);
@@ -361,7 +361,7 @@ static int lfsr_bd_flush(lfs_t *lfs, uint32_t *cksum_) {
// flush // flush
int err = lfsr_bd_prog_(lfs, lfs->pcache.block, int err = lfsr_bd_prog_(lfs, lfs->pcache.block,
lfs->pcache.off, lfs->pcache.buffer, size, lfs->pcache.off, lfs->pcache.buffer, size,
cksum_); cksum_, align);
if (err) { if (err) {
return err; return err;
} }
@@ -376,7 +376,7 @@ static int lfsr_bd_flush(lfs_t *lfs, uint32_t *cksum_) {
static int lfsr_bd_prognext(lfs_t *lfs, lfs_block_t block, lfs_size_t off, static int lfsr_bd_prognext(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
lfs_size_t size, lfs_size_t size,
uint8_t **buffer_, lfs_size_t *size_, uint8_t **buffer_, lfs_size_t *size_,
uint32_t *cksum_) { uint32_t *cksum_, bool align) {
// must be in-bounds // must be in-bounds
LFS_ASSERT(block < lfs->cfg->block_count); LFS_ASSERT(block < lfs->cfg->block_count);
LFS_ASSERT(off+size <= lfs->cfg->block_size); LFS_ASSERT(off+size <= lfs->cfg->block_size);
@@ -403,7 +403,7 @@ static int lfsr_bd_prognext(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
} }
// flush pcache? // flush pcache?
int err = lfsr_bd_flush(lfs, cksum_); int err = lfsr_bd_flush(lfs, cksum_, align);
if (err) { if (err) {
return err; return err;
} }
@@ -432,7 +432,7 @@ static int lfsr_bd_prognext(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
// with optional checksum // with optional checksum
static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off, static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
const void *buffer, lfs_size_t size, const void *buffer, lfs_size_t size,
uint32_t *cksum_) { uint32_t *cksum_, bool align) {
// must be in-bounds // must be in-bounds
LFS_ASSERT(block < lfs->cfg->block_count); LFS_ASSERT(block < lfs->cfg->block_count);
LFS_ASSERT(off+size <= lfs->cfg->block_size); LFS_ASSERT(off+size <= lfs->cfg->block_size);
@@ -452,7 +452,7 @@ static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
lfs_size_t size__; lfs_size_t size__;
int err = lfsr_bd_prognext(lfs, block, off_, size_, int err = lfsr_bd_prognext(lfs, block, off_, size_,
&buffer__, &size__, &buffer__, &size__,
cksum_); cksum_, align);
if (err) { if (err) {
return err; return err;
} }
@@ -470,14 +470,14 @@ static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
&& size_ >= lfs->cfg->pcache_size) { && size_ >= lfs->cfg->pcache_size) {
// flush our pcache first, some devices don't support // flush our pcache first, some devices don't support
// out-of-order progs in a block // out-of-order progs in a block
int err = lfsr_bd_flush(lfs, cksum_); int err = lfsr_bd_flush(lfs, cksum_, align);
if (err) { if (err) {
return err; return err;
} }
lfs_size_t d = lfs_aligndown(size_, lfs->cfg->prog_size); lfs_size_t d = lfs_aligndown(size_, lfs->cfg->prog_size);
err = lfsr_bd_prog_(lfs, block, off_, buffer_, d, err = lfsr_bd_prog_(lfs, block, off_, buffer_, d,
cksum_); cksum_, align);
if (err) { if (err) {
return err; return err;
} }
@@ -493,50 +493,23 @@ static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
lfs_size_t size__; lfs_size_t size__;
int err = lfsr_bd_prognext(lfs, block, off_, size_, int err = lfsr_bd_prognext(lfs, block, off_, size_,
&buffer__, &size__, &buffer__, &size__,
cksum_); cksum_, align);
if (err) { if (err) {
return err; return err;
} }
} }
// optional checksum // optional checksum
if (cksum_) { if (cksum_ && !align) {
*cksum_ = lfs_crc32c(*cksum_, buffer, size); *cksum_ = lfs_crc32c(*cksum_, buffer, size);
} }
return 0; return 0;
} }
// unprog can undo a pending prog as long as it's still in our pcache
//
// this is useful for aligning progs retroactively
static int lfsr_bd_unprog(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
lfs_size_t size,
uint32_t *cksum_) {
// we don't really use these, but they should match the pcache, the
// compiler should optimize these away anyways
LFS_ASSERT(block == lfs->pcache.block);
LFS_ASSERT(off == lfs->pcache.off + lfs->pcache.size);
// we can't unprog flushed progs
LFS_ASSERT(lfs->pcache.size >= size);
// unprog our prog
lfs->pcache.size -= size;
if (cksum_) {
// recalculate cksum from the last flush
*cksum_ = lfs_crc32c(
// no flush yet?
(lfs->pcache.off == 0) ? 0 : lfs->pcksum,
lfs->pcache.buffer, lfs->pcache.size);
}
return 0;
}
static int lfsr_bd_sync(lfs_t *lfs) { static int lfsr_bd_sync(lfs_t *lfs) {
// make sure we flush any caches // make sure we flush any caches
int err = lfsr_bd_flush(lfs, NULL); int err = lfsr_bd_flush(lfs, NULL, false);
if (err) { if (err) {
return err; return err;
} }
@@ -630,7 +603,7 @@ static int lfsr_bd_cpy(lfs_t *lfs,
lfs_block_t dst_block, lfs_size_t dst_off, lfs_block_t dst_block, lfs_size_t dst_off,
lfs_block_t src_block, lfs_size_t src_off, lfs_size_t hint, lfs_block_t src_block, lfs_size_t src_off, lfs_size_t hint,
lfs_size_t size, lfs_size_t size,
uint32_t *cksum_) { uint32_t *cksum_, bool align) {
// we don't really use hint here because we go through our pcache // we don't really use hint here because we go through our pcache
(void)hint; (void)hint;
// must be in-bounds // must be in-bounds
@@ -650,7 +623,7 @@ static int lfsr_bd_cpy(lfs_t *lfs,
lfs_size_t size__; lfs_size_t size__;
int err = lfsr_bd_prognext(lfs, dst_block, dst_off_, size_, int err = lfsr_bd_prognext(lfs, dst_block, dst_off_, size_,
&buffer__, &size__, &buffer__, &size__,
cksum_); cksum_, align);
if (err) { if (err) {
return err; return err;
} }
@@ -662,7 +635,7 @@ static int lfsr_bd_cpy(lfs_t *lfs,
} }
// optional checksum // optional checksum
if (cksum_) { if (cksum_ && !align) {
*cksum_ = lfs_crc32c(*cksum_, buffer__, size__); *cksum_ = lfs_crc32c(*cksum_, buffer__, size__);
} }
@@ -676,7 +649,7 @@ static int lfsr_bd_cpy(lfs_t *lfs,
static int lfsr_bd_set(lfs_t *lfs, lfs_block_t block, lfs_size_t off, static int lfsr_bd_set(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
uint8_t c, lfs_size_t size, uint8_t c, lfs_size_t size,
uint32_t *cksum_) { uint32_t *cksum_, bool align) {
// must be in-bounds // must be in-bounds
LFS_ASSERT(block < lfs->cfg->block_count); LFS_ASSERT(block < lfs->cfg->block_count);
LFS_ASSERT(off+size <= lfs->cfg->block_size); LFS_ASSERT(off+size <= lfs->cfg->block_size);
@@ -688,7 +661,7 @@ static int lfsr_bd_set(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
lfs_size_t size__; lfs_size_t size__;
int err = lfsr_bd_prognext(lfs, block, off_, size_, int err = lfsr_bd_prognext(lfs, block, off_, size_,
&buffer__, &size__, &buffer__, &size__,
cksum_); cksum_, align);
if (err) { if (err) {
return err; return err;
} }
@@ -696,7 +669,7 @@ static int lfsr_bd_set(lfs_t *lfs, lfs_block_t block, lfs_size_t off,
lfs_memset(buffer__, c, size__); lfs_memset(buffer__, c, size__);
// optional checksum // optional checksum
if (cksum_) { if (cksum_ && !align) {
*cksum_ = lfs_crc32c(*cksum_, buffer__, size__); *cksum_ = lfs_crc32c(*cksum_, buffer__, size__);
} }
@@ -1217,7 +1190,7 @@ static lfs_ssize_t lfsr_bd_readtag(lfs_t *lfs,
static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs, static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfs_block_t block, lfs_size_t off,
lfsr_tag_t tag, lfsr_rid_t weight, lfs_size_t size, lfsr_tag_t tag, lfsr_rid_t weight, lfs_size_t size,
uint32_t *cksum_) { uint32_t *cksum_, bool align) {
// bit 7 is reserved for future subtype extensions // bit 7 is reserved for future subtype extensions
LFS_ASSERT(!(tag & 0x80)); LFS_ASSERT(!(tag & 0x80));
// weight should not exceed 31-bits // weight should not exceed 31-bits
@@ -1244,11 +1217,11 @@ static lfs_ssize_t lfsr_bd_progtag(lfs_t *lfs,
d += d_; d += d_;
// ignore the valid bit when calculating checksums // ignore the valid bit when calculating checksums
if (cksum_) { if (cksum_ && !align) {
*cksum_ ^= tag_buf[0] & 0x80; *cksum_ ^= tag_buf[0] & 0x80;
} }
int err = lfsr_bd_prog(lfs, block, off, tag_buf, d, int err = lfsr_bd_prog(lfs, block, off, tag_buf, d,
cksum_); cksum_, align);
if (err) { if (err) {
LFS_ASSERT(err < 0); LFS_ASSERT(err < 0);
return err; return err;
@@ -1477,13 +1450,13 @@ static lfs_scmp_t lfsr_data_namecmp(lfs_t *lfs, lfsr_data_t data,
static int lfsr_bd_progdata(lfs_t *lfs, static int lfsr_bd_progdata(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfsr_data_t data, lfs_block_t block, lfs_size_t off, lfsr_data_t data,
uint32_t *cksum_) { uint32_t *cksum_, bool align) {
// on-disk? // on-disk?
if (lfsr_data_ondisk(data)) { if (lfsr_data_ondisk(data)) {
int err = lfsr_bd_cpy(lfs, block, off, int err = lfsr_bd_cpy(lfs, block, off,
data.u.disk.block, data.u.disk.off, lfsr_data_size(data), data.u.disk.block, data.u.disk.off, lfsr_data_size(data),
lfsr_data_size(data), lfsr_data_size(data),
cksum_); cksum_, align);
if (err) { if (err) {
return err; return err;
} }
@@ -1492,7 +1465,7 @@ static int lfsr_bd_progdata(lfs_t *lfs,
} else { } else {
int err = lfsr_bd_prog(lfs, block, off, int err = lfsr_bd_prog(lfs, block, off,
data.u.buffer, data.size, data.u.buffer, data.size,
cksum_); cksum_, align);
if (err) { if (err) {
return err; return err;
} }
@@ -1618,11 +1591,11 @@ static inline lfs_size_t lfsr_cat_size(const void *cat, int16_t count) {
static int lfsr_bd_progcat(lfs_t *lfs, static int lfsr_bd_progcat(lfs_t *lfs,
lfs_block_t block, lfs_size_t off, lfs_block_t block, lfs_size_t off,
const void *cat, int16_t count, const void *cat, int16_t count,
uint32_t *cksum_) { uint32_t *cksum_, bool align) {
// direct buffer? // direct buffer?
if (count >= 0) { if (count >= 0) {
return lfsr_bd_prog(lfs, block, off, cat, count, return lfsr_bd_prog(lfs, block, off, cat, count,
cksum_); cksum_, align);
// indirect concatenated data? // indirect concatenated data?
} else { } else {
@@ -1630,7 +1603,7 @@ static int lfsr_bd_progcat(lfs_t *lfs,
lfs_size_t data_count = -count; lfs_size_t data_count = -count;
for (lfs_size_t i = 0; i < data_count; i++) { for (lfs_size_t i = 0; i < data_count; i++) {
int err = lfsr_bd_progdata(lfs, block, off, datas[i], int err = lfsr_bd_progdata(lfs, block, off, datas[i],
cksum_); cksum_, align);
if (err) { if (err) {
return err; return err;
} }
@@ -2571,7 +2544,7 @@ static int lfsr_rbyd_appendrev(lfs_t *lfs, lfsr_rbyd_t *rbyd, uint32_t rev) {
uint32_t cksum_ = rbyd->cksum; uint32_t cksum_ = rbyd->cksum;
int err = lfsr_bd_prog(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), int err = lfsr_bd_prog(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd),
&rev_buf, sizeof(uint32_t), &rev_buf, sizeof(uint32_t),
&cksum_); &cksum_, false);
if (err) { if (err) {
return err; return err;
} }
@@ -2601,7 +2574,7 @@ static int lfsr_rbyd_appendtag(lfs_t *lfs, lfsr_rbyd_t *rbyd,
lfs_ssize_t d = lfsr_bd_progtag(lfs, lfs_ssize_t d = lfsr_bd_progtag(lfs,
rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), rbyd->blocks[0], lfsr_rbyd_eoff(rbyd),
tag, weight, size, tag, weight, size,
&cksum_); &cksum_, false);
if (d < 0) { if (d < 0) {
return d; return d;
} }
@@ -2626,7 +2599,7 @@ static int lfsr_rbyd_appendcat(lfs_t *lfs, lfsr_rbyd_t *rbyd,
uint32_t cksum_ = rbyd->cksum; uint32_t cksum_ = rbyd->cksum;
int err = lfsr_bd_progcat(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), int err = lfsr_bd_progcat(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd),
cat, count, cat, count,
&cksum_); &cksum_, false);
if (err) { if (err) {
return err; return err;
} }
@@ -3483,7 +3456,7 @@ static int lfsr_rbyd_appendcksum(lfs_t *lfs, lfsr_rbyd_t *rbyd) {
err = lfsr_bd_prog(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd), err = lfsr_bd_prog(lfs, rbyd->blocks[0], lfsr_rbyd_eoff(rbyd),
cksum_buf, 2+1+4+4, cksum_buf, 2+1+4+4,
NULL); NULL, false);
if (err) { if (err) {
return err; return err;
} }
@@ -11101,7 +11074,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
err = lfsr_bd_prog(lfs, bptr.data.u.disk.block, err = lfsr_bd_prog(lfs, bptr.data.u.disk.block,
bptr.cksize, bptr.cksize,
&buffer[pos_ - pos], d_, &buffer[pos_ - pos], d_,
&bptr.cksum); &bptr.cksum, true);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_RANGE);
// bad prog? try another block // bad prog? try another block
@@ -11161,7 +11134,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
lfsr_data_slice(bptr_.data, lfsr_data_slice(bptr_.data,
pos_ - (bid_-(weight_-1)), pos_ - (bid_-(weight_-1)),
d_), d_),
&bptr.cksum); &bptr.cksum, true);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_RANGE);
// bad prog? try another block // bad prog? try another block
@@ -11183,7 +11156,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
// found a hole? fill with zeros // found a hole? fill with zeros
err = lfsr_bd_set(lfs, bptr.data.u.disk.block, bptr.cksize, err = lfsr_bd_set(lfs, bptr.data.u.disk.block, bptr.cksize,
0, d, 0, d,
&bptr.cksum); &bptr.cksum, true);
if (err) { if (err) {
LFS_ASSERT(err != LFS_ERR_RANGE); LFS_ASSERT(err != LFS_ERR_RANGE);
// bad prog? try another block // bad prog? try another block
@@ -11202,24 +11175,11 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file,
// the pcache greatly simplifies the above loop, though we may end // the pcache greatly simplifies the above loop, though we may end
// up reading more than is strictly necessary. // up reading more than is strictly necessary.
lfs_ssize_t d = bptr.cksize % lfs->cfg->prog_size; lfs_ssize_t d = bptr.cksize % lfs->cfg->prog_size;
if (d != 0) { lfs->pcache.size -= d;
err = lfsr_bd_unprog(lfs, bptr.data.u.disk.block, bptr.cksize, bptr.cksize -= d;
d,
&bptr.cksum);
if (err) {
// bad prog? try another block
if (err == LFS_ERR_CORRUPT) {
goto relocate;
}
return err;
}
bptr.cksize -= d;
}
// TODO validate?
// finalize our write // finalize our write
err = lfsr_bd_flush(lfs, &bptr.cksum); err = lfsr_bd_flush(lfs, &bptr.cksum, true);
if (err) { if (err) {
// bad prog? try another block // bad prog? try another block
if (err == LFS_ERR_CORRUPT) { if (err == LFS_ERR_CORRUPT) {
lfs.h
-1
View File
@@ -611,7 +611,6 @@ typedef struct lfs {
lfs_size_t size; lfs_size_t size;
uint8_t *buffer; uint8_t *buffer;
} pcache; } pcache;
uint32_t pcksum;
struct lfs_lookahead { struct lfs_lookahead {
lfs_block_t start; lfs_block_t start;
tests/test_rbyd.toml
+58 -58
View File
@@ -2842,9 +2842,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// update each tag in permutation order // update each tag in permutation order
for (unsigned j = 0; j < N; j++) { for (unsigned j = 0; j < N; j++) {
@@ -3152,9 +3152,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
@@ -3302,9 +3302,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
@@ -3932,9 +3932,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// remove each tag in permutation order // remove each tag in permutation order
for (unsigned j = 0; j < N; j++) { for (unsigned j = 0; j < N; j++) {
@@ -6081,9 +6081,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// update each tag in permutation order // update each tag in permutation order
for (unsigned j = 0; j < N*M; j++) { for (unsigned j = 0; j < N*M; j++) {
@@ -6233,9 +6233,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
@@ -6428,9 +6428,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, 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++) {
@@ -10627,9 +10627,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
@@ -10796,9 +10796,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
@@ -10989,9 +10989,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
@@ -11126,9 +11126,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0; LFSR_ATTR(LFSR_TAG_RM, -1, LFSR_DATA_NULL()))) => 0;
@@ -11574,9 +11574,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// delete each rid in permutation order // delete each rid in permutation order
for (unsigned j = 0; j < N; j++) { for (unsigned j = 0; j < N; j++) {
@@ -11730,9 +11730,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// delete each rid in permutation order // delete each rid in permutation order
for (unsigned j = 0; j < N; j++) { for (unsigned j = 0; j < N; j++) {
@@ -13820,9 +13820,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_GROW, +D, LFSR_DATA_NULL()))) => 0; LFSR_ATTR(LFSR_TAG_GROW, +D, LFSR_DATA_NULL()))) => 0;
@@ -13952,9 +13952,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
@@ -14096,9 +14096,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
@@ -14253,9 +14253,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_GROW, -D, LFSR_DATA_NULL()))) => 0; LFSR_ATTR(LFSR_TAG_GROW, -D, LFSR_DATA_NULL()))) => 0;
@@ -14385,9 +14385,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
@@ -14529,9 +14529,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
@@ -14685,9 +14685,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0; LFSR_ATTR(LFSR_TAG_RM, -W, LFSR_DATA_NULL()))) => 0;
@@ -14850,9 +14850,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS(
LFSR_ATTR( LFSR_ATTR(
@@ -15483,9 +15483,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// remove with a wide tag // remove with a wide tag
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
@@ -15627,9 +15627,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// replace with bitwise inverse // replace with bitwise inverse
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
@@ -15869,9 +15869,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// remove with a wide tag // remove with a wide tag
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
@@ -16023,9 +16023,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// replace with bitwise inverse // replace with bitwise inverse
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
@@ -16260,9 +16260,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// remove with a wide tag // remove with a wide tag
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
@@ -16404,9 +16404,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// replace with bitwise inverse // replace with bitwise inverse
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
@@ -16634,9 +16634,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// remove with a wide tag // remove with a wide tag
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(
@@ -16778,9 +16778,9 @@ code = '''
lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0;
lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, lfsr_bd_prog(&lfs, rbyd.blocks[0], 0,
backup_block, lfsr_rbyd_eoff(&rbyd), backup_block, lfsr_rbyd_eoff(&rbyd),
NULL) => 0; NULL, false) => 0;
lfsr_bd_flush(&lfs, lfsr_bd_flush(&lfs,
NULL) => 0; NULL, false) => 0;
// replace with bitwise inverse // replace with bitwise inverse
lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS(