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) {