From 35434f8b5437384a473ba6e5416c43dc5b15a36a Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Tue, 24 Oct 2023 22:26:08 -0500 Subject: [PATCH] Removed remnants of slice code, and cleaned things up a bit --- lfs.c | 1451 +---------------------------------------- scripts/dbgbtree.py | 2 - scripts/dbglfs.py | 58 +- scripts/dbgmtree.py | 2 - scripts/dbgrbyd.py | 2 - tests/test_btree.toml | 446 ++++++------- 6 files changed, 251 insertions(+), 1710 deletions(-) diff --git a/lfs.c b/lfs.c index 5198cb45..989850ef 100644 --- a/lfs.c +++ b/lfs.c @@ -609,7 +609,6 @@ enum lfsr_tag_type { LFSR_TAG_STRUCT = 0x0300, LFSR_TAG_DATA = 0x0300, - LFSR_TAG_SLICE = 0x0304, LFSR_TAG_TRUNK = 0x0308, LFSR_TAG_DID = 0x030c, LFSR_TAG_BLOCK = 0x0310, @@ -2062,56 +2061,6 @@ static int lfsr_data_readtrunk(lfs_t *lfs, lfsr_data_t *data, } -// data slices on-disk encoding - -// 2 leb128s => 10 bytes (worst case) -#define LFSR_SLICE_DSIZE (5+5) - -#define LFSR_DATA_FROMSLICE(_slice, _buffer) \ - lfsr_data_fromslice(_slice, _buffer) - -static lfsr_data_t lfsr_data_fromslice(const lfsr_data_t *slice, - uint8_t buffer[static LFSR_SLICE_DSIZE]) { - LFS_ASSERT(lfsr_data_ondisk(slice)); - lfs_ssize_t d = 0; - - // write the offset and size - lfs_ssize_t d_ = lfs_toleb128(lfsr_data_size(slice), &buffer[d], 5); - LFS_ASSERT(d_ >= 0); - d += d_; - - d_ = lfs_toleb128(slice->u.disk.off, &buffer[d], 5); - LFS_ASSERT(d_ >= 0); - d += d_; - - return LFSR_DATA_BUF(buffer, d); -} - -static int lfsr_data_readslice(lfs_t *lfs, lfsr_data_t *data, - lfsr_data_t *slice) { - // bit of a hack here, but we can assume the slice is on the same - // block as our data - LFS_ASSERT(lfsr_data_ondisk(data)); - lfs_block_t block = data->u.disk.block; - - // read the block, offset, and size - lfs_size_t size; - int err = lfsr_data_readleb128(lfs, data, (int32_t*)&size); - if (err) { - return err; - } - - lfs_size_t off; - err = lfsr_data_readleb128(lfs, data, (int32_t*)&off); - if (err) { - return err; - } - - *slice = LFSR_DATA_DISK(block, off, size); - return 0; -} - - // block pointer on-disk encoding // 3 leb128s => 15 bytes (worst case) @@ -3460,28 +3409,11 @@ static int lfsr_rbyd_appendcompactrbyd(lfs_t *lfs, lfsr_rbyd_t *rbyd_, break; } - // special handling for slice tags, we dereference these - if (lfsr_tag_key(tag) == LFSR_TAG_SLICE) { - lfsr_data_t slice; - err = lfsr_data_readslice(lfs, &data, &slice); - if (err) { - return err; - } - - err = lfsr_rbyd_appendcompactattr(lfs, rbyd_, - lfsr_tag_mode(tag) | LFSR_TAG_DATA, weight, slice); - if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); - return err; - } - // write the tag - } else { - err = lfsr_rbyd_appendcompactattr(lfs, rbyd_, tag, weight, data); - if (err) { - LFS_ASSERT(err != LFS_ERR_RANGE); - return err; - } + err = lfsr_rbyd_appendcompactattr(lfs, rbyd_, tag, weight, data); + if (err) { + LFS_ASSERT(err != LFS_ERR_RANGE); + return err; } } @@ -3680,20 +3612,8 @@ static lfs_ssize_t lfsr_rbyd_estimate_(lfs_t *lfs, const lfsr_rbyd_t *rbyd, rid = rid__; weight += weight_; - // special handling for slice tags, we dereference these - if (lfsr_tag_key(tag) == LFSR_TAG_SLICE) { - lfsr_data_t slice; - err = lfsr_data_readslice(lfs, &data, &slice); - if (err) { - return err; - } - - dsize += LFSR_ATTR_ESTIMATE + lfsr_data_size(&slice); - // include the cost of this tag - } else { - dsize += LFSR_ATTR_ESTIMATE + lfsr_data_size(&data); - } + dsize += LFSR_ATTR_ESTIMATE + lfsr_data_size(&data); } if (rid_) { @@ -5908,22 +5828,12 @@ static lfs_ssize_t lfsr_mdir_estimate_(lfs_t *lfs, const lfsr_mdir_t *mdir, break; } - // special handling for slice tags, we dereference these - if (lfsr_tag_key(tag) == LFSR_TAG_SLICE) { - lfsr_data_t slice; - err = lfsr_data_readslice(lfs, &data, &slice); - if (err) { - return err; - } - - dsize += LFSR_ATTR_ESTIMATE + lfsr_data_size(&slice); - // special handling for shrub trunks, we need to include the compacted // cost of the shrub in our estimate // // this is what would make lfsr_rbyd_estimate recursive, and why we // need a second function... - } else if (tag == LFSR_TAG_TRUNK) { + if (tag == LFSR_TAG_TRUNK) { lfsr_rbyd_t shrub; err = lfsr_data_readtrunk(lfs, &data, &shrub); if (err) { @@ -8610,9 +8520,8 @@ static int lfsr_mdir_stat(lfs_t *lfs, lfsr_mdir_t *mdir, lfsr_mid_t mid, if (err != LFS_ERR_NOENT && tag == LFSR_TAG_DATA) { info->size = lfsr_data_size(&data); - // or a slice/shrub, size is always first field here - } else if (err != LFS_ERR_NOENT && ( - tag == LFSR_TAG_SLICE || tag == LFSR_TAG_TRUNK)) { + // or a shrub, size is always first field here + } else if (err != LFS_ERR_NOENT && tag == LFSR_TAG_TRUNK) { err = lfsr_data_readleb128(lfs, &data, (int32_t*)&info->size); if (err) { return err; @@ -9023,13 +8932,6 @@ int lfsr_file_opencfg(lfs_t *lfs, lfsr_file_t *file, file->shrub.u.data = data; file->size = lfsr_data_size(&file->shrub.u.data); - // or a slice (indirect inlined data) - } else if (err != LFS_ERR_NOENT && tag == LFSR_TAG_SLICE) { - err = lfsr_data_readslice(lfs, &data, &file->shrub.u.data); - if (err) { - return err; - } - // or a shrub (inlined tree) } else if (err != LFS_ERR_NOENT && tag == LFSR_TAG_TRUNK) { err = lfsr_data_readtrunk(lfs, &data, @@ -9129,72 +9031,6 @@ int lfsr_file_close(lfs_t *lfs, lfsr_file_t *file) { return err; } -// convert tagged data into a direct reference to the underlying data -static int lfsr_data_deref(lfs_t *lfs, lfsr_tag_t tag, lfsr_data_t data, - lfsr_data_t *slice_, lfsr_bptr_t *bptr_) { - LFS_ASSERT(lfsr_data_ondisk(&data)); - - // data? do nothing, data is data - if (lfsr_tag_key(tag) == LFSR_TAG_DATA) { - if (slice_) { - *slice_ = data; - } - - // follow slices - } else if (lfsr_tag_key(tag) == LFSR_TAG_SLICE) { - lfsr_data_t slice; - int err = lfsr_data_readslice(lfs, &data, &slice); - if (err) { - return err; - } - - if (slice_) { - *slice_ = slice; - } - - // follow block pointers - } else if (lfsr_tag_key(tag) == LFSR_TAG_BLOCK) { - lfsr_bptr_t bptr; - int err = lfsr_data_readbptr(lfs, &data, &bptr); - if (err) { - return err; - } - - // TODO should bptr just contain a data field? - // TODO should lfsr_data_deref eventually just return a bptr? - if (slice_) { - *slice_ = LFSR_DATA_DISK( - bptr.block, - bptr.off, - bptr.size); - } - if (bptr_) { - *bptr_ = bptr; - } - } - - return 0; -} - -static int lfsr_data_derefsize(lfs_t *lfs, lfsr_tag_t tag, lfsr_data_t data, - lfs_off_t *size_) { - LFS_ASSERT(lfsr_data_ondisk(&data)); - - // data is our one special case, where size is implicit - if (lfsr_tag_key(tag) == LFSR_TAG_DATA) { - *size_ = lfsr_data_size(&data); - return 0; - - // all other data types are prefixed with a size field - } else { - int err = lfsr_data_readleb128(lfs, &data, (int32_t*)size_); - if (err) { - return err; - } - return 0; - } -} - // common iterator over data elements in a rbyd/btree static int lfsr_tree_readnext(lfs_t *lfs, const lfsr_tree_t *tree, lfs_off_t pos, lfs_off_t size, @@ -9213,13 +9049,20 @@ static int lfsr_tree_readnext(lfs_t *lfs, const lfsr_tree_t *tree, return err; } LFS_ASSERT(lfsr_tag_key(tag) == LFSR_TAG_DATA - || lfsr_tag_key(tag) == LFSR_TAG_SLICE || lfsr_tag_key(tag) == LFSR_TAG_BLOCK); - // follow any indirect slices/block pointers - err = lfsr_data_deref(lfs, tag, data, &data, NULL); - if (err) { - return err; + // decode bptrs + if (tag == LFSR_TAG_BLOCK) { + lfsr_bptr_t bptr; + err = lfsr_data_readbptr(lfs, &data, &bptr); + if (err) { + return err; + } + + data = LFSR_DATA_DISK( + bptr.block, + bptr.off, + bptr.size); } LFS_ASSERT(lfsr_data_size(&data) <= weight); @@ -9453,302 +9296,6 @@ lfs_ssize_t lfsr_file_read(lfs_t *lfs, lfsr_file_t *file, return read; } -// we build a variable -- but bounded -- number of attributes when we carve -#define LFSR_CARVE_ATTRS 4 - -#define LFSR_CARVE_DSIZE ( \ - 2*((LFSR_SLICE_DSIZE > LFSR_BPTR_DSIZE) \ - ? LFSR_SLICE_DSIZE \ - : LFSR_BPTR_DSIZE)) - -//static lfs_ssize_t lfsr_tree_buildcarve(lfs_t *lfs, const lfsr_tree_t *tree, -// lfs_off_t pos, lfs_off_t weight, lfs_soff_t delta, -// lfsr_tag_t tag, lfsr_data_t data, -// lfs_soff_t *estimate_, -// lfsr_attr_t attrs[static LFSR_CARVE_ATTRS], -// uint8_t buffer[static LFSR_CARVE_DSIZE]) { -// // TODO need size? -// // we should never try to shove more data than can fit in a given weight -// LFS_ASSERT(lfsr_data_size(&data) <= weight + delta); -// -// // allocate attrs/buffer as necessary -// lfs_size_t attr_count = 0; -// lfs_size_t buffer_off = 0; -// -// // keeep track of removed data, we combined this into a single attr, -// // and keep track of how our changes will affect our size estimate -// lfs_off_t rm = 0; -// lfs_soff_t estimate = 0; -// -// // try to carve any existing data -// lfs_off_t pos_ = pos; -// while (pos_ < lfs_min32(pos+weight, lfsr_tree_size(tree))) { -// lfsr_bid_t bid_; -// lfsr_tag_t tag_; -// lfsr_bid_t weight_; -// lfsr_data_t data_; -// // the tree may be aliased to either a sprout or block pointer if -// // we're creating a new btree, assume sprout if we're a shrub, -// // otherwise a block pointer -// if (!lfsr_tree_hasbtree(tree) && lfsr_tag_isshrub(tag)) { -// const lfsr_data_t *slice = (const lfsr_data_t*)tree; -// bid_ = lfsr_data_size(slice)-1; -// tag_ = tag; -// weight_ = lfsr_data_size(slice); -// data_ = *slice; -// } else if (!lfsr_tree_hasbtree(tree)) { -// // TODO -// LFS_ASSERT(false); -// } else { -// int err = lfsr_btree_lookupnext(lfs, &tree->u.btree, pos_, -// &bid_, &tag_, &weight_, &data_); -// if (err) { -// LFS_ASSERT(err != LFS_ERR_NOENT); -// return err; -// } -// } -// LFS_ASSERT(lfsr_tag_key(tag_) == LFSR_TAG_DATA -// || lfsr_tag_key(tag_) == LFSR_TAG_SLICE -// || lfsr_tag_key(tag_) == LFSR_TAG_BLOCK); -// -// // go ahead and dereference to get to the actual data -// lfsr_data_t slice_; -// lfsr_bptr_t bptr_; -// int err = lfsr_data_deref(lfs, tag_, data_, &slice_, &bptr_); -// if (err) { -// return err; -// } -// LFS_ASSERT(lfsr_data_size(&slice_) <= weight_); -// -//// // get the physical data size -//// lfs_size_t size_; -//// err = lfsr_data_derefsize(lfs, tag_, data_, &size_); -//// if (err) { -//// return err; -//// } -//// LFS_ASSERT(size_ <= weight_); -// -// // note an entry can be both a left and right sibling! -// -// // found left sibling? -// if (pos > bid_-(weight_-1)) { -// lfs_off_t overlap_ = (bid_+1) - pos; -// LFS_ASSERT((lfs_soff_t)overlap_ >= 0); -// -// // carve in-rbyd data? -// if (lfsr_tag_key(tag_) == LFSR_TAG_DATA -// || lfsr_tag_key(tag_) == LFSR_TAG_SLICE) { -// lfsr_data_t slice__ = LFSR_DATA_DISK( -// slice_.u.disk.block, -// slice_.u.disk.off, -// lfs_min32( -// weight_ - overlap_, -// lfsr_data_size(&slice_))); -// -// // some special cases require a new tag: if we're creating a -// // new btree -// if (!lfsr_tree_hasbtree(tree)) { -// attrs[attr_count++] = LFSR_ATTR(0, -// TAG(lfsr_tag_mode(tag) -// | LFSR_TAG_SLICE), +(weight_ - overlap_), -// FROMSLICE(&slice__, &buffer[buffer_off])); -// buffer += LFSR_SLICE_DSIZE; -// -// // update our estimate -// estimate += lfsr_data_size(&slice__); -// -// } else { -// attrs[attr_count++] = LFSR_ATTR(bid_, -// TAG(lfsr_tag_mode(tag) -// | LFSR_TAG_GROW(WIDE(SLICE))), -overlap_, -// FROMSLICE(&slice__, &buffer[buffer_off])); -// buffer += LFSR_SLICE_DSIZE; -// -// // update our estimate -// estimate -= (lfsr_data_size(&slice_) -// - lfsr_data_size(&slice__)); -// // we may remove a hole here -// if (lfsr_data_size(&slice_) < weight_ -// && lfsr_data_size(&slice__) == weight_ - overlap_) { -// estimate -= LFSR_ATTR_ESTIMATE; -// } -// } -// -// // carve block pointer? -// } else if (lfsr_tag_key(tag_) == LFSR_TAG_BLOCK) { -// // TODO -// LFS_ASSERT(false); -//// lfsr_bptr_t bptr_; -//// int err = lfsr_data_readbptr(lfs, &data_, &bptr_); -//// if (err) { -//// return err; -//// } -//// LFS_ASSERT(bptr_.size <= weight_); -//// -//// // are we carving the block too small? -//// if (bptr_.size <= lfs->cfg->crystallize_size) { -//// attrs[attr_count++] = LFSR_ATTR(bid_, -//// GROW(), -overlap_, DATA( -//// data_.u.disk.block, -//// data_.u.disk.off, -//// weight_ - overlap_})); -//// } else { -//// attrs[attr_count++] = LFSR_ATTR(bid_, -//// GROW(), -overlap_, FROMBPTR( -//// (&(lfsr_bptr_t){ -//// .block=data_.u.disk.block, -//// .off=data_.u.disk.off, -//// .size=weight_ - overlap_}), -//// &buffer[buffer_off])); -//// buffer += LFSR_BPTR_DSIZE; -//// } -// } -// -// // TODO wait is this the same on all branches? -// pos_ = bid_+1; -// } -// -// // found right sibling? -// if (pos + weight < bid_+1) { -// lfs_off_t overlap_ = (pos + weight) - (bid_-(weight_-1)); -// LFS_ASSERT((lfs_soff_t)overlap_ >= 0); -// -// // carve in-rbyd data? -// if (lfsr_tag_key(tag_) == LFSR_TAG_DATA -// || lfsr_tag_key(tag_) == LFSR_TAG_SLICE) { -// lfsr_data_t slice__ = LFSR_DATA_DISK( -// slice_.u.disk.block, -// slice_.u.disk.off + lfs_min32( -// overlap_, -// lfsr_data_size(&slice_)), -// lfsr_data_size(&slice_) - lfs_min32( -// overlap_, -// lfsr_data_size(&slice_))); -// -// // some special cases require a new tag: if we're creating a -// // new btree, or if left/right siblings are the same -// if (!lfsr_tree_hasbtree(tree) || overlap_ > weight) { -// attrs[attr_count++] = LFSR_ATTR(pos, -// TAG(lfsr_tag_mode(tag) -// | LFSR_TAG_SLICE), +(weight_ - overlap_), -// FROMSLICE(&slice__, &buffer[buffer_off])); -// buffer += LFSR_SLICE_DSIZE; -// -// // update our estimate -// estimate += lfsr_data_size(&slice__); -// // if we split, we may actually create a hole -// if (lfsr_data_size(&slice__) < weight_ - overlap_) { -// estimate += LFSR_ATTR_ESTIMATE; -// } -// -// } else { -// // we need to account for changes to left sibling here -// attrs[attr_count++] = LFSR_ATTR(pos+rm+weight_-1, -// TAG(lfsr_tag_mode(tag) -// | LFSR_TAG_GROW(WIDE(SLICE))), -overlap_, -// FROMSLICE(&slice__, &buffer[buffer_off])); -// buffer += LFSR_SLICE_DSIZE; -// -// // update our estimate -// estimate -= (lfsr_data_size(&slice_) -// - lfsr_data_size(&slice__)); -// } -// -// // carve block pointer? -// } else if (lfsr_tag_key(tag_) == LFSR_TAG_BLOCK) { -// // TODO -// // TODO note this needs to handle both siblings being -// // larger than crystallize size (force one to crystallize) -// LFS_ASSERT(false); -// } -// -// pos_ = bid_+1; -// } -// -// // found fully overwritten data? -// if (pos <= bid_-(weight_-1) && pos + weight >= bid_+1) { -// // combine all rms into a single attr -// rm += weight_; -// -// // update estimate -// estimate -= lfsr_data_size(&slice_); -// // include any removed holes -// if (lfsr_data_size(&slice_) < weight_) { -// estimate -= LFSR_ATTR_ESTIMATE; -// } -// -// pos_ = bid_+1; -// } -// } -// -// // write the combined rm attribute -// if (rm > 0) { -// attrs[attr_count++] = LFSR_ATTR(pos+rm-1, -// TAG(lfsr_tag_mode(tag) -// | LFSR_TAG_RM), -rm, -// NULL); -// } -// -// // TODO make sure data-less holes get coalesced, though not we don't -// // accurately track coalesced holes with our estimate because it simplifies -// // things... document? -// -// // there's a few cases we need to append an extra tag: we're appended data -// // past the end of our btree and need a hole, or we're creating a new -// // btree and didn't carve the existing data -// if (!lfsr_tree_hasbtree(tree) -// && lfsr_tree_size(tree) > 0 -// && (pos >= lfsr_tree_size(tree) -// || pos + weight == 0)) { -// // note we never grow and rm a btree at the same time -// LFS_ASSERT(rm == 0); -// -// attrs[attr_count++] = LFSR_ATTR(0, -// TAG(lfsr_tag_mode(tag) -// | LFSR_TAG_DATA), +lfs_max32(pos, lfsr_tree_size(tree)), -// DATA(*(const lfsr_data_t*)tree)); -// -// // update our estimate -// estimate += lfsr_data_size((const lfsr_data_t*)tree); -// // we may be making a hole here -// if (pos > lfsr_tree_size(tree)) { -// estimate += LFSR_ATTR_ESTIMATE; -// } -// -// // need a hole? -// } else if (pos > lfsr_tree_size(tree)) { -// // note we never grow and rm a btree at the same time -// LFS_ASSERT(rm == 0); -// -// attrs[attr_count++] = LFSR_ATTR(lfsr_tree_size(tree), -// TAG(lfsr_tag_mode(tag) -// | LFSR_TAG_DATA), +(pos - lfsr_tree_size(tree)), -// NULL); -// -// // turns out making a hole, makes a hole -// estimate += LFSR_ATTR_ESTIMATE; -// } -// -// // finally append our data -// if (weight + delta > 0) { -// attrs[attr_count++] = LFSR_ATTR(pos, -// TAG(tag), +(weight + delta), DATA(data)); -// -// // update our estimate -// estimate += lfsr_data_size(&data); -// // include the overhead of any new holes -// if (lfsr_data_size(&data) < weight + delta) { -// estimate += LFSR_ATTR_ESTIMATE; -// } -// } -// -// LFS_ASSERT(attr_count <= LFSR_CARVE_ATTRS); -// LFS_ASSERT(buffer_off <= LFSR_CARVE_DSIZE); -// if (estimate_) { -// *estimate_ = estimate; -// } -// return attr_count; -//} // needed by lfsr_file_flushbuffer static int lfsr_file_flushshrub(lfs_t *lfs, lfsr_file_t *file); @@ -10196,6 +9743,7 @@ static int lfsr_file_carvetree(lfs_t *lfs, lfsr_file_t *file, bptr_.off, bptr_.size); } + LFS_ASSERT(lfsr_data_size(&data_) <= weight_); // note an entry can be both a left and right sibling! @@ -10741,6 +10289,7 @@ static int lfsr_file_flushshrub(lfs_t *lfs, lfsr_file_t *file) { bptr_.off, bptr_.size); } + LFS_ASSERT(lfsr_data_size(&data_) <= weight_); } // can we coalesce? @@ -10828,6 +10377,7 @@ static int lfsr_file_flushshrub(lfs_t *lfs, lfsr_file_t *file) { bptr_.off, bptr_.size); } + LFS_ASSERT(lfsr_data_size(&data_) <= weight_); } // can we coalesce? @@ -10874,961 +10424,6 @@ static int lfsr_file_flushshrub(lfs_t *lfs, lfsr_file_t *file) { return 0; } -//// TODO deduplicate carveshrub and flushshrub -//// TODO buildcarveshrub? -//static int lfsr_file_carveshrub(lfs_t *lfs, lfsr_file_t *file, -// lfs_off_t pos, lfs_off_t weight, lfs_soff_t delta, -// lfsr_data_t data) { -// // we should never try to shove more data into less weight -// LFS_ASSERT(lfsr_data_size(&data) <= weight); -// -// // build up attributes that flush our buffer, at this point -// // this has basically turned into a tiny compiler -// lfsr_attr_t scratch_attrs[4]; -// lfsr_attr_t *attrs_ = scratch_attrs; -// lfsr_data_t scratch_datas[4]; -// lfsr_data_t *datas_ = scratch_datas; -// *datas_++ = data; -// -// // TODO does this need to be cleaned up? -// uint8_t scratch_buf[LFSR_SLICE_DSIZE]; -// uint8_t scratch_buf_[LFSR_SLICE_DSIZE]; -// -// // TODO what happens if another driver wrote a zero-weight shrub? need -// // to test this... -// -// // keep track of how our changes affect our estimate -// lfs_off_t estimate; -// -// // and any overlap that we need to adjust for when we remove data -// lfs_soff_t left_overlap; -// lfs_soff_t right_overlap; -// -// // TODO is there a better way to do this? -// -// // to handle sprout->shrub transitions, we set estimate to zero and -// // pretend we've overlapped the entire data -// if (!lfsr_shrub_hasshrub(&file->shrub)) { -// estimate = 0; -// left_overlap = lfsr_shrub_size(&file->shrub); -// right_overlap = lfsr_shrub_size(&file->shrub); -// } else { -// estimate = file->shrub.u.shrub.estimate; -// left_overlap = 0; -// right_overlap = 0; -// } -// -// // has left sibling? -// if (pos > 0) { -// lfsr_srid_t left_rid; -// lfsr_rid_t left_weight; -// lfsr_data_t left_data; -// if (!lfsr_shrub_hasshrub(&file->shrub)) { -// left_rid = lfsr_data_size(&file->shrub.u.data)-1; -// left_weight = lfsr_data_size(&file->shrub.u.data); -// left_data = file->shrub.u.data; -// } else { -// lfsr_tag_t left_tag; -// int err = lfsr_rbyd_lookupnext(lfs, &file->shrub.u.rbyd, -// lfs_min32( -// pos, -// file->shrub.u.rbyd.weight)-1, 0, -// &left_rid, &left_tag, &left_weight, &left_data); -// if (err) { -// LFS_ASSERT(err != LFS_ERR_NOENT); -// return err; -// } -// LFS_ASSERT(left_tag == LFSR_TAG_SHRUB(DATA)); -// LFS_ASSERT(lfsr_data_size(&left_data) <= left_weight); -// } -// -// // note this can be negative! -// left_overlap = (left_rid+1) - pos; -// LFS_ASSERT(left_overlap >= 0 -// || lfsr_shrub_size(&file->shrub) < pos); -// -// // can we coalesce left data? -// if (left_rid-(left_weight-1) + lfsr_data_size(&left_data) -// >= pos -// && pos+weight+delta - (left_rid-(left_weight-1)) -// <= lfs->cfg->coalesce_size) { -// scratch_datas[0] = LFSR_DATA_DISK( -// left_data.u.disk.block, -// left_data.u.disk.off, -// left_weight - left_overlap); -// scratch_datas[1] = data; -// datas_ = &scratch_datas[2]; -// data = lfsr_data_fromcat(&scratch_datas[0], 2); -// weight += left_weight - left_overlap; -// pos = left_rid-(left_weight-1); -// // only zero overlap if we're not transitioning from a sprout -// if (lfsr_shrub_hasshrub(&file->shrub)) { -// left_overlap = 0; -// } -// -// // need to append left data? this can happend if we're -// // transitioning from a sprout to a shrub -// } else if (!lfsr_shrub_hasshrub(&file->shrub)) { -// *attrs_++ = LFSR_ATTR(left_rid-(left_weight-1), -// SHRUB(DATA), +left_weight - left_overlap, DISK( -// left_data.u.disk.block, -// left_data.u.disk.off, -// left_weight - lfs_smax32(left_overlap, 0))); -// -// estimate += LFSR_ATTR_ESTIMATE -// + (left_weight - lfs_smax32(left_overlap, 0)); -// -// // need to carve out left data? -// } else if (left_rid-(left_weight-1) + lfsr_data_size(&left_data) -// > pos) { -// *attrs_++ = LFSR_ATTR(left_rid, -// SHRUB(GROW(SLICE)), -left_overlap, -// FROMSLICE(&LFSR_DATA_DISK( -// left_data.u.disk.block, -// left_data.u.disk.off, -// left_weight - left_overlap), -// scratch_buf)); -// -// estimate -= left_rid-(left_weight-1) -// + lfsr_data_size(&left_data) -// - pos; -// -// // adjust left sibling with a grow attr, avoiding a data copy -// } else if (left_overlap != 0) { -// *attrs_++ = LFSR_ATTR(left_rid, -// SHRUB(GROW), -left_overlap, NULL); -// } -// } -// -// // has right sibling? -// if (pos + weight < lfsr_shrub_size(&file->shrub)) { -// lfsr_srid_t right_rid; -// lfsr_rid_t right_weight; -// lfsr_data_t right_data; -// if (!lfsr_shrub_hasshrub(&file->shrub)) { -// right_rid = lfsr_data_size(&file->shrub.u.data)-1; -// right_weight = lfsr_data_size(&file->shrub.u.data); -// right_data = file->shrub.u.data; -// } else { -// lfsr_tag_t right_tag; -// int err = lfsr_rbyd_lookupnext(lfs, &file->shrub.u.rbyd, -// pos + weight, 0, -// &right_rid, &right_tag, &right_weight, &right_data); -// if (err) { -// LFS_ASSERT(err != LFS_ERR_NOENT); -// return err; -// } -// LFS_ASSERT(right_tag == LFSR_TAG_SHRUB(DATA)); -// LFS_ASSERT(lfsr_data_size(&right_data) <= right_weight); -// } -// -// right_overlap = (pos + weight) - (right_rid-(right_weight-1)); -// LFS_ASSERT(right_overlap >= 0); -// -// // can we coalesce right data? -// if ((lfsr_data_size(&data) == weight + delta -// && (lfs_soff_t)(lfsr_data_size(&data) -// + lfsr_data_size(&right_data) -// - right_overlap) -// <= (lfs_soff_t)lfs->cfg->coalesce_size) -// || lfsr_data_size(&right_data) - right_overlap == 0) { -// *datas_++ = LFSR_DATA_DISK( -// right_data.u.disk.block, -// right_data.u.disk.off + right_overlap, -// lfsr_data_size(&right_data) - lfs_min32( -// right_overlap, -// lfsr_data_size(&right_data))); -// data = lfsr_data_fromcat( -// scratch_datas, -// datas_ - scratch_datas); -// weight += right_weight - right_overlap; -// // only zero overlap if we're not transitioning from a sprout -// if (lfsr_shrub_hasshrub(&file->shrub)) { -// right_overlap = 0; -// } -// -// // need to append right data? this can happen if we're -// // transitioning from sprout to shrub, or left and right sibling -// // are the same -// } else if (!lfsr_shrub_hasshrub(&file->shrub) -// || right_overlap > (lfs_soff_t)weight) { -// *attrs_++ = LFSR_ATTR(right_rid - left_overlap + 1, -// SHRUB(DATA), +right_weight - right_overlap, -// DISK( -// right_data.u.disk.block, -// right_data.u.disk.off + right_overlap, -// lfsr_data_size(&right_data) - lfs_min32( -// right_overlap, -// lfsr_data_size(&right_data)))); -// -// estimate += LFSR_ATTR_ESTIMATE -// + lfsr_data_size(&right_data) - lfs_min32( -// right_overlap, -// lfsr_data_size(&right_data)); -// -// // need to carve out right data? -// } else if (right_overlap > 0) { -// *attrs_++ = LFSR_ATTR(right_rid - left_overlap, -// SHRUB(GROW(SLICE)), -right_overlap, -// FROMSLICE(&LFSR_DATA_DISK( -// right_data.u.disk.block, -// right_data.u.disk.off + right_overlap, -// lfsr_data_size(&right_data) - lfs_min32( -// right_overlap, -// lfsr_data_size(&right_data))), -// scratch_buf_)); -// -// estimate -= right_overlap; -// } -// } -// -// // remove any data we're overwriting, accounting for sibling changes -// lfs_soff_t rm = lfs_smin32( -// weight, -// lfsr_shrub_size(&file->shrub) - pos) -// - left_overlap -// - right_overlap; -// if (rm > 0) { -// // we shouldn't remove anything if we're transitioning from a sprout -// LFS_ASSERT(lfsr_shrub_hasshrub(&file->shrub)); -// -// // range remove any remaining attrs -// *attrs_++ = LFSR_ATTR(pos+rm-1, SHRUB(RM), -rm, NULL); -// -// // updating our estimate gets a bit tricky here -// lfs_ssize_t rm_estimate = lfsr_rbyd_estimate(lfs, -// &file->shrub.u.rbyd, -// pos + left_overlap, -// pos + left_overlap + rm, -// NULL); -// if (rm_estimate < 0) { -// return rm_estimate; -// } -// estimate -= rm_estimate; -// } -// -// // append our buffer -// if (weight + delta > 0) { -// *attrs_++ = LFSR_ATTR(pos, -// SHRUB(DATA), +weight + delta, DATA(data)); -// -// estimate += LFSR_ATTR_ESTIMATE -// + lfsr_data_size(&data); -// } -// -// // TODO can this happen? should we even have special handling here? -// // this is a noop? -// if (attrs_ == scratch_attrs) { -// return 0; -// } -// -// // TODO -// // we can't let our inline shrub overflow our inline size, so if our -// // estimate overflows, we need to flush inlined data -// LFS_ASSERT((lfs_soff_t)estimate >= 0); -// // TODO can truncate/fruncate trigger this? say fruncate creates a hole, -// // should carveshrub just call flushshrub if we overflow? -// if (estimate > lfs->cfg->inline_size) { -// return LFS_ERR_RANGE; -// } -// -// // commit our attributes -// // TODO can we ever end up with no attrs here? -// int err = lfsr_mdir_commit(lfs, &file->m.mdir, LFSR_ATTRS( -// LFSR_ATTR_(file->m.mdir.mid, SHRUBATTRS, 0, SHRUBATTRS(file, -// scratch_attrs, -// attrs_ - scratch_attrs)))); -// if (err) { -// return err; -// } -// -// // update estimate -// file->shrub.u.shrub.estimate = estimate; -// return 0; -//} - -//static int lfsr_file_carvetree(lfs_t *lfs, lfsr_file_t *file, -// lfs_off_t pos, lfs_off_t weight, lfs_soff_t delta, -// lfsr_tag_t tag, lfsr_data_t data) { -// // this is similar to lfsr_file_carveshrub, except instead of building -// // an attribute list, we modify the btree directly in a copy-on-write -// // fashion -// // -// // in theory range-deletions could make this faster, but that would -// // require btree range-deletions to be implemented -// -// // TODO actually, should lfsr_file_carveshrub be structured more like -// // this one? with a single loop and no rm estimate call? -// -// // scratch datas to track any coalescing data -// lfsr_data_t scratch_datas[4]; -// lfsr_data_t *datas_ = scratch_datas; -// *datas_++ = data; -// -// // TODO support direct blocks here -// LFS_ASSERT(lfsr_tree_hasbtree(&file->tree)); -// -// // first coalesce/carve/remove any existing data -// // -// // note we start/end +1 to see if we can coalesce any siblings -// // -// lfs_off_t pos_ = lfs_smax32( -// lfs_min32(pos, lfsr_btree_weight(&file->tree.u.btree)) - 1, -// 0); -// lfs_off_t rm = 0; -// while (pos_+rm < pos+weight+1 -// && pos_ < lfsr_btree_weight(&file->tree.u.btree)) { -// lfsr_bid_t bid_; -// lfsr_tag_t tag_; -// lfsr_bid_t weight_; -// lfsr_data_t data_; -// int err = lfsr_btree_lookupnext(lfs, &file->tree.u.btree, pos_, -// &bid_, &tag_, &weight_, &data_); -// if (err) { -// LFS_ASSERT(err != LFS_ERR_NOENT); -// return err; -// } -// LFS_ASSERT(tag == LFSR_TAG_DATA -// || tag == LFSR_TAG_BLOCK); -// -// // found left sibling? -// if (pos > bid_-(weight_-1)) { -// // note! this may go negative -// lfs_soff_t overlap_ = (bid_+1) - pos; -// LFS_ASSERT(overlap_ >= 0 -// || pos > lfsr_btree_weight(&file->tree.u.btree)); -// -// if (tag_ == LFSR_TAG_DATA) { -// LFS_ASSERT(lfsr_data_size(&data_) <= weight_); -// -// // can we coalesce left data? this is only possible if our -// // new data is not a block and there is no hole on the left -// if (tag == LFSR_TAG_DATA -// && pos <= bid_-(weight_-1)+lfsr_data_size(&data_) -// && lfsr_data_size(&data) + (weight_ - overlap_) -// <= lfs->cfg->crystallize_size) { -// // note! this is a reference to cow data! this may need -// // special care for non-pure-cow allocators -// scratch_datas[0] = LFSR_DATA_DISK( -// data_.u.disk.block, -// data_.u.disk.off, -// weight_ - overlap_); -// scratch_datas[1] = data; -// datas_ = &scratch_datas[2]; -// data = lfsr_data_fromcat(&scratch_datas[0], 2); -// pos = bid_-(weight_-1); -// weight += weight_ - overlap_; -// -// // removing data we're referencing? this gets pretty -// // cursed... -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, RM, -weight_, NULL))); -// if (err) { -// return err; -// } -// -// // can we get away with a grow attribute? -// } else if (pos >= bid_-(weight_-1)+lfsr_data_size(&data_)) { -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, GROW, -overlap_, NULL))); -// if (err) { -// return err; -// } -// -// // need to carve left data -// } else { -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, -// GROW(DATA), -overlap_, -// DISK( -// data_.u.disk.block, -// data_.u.disk.off, -// weight_ - overlap_)))); -// if (err) { -// return err; -// } -// } -// -// // did we split data? -// if (overlap_ > (lfs_soff_t)weight) { -// // did we split actual data? -// if (pos+weight < bid_-(weight_-1)+lfsr_data_size(&data_)) { -// // we MUST coalesce here, otherwise we risk dagging -// LFS_ASSERT(tag == LFSR_TAG_DATA); -// LFS_ASSERT(lfsr_data_size(&data_) -// <= lfs->cfg->crystallize_size); -// LFS_ASSERT(datas_ - scratch_datas == 2); -// -// // note! this is a reference to cow data! this may need -// // special care for non-pure-cow allocators -// *datas_++ = LFSR_DATA_DISK( -// data_.u.disk.block, -// data_.u.disk.off -// + (weight_ - overlap_) + weight, -// lfsr_data_size(&data_) - lfs_min32( -// (weight_ - overlap_) + weight, -// lfsr_data_size(&data_))); -// data = lfsr_data_fromcat( -// scratch_datas, -// datas_ - scratch_datas); -// weight += weight_ - overlap_; -// -// // otherwise we just add our hole to our weight -// } else { -// weight += overlap_ - weight; -// } -// } -// -// } else if (tag_ == LFSR_TAG_BLOCK) { -// lfsr_bptr_t bptr_; -// err = lfsr_data_readbptr(lfs, &data_, &bptr_); -// if (err) { -// return err; -// } -// LFS_ASSERT(bptr_.size <= weight_); -// -// // can we coalesce left data? this is only possible if our -// // new data is not a block and there is no hole on the left -// if (tag == LFSR_TAG_DATA -// && pos <= bid_-(weight_-1)+bptr_.size -// && lfsr_data_size(&data) + (weight_ - overlap_) -// <= lfs->cfg->crystallize_size) { -// // note! this is a reference to cow data! this may need -// // special care for non-pure-cow allocators -// scratch_datas[0] = LFSR_DATA_DISK( -// bptr_.block, -// bptr_.off, -// weight_ - overlap_); -// scratch_datas[1] = data; -// datas_ = &scratch_datas[2]; -// data = lfsr_data_fromcat(&scratch_datas[0], 2); -// pos = bid_-(weight_-1); -// weight += weight_ - overlap_; -// -// // removing data we're referencing? this gets pretty -// // cursed... -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, RM, -weight_, NULL))); -// if (err) { -// return err; -// } -// -// // can we get away with a grow attribute? -// } else if (pos >= bid_-(weight_-1)+bptr_.size) { -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, GROW, -overlap_, NULL))); -// if (err) { -// return err; -// } -// -// // need to carve left data -// } else { -// bptr_.size = weight_ - overlap_; -// -// uint8_t bptr_buf[LFSR_BPTR_DSIZE]; -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, -// GROW(BLOCK), -overlap_, -// FROMBPTR(&bptr_, bptr_buf)))); -// if (err) { -// return err; -// } -// } -// -// // did we split data? -// if (overlap_ > (lfs_soff_t)weight) { -// // did we split actual data? -// if (pos+weight < bid_-(weight_-1)+bptr_.size) { -// // we MUST coalesce here, otherwise we risk dagging -// LFS_ASSERT(tag == LFSR_TAG_DATA); -// LFS_ASSERT(bptr_.size <= lfs->cfg->crystallize_size); -// LFS_ASSERT(datas_ - scratch_datas == 2); -// -// // note! this is a reference to cow data! this may need -// // special care for non-pure-cow allocators -// *datas_++ = LFSR_DATA_DISK( -// bptr_.block, -// bptr_.off -// + (weight_ - overlap_) + weight, -// bptr_.size - lfs_min32( -// (weight_ - overlap_) + weight, -// bptr_.size)); -// data = lfsr_data_fromcat( -// scratch_datas, -// datas_ - scratch_datas); -// weight += weight_ - overlap_; -// -// // otherwise we just add our hole to our weight -// } else { -// weight += overlap_ - weight; -// } -// } -// } -// -// pos_ = pos; -// rm += lfs_smax32(overlap_, 0); -// -// // found right sibling? -// } else if (pos + weight-rm < bid_+1) { -// lfs_soff_t overlap_ = (pos + weight-rm) - (bid_-(weight_-1)); -// LFS_ASSERT(overlap_ >= 0); -// -// if (tag_ == LFSR_TAG_DATA) { -// LFS_ASSERT(lfsr_data_size(&data_) <= weight_); -// -// // can we coalesce right data? this is only possible if our -// // new data is not a block, or our right data has no data -// if ((tag == LFSR_TAG_DATA -// && lfsr_data_size(&data) == weight + delta -// && lfsr_data_size(&data) -// + lfsr_data_size(&data_) -// - overlap_ -// <= lfs->cfg->crystallize_size) -// || lfsr_data_size(&data_) - overlap_ == 0) { -// // note! this is a reference to cow data! this may need -// // special care for non-pure-cow allocators -// *datas_++ = LFSR_DATA_DISK( -// data_.u.disk.block, -// data_.u.disk.off + overlap_, -// lfsr_data_size(&data_) - lfs_min32( -// overlap_, -// lfsr_data_size(&data_))); -// data = lfsr_data_fromcat( -// scratch_datas, -// datas_ - scratch_datas); -// weight += weight_ - overlap_; -// -// // removing data we're referencing? this gets pretty -// // cursed... -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, RM, -weight_, NULL))); -// if (err) { -// return err; -// } -// -// // need to carve right data -// } else { -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, -// GROW(DATA), -overlap_, -// DISK( -// data_.u.disk.block, -// data_.u.disk.off + overlap_, -// lfsr_data_size(&data_) - lfs_min32( -// overlap_, -// lfsr_data_size(&data_)))))); -// if (err) { -// return err; -// } -// } -// -// } else if (tag_ == LFSR_TAG_BLOCK) { -// lfsr_bptr_t bptr_; -// err = lfsr_data_readbptr(lfs, &data_, &bptr_); -// if (err) { -// return err; -// } -// LFS_ASSERT(bptr_.size <= weight_); -// -// // can we coalesce right data? this is only possible if our -// // new data is not a block, or our right data has no data -// if ((tag == LFSR_TAG_DATA -// && lfsr_data_size(&data) == weight + delta -// && lfsr_data_size(&data) -// + bptr_.size -// - overlap_ -// <= lfs->cfg->crystallize_size) -// || bptr_.size - overlap_ == 0) { -// // note! this is a reference to cow data! this may need -// // special care for non-pure-cow allocators -// *datas_++ = LFSR_DATA_DISK( -// bptr_.block, -// bptr_.off + overlap_, -// bptr_.size - lfs_min32( -// overlap_, -// bptr_.size)); -// data = lfsr_data_fromcat( -// scratch_datas, -// datas_ - scratch_datas); -// weight += weight_ - overlap_; -// -// // removing data we're referencing? this gets pretty -// // cursed... -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, RM, -weight_, NULL))); -// if (err) { -// return err; -// } -// -// // need to carve right data -// } else { -// bptr_.off += overlap_; -// bptr_.size -= overlap_; -// -// uint8_t bptr_buf[LFSR_BPTR_DSIZE]; -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, -// LFSR_ATTRS( -// LFSR_ATTR(bid_, -// GROW(BLOCK), -overlap_, -// FROMBPTR(&bptr_, bptr_buf)))); -// if (err) { -// return err; -// } -// -// } -// } -// -// pos_ += 1; -// rm += overlap_; -// -// // found fully overwritten entry, remove -// } else { -// err = lfsr_btree_commit(lfs, &file->tree.u.btree, LFSR_ATTRS( -// LFSR_ATTR(bid_, RM, -weight_, NULL))); -// if (err) { -// return err; -// } -// -// rm += weight_; -// } -// } -// -// // need a hole? -// if (pos > lfsr_btree_weight(&file->tree.u.btree)) { -// // we should be able to handle non-zero btree holes with grow -// // attributes above -// LFS_ASSERT(lfsr_btree_weight(&file->tree.u.btree) == 0); -// -// int err = lfsr_btree_commit(lfs, &file->tree.u.btree, LFSR_ATTRS( -// LFSR_ATTR(lfsr_btree_weight(&file->tree.u.btree), -// DATA, +(pos - lfsr_btree_weight(&file->tree.u.btree)), -// NULL))); -// if (err) { -// return err; -// } -// } -// -// // finally commit our new data -// int err = lfsr_btree_commit(lfs, &file->tree.u.btree, LFSR_ATTRS( -// LFSR_ATTR(pos, TAG(tag), +weight + delta, DATA(data)))); -// if (err) { -// return err; -// } -// -// return 0; -//} -// -//static int lfsr_file_flushshrub(lfs_t *lfs, lfsr_file_t *file) { -// // iterate through our buffer/sprout/shrub and flush everything into -// // our btree -// lfs_off_t inlined_pos = 0; -// while (inlined_pos < file->size) { -// lfs_ssize_t d = file->size - inlined_pos; -// lfsr_data_t inlined_data; -// -// // TODO would it make more sense to move this into a separate function? -// // TODO lfsr_file_inlinednext maybe? and call from lfsr_file_readnext? -// -// // any data in our write buffer? -// if (inlined_pos < file->buffer_pos + file->buffer_size) { -// if (inlined_pos >= file->buffer_pos) { -// d = lfs_min32( -// d, -// file->buffer_size - (inlined_pos - file->buffer_pos)); -// -// inlined_data = LFSR_DATA_BUF( -// &file->buffer[inlined_pos - file->buffer_pos], -// d); -// goto flush; -// } -// -// // buffered data takes priority -// d = lfs_min32(d, file->buffer_pos - inlined_pos); -// } -// -// // has a sprout? -// if (lfsr_shrub_hassprout(&file->shrub) -// && inlined_pos < lfsr_shrub_size(&file->shrub)) { -// d = lfs_min32( -// d, -// lfsr_data_size(&file->shrub.u.data)); -// -// inlined_data = LFSR_DATA_DISK( -// file->shrub.u.data.u.disk.block, -// file->shrub.u.data.u.disk.off + inlined_pos, -// d); -// goto flush; -// -// // has a shrub? -// } else if (lfsr_shrub_hasshrub(&file->shrub) -// && inlined_pos < lfsr_shrub_size(&file->shrub)) { -// lfsr_srid_t rid; -// lfsr_tag_t tag; -// lfsr_rid_t weight; -// lfsr_data_t data; -// int err = lfsr_rbyd_lookupnext(lfs, &file->shrub.u.rbyd, -// inlined_pos, 0, -// &rid, &tag, &weight, &data); -// if (err) { -// LFS_ASSERT(err != LFS_ERR_NOENT); -// return err; -// } -// LFS_ASSERT(tag == LFSR_TAG_SHRUB(DATA)); -// LFS_ASSERT(lfsr_data_size(&data) <= weight); -// -// if (inlined_pos < rid-(weight-1) + lfsr_data_size(&data)) { -// d = lfs_min32( -// d, -// lfsr_data_size(&data) -// - (inlined_pos - (rid-(weight-1)))); -// -// inlined_data = LFSR_DATA_DISK( -// data.u.disk.block, -// data.u.disk.off + (inlined_pos - (rid-(weight-1))), -// d); -// goto flush; -// } -// -// // found a hole, just make sure next leaf takes priority -// d = lfs_min32(d, rid+1 - inlined_pos); -// } -// -// // found a hole? skip -// inlined_pos += d; -// continue; -// -// flush:; -// // first we need to figure out if we can coalesce or need a new block -// lfs_off_t crystal_pos = inlined_pos; -// lfs_off_t crystal_size = lfsr_data_size(&inlined_data); -// -// // don't check our crystallization threshold yet, we always need to -// // lookup our left sibling to determine the best crystal alignment -// -// // TODO when do we create single blocks? -// -// // no btree yet? alloc a new root node -// if (!lfsr_tree_hasbtree(&file->tree)) { -// // TODO allow single blocks -// LFS_ASSERT(!lfsr_tree_hasbptr(&file->tree)); -// -// // TODO btree alloc? -// int err = lfsr_rbyd_alloc(lfs, &file->tree.u.btree.u.rbyd); -// if (err) { -// return err; -// } -// -// } else { -// // has left sibling? -// if (inlined_pos > 0) { -// lfsr_bid_t left_bid; -// lfsr_tag_t left_tag; -// lfsr_bid_t left_weight; -// lfsr_data_t left_data; -// int err = lfsr_btree_lookupnext(lfs, &file->tree.u.btree, -// lfs_min32( -// inlined_pos, -// lfsr_btree_weight(&file->tree.u.btree))-1, -// &left_bid, &left_tag, &left_weight, &left_data); -// if (err) { -// LFS_ASSERT(err != LFS_ERR_NOENT); -// return err; -// } -// LFS_ASSERT(left_tag == LFSR_TAG_DATA -// || left_tag == LFSR_TAG_BLOCK); -// -// lfs_off_t left_size; -// // is inlined data? -// if (left_tag == LFSR_TAG_DATA) { -// left_size = lfsr_data_size(&left_data); -// LFS_ASSERT(left_size <= left_weight); -// -// // is a block? -// } else if (left_tag == LFSR_TAG_BLOCK) { -// lfsr_bptr_t bptr; -// err = lfsr_data_readbptr(lfs, &left_data, &bptr); -// if (err) { -// return err; -// } -// LFS_ASSERT(bptr.size <= left_weight); -// left_size = bptr.size; -// } -// -// // coalescable? this requires we either overlap, or left sibling -// // is not a full block -// if (crystal_pos - (left_bid-(left_weight-1)) -// < lfs->cfg->block_size -// && crystal_pos -// <= left_bid-(left_weight-1)+left_size) { -// crystal_size += crystal_pos - (left_bid-(left_weight-1)); -// crystal_pos = left_bid-(left_weight-1); -// } -// } -// -// // scan our crystallizing region to see how much data could be -// // merged if we created a block here -// while (crystal_size <= lfs->cfg->crystallize_size -// && crystal_pos + crystal_size < file->size) { -// lfs_off_t weight; -// lfsr_data_t data; -// int err = lfsr_file_readnext(lfs, file, -// crystal_pos + crystal_size, file->size, -// &weight, &data); -// if (err) { -// // end of file? -// if (err == LFS_ERR_NOENT) { -// break; -// } -// return err; -// } -// LFS_ASSERT(weight > 0); -// -// // found a hole? just stop here -// if (lfsr_data_size(&data) == 0) { -// break; -// } -// -// crystal_size += lfsr_data_size(&data); -// } -// } -// -// // not enough crystallized data for a block? inline the data directly, -// // potentially coalescing with any neighbors -// if (crystal_size < lfs->cfg->crystallize_size) { -// // write inlined data into our tree -// int err = lfsr_file_carvetree(lfs, file, -// inlined_pos, lfsr_data_size(&inlined_data), 0, -// LFSR_TAG_DATA, inlined_data); -// if (err) { -// return err; -// } -// -// inlined_pos += lfsr_data_size(&inlined_data); -// -// // exceeded crystallization threshold? create a new block -// } else { -// // allocate a new block -// lfs_block_t block; -// int err = lfs_alloc(lfs, &block); -// if (err) { -// return err; -// } -// -// // TODO should lfs_alloc handle erase? -// err = lfsr_bd_erase(lfs, block); -// if (err) { -// return err; -// } -// -// // TODO becksum? -// // copy any data underneath our block into our block -// lfs_off_t pos = crystal_pos; -// lfs_off_t size = lfs->cfg->block_size; -// while (size > 0) { -// lfs_off_t weight; -// lfsr_data_t data; -// err = lfsr_file_readnext(lfs, file, pos, size, -// &weight, &data); -// if (err) { -// // end of file? -// if (err == LFS_ERR_NOENT) { -// break; -// } -// return err; -// } -// LFS_ASSERT(weight > 0); -// -// // TODO we should probably NOT stop or we risk excessive -// // fragmentation when there are small holes -// -// // found a hole? just stop here -// if (lfsr_data_size(&data) == 0) { -// break; -// } -// -// err = lfsr_bd_progdata(lfs, block, pos - crystal_pos, -// data, -// NULL); -// if (err) { -// return err; -// } -// -// pos += lfsr_data_size(&data); -// size -= lfsr_data_size(&data); -// } -// -// // TODO validate? -// // finalize our write -// err = lfsr_bd_flush(lfs); -// if (err) { -// return err; -// } -// -// // create our block pointer -// lfsr_bptr_t bptr = { -// .block = block, -// .off = 0, -// .size = pos - crystal_pos, -// }; -// -// // and write it into our tree -// uint8_t bptr_buf[LFSR_BPTR_DSIZE]; -// err = lfsr_file_carvetree(lfs, file, -// crystal_pos, bptr.size, 0, -// LFSR_TAG_BLOCK, lfsr_data_frombptr(&bptr, bptr_buf)); -// if (err) { -// return err; -// } -// -// inlined_pos = crystal_pos + bptr.size; -// } -// } -// -// // at this point we should have flushed both our inlined data and -// // our buffer -// file->buffer_size = 0; -// file->shrub.u.data = LFSR_DATA_DISK(0, 0, 0); -// return 0; -//} - -//static int lfsr_file_flushbuffer(lfs_t *lfs, lfsr_file_t *file) { -// // TODO restructure this based on how flushshrub interacts with -// // our buffer? -// while (file->buffer_size > 0) { -// // try to flush our buffer into our shrub -// int err = lfsr_file_carveshrub(lfs, file, -// file->buffer_pos, file->buffer_size, 0, -// LFSR_TAG_SHRUB(DATA), -// LFSR_DATA_BUF(file->buffer, file->buffer_size)); -// if (err) { -// // uh oh, doesn't fit? flush inlined data and try again -// if (err == LFS_ERR_RANGE) { -// err = lfsr_file_flushshrub(lfs, file); -// if (err) { -// return err; -// } -// -// continue; -// } -// return err; -// } -// -// // we've flushed our buffer -// file->buffer_size = 0; -// } -// -// return 0; -//} - lfs_ssize_t lfsr_file_write(lfs_t *lfs, lfsr_file_t *file, const void *buffer, lfs_size_t size) { LFS_ASSERT(lfsr_file_iswriteable(file)); diff --git a/scripts/dbgbtree.py b/scripts/dbgbtree.py index 8759216c..064bfe43 100755 --- a/scripts/dbgbtree.py +++ b/scripts/dbgbtree.py @@ -31,7 +31,6 @@ TAG_REG = 0x0202 TAG_DIR = 0x0203 TAG_STRUCT = 0x0300 TAG_DATA = 0x0300 -TAG_SLICE = 0x0304 TAG_TRUNK = 0x0308 TAG_DID = 0x030c TAG_BLOCK = 0x0310 @@ -178,7 +177,6 @@ def tagrepr(tag, w, size, off=None): return '%s%s%s %d' % ( 'shrub' if tag & TAG_SHRUB else '', 'data' if (tag & 0xfff) == TAG_DATA - else 'slice' if (tag & 0xfff) == TAG_SLICE else 'trunk' if (tag & 0xfff) == TAG_TRUNK else 'did' if (tag & 0xfff) == TAG_DID else 'block' if (tag & 0xfff) == TAG_BLOCK diff --git a/scripts/dbglfs.py b/scripts/dbglfs.py index 9804f201..9f329551 100755 --- a/scripts/dbglfs.py +++ b/scripts/dbglfs.py @@ -32,7 +32,6 @@ TAG_REG = 0x0202 TAG_DIR = 0x0203 TAG_STRUCT = 0x0300 TAG_DATA = 0x0300 -TAG_SLICE = 0x0304 TAG_TRUNK = 0x0308 TAG_DID = 0x030c TAG_BLOCK = 0x0310 @@ -194,7 +193,6 @@ def tagrepr(tag, w, size, off=None): return '%s%s%s %d' % ( 'shrub' if tag & TAG_SHRUB else '', 'data' if (tag & 0xfff) == TAG_DATA - else 'slice' if (tag & 0xfff) == TAG_SLICE else 'trunk' if (tag & 0xfff) == TAG_TRUNK else 'did' if (tag & 0xfff) == TAG_DID else 'block' if (tag & 0xfff) == TAG_BLOCK @@ -1200,14 +1198,6 @@ def frepr(mdir, rid, tag): if not done and rid_ == rid and tag_ == TAG_DATA: size = max(size, len(data)) structs.append('data 0x%x.%x %d' % (mdir.block, j+d, len(data))) - # sliced sprout? - done, rid_, tag_, w_, j, d, data, _ = mdir.lookup(rid, TAG_SLICE) - if not done and rid_ == rid and tag_ == TAG_SLICE: - d = 0 - size_, d_ = fromleb128(data[d:]); d += d_ - off, d_ = fromleb128(data[d:]); d += d_ - size = max(size, size_) - structs.append('slice 0x%x.%x %d' % (mdir.block, off, size_)) # shrub? done, rid_, tag_, w_, j, d, data, _ = mdir.lookup(rid, TAG_TRUNK) if not done and rid_ == rid and tag_ == TAG_TRUNK: @@ -1257,19 +1247,6 @@ def dbg_fstruct(f, block_size, mdir, rid, tag, j, d, data, *, j, 0) w = len(data) - # sliced sprout? - elif tag == TAG_SLICE: - btree = Rbyd( - mdir.block, - mdir.data, - mdir.rev, - mdir.eoff, - j, - 0) - d = 0 - size, d_ = fromleb128(data[d:]); d += d_ - off, d_ = fromleb128(data[d:]); d += d_ - w = size # shrub? elif tag == TAG_TRUNK: d = 0 @@ -1323,12 +1300,8 @@ def dbg_fstruct(f, block_size, mdir, rid, tag, j, d, data, *, a_bid, a_bd, a_rid, a_tag = branch.a b_bid, b_bd, b_rid, b_tag = branch.b tree_.add(TBranch( - a=(a_bid, a_bd, a_rid, a_tag, - (a_tag & 0xfff) == TAG_SLICE - or (a_tag & 0xfff) == TAG_BLOCK), - b=(b_bid, b_bd, b_rid, b_tag, - (b_tag & 0xfff) == TAG_SLICE - or (b_tag & 0xfff) == TAG_BLOCK), + a=(a_bid, a_bd, a_rid, a_tag, (a_tag & 0xfff) == TAG_BLOCK), + b=(b_bid, b_bd, b_rid, b_tag, (b_tag & 0xfff) == TAG_BLOCK), d=branch.d + (1 if args.get('inner') else 0), c=branch.c, )) @@ -1336,7 +1309,6 @@ def dbg_fstruct(f, block_size, mdir, rid, tag, j, d, data, *, # connect our source tag if we are showing inner nodes if (tag != TAG_DATA - and tag != TAG_SLICE and tag != TAG_BLOCK and args.get('inner')): if tree: @@ -1518,8 +1490,7 @@ def dbg_fstruct(f, block_size, mdir, rid, tag, j, d, data, *, else ''), 21+2*w_width, '%s%s%s 0x%x.%x %d' % ( 'shrub' if tag & TAG_SHRUB else '', - 'slice' if (tag & 0xfff) == TAG_SLICE - else 'block', + 'block', ' w%d' % w if w else '', block, off, size), next(xxd(data, 8), '') @@ -1640,38 +1611,19 @@ def dbg_fstruct(f, block_size, mdir, rid, tag, j, d, data, *, for tag, j, d, data in tags if tag & 0x7f00 != TAG_NAME] - # found a slice or block in the tags? - slice = None + # found a block in the tags? bptr = None if (not args.get('struct_depth') or len(path) < args.get('struct_depth')): - slice = next(((tag, j, d, data) - for tag, j, d, data in tags - if (tag & 0xfff) == TAG_SLICE), - None) bptr = next(((tag, j, d, data) for tag, j, d, data in tags if (tag & 0xfff) == TAG_BLOCK), None) # show other btree entries - if args.get('inner') or (not slice and not bptr): + if args.get('inner') or not bptr: dbg_branch(bid, w, rbyd, rid, tags, len(path)-1) - if slice: - # decode slice - _, _, _, data = slice - d = 0 - size, d_ = fromleb128(data[d:]); d += d_ - off, d_ = fromleb128(data[d:]); d += d_ - - # slices reference our rbyd - data = rbyd.data[off:off+size] - - # show the slice - dbg_block(bid, w, rbyd, rid, slice, - rbyd.block, off, size, data, len(path)-1) - if bptr: # decode block pointer _, _, _, data = bptr diff --git a/scripts/dbgmtree.py b/scripts/dbgmtree.py index fa211df8..733a3412 100755 --- a/scripts/dbgmtree.py +++ b/scripts/dbgmtree.py @@ -31,7 +31,6 @@ TAG_REG = 0x0202 TAG_DIR = 0x0203 TAG_STRUCT = 0x0300 TAG_DATA = 0x0300 -TAG_SLICE = 0x0304 TAG_TRUNK = 0x0308 TAG_DID = 0x030c TAG_BLOCK = 0x0310 @@ -193,7 +192,6 @@ def tagrepr(tag, w, size, off=None): return '%s%s%s %d' % ( 'shrub' if tag & TAG_SHRUB else '', 'data' if (tag & 0xfff) == TAG_DATA - else 'slice' if (tag & 0xfff) == TAG_SLICE else 'trunk' if (tag & 0xfff) == TAG_TRUNK else 'did' if (tag & 0xfff) == TAG_DID else 'block' if (tag & 0xfff) == TAG_BLOCK diff --git a/scripts/dbgrbyd.py b/scripts/dbgrbyd.py index c57b399b..6d5cb742 100755 --- a/scripts/dbgrbyd.py +++ b/scripts/dbgrbyd.py @@ -40,7 +40,6 @@ TAG_REG = 0x0202 TAG_DIR = 0x0203 TAG_STRUCT = 0x0300 TAG_DATA = 0x0300 -TAG_SLICE = 0x0304 TAG_TRUNK = 0x0308 TAG_DID = 0x030c TAG_BLOCK = 0x0310 @@ -180,7 +179,6 @@ def tagrepr(tag, w, size, off=None): return '%s%s%s %d' % ( 'shrub' if tag & TAG_SHRUB else '', 'data' if (tag & 0xfff) == TAG_DATA - else 'slice' if (tag & 0xfff) == TAG_SLICE else 'trunk' if (tag & 0xfff) == TAG_TRUNK else 'did' if (tag & 0xfff) == TAG_DID else 'block' if (tag & 0xfff) == TAG_BLOCK diff --git a/tests/test_btree.toml b/tests/test_btree.toml index a63cb531..83faa82e 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -146,7 +146,7 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -161,7 +161,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); @@ -185,9 +185,9 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -202,13 +202,13 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); @@ -231,9 +231,9 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -248,13 +248,13 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); @@ -278,11 +278,11 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("c", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -297,19 +297,19 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); lfsr_btree_get(&lfs, &btree, 2, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "c", 1) == 0); @@ -332,11 +332,11 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("c", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -351,19 +351,19 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); lfsr_btree_get(&lfs, &btree, 2, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "c", 1) == 0); @@ -392,7 +392,7 @@ code = ''' const char *alphas = "abcdefghijklmnopqrstuvwxyz"; lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -415,7 +415,7 @@ code = ''' for (lfs_size_t i = 0; i < n; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } @@ -444,7 +444,7 @@ code = ''' const char *alphas = "abcdefghijklmnopqrstuvwxyz"; lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[(N-1-i) % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -467,7 +467,7 @@ code = ''' for (lfs_size_t i = 0; i < n; i++) { lfsr_btree_get(&lfs, &btree, n-1-i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &alphas[(N-1-i) % 26], 1) == 0); } @@ -511,7 +511,7 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - int err = lfsr_btree_push(&lfs, &btree, bid, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, bid, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -548,7 +548,7 @@ code = ''' for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -582,7 +582,7 @@ code = ''' const char *alphas = "abcdefghijklmnopqrstuvwxyz"; lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_BLOCK, W, + int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_DATA, W, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -605,7 +605,7 @@ code = ''' for (lfs_size_t i = 0; i < n; i++) { lfsr_btree_get(&lfs, &btree, i*W+W-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } @@ -621,7 +621,7 @@ code = ''' lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == i*W+W-1); - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -677,7 +677,7 @@ code = ''' // add to btree int err = lfsr_btree_push(&lfs, &btree, - weighted_bid, LFSR_TAG_BLOCK, weight, + weighted_bid, LFSR_TAG_DATA, weight, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -735,7 +735,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -757,7 +757,7 @@ code = ''' lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -789,10 +789,10 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; // update the tree - lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("A", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -807,7 +807,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); @@ -830,14 +830,14 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; // update the tree - lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("A", 1)) => 0; - lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("B", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -852,13 +852,13 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); @@ -881,18 +881,18 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("c", 1)) => 0; // update the tree - lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("A", 1)) => 0; - lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("B", 1)) => 0; - lfsr_btree_set(&lfs, &btree, 2, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 2, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("C", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -907,19 +907,19 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); lfsr_btree_get(&lfs, &btree, 2, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "C", 1) == 0); @@ -946,7 +946,7 @@ code = ''' const char *alphas = "abcdefghijklmnopqrstuvwxyz"; const char *uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -960,7 +960,7 @@ code = ''' } // update the tree for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_set(&lfs, &btree, i, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_set(&lfs, &btree, i, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&uppers[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -986,7 +986,7 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &uppers[i % 26], 1) == 0); } @@ -1018,7 +1018,7 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1046,7 +1046,7 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % N; // update btree - int err = lfsr_btree_set(&lfs, &btree, bid, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_set(&lfs, &btree, bid, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&uppers[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1081,7 +1081,7 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -1114,7 +1114,7 @@ code = ''' const char *alphas = "abcdefghijklmnopqrstuvwxyz"; const char *uppers = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_BLOCK, W, + int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_DATA, W, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1128,7 +1128,7 @@ code = ''' } // update the tree for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_set(&lfs, &btree, i*W+W-1, LFSR_TAG_BLOCK, W, + int err = lfsr_btree_set(&lfs, &btree, i*W+W-1, LFSR_TAG_DATA, W, LFSR_DATA_BUF(&uppers[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1154,7 +1154,7 @@ code = ''' for (lfs_size_t i = 0; i < N; i++) { lfsr_btree_get(&lfs, &btree, i*W+W-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &uppers[i % 26], 1) == 0); } @@ -1170,7 +1170,7 @@ code = ''' lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == i*W+W-1); - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -1202,7 +1202,7 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_BLOCK, W, + int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_DATA, W, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1241,7 +1241,7 @@ code = ''' // update btree int err = lfsr_btree_set(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_TAG_BLOCK, weight, + weighted_bid+sim_weights[bid]-1, LFSR_TAG_DATA, weight, LFSR_DATA_BUF(&uppers[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1295,7 +1295,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -1317,7 +1317,7 @@ code = ''' lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -1350,7 +1350,7 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; // pop! lfsr_btree_pop(&lfs, &btree, 0) => 0; @@ -1369,7 +1369,7 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("A", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -1380,7 +1380,7 @@ code = ''' // try looking up tags lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); @@ -1403,9 +1403,9 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; // pop! lfsr_btree_pop(&lfs, &btree, 1) => 0; @@ -1422,7 +1422,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); @@ -1430,7 +1430,7 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("B", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -1441,13 +1441,13 @@ code = ''' // try looking up tags lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); @@ -1470,9 +1470,9 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; // pop! lfsr_btree_pop(&lfs, &btree, 0) => 0; @@ -1489,7 +1489,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); @@ -1497,7 +1497,7 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("A", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -1508,13 +1508,13 @@ code = ''' // try looking up tags lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); @@ -1537,11 +1537,11 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; - lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("c", 1)) => 0; // pop! lfsr_btree_pop(&lfs, &btree, 2) => 0; @@ -1558,13 +1558,13 @@ code = ''' lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); @@ -1572,7 +1572,7 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // try to putting it back to see if things still work - lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 2, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("C", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -1583,19 +1583,19 @@ code = ''' // try looking up tags lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); lfsr_btree_get(&lfs, &btree, 1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); lfsr_btree_get(&lfs, &btree, 2, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "C", 1) == 0); @@ -1623,7 +1623,7 @@ code = ''' lfsr_btree_t btree = LFSR_BTREE_NULL; const char *alphas = "abcdefghijklmnopqrstuvwxyz"; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1663,7 +1663,7 @@ code = ''' for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } @@ -1673,20 +1673,20 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // try recovering - lfsr_btree_push(&lfs, &btree, REMAINING, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, REMAINING, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("R", 1)) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } lfsr_btree_get(&lfs, &btree, REMAINING, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "R", 1) == 0); @@ -1714,7 +1714,7 @@ code = ''' lfsr_btree_t btree = LFSR_BTREE_NULL; const char *alphas = "abcdefghijklmnopqrstuvwxyz"; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1753,7 +1753,7 @@ code = ''' for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &alphas[(i+(N-REMAINING)) % 26], 1) == 0); } @@ -1763,19 +1763,19 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // try recovering - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("R", 1)) => 0; lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "R", 1) == 0); for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_get(&lfs, &btree, i+1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &alphas[(i+(N-REMAINING)) % 26], 1) == 0); } @@ -1806,7 +1806,7 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1870,7 +1870,7 @@ code = ''' for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -1904,7 +1904,7 @@ code = ''' lfsr_btree_t btree = LFSR_BTREE_NULL; const char *alphas = "abcdefghijklmnopqrstuvwxyz"; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_BLOCK, W, + int err = lfsr_btree_push(&lfs, &btree, i*W, LFSR_TAG_DATA, W, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -1943,7 +1943,7 @@ code = ''' for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_get(&lfs, &btree, i*W+W-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } @@ -1953,20 +1953,20 @@ code = ''' &tag_, &weight_, buffer, 4) => LFS_ERR_NOENT; // try recovering - lfsr_btree_push(&lfs, &btree, REMAINING*W, LFSR_TAG_BLOCK, W, + lfsr_btree_push(&lfs, &btree, REMAINING*W, LFSR_TAG_DATA, W, LFSR_DATA_BUF("R", 1)) => 0; for (lfs_size_t i = 0; i < REMAINING; i++) { lfsr_btree_get(&lfs, &btree, i*W+W-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } lfsr_btree_get(&lfs, &btree, REMAINING*W+W-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, "R", 1) == 0); @@ -1980,7 +1980,7 @@ code = ''' lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == i*W+W-1); - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -1990,7 +1990,7 @@ code = ''' lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == REMAINING*W+W-1); - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -2044,7 +2044,7 @@ code = ''' } int err = lfsr_btree_push(&lfs, &btree, - weighted_bid, LFSR_TAG_BLOCK, weight, + weighted_bid, LFSR_TAG_DATA, weight, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -2128,7 +2128,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -2150,7 +2150,7 @@ code = ''' lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -2182,13 +2182,13 @@ code = ''' // create a tree with N elements lfsr_btree_t btree = LFSR_BTREE_NULL; const char *alphas = "abcdefghijklmnopqrstuvwxyz"; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[0 % 26], 1)) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { int err = lfsr_btree_split(&lfs, &btree, i-1, LFSR_DATA_NULL, - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&alphas[(i-1) % 26], 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&alphas[(i-0) % 26], 1)); + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[(i-1) % 26], 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[(i-0) % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2210,7 +2210,7 @@ code = ''' for (lfs_size_t i = 0; i < n; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } @@ -2240,7 +2240,7 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("_", 1)) => 0; // set up a simulation to compare against @@ -2259,8 +2259,8 @@ code = ''' // split btree int err = lfsr_btree_split(&lfs, &btree, bid, LFSR_DATA_NULL, - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&alphas[i % 26], 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&uppers[i % 26], 1)); + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&uppers[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2297,7 +2297,7 @@ code = ''' for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -2329,13 +2329,13 @@ code = ''' // create a tree with N elements lfsr_btree_t btree = LFSR_BTREE_NULL; const char *alphas = "abcdefghijklmnopqrstuvwxyz"; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, W, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, W, LFSR_DATA_BUF(&alphas[0 % 26], 1)) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { int err = lfsr_btree_split(&lfs, &btree, (i-1)*W+W-1, LFSR_DATA_NULL, - LFSR_TAG_BLOCK, W, LFSR_DATA_BUF(&alphas[(i-1) % 26], 1), - LFSR_TAG_BLOCK, W, LFSR_DATA_BUF(&alphas[(i-0) % 26], 1)); + LFSR_TAG_DATA, W, LFSR_DATA_BUF(&alphas[(i-1) % 26], 1), + LFSR_TAG_DATA, W, LFSR_DATA_BUF(&alphas[(i-0) % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -2357,7 +2357,7 @@ code = ''' for (lfs_size_t i = 0; i < n; i++) { lfsr_btree_get(&lfs, &btree, i*W+W-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } @@ -2388,7 +2388,7 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, W, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, W, LFSR_DATA_BUF("_", 1)) => 0; // set up a simulation to compare against @@ -2420,9 +2420,9 @@ code = ''' // split btree int err = lfsr_btree_split(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_DATA_NULL, - LFSR_TAG_BLOCK, weight1, + LFSR_TAG_DATA, weight1, LFSR_DATA_BUF(&alphas[i % 26], 1), - LFSR_TAG_BLOCK, weight2, + LFSR_TAG_DATA, weight2, LFSR_DATA_BUF(&uppers[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -2459,7 +2459,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -2506,7 +2506,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -2528,7 +2528,7 @@ code = ''' lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -2565,19 +2565,19 @@ code = ''' // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("_", 1)) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_NULL, - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(buf1, SIZE), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf1, SIZE), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; // force compaction btree.u.rbyd.eoff = -1; memset(buf2, 'b', SIZE); - lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; assert(lfsr_btree_weight(&btree) == 2); @@ -2596,7 +2596,7 @@ code = ''' lfs_size_t weight_; lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buf1, SIZE) => SIZE; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, (SIBLING ? "a" : "b"), 1) == 0); @@ -2627,19 +2627,19 @@ code = ''' // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("_", 1)) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_NULL, - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(buf1, SIZE), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf1, SIZE), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; // force compaction btree.u.rbyd.eoff = -1; memset(buf2, 'b', SIZE); - lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; assert(lfsr_btree_weight(&btree) == 2); @@ -2661,7 +2661,7 @@ code = ''' lfs_size_t weight_; lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buf1, SIZE) => SIZE; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, (SIBLING ? "a" : "b"), 1) == 0); @@ -2692,15 +2692,15 @@ code = ''' // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("_", 1)) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_NULL, - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(buf1, SIZE), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf1, SIZE), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; // force compaction, causing a split, but while we're splitting, // also remove an entry, bringing the split rbyd down to zero mid split @@ -2721,7 +2721,7 @@ code = ''' lfs_size_t weight_; lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buf1, SIZE) => SIZE; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, (SIBLING ? "a" : "b"), 1) == 0); @@ -2752,26 +2752,26 @@ code = ''' // force it to split // the extra push here avoids trying to inline the big entry - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("_", 1)) => 0; uint8_t buf1[SIZE]; memset(buf1, 'a', SIZE); uint8_t buf2[SIZE]; memset(buf2, 'b', SIZE); lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_NULL, - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(buf1, SIZE), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf1, SIZE), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; // force compaction btree.u.rbyd.eoff = -1; memset(buf2, 'b', SIZE); - lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(buf2, SIZE)) => 0; assert(lfsr_btree_weight(&btree) == 2); // now make both entries small so they should be merged if either compacts - lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("a", 1)) => 0; - lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_BLOCK, 1, + lfsr_btree_set(&lfs, &btree, 1, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("b", 1)) => 0; // force compaction, while removing one entry, this drops the rbyd @@ -2790,7 +2790,7 @@ code = ''' lfs_size_t weight_; lfsr_btree_get(&lfs, &btree, 0, &tag_, &weight_, buf1, SIZE) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buf1, (SIBLING ? "a" : "b"), 1) == 0); @@ -2839,7 +2839,7 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree int err = lfsr_btree_push(&lfs, &btree, bid, - LFSR_TAG_BLOCK, 1, + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -2855,7 +2855,7 @@ code = ''' } else if (op == 1) { // update btree int err = lfsr_btree_set(&lfs, &btree, bid, - LFSR_TAG_BLOCK, 1, + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -2904,7 +2904,7 @@ code = ''' for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -2966,7 +2966,7 @@ code = ''' if (op == 0 || bid == sim_size) { // push to btree int err = lfsr_btree_push(&lfs, &btree, weighted_bid, - LFSR_TAG_BLOCK, weight, + LFSR_TAG_DATA, weight, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -2985,7 +2985,7 @@ code = ''' } else if (op == 1) { // update btree int err = lfsr_btree_set(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_TAG_BLOCK, weight, + weighted_bid+sim_weights[bid]-1, LFSR_TAG_DATA, weight, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -3056,7 +3056,7 @@ code = ''' lfsr_btree_get(&lfs, &btree, weighted_bid+sim_weights[i]-1, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -3078,7 +3078,7 @@ code = ''' lfsr_btree_lookupnext(&lfs, &btree, bid_+1, &bid_, &tag_, &weight_, &data_) => 0; assert(bid_ == weighted_bid+sim_weights[i]-1); - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3141,7 +3141,7 @@ code = ''' // create a single-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, @@ -3158,7 +3158,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3166,7 +3166,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3190,12 +3190,12 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1)) => 0; lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aab", 3)), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("0", 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("1", 1)) => 0; + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, btree.u.rbyd.block, @@ -3211,7 +3211,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 0, "aaa", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3219,7 +3219,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 0, "aab", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3227,7 +3227,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 0, "aac", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3251,16 +3251,16 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1)) => 0; lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_CAT(LFSR_DATA_LEB128(1*DID), LFSR_DATA_BUF("aab", 3)), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("0", 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("1", 1)) => 0; + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0; lfsr_btree_split(&lfs, &btree, 1, LFSR_DATA_CAT(LFSR_DATA_LEB128(2*DID), LFSR_DATA_BUF("aac", 3)), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("1", 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("2", 1)) => 0; + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("2", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, btree.u.rbyd.block, @@ -3276,7 +3276,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3284,7 +3284,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3292,7 +3292,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3300,7 +3300,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3324,16 +3324,16 @@ code = ''' // create a two-entry tree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1)) => 0; lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_CAT(LFSR_DATA_LEB128(2*DID), LFSR_DATA_BUF("aac", 3)), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("1", 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("2", 1)) => 0; + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("2", 1)) => 0; lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_CAT(LFSR_DATA_LEB128(1*DID), LFSR_DATA_BUF("aab", 3)), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("0", 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF("1", 1)) => 0; + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF("1", 1)) => 0; printf("btree: w%d 0x%x.%x\n", btree.u.rbyd.weight, btree.u.rbyd.block, @@ -3349,7 +3349,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 0*DID, "aaa", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 0); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3357,7 +3357,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 1*DID, "aab", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 1); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3365,7 +3365,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 2*DID, "aac", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3373,7 +3373,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 3*DID, "aad", 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == 2); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3400,7 +3400,7 @@ code = ''' lfsr_btree_t btree = LFSR_BTREE_NULL; const char *alphas = "abcdefghijklmnopqrstuvwxyz"; const char *nums = "0123456789"; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&nums[0 % 10], 1)) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { @@ -3409,8 +3409,8 @@ code = ''' }; int err = lfsr_btree_split(&lfs, &btree, i-1, LFSR_DATA_CAT(LFSR_DATA_LEB128(i*DID), LFSR_DATA_BUF(name, 3)), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&nums[(i-1) % 10], 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&nums[(i-0) % 10], 1)); + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&nums[(i-1) % 10], 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&nums[(i-0) % 10], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3438,7 +3438,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3466,7 +3466,7 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("_", 1)) => 0; // set up a simulation to compare against @@ -3502,8 +3502,8 @@ code = ''' // split btree int err = lfsr_btree_split(&lfs, &btree, bid, LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3)), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&nums[i % 10], 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&nums[i % 10], 1)); + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&nums[i % 10], 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&nums[i % 10], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3544,7 +3544,7 @@ code = ''' for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3578,7 +3578,7 @@ code = ''' lfsr_btree_t btree = LFSR_BTREE_NULL; const char *alphas = "abcdefghijklmnopqrstuvwxyz"; const char *nums = "0123456789"; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, W, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, W, LFSR_DATA_BUF(&nums[0 % 10], 1)) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { @@ -3587,8 +3587,8 @@ code = ''' }; int err = lfsr_btree_split(&lfs, &btree, (i-1)*W+W-1, LFSR_DATA_CAT(LFSR_DATA_LEB128(i*DID), LFSR_DATA_BUF(name, 3)), - LFSR_TAG_BLOCK, W, LFSR_DATA_BUF(&nums[(i-1) % 10], 1), - LFSR_TAG_BLOCK, W, LFSR_DATA_BUF(&nums[(i-0) % 10], 1)); + LFSR_TAG_DATA, W, LFSR_DATA_BUF(&nums[(i-1) % 10], 1), + LFSR_TAG_DATA, W, LFSR_DATA_BUF(&nums[(i-0) % 10], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3616,7 +3616,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, i*DID, name, 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i*W+W-1); assert(weight_ == W); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3645,7 +3645,7 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, W, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, W, LFSR_DATA_BUF("_", 1)) => 0; // set up a simulation to compare against @@ -3694,8 +3694,8 @@ code = ''' int err = lfsr_btree_split(&lfs, &btree, weighted_bid+sim_weights[bid]-1, LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3)), - LFSR_TAG_BLOCK, weight1, LFSR_DATA_BUF(&nums[i % 10], 1), - LFSR_TAG_BLOCK, weight2, LFSR_DATA_BUF(&nums[i % 10], 1)); + LFSR_TAG_DATA, weight1, LFSR_DATA_BUF(&nums[i % 10], 1), + LFSR_TAG_DATA, weight2, LFSR_DATA_BUF(&nums[i % 10], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3761,7 +3761,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3796,7 +3796,7 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, 1, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, 1, LFSR_DATA_BUF("_", 1)) => 0; // set up a simulation to compare against @@ -3849,8 +3849,8 @@ code = ''' LFSR_DATA_CAT( LFSR_DATA_LEB128(0), LFSR_DATA_BUF(sim_names[bid+1], 3)), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&nums[i % 10], 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(split_buf, 1)); + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&nums[i % 10], 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(split_buf, 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3861,8 +3861,8 @@ code = ''' split_bid, LFSR_DATA_CAT( LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3)), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(split_buf, 1), - LFSR_TAG_BLOCK, 1, LFSR_DATA_BUF(&nums[i % 10], 1)); + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(split_buf, 1), + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&nums[i % 10], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -3880,7 +3880,7 @@ code = ''' } else if (op == 1) { // update btree int err = lfsr_btree_set(&lfs, &btree, bid, - LFSR_TAG_BLOCK, 1, + LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&nums[i % 10], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -3938,7 +3938,7 @@ code = ''' for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == i); assert(weight_ == 1); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -3971,7 +3971,7 @@ code = ''' // create a btree lfsr_btree_t btree = LFSR_BTREE_NULL; - lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_BLOCK, W, + lfsr_btree_push(&lfs, &btree, 0, LFSR_TAG_DATA, W, LFSR_DATA_BUF("_", 1)) => 0; // set up a simulation to compare against @@ -4042,9 +4042,9 @@ code = ''' LFSR_DATA_CAT( LFSR_DATA_LEB128(0), LFSR_DATA_BUF(sim_names[bid+1], 3)), - LFSR_TAG_BLOCK, weight, + LFSR_TAG_DATA, weight, LFSR_DATA_BUF(&nums[i % 10], 1), - LFSR_TAG_BLOCK, split_weight, + LFSR_TAG_DATA, split_weight, LFSR_DATA_BUF(split_buf, 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -4056,9 +4056,9 @@ code = ''' LFSR_DATA_CAT( LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3)), - LFSR_TAG_BLOCK, split_weight, + LFSR_TAG_DATA, split_weight, LFSR_DATA_BUF(split_buf, 1), - LFSR_TAG_BLOCK, weight, + LFSR_TAG_DATA, weight, LFSR_DATA_BUF(&nums[i % 10], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -4080,7 +4080,7 @@ code = ''' } else if (op == 1) { // update btree int err = lfsr_btree_set(&lfs, &btree, - weighted_bid+sim_weights[bid]-1, LFSR_TAG_BLOCK, weight, + weighted_bid+sim_weights[bid]-1, LFSR_TAG_DATA, weight, LFSR_DATA_BUF(&nums[i % 10], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -4163,7 +4163,7 @@ code = ''' lfsr_btree_namelookup(&lfs, &btree, 0, sim_names[i], 3, &bid_, &tag_, &weight_, &data_) => 0; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(weight_ == sim_weights[i]); lfsr_data_read(&lfs, &data_, buffer, 4) => 1; @@ -4199,7 +4199,7 @@ code = ''' const char *alphas = "abcdefghijklmnopqrstuvwxyz"; lfs_size_t n = 0; for (lfs_size_t i = 0; i < N; i++) { - int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, i, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -4222,7 +4222,7 @@ code = ''' for (lfs_size_t i = 0; i < n; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } @@ -4257,7 +4257,7 @@ code = ''' // keep track of seen blocks seen[binfo.u.rbyd.block / 8] |= 1 << (binfo.u.rbyd.block % 8); - } else if (binfo.tag == LFSR_TAG_BLOCK) { + } else if (binfo.tag == LFSR_TAG_DATA) { printf("traversal: %d 0x%x w%d data %d\n", binfo.bid, binfo.tag, @@ -4291,7 +4291,7 @@ code = ''' for (lfs_size_t i = 0; i < n; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &alphas[i % 26], 1) == 0); } @@ -4335,7 +4335,7 @@ code = ''' lfs_size_t bid = TEST_PRNG(&prng) % (sim_size+1); // add to btree - int err = lfsr_btree_push(&lfs, &btree, bid, LFSR_TAG_BLOCK, 1, + int err = lfsr_btree_push(&lfs, &btree, bid, LFSR_TAG_DATA, 1, LFSR_DATA_BUF(&alphas[i % 26], 1)); // ignore space issues if (err == LFS_ERR_NOSPC) { @@ -4372,7 +4372,7 @@ code = ''' for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); } @@ -4408,7 +4408,7 @@ code = ''' // keep track of seen blocks seen[binfo.u.rbyd.block / 8] |= 1 << (binfo.u.rbyd.block % 8); - } else if (binfo.tag == LFSR_TAG_BLOCK) { + } else if (binfo.tag == LFSR_TAG_DATA) { printf("traversal: %d 0x%x w%d data %d\n", binfo.bid, binfo.tag, @@ -4458,7 +4458,7 @@ code = ''' for (lfs_size_t i = 0; i < sim_size; i++) { lfsr_btree_get(&lfs, &btree, i, &tag_, &weight_, buffer, 4) => 1; - assert(tag_ == LFSR_TAG_BLOCK); + assert(tag_ == LFSR_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &sim[i], 1) == 0); }