| Message ID | f4be0966e17600602b1057a6ae219711994df128.1726633812.git.ps@pks.im (mailing list archive) |
|---|---|
| State | Superseded |
| Headers | show |
| Series | reftable: graceful concurrent writes | expand |
I just want to check my understanding of this test, since I think it's the first time I've reviewed anything using this test harness: On Wed Sep 18, 2024 at 2:32 PM AEST, Patrick Steinhardt wrote: > diff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/t-reftable-stack.c > index d62a9c1bed5..a37cc698d87 100644 > --- a/t/unit-tests/t-reftable-stack.c > +++ b/t/unit-tests/t-reftable-stack.c > @@ -271,7 +271,7 @@ static void t_reftable_stack_transaction_api(void) > > reftable_addition_destroy(add); > > - err = reftable_stack_new_addition(&add, st); > + err = reftable_stack_new_addition(&add, st, 0); > check(!err); > > err = reftable_addition_add(add, write_test_ref, &ref); > @@ -292,6 +292,68 @@ static void t_reftable_stack_transaction_api(void) > clear_dir(dir); > } > > +static void t_reftable_stack_transaction_with_reload(void) > +{ > + char *dir = get_tmp_dir(__LINE__); > + struct reftable_stack *st1 = NULL, *st2 = NULL; > + int err; > + struct reftable_addition *add = NULL; > + struct reftable_ref_record refs[2] = { > + { > + .refname = (char *) "refs/heads/a", > + .update_index = 1, > + .value_type = REFTABLE_REF_VAL1, > + .value.val1 = { '1' }, > + }, > + { > + .refname = (char *) "refs/heads/b", > + .update_index = 2, > + .value_type = REFTABLE_REF_VAL1, > + .value.val1 = { '1' }, > + }, > + }; > + struct reftable_ref_record ref = { 0 }; > + Create two reftable stacks that provide a view into the reftable tables inside "dir". > + err = reftable_new_stack(&st1, dir, NULL); > + check(!err); > + err = reftable_new_stack(&st2, dir, NULL); > + check(!err); > + Successfully add refs[0] to the first stack using the transactional API. > + err = reftable_stack_new_addition(&add, st1, 0); > + check(!err); > + err = reftable_addition_add(add, write_test_ref, &refs[0]); > + check(!err); > + err = reftable_addition_commit(add); > + check(!err); > + reftable_addition_destroy(add); > + > + /* > + * The second stack is now outdated, which we should notice. We do not > + * create the addition and lock the stack by default, but allow the > + * reload to happen when REFTABLE_STACK_NEW_ADDITION_RELOAD is set. > + */ We try to open a transaction via the second reftable stack, but the this stack is outdated because we've written to "dir" when the previous stack addition was committed. > + err = reftable_stack_new_addition(&add, st2, 0); > + check_int(err, ==, REFTABLE_OUTDATED_ERROR); Try again, but supply the flag so it performs a reload internally. Write refs[1] to "dir" by committing the transaction. > + err = reftable_stack_new_addition(&add, st2, REFTABLE_STACK_NEW_ADDITION_RELOAD); > + check(!err); > + err = reftable_addition_add(add, write_test_ref, &refs[1]); > + check(!err); > + err = reftable_addition_commit(add); > + check(!err); > + reftable_addition_destroy(add); > + Asserts. > + for (size_t i = 0; i < ARRAY_SIZE(refs); i++) { > + err = reftable_stack_read_ref(st2, refs[i].refname, &ref); > + check(!err); > + check(reftable_ref_record_equal(&refs[i], &ref, GIT_SHA1_RAWSZ)); > + } > + > + reftable_ref_record_release(&ref); > + reftable_stack_destroy(st1); > + reftable_stack_destroy(st2); > + clear_dir(dir); > +} > +
On Wed, Sep 18, 2024 at 07:26:49PM +1000, James Liu wrote: > I just want to check my understanding of this test, since I think it's > the first time I've reviewed anything using this test harness: > > On Wed Sep 18, 2024 at 2:32 PM AEST, Patrick Steinhardt wrote: > > diff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/t-reftable-stack.c > > index d62a9c1bed5..a37cc698d87 100644 > > --- a/t/unit-tests/t-reftable-stack.c > > +++ b/t/unit-tests/t-reftable-stack.c > > @@ -271,7 +271,7 @@ static void t_reftable_stack_transaction_api(void) > > > > reftable_addition_destroy(add); > > > > - err = reftable_stack_new_addition(&add, st); > > + err = reftable_stack_new_addition(&add, st, 0); > > check(!err); > > > > err = reftable_addition_add(add, write_test_ref, &ref); > > @@ -292,6 +292,68 @@ static void t_reftable_stack_transaction_api(void) > > clear_dir(dir); > > } > > > > +static void t_reftable_stack_transaction_with_reload(void) > > +{ > > + char *dir = get_tmp_dir(__LINE__); > > + struct reftable_stack *st1 = NULL, *st2 = NULL; > > + int err; > > + struct reftable_addition *add = NULL; > > + struct reftable_ref_record refs[2] = { > > + { > > + .refname = (char *) "refs/heads/a", > > + .update_index = 1, > > + .value_type = REFTABLE_REF_VAL1, > > + .value.val1 = { '1' }, > > + }, > > + { > > + .refname = (char *) "refs/heads/b", > > + .update_index = 2, > > + .value_type = REFTABLE_REF_VAL1, > > + .value.val1 = { '1' }, > > + }, > > + }; > > + struct reftable_ref_record ref = { 0 }; > > + > > Create two reftable stacks that provide a view into the reftable tables > inside "dir". Yup. > > + err = reftable_new_stack(&st1, dir, NULL); > > + check(!err); > > + err = reftable_new_stack(&st2, dir, NULL); > > + check(!err); > > + > > Successfully add refs[0] to the first stack using the transactional API. Here we only open the stacks without doing anything with them yet. This is preparation for being able to read/write them. > > + err = reftable_stack_new_addition(&add, st1, 0); > > + check(!err); > > + err = reftable_addition_add(add, write_test_ref, &refs[0]); > > + check(!err); > > + err = reftable_addition_commit(add); > > + check(!err); > > + reftable_addition_destroy(add); > > + > > + /* > > + * The second stack is now outdated, which we should notice. We do not > > + * create the addition and lock the stack by default, but allow the > > + * reload to happen when REFTABLE_STACK_NEW_ADDITION_RELOAD is set. > > + */ > > We try to open a transaction via the second reftable stack, but the > this stack is outdated because we've written to "dir" when the previous > stack addition was committed. Yup. > > + err = reftable_stack_new_addition(&add, st2, 0); > > + check_int(err, ==, REFTABLE_OUTDATED_ERROR); > > Try again, but supply the flag so it performs a reload internally. Write > refs[1] to "dir" by committing the transaction. Yup. > > + err = reftable_stack_new_addition(&add, st2, REFTABLE_STACK_NEW_ADDITION_RELOAD); > > + check(!err); > > + err = reftable_addition_add(add, write_test_ref, &refs[1]); > > + check(!err); > > + err = reftable_addition_commit(add); > > + check(!err); > > + reftable_addition_destroy(add); > > + > > Asserts. Exactly. Patrick
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c index e90ddfb98dd..c500fb820a7 100644 --- a/refs/reftable-backend.c +++ b/refs/reftable-backend.c @@ -766,7 +766,7 @@ static int prepare_transaction_update(struct write_transaction_table_arg **out, if (ret) return ret; - ret = reftable_stack_new_addition(&addition, stack); + ret = reftable_stack_new_addition(&addition, stack, 0); if (ret) { if (ret == REFTABLE_LOCK_ERROR) strbuf_addstr(err, "cannot lock references"); @@ -2203,7 +2203,7 @@ static int reftable_be_reflog_expire(struct ref_store *ref_store, if (ret < 0) goto done; - ret = reftable_stack_new_addition(&add, stack); + ret = reftable_stack_new_addition(&add, stack, 0); if (ret < 0) goto done; diff --git a/reftable/reftable-stack.h b/reftable/reftable-stack.h index f4f8cabc7fb..67316b215ed 100644 --- a/reftable/reftable-stack.h +++ b/reftable/reftable-stack.h @@ -37,12 +37,21 @@ uint64_t reftable_stack_next_update_index(struct reftable_stack *st); /* holds a transaction to add tables at the top of a stack. */ struct reftable_addition; +enum { + /* + * Reload the stack when the stack is out-of-date after locking it. + */ + REFTABLE_STACK_NEW_ADDITION_RELOAD = (1 << 0), +}; + /* * returns a new transaction to add reftables to the given stack. As a side - * effect, the ref database is locked. + * effect, the ref database is locked. Accepts REFTABLE_STACK_NEW_ADDITION_* + * flags. */ int reftable_stack_new_addition(struct reftable_addition **dest, - struct reftable_stack *st); + struct reftable_stack *st, + int flags); /* Adds a reftable to transaction. */ int reftable_addition_add(struct reftable_addition *add, diff --git a/reftable/stack.c b/reftable/stack.c index 5ccad2cff31..f9c95d5fa62 100644 --- a/reftable/stack.c +++ b/reftable/stack.c @@ -596,7 +596,8 @@ struct reftable_addition { #define REFTABLE_ADDITION_INIT {0} static int reftable_stack_init_addition(struct reftable_addition *add, - struct reftable_stack *st) + struct reftable_stack *st, + int flags) { struct strbuf lock_file_name = STRBUF_INIT; int err; @@ -626,6 +627,11 @@ static int reftable_stack_init_addition(struct reftable_addition *add, err = stack_uptodate(st); if (err < 0) goto done; + if (err > 0 && flags & REFTABLE_STACK_NEW_ADDITION_RELOAD) { + err = reftable_stack_reload_maybe_reuse(add->stack, 1); + if (err) + goto done; + } if (err > 0) { err = REFTABLE_OUTDATED_ERROR; goto done; @@ -633,9 +639,8 @@ static int reftable_stack_init_addition(struct reftable_addition *add, add->next_update_index = reftable_stack_next_update_index(st); done: - if (err) { + if (err) reftable_addition_close(add); - } strbuf_release(&lock_file_name); return err; } @@ -739,13 +744,14 @@ int reftable_addition_commit(struct reftable_addition *add) } int reftable_stack_new_addition(struct reftable_addition **dest, - struct reftable_stack *st) + struct reftable_stack *st, + int flags) { int err = 0; struct reftable_addition empty = REFTABLE_ADDITION_INIT; REFTABLE_CALLOC_ARRAY(*dest, 1); **dest = empty; - err = reftable_stack_init_addition(*dest, st); + err = reftable_stack_init_addition(*dest, st, flags); if (err) { reftable_free(*dest); *dest = NULL; @@ -759,7 +765,7 @@ static int stack_try_add(struct reftable_stack *st, void *arg) { struct reftable_addition add = REFTABLE_ADDITION_INIT; - int err = reftable_stack_init_addition(&add, st); + int err = reftable_stack_init_addition(&add, st, 0); if (err < 0) goto done; @@ -1608,7 +1614,7 @@ static int reftable_stack_clean_locked(struct reftable_stack *st) int reftable_stack_clean(struct reftable_stack *st) { struct reftable_addition *add = NULL; - int err = reftable_stack_new_addition(&add, st); + int err = reftable_stack_new_addition(&add, st, 0); if (err < 0) { goto done; } diff --git a/t/unit-tests/t-reftable-stack.c b/t/unit-tests/t-reftable-stack.c index d62a9c1bed5..a37cc698d87 100644 --- a/t/unit-tests/t-reftable-stack.c +++ b/t/unit-tests/t-reftable-stack.c @@ -271,7 +271,7 @@ static void t_reftable_stack_transaction_api(void) reftable_addition_destroy(add); - err = reftable_stack_new_addition(&add, st); + err = reftable_stack_new_addition(&add, st, 0); check(!err); err = reftable_addition_add(add, write_test_ref, &ref); @@ -292,6 +292,68 @@ static void t_reftable_stack_transaction_api(void) clear_dir(dir); } +static void t_reftable_stack_transaction_with_reload(void) +{ + char *dir = get_tmp_dir(__LINE__); + struct reftable_stack *st1 = NULL, *st2 = NULL; + int err; + struct reftable_addition *add = NULL; + struct reftable_ref_record refs[2] = { + { + .refname = (char *) "refs/heads/a", + .update_index = 1, + .value_type = REFTABLE_REF_VAL1, + .value.val1 = { '1' }, + }, + { + .refname = (char *) "refs/heads/b", + .update_index = 2, + .value_type = REFTABLE_REF_VAL1, + .value.val1 = { '1' }, + }, + }; + struct reftable_ref_record ref = { 0 }; + + err = reftable_new_stack(&st1, dir, NULL); + check(!err); + err = reftable_new_stack(&st2, dir, NULL); + check(!err); + + err = reftable_stack_new_addition(&add, st1, 0); + check(!err); + err = reftable_addition_add(add, write_test_ref, &refs[0]); + check(!err); + err = reftable_addition_commit(add); + check(!err); + reftable_addition_destroy(add); + + /* + * The second stack is now outdated, which we should notice. We do not + * create the addition and lock the stack by default, but allow the + * reload to happen when REFTABLE_STACK_NEW_ADDITION_RELOAD is set. + */ + err = reftable_stack_new_addition(&add, st2, 0); + check_int(err, ==, REFTABLE_OUTDATED_ERROR); + err = reftable_stack_new_addition(&add, st2, REFTABLE_STACK_NEW_ADDITION_RELOAD); + check(!err); + err = reftable_addition_add(add, write_test_ref, &refs[1]); + check(!err); + err = reftable_addition_commit(add); + check(!err); + reftable_addition_destroy(add); + + for (size_t i = 0; i < ARRAY_SIZE(refs); i++) { + err = reftable_stack_read_ref(st2, refs[i].refname, &ref); + check(!err); + check(reftable_ref_record_equal(&refs[i], &ref, GIT_SHA1_RAWSZ)); + } + + reftable_ref_record_release(&ref); + reftable_stack_destroy(st1); + reftable_stack_destroy(st2); + clear_dir(dir); +} + static void t_reftable_stack_transaction_api_performs_auto_compaction(void) { char *dir = get_tmp_dir(__LINE__); @@ -322,7 +384,7 @@ static void t_reftable_stack_transaction_api_performs_auto_compaction(void) */ st->opts.disable_auto_compact = i != n; - err = reftable_stack_new_addition(&add, st); + err = reftable_stack_new_addition(&add, st, 0); check(!err); err = reftable_addition_add(add, write_test_ref, &ref); @@ -1314,6 +1376,7 @@ int cmd_main(int argc UNUSED, const char *argv[] UNUSED) TEST(t_reftable_stack_reload_with_missing_table(), "stack iteration with garbage tables"); TEST(t_reftable_stack_tombstone(), "'tombstone' refs in stack"); TEST(t_reftable_stack_transaction_api(), "update transaction to stack"); + TEST(t_reftable_stack_transaction_with_reload(), "transaction with reload"); TEST(t_reftable_stack_transaction_api_performs_auto_compaction(), "update transaction triggers auto-compaction"); TEST(t_reftable_stack_update_index_check(), "update transactions with equal update indices"); TEST(t_reftable_stack_uptodate(), "stack must be reloaded before ref update");
In `reftable_stack_new_addition()` we first lock the stack and then check whether it is still up-to-date. If it is not we return an error to the caller indicating that the stack is outdated. This is overly restrictive in our ref transaction interface though: we lock the stack right before we start to verify the transaction, so we do not really care whether it is outdated or not. What we really want is that the stack is up-to-date after it has been locked so that we can verify queued updates against its current state while we know that it is locked for concurrent modification. Introduce a new flag `REFTABLE_STACK_NEW_ADDITION_RELOAD` that alters the behaviour of `reftable_stack_init_addition()` in this case: when we notice that it is out-of-date we reload it instead of returning an error to the caller. This logic will be wired up in the reftable backend in the next commit. Signed-off-by: Patrick Steinhardt <ps@pks.im> --- refs/reftable-backend.c | 4 +- reftable/reftable-stack.h | 13 ++++++- reftable/stack.c | 20 ++++++---- t/unit-tests/t-reftable-stack.c | 67 ++++++++++++++++++++++++++++++++- 4 files changed, 91 insertions(+), 13 deletions(-)