From 85bd28951c07b6f33f8967f8e58b75d54262cb9d Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Thu, 30 Mar 2023 15:28:28 -0500 Subject: [PATCH] Solved rbyd grow/insert ambiguity by adding a device-only "mk" bit This "mk" bit must not be written to disk, it would conflict with the other non-tree tag encodings. But we can use this bit in the context of lfsr_tag_append to disambiguate tags changing weight from inserting new tags. Note that in the context of rbyd compactions, this will make things a bit weird, since it's no longer just a direct one-to-one copy of each tag. To make compactions a bit easier, this implementation allows the "mk" bit to be set on any tag and ignores it when the weight delta is zero. It turns out that this scheme greatly simplifies the awkward leaf-split-alt calculation that previously had several if statements to handle different corner cases, with the caveat that "mk" tags need their ids adjusted by +1. Added this adjustment directly into lfsr_rbyd_append for now, so the upper-level interface can be a bit more intuitive. Though this may need to change later if it is more confusing than helpful. --- lfs.c | 184 +++++++++-------- scripts/dbgrbyd.py | 2 +- tests/test_rbyd.toml | 483 ++++++++++++++++++++++--------------------- 3 files changed, 342 insertions(+), 327 deletions(-) diff --git a/lfs.c b/lfs.c index 427e4a3b..4ecd5806 100644 --- a/lfs.c +++ b/lfs.c @@ -475,10 +475,15 @@ enum lfsr_tag_type { LFSR_TAG_FCRC = 0x1004, // in-device only - LFSR_TAG_NOOP = 0x0006, - LFSR_TAG_GROW = 0x0016, - LFSR_TAG_SHRINK = 0x0026, - LFSR_TAG_FROM = 0x0036, + LFSR_TAG_MKBNAME = 0x1004, + LFSR_TAG_MKREG = 0x1014, + LFSR_TAG_MKDIR = 0x1024, + + LFSR_TAG_MKUATTR = 0x4004, + + LFSR_TAG_GROW = 0x0006, + LFSR_TAG_SHRINK = 0x0016, + LFSR_TAG_FROM = 0x0026, }; #define LFSR_TAG_ALT_(color, dir, key) \ @@ -495,6 +500,10 @@ enum lfsr_tag_type { (LFSR_TAG_UATTR \ | ((0xff & (lfsr_tag_t)(attr)) << 4)) +#define LFSR_TAG_MKUATTR(attr) \ + (LFSR_TAG_MKUATTR \ + | ((0xff & (lfsr_tag_t)(attr)) << 4)) + #define LFSR_TAG_RMUATTR(attr) \ (LFSR_TAG_RMUATTR \ | ((0xff & (lfsr_tag_t)(attr)) << 4)) @@ -508,11 +517,23 @@ static inline uint8_t lfsr_tag_subtype(lfsr_tag_t tag) { return (tag & 0x0ff0) >> 4; } +static inline bool lfsr_tag_ismk(lfsr_tag_t tag) { + return tag & 0x4; +} + +static inline lfsr_tag_t lfsr_tag_setmk(lfsr_tag_t tag) { + return tag | 0x4; +} + +static inline lfsr_tag_t lfsr_tag_setnomk(lfsr_tag_t tag) { + return tag & ~0x4; +} + static inline bool lfsr_tag_isrm(lfsr_tag_t tag) { return tag & 0x2; } -static inline lfsr_tag_t lfsr_tag_mkrm(lfsr_tag_t tag) { +static inline lfsr_tag_t lfsr_tag_setrm(lfsr_tag_t tag) { return tag | 0x2; } @@ -530,7 +551,7 @@ static inline bool lfsr_tag_isalt(lfsr_tag_t tag) { // return tag & 0x1; //} // -//static inline lfsr_tag_t lfsr_tag_mkfound(lfsr_tag_t tag) { +//static inline lfsr_tag_t lfsr_tag_setfound(lfsr_tag_t tag) { // return tag | 0x1; //} @@ -547,11 +568,11 @@ static inline bool lfsr_tag_isred(lfsr_tag_t tag) { return tag & 0x2; } -static inline lfsr_tag_t lfsr_tag_mkblack(lfsr_tag_t tag) { +static inline lfsr_tag_t lfsr_tag_setblack(lfsr_tag_t tag) { return tag & ~0x2; } -static inline lfsr_tag_t lfsr_tag_mkred(lfsr_tag_t tag) { +static inline lfsr_tag_t lfsr_tag_setred(lfsr_tag_t tag) { return tag | 0x2; } @@ -753,9 +774,9 @@ struct lfsr_attr { #define LFSD_ATTR_IF_(_pred, _tag, _id, _delta, _buf, _len, _next) \ LFSD_ATTR_( \ - (_pred) ? (_tag) : LFSR_TAG_NOOP, \ + (_pred) ? (_tag) : LFSR_TAG_UNR, \ _id, \ - _delta, \ + (_pred) ? (_delta) : 0, \ _buf, \ (_pred) ? (_len) : 0, \ _next) @@ -768,7 +789,7 @@ struct lfsr_attr { LFSD_ATTR_DISK_( \ (_pred) ? (_tag) : LFSD_TAG_NOOP, \ _id, \ - _delta, \ + (_pred) ? (_delta) : 0, \ _block, \ _off, \ (_pred) ? (_len) : 0, \ @@ -799,7 +820,7 @@ struct lfsr_attr { #define LFSR_ATTR_IF_(_pred, _tag, _id, _buf, _len, _next) \ LFSR_ATTR_( \ - (_pred) ? (_tag) : LFSR_TAG_NOOP, \ + (_pred) ? (_tag) : LFSR_TAG_UNR, \ _id, \ _buf, \ (_pred) ? (_len) : 0, \ @@ -810,7 +831,7 @@ struct lfsr_attr { #define LFSR_ATTR_DISK_IF_(_pred, _tag, _id, _block, _off, _len, _next) \ LFSR_ATTR_DISK_( \ - (_pred) ? (_tag) : LFSR_TAG_NOOP, \ + (_pred) ? (_tag) : LFSR_TAG_UNR, \ _id, \ _block, \ _off, \ @@ -1897,10 +1918,10 @@ static void lfsr_rbyd_p_red( lfs_ssize_t p_weights[static 3], lfs_off_t p_jumps[static 3]) { // propagate a red edge upwards - p_alts[0] = lfsr_tag_mkblack(p_alts[0]); + p_alts[0] = lfsr_tag_setblack(p_alts[0]); if (p_alts[1]) { - p_alts[1] = lfsr_tag_mkred(p_alts[1]); + p_alts[1] = lfsr_tag_setred(p_alts[1]); // reorder so that top two edges always go in the same direction if (lfsr_tag_isred(p_alts[2])) { @@ -1910,23 +1931,23 @@ static void lfsr_rbyd_p_red( lfsr_tag_t alt_ = p_alts[1]; lfs_ssize_t weight_ = p_weights[1]; lfs_off_t jump_ = p_jumps[1]; - p_alts[1] = lfsr_tag_mkred(p_alts[0]); + p_alts[1] = lfsr_tag_setred(p_alts[0]); p_weights[1] = p_weights[0]; p_jumps[1] = p_jumps[0]; - p_alts[0] = lfsr_tag_mkblack(alt_); + p_alts[0] = lfsr_tag_setblack(alt_); p_weights[0] = weight_; p_jumps[0] = jump_; } else if (lfsr_tag_isparallel(p_alts[0], p_alts[1])) { lfsr_tag_t alt_ = p_alts[2]; lfs_ssize_t weight_ = p_weights[2]; lfs_off_t jump_ = p_jumps[2]; - p_alts[2] = lfsr_tag_mkred(p_alts[1]); + p_alts[2] = lfsr_tag_setred(p_alts[1]); p_weights[2] = p_weights[1]; p_jumps[2] = p_jumps[1]; - p_alts[1] = lfsr_tag_mkred(p_alts[0]); + p_alts[1] = lfsr_tag_setred(p_alts[0]); p_weights[1] = p_weights[0]; p_jumps[1] = p_jumps[0]; - p_alts[0] = lfsr_tag_mkblack(alt_); + p_alts[0] = lfsr_tag_setblack(alt_); p_weights[0] = weight_; p_jumps[0] = jump_; } else { @@ -1940,7 +1961,7 @@ static void lfsr_rbyd_p_red( static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfsr_tag_t tag, lfs_ssize_t id, lfs_ssize_t delta, lfsr_data_t data) { - printf("append w=%d id=%d d=%d\n", rbyd->weight, id, delta); + // 0 tags shouldn't be written to disk, use unr if tag is unreachable LFS_ASSERT(tag != 0); // we can't do anything if we're not erased @@ -1948,12 +1969,18 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, return LFS_ERR_RANGE; } - // TODO do we really need this? // ignore noops - if (tag == LFSR_TAG_NOOP) { + if (tag == LFSR_TAG_UNR && delta == 0) { return 0; } + // treat weightless mks the same as non-mks, easier to just clear + // the bit here than make sure the following logic works out + if (lfsr_tag_ismk(tag) && delta <= 0) { + LFS_ASSERT(delta >= 0); + tag = lfsr_tag_setnomk(tag); + } + // make sure every rbyd starts with its revision count if (rbyd->off == 0) { uint32_t rev; @@ -1982,25 +2009,41 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, // // note lfsr_rbyd_commit will throw out this copy of the rbyd if an // error occurs - LFS_ASSERT(delta >= -(lfs_ssize_t)rbyd->weight); - LFS_ASSERT(id <= rbyd->weight + delta); - rbyd->weight += delta; + lfs_ssize_t id_; + lfs_ssize_t other_id_; + lfsr_tag_t tag_; + lfsr_tag_t other_tag_; + if (lfsr_tag_ismk(tag) && delta > 0) { + LFS_ASSERT(id < rbyd->weight+delta); + LFS_ASSERT(delta >= -(lfs_ssize_t)rbyd->weight); + rbyd->weight += delta; - lfs_ssize_t id_ = id-delta - lfs_smax32(-delta, 0); - lfs_ssize_t other_id_ = id-delta; - lfsr_tag_t tag_ = lfsr_tag_isrm(tag) ? tag & ~0x2 : tag; - lfsr_tag_t other_tag_ = lfsr_tag_isrm(tag) ? (tag & ~0x2) + 0x10 : tag; - - // TODO need this? - // TODO restructure with above? - if (delta > 0) { - id_ += 1; - other_id_ += 1; + // it's a bit ugly, but adjusting the id here makes the following + // logic work out more consistently + id -= delta; + id_ = id + 1; + other_id_ = id + 1; tag_ = 0; other_tag_ = 0; - } + } else if (lfsr_tag_isrm(tag)) { + LFS_ASSERT(id <= rbyd->weight); + LFS_ASSERT(delta >= -(lfs_ssize_t)rbyd->weight); + rbyd->weight += delta; - printf("ids %d..%d\n", id_, other_id_); + id_ = id - lfs_smax32(-delta, 0); + other_id_ = id; + tag_ = tag & ~0x2; + other_tag_ = (tag & ~0x2) + 0x10; + } else { + LFS_ASSERT(id < rbyd->weight); + LFS_ASSERT(delta >= -(lfs_ssize_t)rbyd->weight); + rbyd->weight += delta; + + id_ = id - lfs_smax32(-delta, 0); + other_id_ = id; + tag_ = tag; + other_tag_ = tag; + } // diverged state in case we are removing a range from the tree // @@ -2067,10 +2110,9 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, p_alts[0], p_weights[0], lower_id, upper_id, other_tag_, other_id_)) { - printf("diverged! %x\n", branch); // first take care of any lingering red alts if (lfsr_tag_isred(p_alts[0])) { - alt = lfsr_tag_mkblack(p_alts[0]); + alt = lfsr_tag_setblack(p_alts[0]); weight = p_weights[0]; jump = p_jumps[0]; branch_ = branch; @@ -2089,7 +2131,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, // perfect but it's simpler and compact will take care of any // balance issues that may occur if (diverged) { - alt = lfsr_tag_mkblack(alt); + alt = lfsr_tag_setblack(alt); } // prune? @@ -2108,7 +2150,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lower_id, upper_id, lower_tag, upper_tag)) { if (lfsr_tag_isred(p_alts[0])) { - alt = lfsr_tag_mkblack(p_alts[0]); + alt = lfsr_tag_setblack(p_alts[0]); weight = p_weights[0]; branch_ = jump; jump = p_jumps[0]; @@ -2145,7 +2187,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfs_swap16(&p_alts[0], &alt); lfs_sswap32(&p_weights[0], &weight); lfs_swap32(&p_jumps[0], &jump); - alt = lfsr_tag_mkblack(alt); + alt = lfsr_tag_setblack(alt); lfsr_tag_trim( p_alts[0], p_weights[0], @@ -2210,8 +2252,8 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lfs_swap16(&p_alts[0], &alt); lfs_sswap32(&p_weights[0], &weight); lfs_swap32(&p_jumps[0], &jump); - p_alts[0] = lfsr_tag_mkred(p_alts[0]); - alt = lfsr_tag_mkblack(alt); + p_alts[0] = lfsr_tag_setred(p_alts[0]); + alt = lfsr_tag_setblack(alt); lfsr_tag_flip2(&alt, &weight, p_alts[0], p_weights[0], @@ -2289,8 +2331,6 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, lower_id = other_lower_id; } - printf("found %d\n", id_); - // split leaf nodes? // // note we bias the weights here so that lfsr_rbyd_lookup @@ -2300,61 +2340,34 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd, if (lfsr_tag_isrm(tag_)) { // found an old removed tag, no split needed, just prune the // removed tag - printf("a %x %x\n", branch, rbyd->off); - } else if (id_ < (delta > 0 ? id : id-lfs_smax32(-delta, 0)) - || (id_ == (delta > 0 ? id : id-lfs_smax32(-delta, 0)) - && lfsr_tag_key(tag_) < lfsr_tag_key(tag))) { + } else if (id_ < id-lfs_smax32(-delta, 0) + || (id_ == id-lfs_smax32(-delta, 0) + && (lfsr_tag_ismk(tag) + || lfsr_tag_key(tag_) < lfsr_tag_key(tag)))) { if (lfsr_tag_isrm(tag)) { - printf("b %x %x\n", branch, rbyd->off); // if removed make our tag unreachable alt = LFSR_TAG_ALT(B, LE, 0xfff0); weight = upper_id - lower_id - 1 + delta; } else { // split less than - printf("c %x %x\n", branch, rbyd->off); alt = LFSR_TAG_ALT(R, LE, tag_); weight = id_ - lower_id; } - -// // Also note that this handles the case for rms/unreachables, -// // we might pick up an rm/unreachable during lfsr_tag_lookup, but -// // this is unavoidable in the case we've removed everything in a tree. -// // This probably makes "unreachable" a bad tag name, but I can't think -// // of a better one. -// // -// -// } else if (tag == LFSR_TAG_GROW) { -// // decrease weight when growing -// alt = LFSR_TAG_ALT(B, LE, 0xfff0); -// weight = upper_id - lower_id - 1 + lfsr_data_len(data); -// -// } else if (tag == LFSR_TAG_SHRINK) { -// // decrease weight when shrinking -// if (upper_id - lower_id - 1 > (lfs_ssize_t)lfsr_data_len(data)) { -// alt = LFSR_TAG_ALT(B, LE, 0xfff0); -// weight = upper_id - lower_id - 1 - lfsr_data_len(data); -// } - - } else if (id_ > id-delta - || (id_ == id-delta - && lfsr_tag_key(tag_) > lfsr_tag_key(tag))) { + } else if (id_ > id + || (id_ == id + && (lfsr_tag_ismk(tag) + || lfsr_tag_key(tag_) > lfsr_tag_key(tag)))) { if (lfsr_tag_isrm(tag)) { - printf("d %x %x\n", branch, rbyd->off); // if removed make our tag unreachable alt = LFSR_TAG_ALT(B, LE, 0xfff0); weight = upper_id - lower_id - 1 + delta; } else { - printf("e %x %x\n", branch, rbyd->off); // split greater than alt = LFSR_TAG_ALT(R, GT, tag); - weight = upper_id - id - 1 + delta; + weight = upper_id - id - 1; } - - // TODO rm me - } else { - printf("g %x %x\n", branch, rbyd->off); } if (alt) { @@ -2386,8 +2399,7 @@ leaf:; // note we always need something after the alts! without something between // alts we may not be able to find the trunk of our tree err = lfsr_rbyd_progtag(lfs, rbyd, - // TODO WHY OFF BY ONE delta > 0??? - tag, id /*+(delta > 0 ? delta-1 : delta)*/, lfsr_data_len(data), &rbyd->crc); + lfsr_tag_setnomk(tag), id + delta, lfsr_data_len(data), &rbyd->crc); if (err) { rbyd->erased = false; return err; @@ -3775,7 +3787,7 @@ static int lfsr_btree_update(lfs_t *lfs, lfsr_btree_t *btree, // of the rest return lfsr_btree_commit(lfs, btree, id, &rbyd, LFSR_ATTR_IF_(tag != rtag, - lfsr_tag_mkrm(rtag), rid, NULL, 0, + lfsr_tag_setrm(rtag), rid, NULL, 0, LFSR_ATTR_(tag, rid, buffer, size, LFSR_ATTR_( weight >= rweight ? LFSR_TAG_GROW : LFSR_TAG_SHRINK, diff --git a/scripts/dbgrbyd.py b/scripts/dbgrbyd.py index 8b7c57ae..ecc0064c 100755 --- a/scripts/dbgrbyd.py +++ b/scripts/dbgrbyd.py @@ -315,7 +315,7 @@ def show_log(block_size, data, rev, off, *, if not tag & 0x2: # attach tag to lifetime - i, id_ = index(weights, lower_) + i, id_ = index(weights, id) if i < len(weights): lifetimes[i].add(j) diff --git a/tests/test_rbyd.toml b/tests/test_rbyd.toml index 2abf14eb..e540175d 100644 --- a/tests/test_rbyd.toml +++ b/tests/test_rbyd.toml @@ -3868,7 +3868,7 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -3883,8 +3883,8 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -3903,8 +3903,8 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -3923,9 +3923,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -3948,9 +3948,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, - LFSD_ATTR(REG, 1, +1, "\xcc\xcc\xcc\xcc", 4, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -3973,9 +3973,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xcc\xcc\xcc\xcc", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)))) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -4017,7 +4017,7 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -4034,9 +4034,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -4055,9 +4055,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -4076,11 +4076,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -4103,11 +4103,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -4130,11 +4130,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; assert(rbyd.weight == 3); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -4219,7 +4219,7 @@ code = ''' } attrs[j] = *LFSD_ATTR( - REG, id, +1, names[perm[j] % 6], 4, + MKREG, id, +1, names[perm[j] % 6], 4, (j+1 < N) ? &attrs[j+1] : NULL); } @@ -4325,7 +4325,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id, +1, names[perm[j] % 6], 4, NULL)) => 0; } @@ -4387,8 +4387,8 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, -1, &tag_, &id_, NULL, &off_, &size_) => 0; @@ -4429,8 +4429,8 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, -1, &tag_, &id_, NULL, &off_, &size_) => 0; @@ -4496,9 +4496,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, -1, &tag_, &id_, NULL, &off_, &size_) => 0; @@ -4539,9 +4539,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, -1, &tag_, &id_, NULL, &off_, &size_) => 0; @@ -4644,7 +4644,7 @@ code = ''' } attrs[j] = *LFSD_ATTR( - REG, id, +1, names[perm[j] % 6], 4, + MKREG, id, +1, names[perm[j] % 6], 4, (j+1 < N) ? &attrs[j+1] : NULL); } @@ -4741,7 +4741,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id, +1, names[perm[j] % 6], 4, NULL)) => 0; } @@ -4814,7 +4814,7 @@ code = ''' x = x % (rbyd.weight+1); int err = lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, x, +1, names[x % 6], 4, NULL)); + LFSD_ATTR(MKREG, x, +1, names[x % 6], 4, NULL)); if (err == LFS_ERR_RANGE) { break; } @@ -4863,7 +4863,7 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL))) => 0; assert(rbyd.weight == 1); @@ -4883,9 +4883,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL))))) => 0; assert(rbyd.weight == 2); @@ -4913,9 +4913,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL))))) => 0; assert(rbyd.weight == 2); @@ -4943,11 +4943,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 2, 0, "\xcc\xcc", 2, NULL))))))) => 0; assert(rbyd.weight == 3); @@ -5000,11 +5000,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 1, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 1, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xcc\xcc", 2, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL))))))) => 0; assert(rbyd.weight == 3); @@ -5040,11 +5040,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 1, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xcc\xcc", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL))))))) => 0; assert(rbyd.weight == 3); @@ -5099,7 +5099,7 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL)) => 0; @@ -5120,11 +5120,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL)) => 0; @@ -5153,11 +5153,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL)) => 0; @@ -5186,15 +5186,15 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 2, 0, "\xcc\xcc", 2, NULL)) => 0; @@ -5248,15 +5248,15 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 1, 0, "\xcc\xcc", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL)) => 0; @@ -5293,15 +5293,15 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 1, 0, "\xcc\xcc", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL)) => 0; @@ -5401,7 +5401,7 @@ code = ''' } attrs[(1+M)*j] = *LFSD_ATTR( - REG, id, +1, names[perm[j] % 6], 4, + MKREG, id, +1, names[perm[j] % 6], 4, ((1+M)*j+1 < (1+M)*N) ? &attrs[(1+M)*j+1] : NULL); // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -5522,7 +5522,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id, +1, names[perm[j] % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -5595,9 +5595,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, -1, @@ -5667,9 +5667,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL))))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, 0, -1, @@ -5764,11 +5764,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL)) => 0; @@ -5839,11 +5839,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL)) => 0; @@ -5977,7 +5977,7 @@ code = ''' } attrs[(1+M)*j] = *LFSD_ATTR( - REG, id, +1, names[perm[j] % 6], 4, + MKREG, id, +1, names[perm[j] % 6], 4, ((1+M)*j+1 < N*(1+M)) ? &attrs[(1+M)*j+1] : NULL); // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6095,7 +6095,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id, +1, names[perm[j] % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6182,7 +6182,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, j, +1, names[j % 6], 4, + LFSD_ATTR(MKREG, j, +1, names[j % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6345,7 +6345,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id, +1, names[perm[j] % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6516,7 +6516,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, j, +1, names[j % 6], 4, + LFSD_ATTR(MKREG, j, +1, names[j % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -6655,7 +6655,7 @@ code = ''' // it should fail atomically struct lfsr_attr attrs[1+M]; attrs[0] = *LFSD_ATTR( - REG, x, +1, names[x % 6], 4, + MKREG, x, +1, names[x % 6], 4, M > 0 ? &attrs[1] : NULL); for (unsigned u = 0; u < M; u++) { attrs[1+u] = *LFSD_ATTR( @@ -6720,10 +6720,10 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 1, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 1+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -6740,10 +6740,10 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -6760,11 +6760,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 2, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 2+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -6783,11 +6783,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -6806,11 +6806,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 1, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 1+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -6848,12 +6848,12 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 1, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 1+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -6884,12 +6884,12 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -6920,14 +6920,14 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 2, 0, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 2, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 2+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) => 4; @@ -6969,14 +6969,14 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 2, 0, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7019,14 +7019,14 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 2, 0, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 1, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 1+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7137,7 +7137,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id, +1, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N); @@ -7160,7 +7160,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, j, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, j+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, @@ -7180,7 +7180,7 @@ code = ''' // try recreating the id to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, j, +1, names[j % 6], 6, NULL)) => 0; + LFSD_ATTR(MKREG, j, +1, names[j % 6], 6, NULL)) => 0; assert(rbyd.weight == N); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, @@ -7296,7 +7296,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id, +1, names[perm[j] % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -7325,7 +7325,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, j, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, j+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, @@ -7357,7 +7357,7 @@ code = ''' // try recreating the id to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, j, +1, names[j % 6], 6, NULL)) => 0; + LFSD_ATTR(MKREG, j, +1, names[j % 6], 6, NULL)) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(u+1), j, 0, names[j % 6], 3, NULL)) => 0; @@ -7490,7 +7490,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id, +1, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N); @@ -7513,7 +7513,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, j, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, j+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -7619,7 +7619,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id, +1, names[perm[j] % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -7648,7 +7648,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, j, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, j+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -7721,9 +7721,9 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7738,11 +7738,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL))) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7757,11 +7757,11 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 1, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL))) => 0; + LFSD_ATTR(UNR, 1+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7776,13 +7776,13 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)))) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7797,13 +7797,13 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 2, -1, NULL, 0, - LFSD_ATTR(UNR, 1, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)))) => 0; + LFSD_ATTR(UNR, 2+1, -1, NULL, 0, + LFSD_ATTR(UNR, 1+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7837,10 +7837,10 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7855,13 +7855,13 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL))) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7876,13 +7876,13 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 1, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL))) => 0; + LFSD_ATTR(UNR, 1+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7897,16 +7897,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 2, 0, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 0, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)))) => 0; + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7921,16 +7921,16 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 2, 0, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 2, -1, NULL, 0, - LFSD_ATTR(UNR, 1, -1, NULL, 0, - LFSD_ATTR(UNR, 0, -1, NULL, 0, NULL)))) => 0; + LFSD_ATTR(UNR, 2+1, -1, NULL, 0, + LFSD_ATTR(UNR, 1+1, -1, NULL, 0, + LFSD_ATTR(UNR, 0+1, -1, NULL, 0, NULL)))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_REG, 0, buffer, 4) @@ -7986,7 +7986,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, j, +1, names[j % 6], 4, + LFSD_ATTR(MKREG, j, +1, names[j % 6], 4, NULL)) => 0; } assert(rbyd.weight == N); @@ -8035,7 +8035,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, id, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, id+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -8048,7 +8048,7 @@ code = ''' // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, NULL)) => 0; assert(rbyd.weight == 1); @@ -8132,7 +8132,7 @@ code = ''' for (unsigned j = 0; j < N; j++) { lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, j, +1, names[j % 6], 4, + LFSD_ATTR(MKREG, j, +1, names[j % 6], 4, NULL)) => 0; // note uattrs have a smaller size to help debugging for (unsigned u = 0; u < M; u++) { @@ -8187,7 +8187,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, id, -1, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, id+1, -1, NULL, 0, NULL)) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -8200,7 +8200,7 @@ code = ''' // try resuming from all tags being removed lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, NULL)) => 0; for (unsigned u = 0; u < M; u++) { lfsr_rbyd_commit(&lfs, &rbyd, @@ -8332,7 +8332,7 @@ code = ''' count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, &alpha[i % 26], 1, + LFSD_ATTR(MKREG, id, +1, &alpha[i % 26], 1, NULL)) => 0; } else { // update our sim @@ -8340,7 +8340,7 @@ code = ''' count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, id, -1, NULL, 0, + LFSD_ATTR(UNR, id+1, -1, NULL, 0, NULL)) => 0; } } @@ -8422,23 +8422,24 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; // create three ids lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, - LFSD_ATTR(REG, 2, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 2, +1, "\xcc\xcc\xcc\xcc", 4, NULL)))))) => 0; // delete the last two lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, 1, -2, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, 2+1, -2, NULL, 0, + NULL)) => 0; // create some new ids, if unconditional altgts are used this // will end up losing tags lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xdd\xdd\xdd\xdd", 4, + LFSD_ATTR(MKREG, 1, +1, "\xdd\xdd\xdd\xdd", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xdd\xdd", 2, - LFSD_ATTR(REG, 2, +1, "\xee\xee\xee\xee", 4, + LFSD_ATTR(MKREG, 2, +1, "\xee\xee\xee\xee", 4, LFSD_ATTR(UATTR(1), 2, 0, "\xee\xee", 2, NULL))))) => 0; @@ -8504,7 +8505,7 @@ code = ''' rbyd = init_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, @@ -8524,7 +8525,7 @@ code = ''' // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 2, +2, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 2, +2, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, @@ -8556,7 +8557,7 @@ code = ''' // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 5, +3, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 5, +3, "\xcc\xcc\xcc\xcc", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, @@ -8600,7 +8601,7 @@ code = ''' // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 9, +4, "\xdd\xdd\xdd\xdd", 4, + LFSD_ATTR(MKREG, 9, +4, "\xdd\xdd\xdd\xdd", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, @@ -8656,7 +8657,7 @@ code = ''' // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 14, +5, "\xee\xee\xee\xee", 4, + LFSD_ATTR(MKREG, 14, +5, "\xee\xee\xee\xee", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_REG, 0, @@ -8749,15 +8750,15 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, // make id0 with weight w1 - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, // make id2 with weight w2 - LFSD_ATTR(REG, 2, +2, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 2, +2, "\xbb\xbb\xbb\xbb", 4, // make id5 with weight w3 - LFSD_ATTR(REG, 5, +3, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 5, +3, "\xcc\xcc\xcc\xcc", 4, // make id9 with weight w4 - LFSD_ATTR(REG, 9, +4, "\xdd\xdd\xdd\xdd", 4, + LFSD_ATTR(MKREG, 9, +4, "\xdd\xdd\xdd\xdd", 4, // make id14 with weight w5 - LFSD_ATTR(REG, 14, +5, "\xee\xee\xee\xee", 4, + LFSD_ATTR(MKREG, 14, +5, "\xee\xee\xee\xee", 4, NULL)))))) => 0; // traverse, finding tags and weights @@ -8899,7 +8900,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W+W-1, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } @@ -8989,7 +8990,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W+W-1, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } @@ -9042,7 +9043,7 @@ code = ''' lfs_bd_erase(&lfs, rbyd.block) => 0; lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(3), -1, 0, "unrelated", 9, - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, LFSD_ATTR(UATTR(2), 0, 0, "\xaa\xaa", 2, NULL))))) => 0; @@ -9099,9 +9100,9 @@ code = ''' // make id2 with weight w2 lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, - LFSD_ATTR(UNR, 2, +1, NULL, 0, + LFSD_ATTR(UNR, 1, +1, NULL, 0, LFSD_ATTR(UATTR(2), 2, 0, "\xbb\xbb", 2, NULL))))) => 0; @@ -9194,9 +9195,9 @@ code = ''' // make id5 with weight w3 lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 3, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 3, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 3, 0, "\xcc\xcc", 2, - LFSD_ATTR(UNR, 5, +2, NULL, 0, + LFSD_ATTR(UNR, 3, +2, NULL, 0, LFSD_ATTR(UATTR(2), 5, 0, "\xcc\xcc", 2, NULL))))) => 0; @@ -9325,9 +9326,9 @@ code = ''' // make id9 with weight w4 lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 6, +1, "\xdd\xdd\xdd\xdd", 4, + LFSD_ATTR(MKREG, 6, +1, "\xdd\xdd\xdd\xdd", 4, LFSD_ATTR(UATTR(1), 6, 0, "\xdd\xdd", 2, - LFSD_ATTR(UNR, 9, +3, NULL, 0, + LFSD_ATTR(UNR, 6, +3, NULL, 0, LFSD_ATTR(UATTR(2), 9, 0, "\xdd\xdd", 2, NULL))))) => 0; @@ -9492,9 +9493,9 @@ code = ''' // make id14 with weight w5 lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, 10, +1, "\xee\xee\xee\xee", 4, + LFSD_ATTR(MKREG, 10, +1, "\xee\xee\xee\xee", 4, LFSD_ATTR(UATTR(1), 10, 0, "\xee\xee", 2, - LFSD_ATTR(UNR, 14, +4, NULL, 0, + LFSD_ATTR(UNR, 10, +4, NULL, 0, LFSD_ATTR(UATTR(2), 14, 0, "\xee\xee", 2, NULL))))) => 0; @@ -9721,28 +9722,28 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSD_ATTR(UATTR(3), -1, 0, "unrelated", 9, // make id0 with weight w1 - LFSD_ATTR(REG, 0, +1, "\xaa\xaa\xaa\xaa", 4, + LFSD_ATTR(MKREG, 0, +1, "\xaa\xaa\xaa\xaa", 4, LFSD_ATTR(UATTR(1), 0, 0, "\xaa\xaa", 2, LFSD_ATTR(UATTR(2), 0, 0, "\xaa\xaa", 2, // make id2 with weight w2 - LFSD_ATTR(REG, 1, +1, "\xbb\xbb\xbb\xbb", 4, + LFSD_ATTR(MKREG, 1, +1, "\xbb\xbb\xbb\xbb", 4, LFSD_ATTR(UATTR(1), 1, 0, "\xbb\xbb", 2, - LFSD_ATTR(UNR, 2, +1, NULL, 0, + LFSD_ATTR(UNR, 1, +1, NULL, 0, LFSD_ATTR(UATTR(2), 2, 0, "\xbb\xbb", 2, // make id5 with weight w3 - LFSD_ATTR(REG, 3, +1, "\xcc\xcc\xcc\xcc", 4, + LFSD_ATTR(MKREG, 3, +1, "\xcc\xcc\xcc\xcc", 4, LFSD_ATTR(UATTR(1), 3, 0, "\xcc\xcc", 2, - LFSD_ATTR(UNR, 5, +2, NULL, 0, + LFSD_ATTR(UNR, 3, +2, NULL, 0, LFSD_ATTR(UATTR(2), 5, 0, "\xcc\xcc", 2, // make id9 with weight w4 - LFSD_ATTR(REG, 6, +1, "\xdd\xdd\xdd\xdd", 4, + LFSD_ATTR(MKREG, 6, +1, "\xdd\xdd\xdd\xdd", 4, LFSD_ATTR(UATTR(1), 6, 0, "\xdd\xdd", 2, - LFSD_ATTR(UNR, 9, +3, NULL, 0, + LFSD_ATTR(UNR, 6, +3, NULL, 0, LFSD_ATTR(UATTR(2), 9, 0, "\xdd\xdd", 2, // make id14 with weight w5 - LFSD_ATTR(REG, 10, +1, "\xee\xee\xee\xee", 4, + LFSD_ATTR(MKREG, 10, +1, "\xee\xee\xee\xee", 4, LFSD_ATTR(UATTR(1), 10, 0, "\xee\xee", 2, - LFSD_ATTR(UNR, 14, +4, NULL, 0, + LFSD_ATTR(UNR, 10, +4, NULL, 0, LFSD_ATTR(UATTR(2), 14, 0, "\xee\xee", 2, NULL))))))))))))))))))))) => 0; @@ -10020,9 +10021,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W, +1, names[perm[j] % 6], 4, LFSD_ATTR(UATTR(1), id*W, 0, names[perm[j] % 6], 2, - LFSD_ATTR(UNR, id*W+W-1, +W-1, NULL, 0, + LFSD_ATTR(UNR, id*W, +W-1, NULL, 0, LFSD_ATTR(UATTR(2), id*W+W-1, 0, names[perm[j] % 6], 2, NULL))))) => 0; } @@ -10134,9 +10135,9 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W, +1, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W, +1, names[perm[j] % 6], 4, LFSD_ATTR(UATTR(1), id*W, 0, names[perm[j] % 6], 2, - LFSD_ATTR(UNR, id*W+W-1, +W-1, NULL, 0, + LFSD_ATTR(UNR, id*W, +W-1, NULL, 0, LFSD_ATTR(UATTR(2), id*W+W-1, 0, names[perm[j] % 6], 2, NULL))))) => 0; } @@ -10255,7 +10256,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N*W); @@ -10278,7 +10279,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, j*W, +D, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, j*W+W-1, +D, NULL, 0, + NULL)) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, @@ -10386,7 +10388,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N*W); @@ -10409,7 +10411,8 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, j*W, +D, names[perm[j] % 6], 6, NULL)) => 0; + LFSD_ATTR(REG, j*W+W-1, +D, names[j % 6], 6, + NULL)) => 0; assert(rbyd.weight == N*W+D); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, @@ -10525,7 +10528,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UATTR(2), id*W, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKUATTR(2), id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N*W); @@ -10548,7 +10551,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UATTR(1), j*W, +D, names[perm[j] % 6], 6, + LFSD_ATTR(UATTR(1), j*W+W-1, +D, names[j % 6], 6, NULL)) => 0; assert(rbyd.weight == N*W+D); @@ -10673,7 +10676,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N*W); @@ -10804,7 +10807,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N*W); @@ -10944,7 +10947,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UATTR(2), id*W, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKUATTR(2), id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N*W); @@ -11091,7 +11094,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N*W); @@ -11114,7 +11117,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, j*W+W-1, -W, NULL, 0, NULL)) => 0; + LFSD_ATTR(UNR, j*W+W-1+1, -W, NULL, 0, NULL)) => 0; assert(rbyd.weight == (N-1)*W); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, @@ -11147,7 +11150,7 @@ code = ''' // try recreating the id to make sure things still work printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, j*W, +W, names[j % 6], 6, + LFSD_ATTR(MKREG, j*W+W-1, +W, names[j % 6], 6, NULL)) => 0; assert(rbyd.weight == N*W); @@ -11251,7 +11254,7 @@ code = ''' } lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id*W, +W, names[perm[j] % 6], 4, + LFSD_ATTR(MKREG, id*W+W-1, +W, names[perm[j] % 6], 4, NULL)) => 0; } assert(rbyd.weight == N*W); @@ -11458,7 +11461,7 @@ code = ''' count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, id, +1, &alpha[i % 26], 1, + LFSD_ATTR(MKREG, id, +1, &alpha[i % 26], 1, NULL)) => 0; } else if (op == 1) { // update our sim @@ -11466,7 +11469,7 @@ code = ''' count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, id, -1, NULL, 0, + LFSD_ATTR(UNR, id+1, -1, NULL, 0, NULL)) => 0; } else if (op == 2) { // update our sim @@ -11661,7 +11664,7 @@ code = ''' count += 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(REG, weighted_id, + LFSD_ATTR(MKREG, weighted_id+weight-1, +weight, &alpha[i % 26], 1, NULL)) => 0; } else if (op == 1) { @@ -11674,7 +11677,7 @@ code = ''' count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, - LFSD_ATTR(UNR, weighted_id+weight_, + LFSD_ATTR(UNR, weighted_id+weight_-1+1, -weight_, NULL, 0, NULL)) => 0; } else if (op == 2) {