From 7868ec7122c65c2b010611c975682b0a35c180c6 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Fri, 26 Jan 2024 13:16:36 -0600 Subject: [PATCH] Ported over most rbyd+btree tests to new attr-list format Found a bug, and maybe a fundamental issue: - The lfs_btree_lookupnext_ in lfsr_btree_commit_ no longer needs the min32, since we never commit with bid pointing past the end of the btree anymore. This was mixing the unsigned min32 with our now-signed bid type, causing the wrong btree leaf to be fetched when inserting at bid=-1 in a non-empty btree. Easy fix. - lfsr_btree_commit_ with bid!=-1, rid=-1 (inserting at the beginning of not-the-first rbyd) now actually appends to the leaf to the left of the rbyd instead of inserting into the expected rbyd because of how lfs_btree_lookup_ works. Initially, this doesn't seem like it would be an issue, these should be more-or-less equivalent, but this doesn't match lfsr_btree_namelookup! This is a big problem! This wasn't noticed because it's rare for the high-level tests to trigger that many btree splits with names. Named btrees are only used for the mtree, and we need mdirs to split before the mtree even splits once. Not an easy fix. On the upside, these low-level tests continue to prove themselves valuable, if tedious to maintain... --- lfs.c | 3 +- tests/test_btree.toml | 127 +- tests/test_rbyd.toml | 3093 ++++++++++++++++------------------------- 3 files changed, 1260 insertions(+), 1963 deletions(-) diff --git a/lfs.c b/lfs.c index 7908cf10..efa05a26 100644 --- a/lfs.c +++ b/lfs.c @@ -3998,8 +3998,7 @@ static int lfsr_btree_commit_(lfs_t *lfs, lfsr_btree_t *btree, lfsr_srid_t rid = bid; if (btree->weight > 0) { lfsr_srid_t rid_; - int err = lfsr_btree_lookupnext_(lfs, btree, - lfs_min32(bid, btree->weight-1), + int err = lfsr_btree_lookupnext_(lfs, btree, bid, &bid, &rbyd, &rid_, NULL, NULL, NULL); if (err) { LFS_ASSERT(err != LFS_ERR_NOENT); diff --git a/tests/test_btree.toml b/tests/test_btree.toml index eee3b2ac..261a5172 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -28,8 +28,8 @@ code = ''' lfs_size_t bid, lfsr_tag_t tag, lfs_size_t weight, lfsr_data_t data) { LFS_ASSERT(bid <= btree->weight); - return lfsr_btree_commit(lfs, btree, LFSR_ATTRS( - LFSR_ATTR(bid, TAG(tag), +weight, DATA(data)))); + return lfsr_btree_commit(lfs, btree, bid-1, LFSR_ATTRS( + LFSR_ATTR(TAG(tag), +weight, DATA(data)))); } static int lfsr_btree_set(lfs_t *lfs, lfsr_btree_t *btree, @@ -49,9 +49,9 @@ code = ''' // note we need a second tag here in case our entry has a // name attributes, the name attribute holds the weight not // the struct tag - return lfsr_btree_commit(lfs, btree, LFSR_ATTRS( - LFSR_ATTR(bid, SUBMASK(TAG(tag)), 0, DATA(data)), - LFSR_ATTR(bid, GROW, weight - weight_, NULL()))); + return lfsr_btree_commit(lfs, btree, bid, LFSR_ATTRS( + LFSR_ATTR(SUBMASK(TAG(tag)), 0, DATA(data)), + LFSR_ATTR(GROW, weight - weight_, NULL()))); } static int lfsr_btree_pop(lfs_t *lfs, lfsr_btree_t *btree, lfs_size_t bid) { @@ -66,8 +66,8 @@ code = ''' return err; } - return lfsr_btree_commit(lfs, btree, LFSR_ATTRS( - LFSR_ATTR(bid, RM, -weight_, NULL()))); + return lfsr_btree_commit(lfs, btree, bid, LFSR_ATTRS( + LFSR_ATTR(RM, -weight_, NULL()))); } static int lfsr_btree_split(lfs_t *lfs, lfsr_btree_t *btree, @@ -88,21 +88,17 @@ code = ''' lfsr_attr_t attrs[4]; lfs_size_t attr_count = 0; - attrs[attr_count++] = LFSR_ATTR(bid, GROW, +weight1-weight_, NULL()); - attrs[attr_count++] = LFSR_ATTR(bid-(weight_-1)+weight1-1, - TAG(tag1), 0, DATA(data1)); + attrs[attr_count++] = LFSR_ATTR(GROW, +weight1-weight_, NULL()); + attrs[attr_count++] = LFSR_ATTR(TAG(tag1), 0, DATA(data1)); if (lfsr_data_size(&name) > 0) { - attrs[attr_count++] = LFSR_ATTR(bid-(weight_-1)+weight1, - NAME, +weight2, DATA(name)); - attrs[attr_count++] = LFSR_ATTR(bid-(weight_-1)+weight1+weight2-1, - TAG(tag2), 0, DATA(data2)); + attrs[attr_count++] = LFSR_ATTR(NAME, +weight2, DATA(name)); + attrs[attr_count++] = LFSR_ATTR(TAG(tag2), 0, DATA(data2)); } else { - attrs[attr_count++] = LFSR_ATTR(bid-(weight_-1)+weight1, - TAG(tag2), +weight2, DATA(data2)); + attrs[attr_count++] = LFSR_ATTR(TAG(tag2), +weight2, DATA(data2)); } LFS_ASSERT(attr_count <= sizeof(attrs)/sizeof(lfsr_attr_t)); - return lfsr_btree_commit(lfs, btree, attrs, attr_count); + return lfsr_btree_commit(lfs, btree, bid, attrs, attr_count); } ''' @@ -3188,10 +3184,10 @@ code = ''' // create a single-entry tree lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +1, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), - LFSR_ATTR(0, DATA, 0, BUF("0", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +1, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), + LFSR_ATTR(DATA, 0, BUF("0", 1)))) => 0; printf("btree: w%d 0x%x.%x\n", btree.weight, btree.blocks[0], @@ -3240,10 +3236,10 @@ code = ''' // create a two-entry tree lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +1, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), - LFSR_ATTR(0, DATA, 0, BUF("0", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +1, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), + LFSR_ATTR(DATA, 0, BUF("0", 1)))) => 0; lfsr_btree_split(&lfs, &btree, 0, LFSR_DATA_CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aab", 3)), LFSR_TAG_DATA, 1, LFSR_DATA_BUF("0", 1), @@ -3304,10 +3300,10 @@ code = ''' // create a two-entry tree lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +1, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), - LFSR_ATTR(0, DATA, 0, BUF("0", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +1, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), + LFSR_ATTR(DATA, 0, 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_DATA, 1, LFSR_DATA_BUF("0", 1), @@ -3380,10 +3376,10 @@ code = ''' // create a two-entry tree lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +1, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), - LFSR_ATTR(0, DATA, 0, BUF("0", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +1, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("aaa", 3))), + LFSR_ATTR( DATA, 0, 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_DATA, 1, LFSR_DATA_BUF("1", 1), @@ -3462,10 +3458,10 @@ code = ''' char name[3] = { alphas[(0/26/26) % 26], alphas[(0/26) % 26], alphas[0 % 26] }; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +1, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(0, DATA, 0, BUF(&nums[0 % 10], 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +1, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), + LFSR_ATTR(DATA, 0, BUF(&nums[0 % 10], 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { char name[3] = { @@ -3531,10 +3527,10 @@ code = ''' // create a btree lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +1, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), - LFSR_ATTR(0, DATA, 0, BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +1, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), + LFSR_ATTR(DATA, 0, BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3649,10 +3645,10 @@ code = ''' char name[3] = { alphas[(0/26/26) % 26], alphas[(0/26) % 26], alphas[0 % 26] }; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +W, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(W-1, DATA, 0, BUF(&nums[0 % 10], 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +W, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), + LFSR_ATTR(DATA, 0, BUF(&nums[0 % 10], 1)))) => 0; lfs_size_t n = 1; for (lfs_size_t i = 1; i < N; i++) { char name[3] = { @@ -3719,10 +3715,10 @@ code = ''' // create a btree lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +W, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), - LFSR_ATTR(W-1, DATA, 0, BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +W, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), + LFSR_ATTR(DATA, 0, BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3873,10 +3869,10 @@ code = ''' // create a btree lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +1, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), - LFSR_ATTR(0, DATA, 0, BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +1, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), + LFSR_ATTR(DATA, 0, BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -3922,12 +3918,12 @@ code = ''' assert(cmp >= 0); assert(lfs_cmp(cmp) != 0); if (lfs_cmp(cmp) > 0) { - int err = lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(split_bid, - NAME, +1, CAT( + int err = lfsr_btree_commit(&lfs, &btree, + split_bid-1, LFSR_ATTRS( + LFSR_ATTR(NAME, +1, CAT( LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(split_bid, DATA, 0, BUF(&nums[i % 10], 1)))); + LFSR_ATTR(DATA, 0, BUF(&nums[i % 10], 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; @@ -4043,10 +4039,10 @@ code = ''' // create a btree lfsr_btree_t btree; lfsr_btree_alloc(&lfs, &btree) => 0; - lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(0, - NAME, +W, CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), - LFSR_ATTR(W-1, DATA, 0, BUF("_", 1)))) => 0; + lfsr_btree_commit(&lfs, &btree, -1, LFSR_ATTRS( + LFSR_ATTR(NAME, +W, + CAT(LFSR_DATA_LEB128(0), LFSR_DATA_BUF("___", 3))), + LFSR_ATTR(DATA, 0, BUF("_", 1)))) => 0; // set up a simulation to compare against // @@ -4104,13 +4100,12 @@ code = ''' assert(cmp >= 0); assert(lfs_cmp(cmp) != 0); if (lfs_cmp(cmp) > 0) { - int err = lfsr_btree_commit(&lfs, &btree, LFSR_ATTRS( - LFSR_ATTR(split_bid-(split_weight-1), - NAME, +weight, CAT( + int err = lfsr_btree_commit(&lfs, &btree, + split_bid-(split_weight-1)-1, LFSR_ATTRS( + LFSR_ATTR(NAME, +weight, CAT( LFSR_DATA_LEB128(0), LFSR_DATA_BUF(name, 3))), - LFSR_ATTR(split_bid-(split_weight-1)+(weight-1), - DATA, 0, BUF(&nums[i % 10], 1)))); + LFSR_ATTR(DATA, 0, BUF(&nums[i % 10], 1)))); // ignore space issues if (err == LFS_ERR_NOSPC) { break; diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 177557d9..977dcd3e 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -29,6 +29,37 @@ code = ''' } ''' +[cases.test_rbyd_atomic_commit] +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, CFG) => 0; + + lfsr_rbyd_t init_rbyd = { + .blocks[0] = 0, + .eoff = 0, + .cksum = 0, + .trunk = 0, + .weight = 0, + }; + lfsr_rbyd_t rbyd; + + // commit with one attribute + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + + // commit with two attributes + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; +''' + [cases.test_rbyd_commit] in = 'lfs.c' code = ''' @@ -47,48 +78,17 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; -''' - -[cases.test_rbyd_multi_commit] -in = 'lfs.c' -code = ''' - lfs_t lfs; - lfs_init(&lfs, CFG) => 0; - - lfsr_rbyd_t init_rbyd = { - .blocks[0] = 0, - .eoff = 0, - .cksum = 0, - .trunk = 0, - .weight = 0, - }; - lfsr_rbyd_t rbyd; - - // commit with one attribute - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - - // commit with two attributes - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' @@ -110,21 +110,133 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + + // fetch lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // commit with the second attribute - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; ''' +# [cases.test_rbyd_atomic_fetchmatch] # [cases.test_rbyd_fetchmatch] -# [cases.test_rbyd_multi_fetchmatch] # TODO we really need to test dense keys... +[cases.test_rbyd_atomic_lookup] +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, CFG) => 0; + + lfsr_rbyd_t init_rbyd = { + .blocks[0] = 0, + .eoff = 0, + .cksum = 0, + .trunk = 0, + .weight = 0, + }; + lfsr_rbyd_t rbyd; + lfsr_tag_t tag_; + lfs_ssize_t rid_; + lfsr_data_t data_; + + // commit with one attribute + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + + // commit with two attributes + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + + // commit with two attributes, in the other direction + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; +''' + [cases.test_rbyd_lookup] in = 'lfs.c' code = ''' @@ -146,8 +258,8 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -169,9 +281,10 @@ code = ''' // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -203,9 +316,10 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -235,7 +349,7 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' -[cases.test_rbyd_multi_lookup] +[cases.test_rbyd_atomic_get] in = 'lfs.c' code = ''' lfs_t lfs; @@ -249,102 +363,69 @@ code = ''' .weight = 0, }; lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; + uint8_t buffer[4]; // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) + => 4; + assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) + => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) + => 4; + assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) + => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(2)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) + => 4; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) + => 4; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) + => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(2)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) + => 4; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) + => 4; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) + => LFS_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(2)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) + => 4; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) + => 4; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) + => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(2)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) + => 4; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) + => 4; + lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) + => LFS_ERR_NOENT; ''' [cases.test_rbyd_get] @@ -366,8 +447,8 @@ code = ''' // commit with one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) => 4; @@ -385,9 +466,10 @@ code = ''' // commit with two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) => 4; @@ -407,90 +489,10 @@ code = ''' // commit with two attributes, in the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) - => 4; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) - => 4; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) - => LFS_ERR_NOENT; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) - => 4; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) - => 4; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) - => LFS_ERR_NOENT; -''' - -[cases.test_rbyd_multi_get] -in = 'lfs.c' -code = ''' - lfs_t lfs; - lfs_init(&lfs, CFG) => 0; - - lfsr_rbyd_t init_rbyd = { - .blocks[0] = 0, - .eoff = 0, - .cksum = 0, - .trunk = 0, - .weight = 0, - }; - lfsr_rbyd_t rbyd; - uint8_t buffer[4]; - - // commit with one attribute - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) - => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) - => LFS_ERR_NOENT; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) - => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) - => LFS_ERR_NOENT; - - // commit with two attributes - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) - => 4; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) - => 4; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) - => LFS_ERR_NOENT; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) - => 4; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) - => 4; - lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), buffer, 4) - => LFS_ERR_NOENT; - - // commit with two attributes, in the other direction - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), buffer, 4) => 4; lfsr_rbyd_get(&lfs, &rbyd, -1, LFSR_TAG_UATTR(2), buffer, 4) @@ -531,9 +533,9 @@ code = ''' // 1 1 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -553,9 +555,9 @@ code = ''' // 2 2 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -594,10 +596,10 @@ code = ''' // 1 2 1 2 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -617,10 +619,10 @@ code = ''' // 1 2 1 2 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -661,10 +663,10 @@ code = ''' // 1 2 1 2 3 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -691,10 +693,10 @@ code = ''' // 2 3 2 3 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -740,11 +742,11 @@ code = ''' // 1 2 3 1 2 3 3 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -771,11 +773,11 @@ code = ''' // 1 2 3 1 2 3 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -802,11 +804,11 @@ code = ''' // 1 2 3 1 2 3 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -833,11 +835,11 @@ code = ''' // 3 1 2 3 1 2 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -885,11 +887,11 @@ code = ''' // 1 2 3 1 2 3 4 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -923,11 +925,11 @@ code = ''' // 1 3 4 1 3 4 2 1 3 4 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -961,11 +963,11 @@ code = ''' // 2 3 4 2 3 4 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -999,11 +1001,11 @@ code = ''' // 4 2 3 4 2 3 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1056,11 +1058,11 @@ code = ''' // 1 2 3 1 2 3 4 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1094,11 +1096,11 @@ code = ''' // 1 2 4 1 2 4 3 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1132,11 +1134,11 @@ code = ''' // 1 4 2 1 4 2 3 1 4 2 3 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1170,11 +1172,11 @@ code = ''' // 4 1 2 4 1 2 3 4 1 2 3 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1229,12 +1231,12 @@ code = ''' // 1 2 3 4 1 2 3 4 4 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1270,12 +1272,12 @@ code = ''' // 1 2 3 4 1 2 3 4 3 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1309,12 +1311,12 @@ code = ''' // 1 2 3 4 1 2 3 4 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1348,12 +1350,12 @@ code = ''' // 1 2 3 4 1 2 3 4 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1410,12 +1412,12 @@ code = ''' // 1 2 3 4 1 2 3 4 5 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1458,12 +1460,12 @@ code = ''' // 1 2 4 5 1 2 4 5 3 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1504,12 +1506,12 @@ code = ''' // 1 3 4 5 1 3 4 5 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1550,12 +1552,12 @@ code = ''' // 2 3 4 5 2 3 4 5 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1617,13 +1619,13 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 5 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1666,13 +1668,13 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1715,13 +1717,13 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1785,13 +1787,13 @@ code = ''' // 1 2 3 4 5 1 2 3 4 5 6 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(-1, UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1839,13 +1841,13 @@ code = ''' // 1 3 4 5 6 1 3 4 5 6 2 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(-1, UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1893,13 +1895,13 @@ code = ''' // 2 3 4 5 6 2 3 4 5 6 1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(-1, UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(6), 0, BUF("\xff\xff\xff\xff", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), @@ -1934,7 +1936,7 @@ code = ''' assert(lfsr_data_size(&data_) == 4); ''' -[cases.test_rbyd_permutations] +[cases.test_rbyd_atomic_permutations] defines.N = 'range(1, 8)' # -1 => exhaust all permutations # n => reproduce a specific permutation @@ -1982,14 +1984,14 @@ code = ''' // build the attribute list for the current permutation struct lfsr_attr attrs[N]; for (unsigned j = 0; j < N; j++) { - attrs[j] = LFSR_ATTR(-1, UATTR(perm[j]+1), 0, + attrs[j] = LFSR_ATTR(UATTR(perm[j]+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)); } // test the given permutation rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, attrs, N) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; for (unsigned j = 0; j < N; j++) { @@ -2022,7 +2024,7 @@ code = ''' } ''' -[cases.test_rbyd_multi_permutations] +[cases.test_rbyd_permutations] defines.N = 'range(1, 8)' # -1 => exhaust all permutations # n => reproduce a specific permutation @@ -2073,8 +2075,8 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(perm[j]+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(perm[j]+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -2109,6 +2111,95 @@ code = ''' } ''' +[cases.test_rbyd_atomic_traverse] +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, CFG) => 0; + + lfsr_rbyd_t init_rbyd = { + .blocks[0] = 0, + .eoff = 0, + .cksum = 0, + .trunk = 0, + .weight = 0, + }; + lfsr_rbyd_t rbyd; + lfsr_tag_t tag_; + lfs_ssize_t rid_; + lfsr_data_t data_; + + // traverse requires correct biasing of the weights in the rbyd tree + // so that lookups return strictly the tag greater than or equal to + // the tag requested + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + + // also try the other direction + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; + lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(rid_ == -1); + assert(lfsr_data_size(&data_) == 4); + lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, + &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; +''' + [cases.test_rbyd_traverse] in = 'lfs.c' code = ''' @@ -2132,9 +2223,10 @@ code = ''' // the tag requested rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2166,9 +2258,10 @@ code = ''' // also try the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -2198,98 +2291,7 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' -[cases.test_rbyd_multi_traverse] -in = 'lfs.c' -code = ''' - lfs_t lfs; - lfs_init(&lfs, CFG) => 0; - - lfsr_rbyd_t init_rbyd = { - .blocks[0] = 0, - .eoff = 0, - .cksum = 0, - .trunk = 0, - .weight = 0, - }; - lfsr_rbyd_t rbyd; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - - // traverse requires correct biasing of the weights in the rbyd tree - // so that lookups return strictly the tag greater than or equal to - // the tag requested - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(2)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(2)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - - // also try the other direction - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(2)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(2)); - assert(rid_ == -1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; -''' - -[cases.test_rbyd_traverse_permutations] +[cases.test_rbyd_atomic_traverse_permutations] defines.N = 'range(1, 8)' # -1 => exhaust all permutations # n => reproduce a specific permutation @@ -2333,14 +2335,14 @@ code = ''' // build the attribute list for the current permutation struct lfsr_attr attrs[N]; for (unsigned j = 0; j < N; j++) { - attrs[j] = LFSR_ATTR(-1, UATTR(perm[j]+1), 0, + attrs[j] = LFSR_ATTR(UATTR(perm[j]+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)); } // test the given permutation rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, attrs, N) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; // try traversing all tags @@ -2358,7 +2360,7 @@ code = ''' } ''' -[cases.test_rbyd_multi_traverse_permutations] +[cases.test_rbyd_traverse_permutations] defines.N = 'range(1, 8)' # -1 => exhaust all permutations # n => reproduce a specific permutation @@ -2406,8 +2408,8 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(perm[j]+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(perm[j]+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -2462,8 +2464,8 @@ code = ''' lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(j+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(j+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -2502,8 +2504,8 @@ code = ''' // update each tag in permutation order for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(perm[j]+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(perm[j]+1), 0, BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; } @@ -2580,8 +2582,8 @@ code = ''' = (ORDER == 0) ? i : (ORDER == 1) ? (((lfs_size_t)-1) - i) : TEST_PRNG(&prng); - int err = lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(x & 0x7f), 0, BUF("\xaa\xaa\xaa\xaa", 4)))); + int err = lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(x & 0x7f), 0, BUF("\xaa\xaa\xaa\xaa", 4)))); if (err == LFS_ERR_RANGE) { break; } @@ -2630,10 +2632,10 @@ code = ''' // add and remove one attribute rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -2649,11 +2651,11 @@ code = ''' // commit with two attributes, remove the first one rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -2685,11 +2687,11 @@ code = ''' // commit with two attributes, remove the second one rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(2)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(2)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -2766,8 +2768,8 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(perm[j]+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(perm[j]+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -2790,8 +2792,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(j+1)), 0, NULL()))) + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(j+1)), 0, NULL()))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -2818,8 +2820,8 @@ code = ''' // try appending the tag back to make sure things still work printf("--- append: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(j+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(j+1), 0, BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -2913,8 +2915,8 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(perm[j]+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(perm[j]+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } @@ -2937,8 +2939,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(j+1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(j+1)), 0, NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -2989,9 +2991,9 @@ code = ''' // create a tree two attributes rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3016,8 +3018,8 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3041,8 +3043,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(3)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(3)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3066,8 +3068,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(5)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(5)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3138,17 +3140,17 @@ code = ''' // create a tree rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(3), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(4), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(5), 0, BUF("\xee\xee\xee\xee", 4)))) => 0; // remove several attributes - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()), - LFSR_ATTR(-1, RM(UATTR(3)), 0, NULL()), - LFSR_ATTR(-1, RM(UATTR(5)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()), + LFSR_ATTR(RM(UATTR(3)), 0, NULL()), + LFSR_ATTR(RM(UATTR(5)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; @@ -3174,8 +3176,8 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3199,8 +3201,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(3)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(3)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3224,8 +3226,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(5)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(5)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3251,8 +3253,8 @@ code = ''' // try to remove the tags again, just to make sure (keep in mind // these removes still commit to the rbyd) - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3276,8 +3278,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(3)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(3)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3301,8 +3303,8 @@ code = ''' lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(5), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(5)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(5)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); @@ -3373,10 +3375,10 @@ code = ''' // commit with one attribute, remove it rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3392,12 +3394,12 @@ code = ''' // commit with two attributes, remove both rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()), - LFSR_ATTR(-1, RM(UATTR(2)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()), + LFSR_ATTR(RM(UATTR(2)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3413,12 +3415,12 @@ code = ''' // commit with two attributes, remove both in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(2)), 0, NULL()), - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(2)), 0, NULL()), + LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(1), &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; @@ -3467,8 +3469,8 @@ code = ''' lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(j+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(j+1), 0, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; } // copy block so we can reset after each remove @@ -3507,8 +3509,8 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(perm[j]+1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(perm[j]+1)), 0, NULL()))) => 0; } // check that all tags are now removed @@ -3519,8 +3521,8 @@ code = ''' } // try resuming from all tags being removed - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -3616,15 +3618,15 @@ code = ''' // update our sim sim[attr] = alpha[i % 26]; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(attr), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(attr), 0, BUF(&alpha[i % 26], 1)))) => 0; } else { // update our sim sim[attr] = '\0'; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(attr)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(attr)), 0, NULL()))) => 0; } } @@ -3674,7 +3676,7 @@ code = ''' ### Insertion testing ### -[cases.test_rbyd_create] +[cases.test_rbyd_atomic_create] in = 'lfs.c' code = ''' lfs_t lfs; @@ -3693,8 +3695,8 @@ code = ''' // try to create one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -3708,29 +3710,9 @@ code = ''' // try to create two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - - assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - - // try to create two in the other direction - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -3748,60 +3730,10 @@ code = ''' // create a third to the right rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - - assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - - // create a third to the left - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - - assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - - // create a third in the middle - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -3821,7 +3753,7 @@ code = ''' assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); ''' -[cases.test_rbyd_multi_create] +[cases.test_rbyd_create] in = 'lfs.c' code = ''' lfs_t lfs; @@ -3840,8 +3772,8 @@ code = ''' // try to create one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -3857,10 +3789,10 @@ code = ''' // try to create two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -3878,10 +3810,10 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -3899,12 +3831,12 @@ code = ''' // create a third to the right rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -3926,12 +3858,12 @@ code = ''' // create a third to the left rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -3953,12 +3885,12 @@ code = ''' // create a third in the middle rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -3983,105 +3915,6 @@ defines.N = 'range(1, 8)' # -1 => exhaust all permutations # n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' -code = ''' - lfs_t lfs; - lfs_init(&lfs, CFG) => 0; - - lfsr_rbyd_t init_rbyd = { - .blocks[0] = 0, - .eoff = 0, - .cksum = 0, - .trunk = 0, - .weight = 0, - }; - lfsr_rbyd_t rbyd; - const uint8_t names[6][4] = { - "\xaa\xaa\xaa\xaa", - "\xbb\xbb\xbb\xbb", - "\xcc\xcc\xcc\xcc", - "\xdd\xdd\xdd\xdd", - "\xee\xee\xee\xee", - "\xff\xff\xff\xff", - }; - uint8_t buffer[4]; - - // keep track of the worst case log size - lfs_size_t worst_size = 0; - size_t worst_perm_i = 0; - - // test all permutations of a given size - size_t perm_count = TEST_FACTORIAL(N); - for (size_t i = 0; - i < ((PERMUTATION == -1) ? perm_count : 1); - i++) { - uint32_t perm[N]; - size_t perm_i = (PERMUTATION == -1) ? i : (size_t)PERMUTATION; - TEST_PERMUTATION(perm_i, perm, N); - - // print permutation to help debugging - printf("--- permutation: %zd [", perm_i); - for (unsigned j = 0; j < N; j++) { - if (j > 0) { - printf(", "); - } - printf("%d", perm[j]); - } - printf("] ---\n"); - - // build the attribute list for the current permutation - struct lfsr_attr attrs[N]; - for (unsigned j = 0; j < N; j++) { - // adjust rid based on future insertions - uint16_t rid = perm[j]; - for (unsigned k = j+1; k < N; k++) { - if (perm[j] > perm[k]) { - rid -= 1; - } - } - - attrs[j] = LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)); - } - - // test the given permutation - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == N); - for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, names[j % 6], 4) == 0); - } - - // keep track of the worst size - if (rbyd.eoff > worst_size) { - worst_size = rbyd.eoff; - worst_perm_i = perm_i; - } - } - - // test that tree is self-balancing, we should be strictly bounded - // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N; - printf("--- summary ---\n"); - printf("worst permutation: %zd\n", worst_perm_i); - printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); - printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); - // note this only holds true with byte-level progs - if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); - } -''' - -[cases.test_rbyd_multi_create_permutations] -defines.N = 'range(1, 8)' -# -1 => exhaust all permutations -# n => reproduce a specific permutation -defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' in = 'lfs.c' @@ -4142,8 +3975,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4176,7 +4009,7 @@ code = ''' } ''' -[cases.test_rbyd_create_traverse] +[cases.test_rbyd_atomic_create_traverse] in = 'lfs.c' code = ''' lfs_t lfs; @@ -4200,51 +4033,9 @@ code = ''' // the tag requested rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == 0); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == 1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == 0); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == 1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - - // also try the other direction - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4282,7 +4073,7 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' -[cases.test_rbyd_multi_create_traverse] +[cases.test_rbyd_create_traverse] in = 'lfs.c' code = ''' lfs_t lfs; @@ -4306,10 +4097,10 @@ code = ''' // the tag requested rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4349,10 +4140,10 @@ code = ''' // also try the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -4395,95 +4186,6 @@ defines.N = 'range(1, 8)' # -1 => exhaust all permutations # n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' -code = ''' - lfs_t lfs; - lfs_init(&lfs, CFG) => 0; - - lfsr_rbyd_t init_rbyd = { - .blocks[0] = 0, - .eoff = 0, - .cksum = 0, - .trunk = 0, - .weight = 0, - }; - lfsr_rbyd_t rbyd; - const uint8_t names[6][4] = { - "\xaa\xaa\xaa\xaa", - "\xbb\xbb\xbb\xbb", - "\xcc\xcc\xcc\xcc", - "\xdd\xdd\xdd\xdd", - "\xee\xee\xee\xee", - "\xff\xff\xff\xff", - }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - uint8_t buffer[4]; - - // test all permutations of a given size - size_t perm_count = TEST_FACTORIAL(N); - for (size_t i = 0; - i < ((PERMUTATION == -1) ? perm_count : 1); - i++) { - uint32_t perm[N]; - size_t perm_i = (PERMUTATION == -1) ? i : (size_t)PERMUTATION; - TEST_PERMUTATION(perm_i, perm, N); - - // print permutation to help debugging - printf("--- permutation: %zd [", perm_i); - for (unsigned j = 0; j < N; j++) { - if (j > 0) { - printf(", "); - } - printf("%d", perm[j]); - } - printf("] ---\n"); - - // build the attribute list for the current permutation - struct lfsr_attr attrs[N]; - for (unsigned j = 0; j < N; j++) { - // adjust rid based on future insertions - uint16_t rid = perm[j]; - for (unsigned k = j+1; k < N; k++) { - if (perm[j] > perm[k]) { - rid -= 1; - } - } - - attrs[j] = LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)); - } - - // test the given permutation - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, attrs, N) => 0; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == N); - // try traversing all tags - tag_ = 0; - rid_ = -1; - for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == j); - assert(lfsr_data_size(&data_) == 4); - - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, names[j % 6], 4) == 0); - } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - } -''' - -[cases.test_rbyd_multi_create_traverse_permutations] -defines.N = 'range(1, 8)' -# -1 => exhaust all permutations -# n => reproduce a specific permutation -defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' in = 'lfs.c' @@ -4543,8 +4245,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; } lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; @@ -4613,8 +4315,8 @@ code = ''' : (uint16_t)TEST_PRNG(&prng); x = x % (rbyd.weight+1); - int err = lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(x, REG, +1, BUF(names[x % 6], 4)))); + int err = lfsr_rbyd_commit(&lfs, &rbyd, x-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[x % 6], 4)))); if (err == LFS_ERR_RANGE) { break; } @@ -4640,7 +4342,7 @@ code = ''' ### Mixed create and attr testing ### -[cases.test_rbyd_mixed] +[cases.test_rbyd_atomic_mixed] in = 'lfs.c' code = ''' lfs_t lfs; @@ -4659,9 +4361,9 @@ code = ''' // try to create one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -4679,41 +4381,11 @@ code = ''' // try to create two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - - assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == 2); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - - // try to create two in the other direction - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb", 2)), - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -4739,13 +4411,13 @@ code = ''' // create a third to the right rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(2, UATTR(1), 0, BUF( "\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -4792,89 +4464,9 @@ code = ''' assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - - // create a third to the left - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xcc\xcc", 2)), - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; - - assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - - // create a third in the middle - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xcc\xcc", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - - assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xcc\xcc", 2) == 0); - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == 3); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 1, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, "\xcc\xcc\xcc\xcc", 4) == 0); - lfsr_rbyd_get(&lfs, &rbyd, 2, LFSR_TAG_UATTR(1), buffer, 4) => 2; - assert(memcmp(buffer, "\xcc\xcc", 2) == 0); ''' -[cases.test_rbyd_multi_mixed] +[cases.test_rbyd_mixed] in = 'lfs.c' code = ''' lfs_t lfs; @@ -4893,10 +4485,10 @@ code = ''' // try to create one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -4914,14 +4506,14 @@ code = ''' // try to create two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -4947,14 +4539,14 @@ code = ''' // try to create two in the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -4980,18 +4572,18 @@ code = ''' // create a third to the right rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(2, UATTR(1), 0, BUF( "\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -5042,18 +4634,18 @@ code = ''' // create a third to the left rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -5087,18 +4679,18 @@ code = ''' // create a third in the middle rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -5136,118 +4728,6 @@ defines.M = 'range(1, 4)' # -1 => exhaust all permutations # n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' -code = ''' - lfs_t lfs; - lfs_init(&lfs, CFG) => 0; - - lfsr_rbyd_t init_rbyd = { - .blocks[0] = 0, - .eoff = 0, - .cksum = 0, - .trunk = 0, - .weight = 0, - }; - lfsr_rbyd_t rbyd; - const uint8_t names[6][4] = { - "\xaa\xaa\xaa\xaa", - "\xbb\xbb\xbb\xbb", - "\xcc\xcc\xcc\xcc", - "\xdd\xdd\xdd\xdd", - "\xee\xee\xee\xee", - "\xff\xff\xff\xff", - }; - uint8_t buffer[4]; - - // keep track of the worst case log size - lfs_size_t worst_size = 0; - size_t worst_perm_i = 0; - - // test all permutations of a given size - size_t perm_count = TEST_FACTORIAL(N); - for (size_t i = 0; - i < ((PERMUTATION == -1) ? perm_count : 1); - i++) { - uint32_t perm[N]; - size_t perm_i = (PERMUTATION == -1) ? i : (size_t)PERMUTATION; - TEST_PERMUTATION(perm_i, perm, N); - - // print permutation to help debugging - printf("--- permutation: %zd [", perm_i); - for (unsigned j = 0; j < N; j++) { - if (j > 0) { - printf(", "); - } - printf("%d", perm[j]); - } - printf("] ---\n"); - - // build the attribute list for the current permutation - struct lfsr_attr attrs[(1+M)*N]; - for (unsigned j = 0; j < N; j++) { - // adjust rid based on future insertions - uint16_t rid = perm[j]; - for (unsigned k = j+1; k < N; k++) { - if (perm[j] > perm[k]) { - rid -= 1; - } - } - - attrs[(1+M)*j] = LFSR_ATTR(rid, REG, +1, - BUF(names[perm[j] % 6], 4)); - // note uattrs have a smaller size to help debugging - for (unsigned u = 0; u < M; u++) { - attrs[(1+M)*j+1+u] = LFSR_ATTR(rid, UATTR(u+1), 0, - BUF(names[perm[j] % 6], 2)); - } - } - - // test the given permutation - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, attrs, (1+M)*N) => 0; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == N); - for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_REG, buffer, 4) => 4; - assert(memcmp(buffer, names[j % 6], 4) == 0); - - for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_get(&lfs, &rbyd, j, LFSR_TAG_UATTR(u+1), buffer, 4) - => 2; - assert(memcmp(buffer, names[j % 6], 2) == 0); - } - } - - // keep track of the worst size - if (rbyd.eoff > worst_size) { - worst_size = rbyd.eoff; - worst_perm_i = perm_i; - } - } - - // test that tree is self-balancing, we should be strictly bounded - // by height <= 2*log(n)+1, assume tags are strictly <=12 bytes - lfs_size_t n = 1 + N + N*M; - printf("--- summary ---\n"); - printf("worst permutation: %zd\n", worst_perm_i); - printf("worst size: %u B (N=%u, estimate=%u)\n", - worst_size, n, 12*n*(2*lfs_nlog2(n)+1)+4); - printf("worst avg height: %u B (N=%u, estimate=%u)\n", - worst_size / n, n, 12*(2*lfs_nlog2(n)+1)+4); - // note this only holds true with byte-level progs - if (PROG_SIZE == 1) { - assert(worst_size / n <= 12*(2*lfs_nlog2(n)+1)+4); - } -''' - -[cases.test_rbyd_multi_mixed_permutations] -defines.N = 'range(1, 7)' -defines.M = 'range(1, 4)' -# -1 => exhaust all permutations -# n => reproduce a specific permutation -defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' in = 'lfs.c' @@ -5308,12 +4788,12 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR(u+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -5353,7 +4833,7 @@ code = ''' } ''' -[cases.test_rbyd_mixed_traverse] +[cases.test_rbyd_atomic_mixed_traverse] in = 'lfs.c' code = ''' lfs_t lfs; @@ -5377,83 +4857,11 @@ code = ''' // the tag requested rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == 0); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == 0); - assert(lfsr_data_size(&data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; - assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == 1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == 1); - assert(lfsr_data_size(&data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; - assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == 0); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == 0); - assert(lfsr_data_size(&data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; - assert(memcmp(buffer, "\xaa\xaa", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == 1); - assert(lfsr_data_size(&data_) == 4); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(1)); - assert(rid_ == 1); - assert(lfsr_data_size(&data_) == 2); - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; - assert(memcmp(buffer, "\xbb\xbb", 2) == 0); - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - - // also try the other direction - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb", 2)), - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5519,7 +4927,7 @@ code = ''' &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; ''' -[cases.test_rbyd_multi_mixed_traverse] +[cases.test_rbyd_mixed_traverse] in = 'lfs.c' code = ''' lfs_t lfs; @@ -5543,14 +4951,14 @@ code = ''' // the tag requested rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5618,14 +5026,14 @@ code = ''' // also try the other direction rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, &rid_, &tag_, NULL, &data_) => 0; @@ -5697,114 +5105,6 @@ defines.M = 'range(1, 4)' # -1 => exhaust all permutations # n => reproduce a specific permutation defines.PERMUTATION = -1 -in = 'lfs.c' -code = ''' - lfs_t lfs; - lfs_init(&lfs, CFG) => 0; - - lfsr_rbyd_t init_rbyd = { - .blocks[0] = 0, - .eoff = 0, - .cksum = 0, - .trunk = 0, - .weight = 0, - }; - lfsr_rbyd_t rbyd; - const uint8_t names[6][4] = { - "\xaa\xaa\xaa\xaa", - "\xbb\xbb\xbb\xbb", - "\xcc\xcc\xcc\xcc", - "\xdd\xdd\xdd\xdd", - "\xee\xee\xee\xee", - "\xff\xff\xff\xff", - }; - lfsr_tag_t tag_; - lfs_ssize_t rid_; - lfsr_data_t data_; - uint8_t buffer[4]; - - // test all permutations of a given size - size_t perm_count = TEST_FACTORIAL(N); - for (size_t i = 0; - i < ((PERMUTATION == -1) ? perm_count : 1); - i++) { - uint32_t perm[N]; - size_t perm_i = (PERMUTATION == -1) ? i : (size_t)PERMUTATION; - TEST_PERMUTATION(perm_i, perm, N); - - // print permutation to help debugging - printf("--- permutation: %zd [", perm_i); - for (unsigned j = 0; j < N; j++) { - if (j > 0) { - printf(", "); - } - printf("%d", perm[j]); - } - printf("] ---\n"); - - // build the attribute list for the current permutation - struct lfsr_attr attrs[(1+M)*N]; - for (unsigned j = 0; j < N; j++) { - // adjust rid based on future insertions - uint16_t rid = perm[j]; - for (unsigned k = j+1; k < N; k++) { - if (perm[j] > perm[k]) { - rid -= 1; - } - } - - attrs[(1+M)*j] = LFSR_ATTR(rid, REG, +1, - BUF(names[perm[j] % 6], 4)); - // note uattrs have a smaller size to help debugging - for (unsigned u = 0; u < M; u++) { - attrs[(1+M)*j+1+u] = LFSR_ATTR(rid, UATTR(u+1), 0, - BUF(names[perm[j] % 6], 2)); - } - } - - // test the given permutation - rbyd = init_rbyd; - lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, attrs, (1+M)*N) => 0; - - lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], 0) => 0; - assert(rbyd.weight == N); - - // try traversing all tags - tag_ = 0; - rid_ = -1; - for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_REG); - assert(rid_ == j); - assert(lfsr_data_size(&data_) == 4); - - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 4; - assert(memcmp(buffer, names[j % 6], 4) == 0); - - for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => 0; - assert(tag_ == LFSR_TAG_UATTR(u+1)); - assert(rid_ == j); - assert(lfsr_data_size(&data_) == 2); - - lfsr_rbyd_get(&lfs, &rbyd, rid_, tag_, buffer, 4) => 2; - assert(memcmp(buffer, names[j % 6], 2) == 0); - } - } - lfsr_rbyd_lookupnext(&lfs, &rbyd, rid_, tag_+1, - &rid_, &tag_, NULL, &data_) => LFS_ERR_NOENT; - } -''' - -[cases.test_rbyd_multi_mixed_traverse_permutations] -defines.N = 'range(1, 7)' -defines.M = 'range(1, 4)' -# -1 => exhaust all permutations -# n => reproduce a specific permutation -defines.PERMUTATION = -1 # large progs take too long for now if = 'PROG_SIZE < 512' in = 'lfs.c' @@ -5864,12 +5164,12 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR(u+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -5948,12 +5248,12 @@ code = ''' lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, REG, +1, BUF(names[j % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[j % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, UATTR(u+1), 0, BUF(names[j % 6], 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[j % 6], 2)))) => 0; } } @@ -5993,8 +5293,8 @@ code = ''' // update each tag in permutation order for (unsigned j = 0; j < N*M; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(perm[j]/M, UATTR(perm[j]%M+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS( + LFSR_ATTR(UATTR(perm[j]%M+1), 0, BUF(names[(perm[j]/M) % 6], 3)))) => 0; } @@ -6107,12 +5407,12 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR(u+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -6136,8 +5436,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j/M, RM(UATTR((j%M)+1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR((j%M)+1)), 0, NULL()))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; for (unsigned k = 0; k < N; k++) { @@ -6176,8 +5476,8 @@ code = ''' // try append the tag back to make sure things still work printf("--- append: rid%jd, %jd ---\n", j/M, (j%M)+1); - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j/M, UATTR((j%M)+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, j/M, LFSR_ATTRS( + LFSR_ATTR(UATTR((j%M)+1), 0, BUF(names[(j/M)%6], 3)))) => 0; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -6275,12 +5575,12 @@ code = ''' lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, REG, +1, BUF(names[j % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[j % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, UATTR(u+1), 0, BUF(names[j % 6], 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[j % 6], 2)))) => 0; } } @@ -6320,8 +5620,8 @@ code = ''' // remove each tag in permutation order for (unsigned j = 0; j < N*M; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(perm[j]/M, RM(UATTR(perm[j]%M+1)), + lfsr_rbyd_commit(&lfs, &rbyd, perm[j]/M, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(perm[j]%M+1)), 0, NULL()))) => 0; } @@ -6412,12 +5712,12 @@ code = ''' // build a single attribute list with all attributes, if this fails // it should fail atomically struct lfsr_attr attrs[1+M]; - attrs[0] = LFSR_ATTR(x, REG, +1, BUF(names[x % 6], 4)); + attrs[0] = LFSR_ATTR(REG, +1, BUF(names[x % 6], 4)); for (unsigned u = 0; u < M; u++) { - attrs[1+u] = LFSR_ATTR(x, UATTR(u+1), 0, BUF(names[x % 6], 2)); + attrs[1+u] = LFSR_ATTR(UATTR(u+1), 0, BUF(names[x % 6], 2)); } - int err = lfsr_rbyd_commit(&lfs, &rbyd, attrs, 1+M); + int err = lfsr_rbyd_commit(&lfs, &rbyd, x-1, attrs, 1+M); if (err == LFS_ERR_RANGE) { break; } @@ -6517,12 +5817,12 @@ code = ''' } // note the data size differences here - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(perm[j]+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(perm[j]+1), 0, BUF(names[perm[j] % 6], 1)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; } @@ -6656,16 +5956,16 @@ code = ''' } // note the data size differences here - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(perm[j]+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(perm[j]+1), 0, BUF(names[perm[j] % 6], 1)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR(u+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -6771,11 +6071,11 @@ code = ''' // try to delete one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -6791,11 +6091,11 @@ code = ''' // try to delete the other rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -6811,12 +6111,12 @@ code = ''' // try to delete the largest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(2, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -6834,12 +6134,12 @@ code = ''' // try to delete the smallest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -6857,12 +6157,12 @@ code = ''' // try to delete the middle rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -6897,13 +6197,13 @@ code = ''' // try to delete one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -6933,13 +6233,13 @@ code = ''' // try to delete the other rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -6969,15 +6269,15 @@ code = ''' // try to delete the largest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(2, UATTR(1), 0, BUF( "\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(2, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => 4; @@ -7018,15 +6318,15 @@ code = ''' // try to delete the smallest of three rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(2, UATTR(1), 0, BUF( "\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7068,15 +6368,15 @@ code = ''' // try to delete the middle rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(2, UATTR(1), 0, BUF( "\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7184,8 +6484,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -7208,8 +6508,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -7227,8 +6527,8 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, REG, +1, BUF(names[j % 6], 6)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -7340,12 +6640,12 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR(u+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -7370,8 +6670,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -7401,11 +6701,11 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, REG, +1, BUF(names[j % 6], 6)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[j % 6], 6)))) => 0; for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, UATTR(u+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[j % 6], 3)))) => 0; } assert(rbyd.weight == N); @@ -7531,8 +6831,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -7555,8 +6855,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -7657,12 +6957,12 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR(u+1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[perm[j] % 6], 2)))) => 0; } } @@ -7687,8 +6987,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -7757,10 +7057,10 @@ code = ''' // create and delete one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7774,12 +7074,12 @@ code = ''' // create and delete two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()), + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7793,12 +7093,13 @@ code = ''' // create and delete two ids in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7812,14 +7113,14 @@ code = ''' // create and delete three ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()), + LFSR_ATTR(RM, -1, NULL()), + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7833,14 +7134,16 @@ code = ''' // create and delete three ids in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(2, RM, -1, NULL()), - LFSR_ATTR(1, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7850,6 +7153,7 @@ code = ''' assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) => LFS_ERR_NOENT; + ''' [cases.test_rbyd_delete_all_range] @@ -7871,11 +7175,11 @@ code = ''' // create and delete one rid rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7889,14 +7193,14 @@ code = ''' // create and delete two ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 1, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()), + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7910,14 +7214,15 @@ code = ''' // create and delete two ids in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7931,17 +7236,17 @@ code = ''' // create and delete three ids rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(2, UATTR(1), 0, BUF( "\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()), + LFSR_ATTR(RM, -1, NULL()), + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -7955,17 +7260,19 @@ code = ''' // create and delete three ids in the other order rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF( "\xaa\xaa", 2)), - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF( "\xbb\xbb", 2)), - LFSR_ATTR(2, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(2, UATTR(1), 0, BUF( "\xcc\xcc", 2)))) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(2, RM, -1, NULL()), - LFSR_ATTR(1, RM, -1, NULL()), - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, 0, LFSR_TAG_REG, buffer, 4) @@ -8018,8 +7325,8 @@ code = ''' lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, REG, +1, BUF(names[j % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[j % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -8068,8 +7375,8 @@ code = ''' } lfs_size_t rbyd_weight_before = rbyd.weight; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -8081,8 +7388,8 @@ code = ''' => LFS_ERR_NOENT; // try resuming from all tags being removed - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; assert(rbyd.weight == 1); @@ -8163,12 +7470,12 @@ code = ''' lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; for (unsigned j = 0; j < N; j++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, REG, +1, BUF(names[j % 6], 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[j % 6], 4)))) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, UATTR(u+1), 0, BUF(names[j % 6], 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF(names[j % 6], 2)))) => 0; } } assert(rbyd.weight == N); @@ -8218,8 +7525,8 @@ code = ''' } lfs_size_t rbyd_weight_before = rbyd.weight; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -8231,12 +7538,12 @@ code = ''' => LFS_ERR_NOENT; // try resuming from all tags being removed - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa\xaa\xaa", 6)))) => 0; for (unsigned u = 0; u < M; u++) { - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, UATTR(u+1), 0, BUF("\xaa\xaa\xaa", 3)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(UATTR(u+1), 0, BUF("\xaa\xaa\xaa", 3)))) => 0; } assert(rbyd.weight == 1); @@ -8348,15 +7655,15 @@ code = ''' sim[rid] = alpha[i % 26]; count += 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(&alpha[i % 26], 1)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(&alpha[i % 26], 1)))) => 0; } else { // update our sim memmove(sim+rid, sim+rid+1, count-rid-1); count -= 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; } } @@ -8418,8 +7725,8 @@ code = ''' // make id0 with weight w1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -8437,8 +7744,8 @@ code = ''' assert(lfsr_data_size(&data_) == 4); // make id2 with weight w2 - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +2, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +2, BUF("\xbb\xbb\xbb\xbb", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -8468,8 +7775,8 @@ code = ''' assert(lfsr_data_size(&data_) == 4); // make id5 with weight w3 - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(3, REG, +3, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( + LFSR_ATTR(REG, +3, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -8511,8 +7818,8 @@ code = ''' assert(lfsr_data_size(&data_) == 4); // make id9 with weight w4 - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(6, REG, +4, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 5, LFSR_ATTRS( + LFSR_ATTR(REG, +4, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -8566,8 +7873,8 @@ code = ''' assert(lfsr_data_size(&data_) == 4); // make id14 with weight w5 - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(10, REG, +5, BUF("\xee\xee\xee\xee", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 9, LFSR_ATTRS( + LFSR_ATTR(REG, +5, BUF("\xee\xee\xee\xee", 4)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, 0, LFSR_TAG_REG, &rid_, &tag_, &weight_, &data_) => 0; @@ -8654,17 +7961,17 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( // make id0 with weight w1 - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), // make id2 with weight w2 - LFSR_ATTR(1, REG, +2, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(REG, +2, BUF("\xbb\xbb\xbb\xbb", 4)), // make id5 with weight w3 - LFSR_ATTR(3, REG, +3, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(REG, +3, BUF("\xcc\xcc\xcc\xcc", 4)), // make id9 with weight w4 - LFSR_ATTR(6, REG, +4, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(REG, +4, BUF("\xdd\xdd\xdd\xdd", 4)), // make id14 with weight w5 - LFSR_ATTR(10, REG, +5, BUF("\xee\xee\xee\xee", 4)))) => 0; + LFSR_ATTR(REG, +5, BUF("\xee\xee\xee\xee", 4)))) => 0; // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, @@ -8801,8 +8108,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +W, BUF(names[perm[j] % 6], 4)))) => 0; } @@ -8888,8 +8195,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +W, BUF(names[perm[j] % 6], 4)))) => 0; } @@ -8937,11 +8244,11 @@ code = ''' // make id0 with weight w1 rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)), - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(0, UATTR(2), 0, BUF("\xaa\xaa", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)), + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(UATTR(2), 0, BUF("\xaa\xaa", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -8995,11 +8302,11 @@ code = ''' assert(lfsr_data_size(&data_) == 2); // make id2 with weight w2 - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(1, RM, +1, NULL()), - LFSR_ATTR(2, UATTR(2), 0, BUF("\xbb\xbb", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR(GROW, +1, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -9089,11 +8396,11 @@ code = ''' assert(lfsr_data_size(&data_) == 2); // make id5 with weight w3 - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(3, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(3, UATTR(1), 0, BUF("\xcc\xcc", 2)), - LFSR_ATTR(3, RM, +2, NULL()), - LFSR_ATTR(5, UATTR(2), 0, BUF("\xcc\xcc", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 2, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)), + LFSR_ATTR(GROW, +2, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF("\xcc\xcc", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -9219,11 +8526,11 @@ code = ''' assert(lfsr_data_size(&data_) == 2); // make id9 with weight w4 - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(6, REG, +1, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(6, UATTR(1), 0, BUF("\xdd\xdd", 2)), - LFSR_ATTR(6, RM, +3, NULL()), - LFSR_ATTR(9, UATTR(2), 0, BUF("\xdd\xdd", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 5, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xdd\xdd", 2)), + LFSR_ATTR(GROW, +3, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF("\xdd\xdd", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -9385,11 +8692,11 @@ code = ''' assert(lfsr_data_size(&data_) == 2); // make id14 with weight w5 - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(10, REG, +1, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(10, UATTR(1), 0, BUF("\xee\xee", 2)), - LFSR_ATTR(10, RM, +4, NULL()), - LFSR_ATTR(14, UATTR(2), 0, BUF("\xee\xee", 2)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 9, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xee\xee", 2)), + LFSR_ATTR(GROW, +4, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF("\xee\xee", 2)))) => 0; lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, LFSR_TAG_UATTR(3), &rid_, &tag_, &weight_, &data_) => 0; @@ -9608,32 +8915,32 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)), + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)), // make id0 with weight w1 - LFSR_ATTR(0, REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, UATTR(1), 0, BUF("\xaa\xaa", 2)), - LFSR_ATTR(0, UATTR(2), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(REG, +1, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xaa\xaa", 2)), + LFSR_ATTR(UATTR(2), 0, BUF("\xaa\xaa", 2)), // make id2 with weight w2 - LFSR_ATTR(1, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, UATTR(1), 0, BUF("\xbb\xbb", 2)), - LFSR_ATTR(1, RM, +1, NULL()), - LFSR_ATTR(2, UATTR(2), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb", 2)), + LFSR_ATTR(GROW, +1, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF("\xbb\xbb", 2)), // make id5 with weight w3 - LFSR_ATTR(3, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(3, UATTR(1), 0, BUF("\xcc\xcc", 2)), - LFSR_ATTR(3, RM, +2, NULL()), - LFSR_ATTR(5, UATTR(2), 0, BUF("\xcc\xcc", 2)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xcc\xcc", 2)), + LFSR_ATTR(GROW, +2, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF("\xcc\xcc", 2)), // make id9 with weight w4 - LFSR_ATTR(6, REG, +1, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(6, UATTR(1), 0, BUF("\xdd\xdd", 2)), - LFSR_ATTR(6, RM, +3, NULL()), - LFSR_ATTR(9, UATTR(2), 0, BUF("\xdd\xdd", 2)), + LFSR_ATTR(REG, +1, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xdd\xdd", 2)), + LFSR_ATTR(GROW, +3, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF("\xdd\xdd", 2)), // make id14 with weight w5 - LFSR_ATTR(10, REG, +1, BUF("\xee\xee\xee\xee", 4)), - LFSR_ATTR(10, UATTR(1), 0, BUF("\xee\xee", 2)), - LFSR_ATTR(10, RM, +4, NULL()), - LFSR_ATTR(14, UATTR(2), 0, BUF("\xee\xee", 2)))) => 0; + LFSR_ATTR(REG, +1, BUF("\xee\xee\xee\xee", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xee\xee", 2)), + LFSR_ATTR(GROW, +4, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF("\xee\xee", 2)))) => 0; // traverse, finding tags and weights lfsr_rbyd_lookupnext(&lfs, &rbyd, -1, 0, @@ -9893,8 +9200,8 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)))) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -9905,11 +9212,11 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid*W, UATTR(1), 0, BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(rid*W, RM, +W-1, NULL()), - LFSR_ATTR(rid*W+W-1, UATTR(2), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR(1), 0, BUF(names[perm[j] % 6], 2)), + LFSR_ATTR(GROW, +W-1, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF(names[perm[j] % 6], 2)))) => 0; } @@ -10004,8 +9311,8 @@ code = ''' // test the given permutation with multiple commits rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.blocks[0]) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(3), 0, BUF("unrelated", 9)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(3), 0, BUF("unrelated", 9)))) => 0; for (unsigned j = 0; j < N; j++) { // adjust rid based on future insertions @@ -10016,11 +9323,11 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid*W, UATTR(1), 0, BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(rid*W, RM, +W-1, NULL()), - LFSR_ATTR(rid*W+W-1, UATTR(2), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR(1), 0, BUF(names[perm[j] % 6], 2)), + LFSR_ATTR(GROW, +W-1, NULL()), + LFSR_ATTR(UATTR(2), 0, BUF(names[perm[j] % 6], 2)))) => 0; } @@ -10134,8 +9441,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +W, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10159,8 +9466,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, RM, +D, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(GROW, +D, NULL()))) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10263,8 +9570,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +W, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10288,8 +9595,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, GROW(REG), +D, + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(GROW(REG), +D, BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); @@ -10401,8 +9708,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, UATTR(2), +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), +W, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10426,8 +9733,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, GROW(UATTR(1)), +D, + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(GROW(UATTR(1)), +D, BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W+D); @@ -10551,8 +9858,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +W, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10576,8 +9883,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, GROW, -D, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(GROW, -D, NULL()))) => 0; assert(rbyd.weight == N*W-D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -10680,8 +9987,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +W, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10705,8 +10012,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, GROW(REG), -D, + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(GROW(REG), -D, BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); @@ -10818,8 +10125,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, UATTR(2), +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(UATTR(2), +W, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10843,8 +10150,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, GROW(UATTR(1)), -D, + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(GROW(UATTR(1)), -D, BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W-D); @@ -10967,8 +10274,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +W, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -10992,8 +10299,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, RM, -W, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(RM, -W, NULL()))) => 0; assert(rbyd.weight == (N-1)*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11024,8 +10331,8 @@ code = ''' // try recreating the rid to make sure things still work printf("--- create: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W, REG, +W, BUF(names[j % 6], 6)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +W, BUF(names[j % 6], 6)))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11123,8 +10430,8 @@ code = ''' } } - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid*W, REG, +W, + lfsr_rbyd_commit(&lfs, &rbyd, rid*W-1, LFSR_ATTRS( + LFSR_ATTR(REG, +W, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N*W); @@ -11149,8 +10456,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false, NULL) => 0; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, UATTR(1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); @@ -11180,8 +10487,8 @@ code = ''' // now try removing the attr printf("--- removing: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, RM(UATTR(1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; assert(rbyd.weight == N*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11205,8 +10512,8 @@ code = ''' // and try putting the attr back just for good measure printf("--- appending: %d ---\n", j); - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j*W+W-1, UATTR(1), 0, + lfsr_rbyd_commit(&lfs, &rbyd, j*W+W-1, LFSR_ATTRS( + LFSR_ATTR(UATTR(1), 0, BUF(names[j % 6], 2)))) => 0; assert(rbyd.weight == N*W); @@ -11316,28 +10623,28 @@ code = ''' sim[rid*(M+1)] = alpha[i % 26]; count += 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(&alpha[i % 26], 1)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(&alpha[i % 26], 1)))) => 0; } else if (op == 1) { // update our sim memmove(sim+rid*(M+1), sim+(rid+1)*(M+1), (count-rid-1)*(M+1)); count -= 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; } else if (op == 2) { // update our sim sim[rid*(M+1) + u+1] = alpha[i % 26]; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR(u), 0, BUF(&alpha[i % 26], 1)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(UATTR(u), 0, BUF(&alpha[i % 26], 1)))) => 0; } else if (op == 3) { // update our sim sim[rid*(M+1) + u+1] = '\0'; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, RM(UATTR(u)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, rid, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(u)), 0, NULL()))) => 0; } } @@ -11481,9 +10788,8 @@ code = ''' sim_weights[rid] = weight; count += 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(weighted_rid, REG, +weight, - BUF(&alpha[i % 26], 1)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +weight, BUF(&alpha[i % 26], 1)))) => 0; } else if (op == 1) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -11493,18 +10799,16 @@ code = ''' (count-rid-1)*sizeof(lfs_size_t)); count -= 1; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(weighted_rid+weight_-1, RM, -weight_, - NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( + LFSR_ATTR(RM, -weight_, NULL()))) => 0; } else if (op == 2) { // get the correct weight from the sim weight_ = sim_weights[rid]; // update our sim sim_weights[rid] += weight; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(weighted_rid+weight_-1, GROW, +weight, - NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( + LFSR_ATTR(GROW, +weight, NULL()))) => 0; } else if (op == 3) { // get the correct weight from the sim weight_ = sim_weights[rid]; @@ -11514,9 +10818,8 @@ code = ''' // update our sim sim_weights[rid] -= weight; // update our rbyd - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(weighted_rid+weight_-1, GROW, -weight, - NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, weighted_rid+weight_-1, LFSR_ATTRS( + LFSR_ATTR(GROW, -weight, NULL()))) => 0; } } @@ -11647,9 +10950,9 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -11734,9 +11037,9 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -11761,8 +11064,8 @@ code = ''' NULL) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, RM(SUBMASK(UATTR)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(RM(SUBMASK(UATTR)), 0, NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -11873,9 +11176,9 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -11900,8 +11203,8 @@ code = ''' NULL) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, SUBMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(SUBMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, BUF(names[j % 6], 3)))) => 0; // try traversing over the tags @@ -12014,11 +11317,11 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(rid, SATTR(0), 0, + LFSR_ATTR(SATTR(0), 0, BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); @@ -12103,11 +11406,11 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(rid, SATTR(0), 0, + LFSR_ATTR(SATTR(0), 0, BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); @@ -12132,8 +11435,8 @@ code = ''' NULL) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, RM(SUBMASK(UATTR)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(RM(SUBMASK(UATTR)), 0, NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -12251,11 +11554,11 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, BUF(names[perm[j] % 6], 2)), - LFSR_ATTR(rid, SATTR(0), 0, + LFSR_ATTR(SATTR(0), 0, BUF(names[perm[j] % 6], 1)))) => 0; } assert(rbyd.weight == N); @@ -12280,8 +11583,8 @@ code = ''' NULL) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, SUBMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(SUBMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, BUF(names[j % 6], 3)))) => 0; // try traversing over the tags @@ -12401,8 +11704,8 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), +1, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), +1, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -12487,8 +11790,8 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), +1, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), +1, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -12513,8 +11816,8 @@ code = ''' NULL) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, RM(SUBMASK(UATTR)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(RM(SUBMASK(UATTR)), 0, NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -12628,8 +11931,8 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), +1, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), +1, BUF(names[perm[j] % 6], 4)))) => 0; } assert(rbyd.weight == N); @@ -12654,8 +11957,8 @@ code = ''' NULL) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, SUBMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(SUBMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, BUF(names[j % 6], 6)))) => 0; // try traversing over the tags @@ -12762,9 +12065,9 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -12849,9 +12152,9 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -12876,8 +12179,8 @@ code = ''' NULL) => 0; // remove with a wide tag - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, RM(SUPMASK(UATTR)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(RM(SUPMASK(UATTR)), 0, NULL()))) => 0; // try traversing over the tags lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.blocks[0], CFG->block_size) => 0; @@ -12988,9 +12291,9 @@ code = ''' } // give each attr a subtype based on its rid + SHIFT - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(rid, REG, +1, BUF(names[perm[j] % 6], 4)), - LFSR_ATTR(rid, UATTR((perm[j] + SHIFT) & 0x7f), 0, + lfsr_rbyd_commit(&lfs, &rbyd, rid-1, LFSR_ATTRS( + LFSR_ATTR(REG, +1, BUF(names[perm[j] % 6], 4)), + LFSR_ATTR(UATTR((perm[j] + SHIFT) & 0x7f), 0, BUF(names[perm[j] % 6], 2)))) => 0; } assert(rbyd.weight == N); @@ -13015,8 +12318,8 @@ code = ''' NULL) => 0; // replace with bitwise inverse - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(j, SUPMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, + lfsr_rbyd_commit(&lfs, &rbyd, j, LFSR_ATTRS( + LFSR_ATTR(SUPMASK(UATTR(~(j + SHIFT) & 0x7f)), 0, BUF(names[j % 6], 3)))) => 0; // try traversing over the tags @@ -13095,10 +12398,10 @@ code = ''' // create a null tag hole rbyd = init_rbyd; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, RM(UATTR(0)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -13137,16 +12440,16 @@ code = ''' // create a null tag hole rbyd = init_rbyd; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, UATTR(2), 0, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, RM(UATTR(0)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(UATTR(2), 0, BUF("\xcc\xcc\xcc\xcc", 4)), + LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; assert(rbyd.weight == 0); // remove a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, RM(UATTR(1)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(1)), 0, NULL()))) => 0; assert(rbyd.weight == 0); // can we still access things? @@ -13185,16 +12488,17 @@ code = ''' // create a null tag hole rbyd = init_rbyd; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(0, REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(1, REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)), - LFSR_ATTR(-1, RM(UATTR(0)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(REG, +1, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(REG, +1, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; assert(rbyd.weight == 2); // delete a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(0, RM, -1, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, 0, LFSR_ATTRS( + LFSR_ATTR(RM, -1, NULL()))) => 0; assert(rbyd.weight == 1); // can we still access things? @@ -13233,17 +12537,16 @@ code = ''' // create a null tag hole rbyd = init_rbyd; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(-1, SATTR(0), 0, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, RM(UATTR(0)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(SATTR(0), 0, BUF("\xdd\xdd\xdd\xdd", 4)), + LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; assert(rbyd.weight == 0); // subwide replace a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, - SUBMASK(UATTR(2)), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(SUBMASK(UATTR(2)), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 0); @@ -13292,17 +12595,17 @@ code = ''' // create a null tag hole rbyd = init_rbyd; - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), - LFSR_ATTR(-1, UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), - LFSR_ATTR(0, REG, +1, BUF("\xdd\xdd\xdd\xdd", 4)), - LFSR_ATTR(-1, RM(UATTR(0)), 0, NULL()))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(UATTR(0), 0, BUF("\xaa\xaa\xaa\xaa", 4)), + LFSR_ATTR(UATTR(1), 0, BUF("\xbb\xbb\xbb\xbb", 4)), + LFSR_ATTR(REG, +1, BUF("\xdd\xdd\xdd\xdd", 4)))) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(RM(UATTR(0)), 0, NULL()))) => 0; assert(rbyd.weight == 1); // supwide replace a neighbor to the hole - lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTRS( - LFSR_ATTR(-1, - SUPMASK(UATTR(2)), 0, + lfsr_rbyd_commit(&lfs, &rbyd, -1, LFSR_ATTRS( + LFSR_ATTR(SUPMASK(UATTR(2)), 0, BUF("\xcc\xcc\xcc\xcc", 4)))) => 0; assert(rbyd.weight == 1);