From b21f4b81fa4eb1ca15135086028ed72cff12504d Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Mon, 19 Feb 2024 01:43:39 -0600 Subject: [PATCH] Cleaned/reworked bd/caching layer We really had ~2 duplicate bd layers for a bit there. This also involved a sort of rewrite of these low-level functions to see if there were simplifications that could be made. A couple tweaks: - Added small low-level lfsr_bd_read/prog/erase/sync_ functions to only wrap the bd callbacks and apply any relevant asserts. These should be the only place we call the bd callbacks to make it easy to read/audit/insert hooks in the future. - Changed pcache flush lazily, rather than eagerly flushing when full. This isn't for any real performance reason, it just makes the code simpler. It's not like we can shove more data into the pcache once full. It's _probably_ a good idea to flush eagerly, to avoid delay more work until sync, but I couldn't figure out how to make this work cleanly without code duplication... - Deduplicated read pcache overwrites via lfsr_bd_read__. This logic is a bit annoying, but we need the pcache to take priority whenever we read from disk, which happens when we both fill our rcache, and bypass our rcache. Since these code paths go different places, another internal function was the only way I could think to deduplicate this. It may appear that our pcache/rcache prioritization loop will make this happen naturally, as it does in lfs_file_read for example, but this doesn't quite work as read-alignment requirements may force us to read past the pcache... Keep in mind read_size may be > prog_size. - Dropped LFS_BLOCK_NULL, now using cache.size=0 to indicate a cache is unused. This avoids a special lfs_block_t value. - Dropped lfsr_bd_readcksum, we never used this. We can always add it back if necessary. In total, the caching bd prog/read functions now look quite a bit more like our file read/write functions, so hopefully that's a good thing. By the virtue of not have ~2 duplicate bd layers, this saves a bit of code: code stack before: 33700 2800 after: 33560 (-0.4%) 2808 (+0.3%) --- lfs.c | 740 ++++++++++++++++++++--------------------- tests/test_fwrite.toml | 14 +- tests/test_rbyd.toml | 703 +++++++++++++++++++-------------------- 3 files changed, 697 insertions(+), 760 deletions(-) diff --git a/lfs.c b/lfs.c index eb7cd40d..427fcf9d 100644 --- a/lfs.c +++ b/lfs.c @@ -9,10 +9,10 @@ #include "lfs_util.h" -// TODO do we still need these? -// some constants used throughout the code -#define LFS_BLOCK_NULL ((lfs_block_t)-1) -#define LFS_BLOCK_INLINE ((lfs_block_t)-2) +//// TODO do we still need these? +//// some constants used throughout the code +//#define LFS_BLOCK_NULL ((lfs_block_t)-1) +//#define LFS_BLOCK_INLINE ((lfs_block_t)-2) // TODO do we still need these? enum { @@ -33,465 +33,430 @@ enum lfs_scmp { typedef int lfs_scmp_t; -/// Caching block device operations /// +/// Simple bd wrappers (asserts go here) /// -static inline void lfs_cache_drop(lfs_t *lfs, lfs_cache_t *rcache) { - // do not zero, cheaper if cache is readonly or only going to be - // written with identical data (during relocates) - (void)lfs; - rcache->block = LFS_BLOCK_NULL; -} - -static inline void lfs_cache_zero(lfs_t *lfs, lfs_cache_t *pcache) { - // zero to avoid information leak - memset(pcache->buffer, 0xff, lfs->cfg->cache_size); - pcache->block = LFS_BLOCK_NULL; -} - -static int lfs_bd_read(lfs_t *lfs, - const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint, - lfs_block_t block, lfs_size_t off, +static int lfsr_bd_read_(lfs_t *lfs, lfs_block_t block, lfs_size_t off, void *buffer, lfs_size_t size) { - uint8_t *data = buffer; - if (block >= lfs->cfg->block_count || - off+size > lfs->cfg->block_size) { - return LFS_ERR_CORRUPT; + // must be in-bounds + LFS_ASSERT(block < lfs->cfg->block_count); + LFS_ASSERT(off+size <= lfs->cfg->block_size); + // must be aligned + LFS_ASSERT(off % lfs->cfg->read_size == 0); + LFS_ASSERT(size % lfs->cfg->read_size == 0); + + // bd read + int err = lfs->cfg->read(lfs->cfg, block, off, buffer, size); + LFS_ASSERT(err <= 0); + if (err) { + return err; } - while (size > 0) { - lfs_size_t diff = size; + return 0; +} - if (pcache && block == pcache->block && - off < pcache->off + pcache->size) { - if (off >= pcache->off) { - // is already in pcache? - diff = lfs_min(diff, pcache->size - (off-pcache->off)); - memcpy(data, &pcache->buffer[off-pcache->off], diff); +static int lfsr_bd_prog_(lfs_t *lfs, lfs_block_t block, lfs_size_t off, + const void *buffer, lfs_size_t size) { + // must be in-bounds + LFS_ASSERT(block < lfs->cfg->block_count); + LFS_ASSERT(off+size <= lfs->cfg->block_size); + // must be aligned + LFS_ASSERT(off % lfs->cfg->prog_size == 0); + LFS_ASSERT(size % lfs->cfg->prog_size == 0); - data += diff; - off += diff; - size -= diff; - continue; - } + // bd prog + int err = lfs->cfg->prog(lfs->cfg, block, off, buffer, size); + LFS_ASSERT(err <= 0); + if (err) { + return err; + } - // pcache takes priority - diff = lfs_min(diff, pcache->off-off); + return 0; +} + +static int lfsr_bd_erase_(lfs_t *lfs, lfs_block_t block) { + // must be in-bounds + LFS_ASSERT(block < lfs->cfg->block_count); + + // bd erase + int err = lfs->cfg->erase(lfs->cfg, block); + LFS_ASSERT(err <= 0); + if (err) { + return err; + } + + return 0; +} + +static int lfsr_bd_sync_(lfs_t *lfs) { + // bd sync + int err = lfs->cfg->sync(lfs->cfg); + LFS_ASSERT(err <= 0); + if (err) { + return err; + } + + return 0; +} + + +/// Caching block device operations /// + +static inline void lfsr_cache_drop(lfs_cache_t *cache) { + cache->size = 0; +} + +static int lfsr_bd_read__(lfs_t *lfs, lfs_block_t block, lfs_size_t off, + void *buffer, lfs_size_t size) { + int err = lfsr_bd_read_(lfs, block, off, buffer, size); + if (err) { + return err; + } + + // overwrite with pcache, since pcache may contain newer data + if (block == lfs->pcache.block + && off < lfs->pcache.off + lfs->pcache.size + && off + size > lfs->pcache.off) { + lfs_size_t off_ = lfs_max(off, lfs->pcache.off); + uint8_t *buffer_ = buffer; + lfs_size_t size_ = lfs_min( + size - (off_-off), + lfs->pcache.size - (off_-lfs->pcache.off)); + memcpy(&buffer_[off_-off], + &lfs->pcache.buffer[off_-lfs->pcache.off], + size_); + } + + return 0; +} + +// caching read +// +// note hint has two convenience: +// 1. 0 = minimal caching +// 2. -1 = maximal caching +static int lfsr_bd_read(lfs_t *lfs, + lfs_block_t block, lfs_size_t off, lfs_size_t hint, + void *buffer, lfs_size_t size) { + // check for in-bounds + LFS_ASSERT(block < lfs->cfg->block_count); + if (off+size > lfs->cfg->block_size) { + return LFS_ERR_RANGE; + } + + lfs_size_t off_ = off; + lfs_size_t hint_ = lfs_max(hint, size); // make sure hint >= size + uint8_t *buffer_ = buffer; + lfs_size_t size_ = size; + while (size_ > 0) { + // already in pcache? + if (block == lfs->pcache.block + && off_ < lfs->pcache.off + lfs->pcache.size + && off_ >= lfs->pcache.off) { + lfs_size_t d = lfs_min( + size_, + lfs->pcache.size - (off_-lfs->pcache.off)); + memcpy(buffer_, &lfs->pcache.buffer[off_-lfs->pcache.off], d); + + off_ += d; + hint_ -= d; + buffer_ += d; + size_ -= d; + continue; } - if (block == rcache->block && - off < rcache->off + rcache->size) { - if (off >= rcache->off) { - // is already in rcache? - diff = lfs_min(diff, rcache->size - (off-rcache->off)); - memcpy(data, &rcache->buffer[off-rcache->off], diff); + // already in rcache? + if (block == lfs->rcache.block + && off_ < lfs->rcache.off + lfs->rcache.size + && off_ >= lfs->rcache.off) { + lfs_size_t d = lfs_min( + size_, + lfs->rcache.size - (off_-lfs->rcache.off)); + memcpy(buffer_, &lfs->rcache.buffer[off_-lfs->rcache.off], d); - data += diff; - off += diff; - size -= diff; - continue; - } - - // rcache takes priority - diff = lfs_min(diff, rcache->off-off); + off_ += d; + hint_ -= d; + buffer_ += d; + size_ -= d; + continue; } - if (size >= hint && off % lfs->cfg->read_size == 0 && - size >= lfs->cfg->read_size) { - // bypass cache? - diff = lfs_aligndown(diff, lfs->cfg->read_size); - int err = lfs->cfg->read(lfs->cfg, block, off, data, diff); + // bypass cache? + if (size_ >= hint_ + && off_ % lfs->cfg->read_size == 0 + && size_ >= lfs->cfg->read_size) { + lfs_size_t d = lfs_aligndown(size_, lfs->cfg->read_size); + int err = lfsr_bd_read__(lfs, block, off_, buffer_, d); if (err) { return err; } - // TODO this was a quick hack, the entire cache system probably - // requires a deeper look - // - // fix overlaps with our pcache - if (pcache - && block == pcache->block - && off < pcache->off + pcache->size - && off + diff > pcache->off) { - lfs_size_t off_ = lfs_max(off, pcache->off); - lfs_size_t diff_ = lfs_min( - diff - (off_-off), - pcache->size - (off_-pcache->off)); - memcpy(&data[off_-off], - &pcache->buffer[off_-pcache->off], - diff_); - } - - data += diff; - off += diff; - size -= diff; + off_ += d; + hint_ -= d; + buffer_ += d; + size_ -= d; continue; } + // drop rcache in case read fails + lfsr_cache_drop(&lfs->rcache); + // load to cache, first condition can no longer fail - LFS_ASSERT(block < lfs->cfg->block_count); - rcache->block = block; - rcache->off = lfs_aligndown(off, lfs->cfg->read_size); - rcache->size = lfs_min( + lfs_size_t off__ = lfs_aligndown(off_, lfs->cfg->read_size); + lfs_size_t size__ = lfs_min( lfs_min( - lfs_alignup(off+lfs_max(size, hint), lfs->cfg->read_size), + lfs_alignup( + off_+lfs_max(size_, hint_), + lfs->cfg->read_size), lfs->cfg->block_size) - - rcache->off, + - off__, lfs->cfg->cache_size); - int err = lfs->cfg->read(lfs->cfg, rcache->block, - rcache->off, rcache->buffer, rcache->size); - LFS_ASSERT(err <= 0); + int err = lfsr_bd_read__(lfs, block, off__, + lfs->rcache.buffer, size__); if (err) { return err; } - // TODO this was a quick hack, the entire cache system probably - // requires a deeper look + lfs->rcache.block = block; + lfs->rcache.off = off__; + lfs->rcache.size = size__; + } + + return 0; +} + +// needed in lfsr_bd_prog +static int lfsr_bd_flush(lfs_t *lfs, uint32_t *flcksum_); + +// caching prog +// +// this has two ways to calculate a cksum, we end up using both: +// - cksum - cksum immediately +// - flcksum - wait until flush to cksum +// +static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off, + const void *buffer, lfs_size_t size, + uint32_t *cksum_, uint32_t *flcksum_) { + // check for in-bounds + LFS_ASSERT(block < lfs->cfg->block_count); + if (off+size > lfs->cfg->block_size) { + return LFS_ERR_RANGE; + } + + lfs_size_t off_ = off; + const uint8_t *buffer_ = buffer; + lfs_size_t size_ = size; + while (size_ > 0) { + // bypass cache? // - // fix overlaps with our pcache - if (pcache - && rcache->block == pcache->block - && rcache->off < pcache->off + pcache->size - && rcache->off + rcache->size > pcache->off) { - lfs_size_t off_ = lfs_max(rcache->off, pcache->off); - lfs_size_t size_ = lfs_min( - rcache->size - (off_-rcache->off), - pcache->size - (off_-pcache->off)); - memcpy(&rcache->buffer[off_-rcache->off], - &pcache->buffer[off_-pcache->off], - size_); + // make sure we flush our pcache first since some devices + // don't support out-of-order progs in a block + // + if (lfs->pcache.size == 0 + && off_ % lfs->cfg->prog_size == 0 + && size_ >= lfs->cfg->prog_size) { + lfs_size_t d = lfs_aligndown(size_, lfs->cfg->prog_size); + int err = lfsr_bd_prog_(lfs, block, off_, buffer_, d); + if (err) { + return err; + } + + // update flushed checksum if requested + if (flcksum_) { + *flcksum_ = lfs_crc32c(*flcksum_, buffer_, d); + } + + off_ += d; + buffer_ += d; + size_ -= d; + continue; } + + // fits in pcache? + if (lfs->pcache.size == 0 + || (block == lfs->pcache.block + && off_ >= lfs->pcache.off + && off_ < lfs->pcache.off + lfs->cfg->cache_size)) { + // unused pcache? make sure to move it so we never overwrite + if (lfs->pcache.size == 0) { + lfs->pcache.block = block; + lfs->pcache.off = lfs_aligndown(off_, lfs->cfg->prog_size); + } + + // zero to avoid any information leaks + memset(&lfs->pcache.buffer[lfs->pcache.size], + 0xff, + (off_-lfs->pcache.off) - lfs->pcache.size); + + lfs_size_t d = lfs_min( + size_, + lfs->cfg->cache_size - (off_-lfs->pcache.off)); + memcpy(&lfs->pcache.buffer[off_-lfs->pcache.off], buffer_, d); + lfs->pcache.size = lfs_max( + lfs->pcache.size, + (off_-lfs->pcache.off) + d); + + off_ += d; + buffer_ += d; + size_ -= d; + continue; + } + + // flush pcache so the above can't fail + int err = lfsr_bd_flush(lfs, flcksum_); + if (err) { + return err; + } + } + + // update rcache if we overlap + if (block == lfs->rcache.block + && off < lfs->rcache.off + lfs->rcache.size + && off + size > lfs->rcache.off) { + lfs_size_t off_ = lfs_max(off, lfs->rcache.off); + const uint8_t *buffer_ = buffer; + lfs_size_t size_ = lfs_min( + size - (off_-off), + lfs->rcache.size - (off_-lfs->rcache.off)); + memcpy(&lfs->rcache.buffer[off_-lfs->rcache.off], + &buffer_[off_-off], + size_); + } + + // optional checksum + if (cksum_) { + *cksum_ = lfs_crc32c(*cksum_, buffer, size); } return 0; } -static int lfs_bd_cmp(lfs_t *lfs, - const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint, - lfs_block_t block, lfs_size_t off, - const void *buffer, lfs_size_t size) { - const uint8_t *data = buffer; - lfs_size_t diff = 0; - // make sure our hint is at least as big as our buffer - hint = lfs_max(hint, size); +// flush any pending programs +static int lfsr_bd_flush(lfs_t *lfs, uint32_t *flcksum_) { + if (lfs->pcache.size != 0) { + // must be in-bounds + LFS_ASSERT(lfs->pcache.block < lfs->cfg->block_count); - for (lfs_size_t i = 0; i < size; i += diff) { - uint8_t dat[8]; + // zero to avoid any information leaks + lfs_size_t aligned_size = lfs_alignup( + lfs->pcache.size, + lfs->cfg->prog_size); + memset(&lfs->pcache.buffer[lfs->pcache.size], + 0xff, + aligned_size - lfs->pcache.size); - diff = lfs_min(size-i, sizeof(dat)); - int err = lfs_bd_read(lfs, - pcache, rcache, hint-i, - block, off+i, &dat, diff); - if (err) { - LFS_ASSERT(err < 0); - return err; - } - - int res = memcmp(dat, data + i, diff); - if (res) { - return (res < 0) ? LFS_CMP_LT : LFS_CMP_GT; - } - } - - return LFS_CMP_EQ; -} - -//static int lfs_bd_crc(lfs_t *lfs, -// const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint, -// lfs_block_t block, lfs_off_t off, lfs_size_t size, uint32_t *crc) { -// lfs_size_t diff = 0; -// -// for (lfs_off_t i = 0; i < size; i += diff) { -// uint8_t dat[8]; -// diff = lfs_min(size-i, sizeof(dat)); -// int err = lfs_bd_read(lfs, -// pcache, rcache, hint-i, -// block, off+i, &dat, diff); -// if (err) { -// return err; -// } -// -// *crc = lfs_crc(*crc, &dat, diff); -// } -// -// return 0; -//} - -static int lfs_bd_crc32c(lfs_t *lfs, - const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint, - lfs_block_t block, lfs_size_t off, lfs_size_t size, uint32_t *crc) { - lfs_size_t diff = 0; - - for (lfs_size_t i = 0; i < size; i += diff) { - uint8_t dat[8]; - diff = lfs_min(size-i, sizeof(dat)); - int err = lfs_bd_read(lfs, - pcache, rcache, lfs_max32(hint, size)-i, - block, off+i, &dat, diff); + // flush + int err = lfsr_bd_prog_(lfs, lfs->pcache.block, + lfs->pcache.off, lfs->pcache.buffer, aligned_size); if (err) { return err; } - *crc = lfs_crc32c(*crc, &dat, diff); - } - - return 0; -} - -#ifndef LFS_READONLY -static int lfs_bd_flush(lfs_t *lfs, - lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate, - uint32_t *flcksum_) { - if (pcache->block != LFS_BLOCK_NULL && pcache->block != LFS_BLOCK_INLINE) { - LFS_ASSERT(pcache->block < lfs->cfg->block_count); - lfs_size_t diff = lfs_alignup(pcache->size, lfs->cfg->prog_size); - int err = lfs->cfg->prog(lfs->cfg, pcache->block, - pcache->off, pcache->buffer, diff); - LFS_ASSERT(err <= 0); - if (err) { - return err; - } - - if (validate) { - // check data on disk - lfs_cache_drop(lfs, rcache); - lfs_scmp_t cmp = lfs_bd_cmp(lfs, - NULL, rcache, diff, - pcache->block, pcache->off, pcache->buffer, diff); - if (cmp < 0) { - return cmp; - } - - if (cmp != LFS_CMP_EQ) { - return LFS_ERR_CORRUPT; - } - } - // this is when we update the the flushed checksum if requested if (flcksum_) { *flcksum_ = lfs_crc32c(*flcksum_, - pcache->buffer, pcache->size); + lfs->pcache.buffer, lfs->pcache.size); } - lfs_cache_zero(lfs, pcache); + // make this cache available + lfsr_cache_drop(&lfs->pcache); } return 0; } -#endif -#ifndef LFS_READONLY -static int lfs_bd_sync(lfs_t *lfs, - lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate) { - lfs_cache_drop(lfs, rcache); - - int err = lfs_bd_flush(lfs, pcache, rcache, validate, NULL); +static int lfsr_bd_sync(lfs_t *lfs) { + // make sure we flush any caches + int err = lfsr_bd_flush(lfs, NULL); if (err) { return err; } - err = lfs->cfg->sync(lfs->cfg); - LFS_ASSERT(err <= 0); - return err; + return lfsr_bd_sync_(lfs); } -#endif -#ifndef LFS_READONLY -static int lfs_bd_prog(lfs_t *lfs, - lfs_cache_t *pcache, lfs_cache_t *rcache, bool validate, - lfs_block_t block, lfs_size_t off, - const void *buffer, lfs_size_t size, - uint32_t *flcksum_) { - const uint8_t *data = buffer; - LFS_ASSERT(block == LFS_BLOCK_INLINE || block < lfs->cfg->block_count); - LFS_ASSERT(off + size <= lfs->cfg->block_size); - - // update rcache if we overlap - if (rcache - && block == rcache->block - && off < rcache->off + rcache->size - && off + size > rcache->off) { - lfs_size_t off_ = lfs_max(off, rcache->off); - lfs_size_t size_ = lfs_min( - size - (off_-off), - rcache->size - (off_-rcache->off)); - memcpy(&rcache->buffer[off_-rcache->off], &data[off_-off], size_); - } - - while (size > 0) { - if (block == pcache->block && - off >= pcache->off && - off < pcache->off + lfs->cfg->cache_size) { - // already fits in pcache? - lfs_size_t diff = lfs_min(size, - lfs->cfg->cache_size - (off-pcache->off)); - memcpy(&pcache->buffer[off-pcache->off], data, diff); - - data += diff; - off += diff; - size -= diff; - - pcache->size = lfs_max(pcache->size, off - pcache->off); - if (pcache->size == lfs->cfg->cache_size) { - // eagerly flush out pcache if we fill up - int err = lfs_bd_flush(lfs, pcache, rcache, validate, - flcksum_); - if (err) { - return err; - } - } - - continue; - } - - // prepare pcache, first condition can no longer fail - lfs_cache_zero(lfs, pcache); - pcache->block = block; - pcache->off = lfs_aligndown(off, lfs->cfg->prog_size); - pcache->size = 0; - } - - return 0; -} -#endif - -#ifndef LFS_READONLY -static int lfs_bd_erase(lfs_t *lfs, lfs_block_t block) { +static int lfsr_bd_erase(lfs_t *lfs, lfs_block_t block) { + // must be in-bounds LFS_ASSERT(block < lfs->cfg->block_count); - // make sure any caches are outdated appropriately here + // make sure we invalidate any caches + if (lfs->pcache.block == block) { + lfsr_cache_drop(&lfs->pcache); + } if (lfs->rcache.block == block) { - lfs_cache_drop(lfs, &lfs->rcache); + lfsr_cache_drop(&lfs->rcache); } - int err = lfs->cfg->erase(lfs->cfg, block); - LFS_ASSERT(err <= 0); - return err; -} -#endif - -// TODO should these be the only bd APIs? -// simpler APIs if assume file caches are irrelevant -// -// note hint has two convenience: -// 1. 0 = minimal caching -// 2. block_size = maximal caching -// -static int lfsr_bd_read(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - void *buffer, lfs_size_t size) { - // check for in-bounds - if (off+size > lfs->cfg->block_size) { - return LFS_ERR_RANGE; - } - - return lfs_bd_read(lfs, &lfs->pcache, &lfs->rcache, hint, - block, off, buffer, size); + return lfsr_bd_erase_(lfs, block); } -// TODO merge lfsr_bd_readcksum/lfsr_bd_cksum somehow? -static int lfsr_bd_readcksum(lfs_t *lfs, - lfs_block_t block, lfs_size_t off, lfs_size_t hint, - void *buffer, lfs_size_t size, - uint32_t *cksum_) { - int err = lfsr_bd_read(lfs, block, off, hint, buffer, size); - if (err) { - return err; - } - *cksum_ = lfs_crc32c(*cksum_, buffer, size); - return 0; -} +// other block device utils static int lfsr_bd_cksum(lfs_t *lfs, lfs_block_t block, lfs_size_t off, lfs_size_t hint, lfs_size_t size, uint32_t *cksum_) { // check for in-bounds + LFS_ASSERT(block < lfs->cfg->block_count); if (off+size > lfs->cfg->block_size) { return LFS_ERR_RANGE; } - return lfs_bd_crc32c(lfs, &lfs->pcache, &lfs->rcache, hint, - block, off, size, cksum_); + lfs_size_t off_ = off; + lfs_size_t hint_ = lfs_max(hint, size); // make sure hint >= size + lfs_size_t size_ = size; + while (size_ > 0) { + // can we do better than this? + uint8_t dat[8]; + lfs_size_t d = lfs_min(size_, sizeof(dat)); + int err = lfsr_bd_read(lfs, block, off_, hint_, &dat, d); + if (err) { + return err; + } + + *cksum_ = lfs_crc32c(*cksum_, &dat, d); + + off_ += d; + hint_ -= d; + size_ -= d; + } + + return 0; } static lfs_scmp_t lfsr_bd_cmp(lfs_t *lfs, lfs_block_t block, lfs_size_t off, lfs_size_t hint, const void *buffer, lfs_size_t size) { // check for in-bounds + LFS_ASSERT(block < lfs->cfg->block_count); if (off+size > lfs->cfg->block_size) { return LFS_ERR_RANGE; } - return lfs_bd_cmp(lfs, &lfs->pcache, &lfs->rcache, hint, - block, off, buffer, size); -} + lfs_size_t off_ = off; + lfs_size_t hint_ = lfs_max(hint, size); // make sure hint >= size + const uint8_t *buffer_ = buffer; + lfs_size_t size_ = size; + while (size_ > 0) { + // TODO can we do better than this? + uint8_t dat[8]; + lfs_size_t d = lfs_min(size_, sizeof(dat)); + int err = lfsr_bd_read(lfs, block, off_, hint_, &dat, d); + if (err) { + return err; + } -// program data with optional checksum -static int lfsr_bd_prog(lfs_t *lfs, lfs_block_t block, lfs_size_t off, - const void *buffer, lfs_size_t size, - uint32_t *cksum_, uint32_t *flcksum_) { - // check for in-bounds - if (off+size > lfs->cfg->block_size) { - return LFS_ERR_RANGE; + int res = memcmp(dat, buffer_, d); + if (res != 0) { + return (res < 0) ? LFS_CMP_LT : LFS_CMP_GT; + } + + off_ += d; + hint_ -= d; + buffer_ += d; + size_ -= d; } - int err = lfs_bd_prog(lfs, &lfs->pcache, &lfs->rcache, false, - block, off, buffer, size, - flcksum_); - if (err) { - return err; - } - - // optional checksum - if (cksum_) { - *cksum_ = lfs_crc32c(*cksum_, buffer, size); - } - - return 0; -} - -static int lfsr_bd_flush(lfs_t *lfs, - uint32_t *flcksum_) { - return lfs_bd_flush(lfs, &lfs->pcache, &lfs->rcache, false, - flcksum_); -} - -static int lfsr_bd_sync(lfs_t *lfs) { - return lfs_bd_sync(lfs, &lfs->pcache, &lfs->rcache, false); -} - -// TODO do we need this? should everything be checked by crc and validation -// be an optional ifdef? -static int lfsr_bd_progvalidate(lfs_t *lfs, lfs_block_t block, lfs_size_t off, - const void *buffer, lfs_size_t size, - uint32_t *cksum_, uint32_t *flcksum_) { - // check for in-bounds - if (off+size > lfs->cfg->block_size) { - lfs_cache_zero(lfs, &lfs->pcache); - return LFS_ERR_RANGE; - } - - int err = lfs_bd_prog(lfs, &lfs->pcache, &lfs->rcache, true, - block, off, buffer, size, - flcksum_); - if (err) { - return err; - } - - // optional checksum - if (cksum_) { - *cksum_ = lfs_crc32c(*cksum_, buffer, size); - } - - return 0; -} - -static int lfsr_bd_syncvalidate(lfs_t *lfs) { - return lfs_bd_sync(lfs, &lfs->pcache, &lfs->rcache, true); -} - -static int lfsr_bd_erase(lfs_t *lfs, lfs_block_t block) { - return lfs_bd_erase(lfs, block); + return LFS_CMP_EQ; } @@ -10543,8 +10508,7 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, // TODO validate? // finalize our write - err = lfsr_bd_flush(lfs, - &bptr.cksum); + err = lfsr_bd_flush(lfs, &bptr.cksum); if (err) { return err; } @@ -10552,8 +10516,8 @@ static int lfsr_file_flush_(lfs_t *lfs, lfsr_file_t *file, // TODO this is a cludge, but right now our bd layer is a mess, // we need caches to be clean so becksum calculation does not pick // up out-of-date pcaches/rcaches - lfs_cache_drop(lfs, &lfs->pcache); - lfs_cache_drop(lfs, &lfs->rcache); + lfsr_cache_drop(&lfs->pcache); + lfsr_cache_drop(&lfs->rcache); // prepare our block pointer LFS_ASSERT(bptr.cksize > 0); @@ -14848,6 +14812,9 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) { // setup read cache + lfs->rcache.block = 0; + lfs->rcache.off = 0; + lfs->rcache.size = 0; if (lfs->cfg->read_buffer) { lfs->rcache.buffer = lfs->cfg->read_buffer; } else { @@ -14859,6 +14826,9 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) { } // setup program cache + lfs->pcache.block = 0; + lfs->pcache.off = 0; + lfs->pcache.size = 0; if (lfs->cfg->prog_buffer) { lfs->pcache.buffer = lfs->cfg->prog_buffer; } else { @@ -14869,10 +14839,6 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) { } } - // zero to avoid information leaks - lfs_cache_zero(lfs, &lfs->rcache); - lfs_cache_zero(lfs, &lfs->pcache); - // setup lookahead buffer, note mount finishes initializing this after // we establish a decent pseudo-random seed LFS_ASSERT(lfs->cfg->lookahead_size > 0); @@ -14916,8 +14882,8 @@ static int lfs_init(lfs_t *lfs, const struct lfs_config *cfg) { } // setup default state - lfs->root[0] = LFS_BLOCK_NULL; - lfs->root[1] = LFS_BLOCK_NULL; +// lfs->root[0] = LFS_BLOCK_NULL; +// lfs->root[1] = LFS_BLOCK_NULL; lfs->mlist = NULL; lfs->seed = 0; lfs->gdisk = (lfs_gstate_t){0}; diff --git a/tests/test_fwrite.toml b/tests/test_fwrite.toml index 5cb0a1da..3fcf06d0 100644 --- a/tests/test_fwrite.toml +++ b/tests/test_fwrite.toml @@ -1033,7 +1033,7 @@ code = ''' sim[i] = 'a' + (TEST_PRNG(&prng) % 26); } lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; - } else if (INIT == 2) { + } else { memset(sim, 0, SIZE); lfsr_file_truncate(&lfs, &file, SIZE) => 0; } @@ -1545,7 +1545,7 @@ code = ''' } lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; size = SIZE; - } else if (INIT == 2) { + } else { memset(sim, 0, SIZE); lfsr_file_truncate(&lfs, &file, SIZE) => 0; size = SIZE; @@ -1686,7 +1686,7 @@ code = ''' } lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; size = SIZE; - } else if (INIT == 2) { + } else { memset(sim, 0, SIZE); lfsr_file_truncate(&lfs, &file, SIZE) => 0; size = SIZE; @@ -1912,7 +1912,7 @@ code = ''' } lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; size = SIZE; - } else if (INIT == 2) { + } else { memset(sim, 0, SIZE); lfsr_file_truncate(&lfs, &file, SIZE) => 0; size = SIZE; @@ -2052,7 +2052,7 @@ code = ''' } lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; size = SIZE; - } else if (INIT == 2) { + } else { memset(sim, 0, SIZE); lfsr_file_truncate(&lfs, &file, SIZE) => 0; size = SIZE; @@ -2211,7 +2211,7 @@ code = ''' } lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; size = SIZE; - } else if (INIT == 2) { + } else { memset(sim, 0, SIZE); lfsr_file_truncate(&lfs, &file, SIZE) => 0; size = SIZE; @@ -2316,7 +2316,7 @@ code = ''' } lfsr_file_write(&lfs, &file, sim, SIZE) => SIZE; size = SIZE; - } else if (INIT == 2) { + } else { memset(sim, 0, SIZE); lfsr_file_truncate(&lfs, &file, SIZE) => 0; size = SIZE; diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index fb55dbbc..c03f4a78 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -30,14 +30,14 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -61,14 +61,14 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -93,7 +93,7 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -131,7 +131,7 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -154,7 +154,7 @@ code = ''' // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -188,7 +188,7 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -241,7 +241,7 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -264,7 +264,7 @@ code = ''' // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -299,7 +299,7 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -352,7 +352,7 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -371,7 +371,7 @@ code = ''' // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -393,7 +393,7 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -432,7 +432,7 @@ code = ''' // commit with one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -451,7 +451,7 @@ code = ''' // commit with two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -474,7 +474,7 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -518,7 +518,7 @@ code = ''' // => .-'| // 1 1 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -540,7 +540,7 @@ code = ''' // => .-'| // 2 2 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -581,7 +581,7 @@ code = ''' // .-'| => .----'| // 1 2 1 2 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -604,7 +604,7 @@ code = ''' // .-'| => .-'| // 1 2 1 2 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -648,7 +648,7 @@ code = ''' // .-'| | .-'| // 1 2 1 2 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -678,7 +678,7 @@ code = ''' // .-'| .--|-'| // 2 3 2 3 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -727,7 +727,7 @@ code = ''' // | .-'| | .----'| // 1 2 3 1 2 3 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -758,7 +758,7 @@ code = ''' // | .-'| | .-'| // 1 2 3 1 2 3 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -789,7 +789,7 @@ code = ''' // | .-'| .--|-'| // 1 2 3 1 2 3 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -820,7 +820,7 @@ code = ''' // .--|-'| | .-'| // 3 1 2 3 1 2 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), @@ -872,7 +872,7 @@ code = ''' // | .-'| | | .-'| // 1 2 3 1 2 3 4 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -910,7 +910,7 @@ code = ''' // | .-'| | .--|-'| .--|--|-'| // 1 3 4 1 3 4 2 1 3 4 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -948,7 +948,7 @@ code = ''' // | .-'| .--|--|-'| // 2 3 4 2 3 4 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -986,7 +986,7 @@ code = ''' // .--|-'| | .--|-'| // 4 2 3 4 2 3 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1043,7 +1043,7 @@ code = ''' // | .-'| | | .-'| // 1 2 3 1 2 3 4 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1081,7 +1081,7 @@ code = ''' // | .-'| | | .-'| // 1 2 4 1 2 4 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1119,7 +1119,7 @@ code = ''' // | .-'| | | .-'| | .--|-'| // 1 4 2 1 4 2 3 1 4 2 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), @@ -1157,7 +1157,7 @@ code = ''' // | .-'| | | .-'| .--|--|-'| // 4 1 2 4 1 2 3 4 1 2 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), @@ -1216,7 +1216,7 @@ code = ''' // | | .-'| | | .----'| // 1 2 3 4 1 2 3 4 4 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1257,7 +1257,7 @@ code = ''' // | | .-'| | | .-'| // 1 2 3 4 1 2 3 4 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1296,7 +1296,7 @@ code = ''' // | | .-'| | .-'| | // 1 2 3 4 1 2 3 4 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1335,7 +1335,7 @@ code = ''' // | | .-'| | .-'| | // 1 2 3 4 1 2 3 4 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1397,7 +1397,7 @@ code = ''' // | | .-'| | | | .-'| // 1 2 3 4 1 2 3 4 5 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1445,7 +1445,7 @@ code = ''' // | | .-'| | | .--|-'| // 1 2 4 5 1 2 4 5 3 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1491,7 +1491,7 @@ code = ''' // | | .-'| | | .-'| | // 1 3 4 5 1 3 4 5 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -1537,7 +1537,7 @@ code = ''' // | | .-'| | | .-'| | // 2 3 4 5 2 3 4 5 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -1604,7 +1604,7 @@ code = ''' // | | | .-'| | | | .----'| // 1 2 3 4 5 1 2 3 4 5 5 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1653,7 +1653,7 @@ code = ''' // | | | .-'| | | .-'| | // 1 2 3 4 5 1 2 3 4 5 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1702,7 +1702,7 @@ code = ''' // | | | .-'| | | .-'| | // 1 2 3 4 5 1 2 3 4 5 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1772,7 +1772,7 @@ code = ''' // | | | .-'| | | | | .-'| // 1 2 3 4 5 1 2 3 4 5 6 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -1826,7 +1826,7 @@ code = ''' // | | | .-'| | | | .-'| | // 1 3 4 5 6 1 3 4 5 6 2 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -1880,7 +1880,7 @@ code = ''' // | | | .-'| | | | .-'| | // 2 3 4 5 6 2 3 4 5 6 1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), @@ -1976,7 +1976,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, attrs, N) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2059,7 +2059,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(perm[j]+1), 0, @@ -2119,7 +2119,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -2153,7 +2153,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -2208,7 +2208,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -2243,7 +2243,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -2327,7 +2327,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, attrs, N) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -2392,7 +2392,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(perm[j]+1), 0, @@ -2447,7 +2447,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -2457,8 +2457,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -2481,11 +2481,10 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // update each tag in permutation order @@ -2555,7 +2554,7 @@ code = ''' // create the rbyd tree rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; // keep appending tags until we run out of space // @@ -2617,7 +2616,7 @@ code = ''' // add and remove one attribute rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -2636,7 +2635,7 @@ code = ''' // commit with two attributes, remove the first one rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -2672,7 +2671,7 @@ code = ''' // commit with two attributes, remove the second one rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -2752,7 +2751,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(perm[j]+1), 0, @@ -2762,8 +2761,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -2771,11 +2770,10 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -2899,7 +2897,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(perm[j]+1), 0, @@ -2909,8 +2907,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -2918,11 +2916,10 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -2976,7 +2973,7 @@ code = ''' // create a tree two attributes rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; @@ -3125,7 +3122,7 @@ code = ''' // create a tree rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -3360,7 +3357,7 @@ code = ''' // commit with one attribute, remove it rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -3379,7 +3376,7 @@ code = ''' // commit with two attributes, remove both rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -3400,7 +3397,7 @@ code = ''' // commit with two attributes, remove both in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -3452,7 +3449,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( @@ -3462,8 +3459,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -3486,11 +3483,10 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // remove each tag in permutation order @@ -3593,7 +3589,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; prng = SEED; for (unsigned i = 0; i < N; i++) { @@ -3684,7 +3680,7 @@ code = ''' // try to create one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -3701,7 +3697,7 @@ code = ''' // try to create two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -3725,7 +3721,7 @@ code = ''' // create a third to the right rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -3774,7 +3770,7 @@ code = ''' // try to create one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -3791,7 +3787,7 @@ code = ''' // try to create two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( @@ -3816,7 +3812,7 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -3841,7 +3837,7 @@ code = ''' // create a third to the right rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( @@ -3874,7 +3870,7 @@ code = ''' // create a third to the left rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( @@ -3907,7 +3903,7 @@ code = ''' // create a third in the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( @@ -3995,7 +3991,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -4064,7 +4060,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 00000000, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -4133,7 +4129,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( @@ -4180,7 +4176,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -4281,7 +4277,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -4346,7 +4342,7 @@ code = ''' // create the rbyd tree rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; // keep inserting tags until we run out of space // @@ -4408,7 +4404,7 @@ code = ''' // try to create one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; @@ -4432,7 +4428,7 @@ code = ''' // try to create two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -4470,7 +4466,7 @@ code = ''' // create a third to the right rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -4563,7 +4559,7 @@ code = ''' // try to create one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -4588,7 +4584,7 @@ code = ''' // try to create two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -4629,7 +4625,7 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -4670,7 +4666,7 @@ code = ''' // create a third to the right rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -4750,7 +4746,7 @@ code = ''' // create a third to the left rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -4807,7 +4803,7 @@ code = ''' // create a third in the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -4920,7 +4916,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -5001,7 +4997,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -5104,7 +5100,7 @@ code = ''' // so that lookups return strictly the tag greater than or equal to // the tag requested rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -5187,7 +5183,7 @@ code = ''' // also try the other direction rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -5325,7 +5321,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -5419,7 +5415,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( @@ -5434,8 +5430,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N*M); @@ -5458,11 +5454,10 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // update each tag in permutation order @@ -5574,7 +5569,7 @@ code = ''' // create given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -5597,8 +5592,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N*M; j++) { @@ -5606,11 +5601,10 @@ code = ''' printf("--- remove: rid%jd, %jd ---\n", j/M, (j%M)+1); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS( @@ -5755,7 +5749,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( @@ -5770,8 +5764,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N*M); @@ -5794,11 +5788,10 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // remove each tag in permutation order @@ -5877,7 +5870,7 @@ code = ''' // create the rbyd tree rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; // keep inserting tags until we run out of space // @@ -5991,7 +5984,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -6135,7 +6128,7 @@ code = ''' // test the given permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -6267,7 +6260,7 @@ code = ''' // try to delete one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -6291,7 +6284,7 @@ code = ''' // try to delete the other rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -6315,7 +6308,7 @@ code = ''' // try to delete the largest of three rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -6344,7 +6337,7 @@ code = ''' // try to delete the smallest of three rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -6373,7 +6366,7 @@ code = ''' // try to delete the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -6420,7 +6413,7 @@ code = ''' // try to delete one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -6456,7 +6449,7 @@ code = ''' // try to delete the other rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -6492,7 +6485,7 @@ code = ''' // try to delete the largest of three rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -6542,7 +6535,7 @@ code = ''' // try to delete the smallest of three rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -6592,7 +6585,7 @@ code = ''' // try to delete the middle rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -6699,7 +6692,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -6718,8 +6711,8 @@ code = ''' // copy block so we can reset after each delete lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -6727,11 +6720,10 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( @@ -6857,7 +6849,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -6882,8 +6874,8 @@ code = ''' // copy block so we can reset after each delete lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -6891,11 +6883,10 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( @@ -7051,7 +7042,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -7070,8 +7061,8 @@ code = ''' // copy block so we can reset after each delete lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -7079,11 +7070,10 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( @@ -7179,7 +7169,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -7204,8 +7194,8 @@ code = ''' // copy block so we can reset after each delete lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -7213,11 +7203,10 @@ code = ''' printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( @@ -7291,7 +7280,7 @@ code = ''' // create and delete one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( @@ -7308,7 +7297,7 @@ code = ''' // create and delete two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -7327,7 +7316,7 @@ code = ''' // create and delete two ids in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; @@ -7347,7 +7336,7 @@ code = ''' // create and delete three ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -7368,7 +7357,7 @@ code = ''' // create and delete three ids in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), @@ -7409,7 +7398,7 @@ code = ''' // create and delete one rid rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; @@ -7427,7 +7416,7 @@ code = ''' // create and delete two ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -7448,7 +7437,7 @@ code = ''' // create and delete two ids in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -7470,7 +7459,7 @@ code = ''' // create and delete three ids rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -7494,7 +7483,7 @@ code = ''' // create and delete three ids in the other order rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), @@ -7558,7 +7547,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( @@ -7569,8 +7558,8 @@ code = ''' // copy block so we can reset after each delete lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -7593,11 +7582,10 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // delete each rid in permutation order @@ -7704,7 +7692,7 @@ code = ''' // create one consistent block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( @@ -7720,8 +7708,8 @@ code = ''' // copy block so we can reset after each delete lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // test all permutations of a given size size_t perm_count = TEST_FACTORIAL(N); @@ -7744,11 +7732,10 @@ code = ''' // restore backup rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // delete each rid in permutation order @@ -7878,7 +7865,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; prng = SEED; count = 0; @@ -7963,7 +7950,7 @@ code = ''' // make id0 with weight w1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; @@ -8199,7 +8186,7 @@ code = ''' lfsr_data_t data_; rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( // make id0 with weight w1 LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), @@ -8338,7 +8325,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -8427,7 +8414,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -8486,7 +8473,7 @@ code = ''' // make id0 with weight w1 rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)), LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), @@ -9157,7 +9144,7 @@ code = ''' lfsr_data_t data_; rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)), // make id0 with weight w1 @@ -9443,7 +9430,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)))) => 0; @@ -9556,7 +9543,7 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)))) => 0; @@ -9679,7 +9666,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -9698,8 +9685,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try growing each rid for (unsigned j = 0; j < N; j++) { @@ -9707,11 +9694,10 @@ code = ''' printf("--- growing: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( @@ -9810,7 +9796,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -9829,8 +9815,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try growing each rid for (unsigned j = 0; j < N; j++) { @@ -9838,11 +9824,10 @@ code = ''' printf("--- growing: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( @@ -9952,7 +9937,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -9971,8 +9956,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try growing each rid for (unsigned j = 0; j < N; j++) { @@ -9980,11 +9965,10 @@ code = ''' printf("--- growing: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( @@ -10107,7 +10091,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10126,8 +10110,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try shrinking each rid for (unsigned j = 0; j < N; j++) { @@ -10135,11 +10119,10 @@ code = ''' printf("--- shrinking: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( @@ -10238,7 +10221,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10257,8 +10240,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try shrinking each rid for (unsigned j = 0; j < N; j++) { @@ -10266,11 +10249,10 @@ code = ''' printf("--- shrinking: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( @@ -10380,7 +10362,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10399,8 +10381,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try shrinking each rid for (unsigned j = 0; j < N; j++) { @@ -10408,11 +10390,10 @@ code = ''' printf("--- shrinking: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( @@ -10534,7 +10515,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10553,8 +10534,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try deleting each rid for (unsigned j = 0; j < N; j++) { @@ -10562,11 +10543,10 @@ code = ''' printf("--- deleting: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( @@ -10695,7 +10675,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -10714,8 +10694,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try appending an attr to each rid, this should not affect // weights at all! @@ -10724,11 +10704,10 @@ code = ''' printf("--- appending: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( @@ -10882,7 +10861,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; prng = SEED; count = 0; @@ -11043,7 +11022,7 @@ code = ''' // set up rbyd block rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; prng = SEED; count = 0; @@ -11222,7 +11201,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11309,7 +11288,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11330,8 +11309,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -11339,11 +11318,10 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // remove with a wide tag @@ -11448,7 +11426,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11469,8 +11447,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -11478,11 +11456,10 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // replace with bitwise inverse @@ -11589,7 +11566,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11678,7 +11655,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11701,8 +11678,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -11710,11 +11687,10 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // remove with a wide tag @@ -11826,7 +11802,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -11849,8 +11825,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -11858,11 +11834,10 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // replace with bitwise inverse @@ -11976,7 +11951,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12062,7 +12037,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12082,8 +12057,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -12091,11 +12066,10 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // remove with a wide tag @@ -12203,7 +12177,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12223,8 +12197,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -12232,11 +12206,10 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // replace with bitwise inverse @@ -12337,7 +12310,7 @@ code = ''' // build the attribute list for the current permutation rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12424,7 +12397,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12445,8 +12418,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try removing each tag for (unsigned j = 0; j < N; j++) { @@ -12454,11 +12427,10 @@ code = ''' printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // remove with a wide tag @@ -12563,7 +12535,7 @@ code = ''' // create given permutation with multiple commits rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions uint16_t rid = perm[j]; @@ -12584,8 +12556,8 @@ code = ''' // copy block so we can reset after each remove lfsr_rbyd_t backup_rbyd = rbyd; uint8_t *backup_block = malloc(rbyd.eoff); - lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.eoff, - rbyd.blocks[0], 0, backup_block, rbyd.eoff) => 0; + lfsr_bd_read(&lfs, rbyd.blocks[0], 0, rbyd.eoff, + backup_block, rbyd.eoff) => 0; // try replacing each tag for (unsigned j = 0; j < N; j++) { @@ -12593,11 +12565,10 @@ code = ''' printf("--- replace: %d ---\n", j); rbyd = backup_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, - rbyd.blocks[0], 0, backup_block, rbyd.eoff, - NULL) => 0; - lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, + lfsr_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_bd_prog(&lfs, rbyd.blocks[0], 0, backup_block, rbyd.eoff, + NULL, NULL) => 0; + lfsr_bd_flush(&lfs, NULL) => 0; // replace with bitwise inverse