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