| Message ID | 20210812004258.74318-3-emilyshaffer@google.com (mailing list archive) |
|---|---|
| State | Superseded |
| Headers | show |
| Series | config-based hooks restarted | expand |
Emily Shaffer <emilyshaffer@google.com> writes: > In many cases, there's no reason not to allow hooks to execute in > parallel. run_processes_parallel() is well-suited - it's a task queue > that runs its housekeeping in series, which means users don't > need to worry about thread safety on their callback data. True > multithreaded execution with the async_* functions isn't necessary here. > Synchronous hook execution can be achieved by only allowing 1 job to run > at a time. > > Teach run_hooks() to use that function for simple hooks which don't > require stdin or capture of stderr. Since run_hooks() has been using run_processes_parallel_tr2() already in the ab/config-based-hooks-base topic, the above description puzzled me quite a bit. I think you meant to say with this step you update the callers to pass either .jobs=1 or .jobs=0 in the hooks_opt, so that hooks _can_ run in parallel (as opposed to using hardcoded jobs=1 in run_hooks() when calling the underlying run_processes_parallel_tr2() function). I do not think SYNC and ASYNC are great adjectives for what you are doing in this step. Wouldn't ASYNC mean "the caller tells the hooks to run, continues without waiting for them to finish"? In order to let more than one hooks to run at the same time, the caller has to continue without waiting for the first one it started so that it can start the second one before the first one finishes (otherwise these two hooks will not run at the same time), but ASYNC implys a lot more than that. After starting all of these hooks, the caller may continue doing things that are not even related to these spawned hooks if a hook is run asynchronously. But I do not think that is what is happening here. After all, run_processes_parallel_tr2() will not return until all of the subprocesses are culled. Perhaps the distinction you are trying to express is easier to convey to readers if you instead used the verb TO RUN with the adverb SERIALLY vs IN PARALLEL (as opposed to SYNCHRONOUSLY vs ASYNCHRONOUSLY)? > diff --git a/builtin/hook.c b/builtin/hook.c > index 4d39c9e75e..12c9126032 100644 > --- a/builtin/hook.c > +++ b/builtin/hook.c > @@ -22,7 +22,7 @@ static const char * const builtin_hook_run_usage[] = { > static int run(int argc, const char **argv, const char *prefix) > { > int i; > - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; > + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_SYNC; > int ignore_missing = 0; > const char *hook_name; > struct list_head *hooks; > @@ -32,6 +32,8 @@ static int run(int argc, const char **argv, const char *prefix) > N_("exit quietly with a zero exit code if the requested hook cannot be found")), > OPT_STRING(0, "to-stdin", &opt.path_to_stdin, N_("path"), > N_("file to read into hooks' stdin")), > + OPT_INTEGER('j', "jobs", &opt.jobs, > + N_("run up to <n> hooks simultaneously")), > OPT_END(), > }; > int ret; OK, so by default "git hook" runs 1 at a time but we can instruct to run the optimal number of jobs via "git hook -j0" etc. > diff --git a/hook.c b/hook.c > index 80e150548c..37f682c6d8 100644 > --- a/hook.c > +++ b/hook.c > @@ -228,6 +228,28 @@ static int notify_hook_finished(int result, > return 0; > } > > +/* > + * Determines how many jobs to use after we know we want to parallelize. First > + * priority is the config 'hook.jobs' and second priority is the number of CPUs. > + */ > +static int configured_hook_jobs(void) > +{ > + /* > + * The config and the CPU count probably won't change during the process > + * lifetime, so cache the result in case we invoke multiple hooks during > + * one process. > + */ > + static int jobs = 0; > + if (jobs) > + return jobs; > + > + if (git_config_get_int("hook.jobs", &jobs)) > + /* if the config isn't set, fall back to CPU count. */ > + jobs = online_cpus(); > + > + return jobs; > +} Not a suggestion to make this improvement as a part of this series, but there already are more than several codepaths doing essentially the same thing as above, taking their own configuration or environment variables and falling back to online_cpus(). It may be worth introducing a shared helper function so that this can become static int configured_hook_jobs(void) { static int jobs; /* no need for "= 0" */ if (!jobs) jobs = default_parallelism("hook.jobs", NULL); return jobs; } where the new helper takes the configuration and environment variable names. Thanks.
On Thu, Aug 12, 2021 at 10:51:01AM -0700, Junio C Hamano wrote: > > Emily Shaffer <emilyshaffer@google.com> writes: > > > In many cases, there's no reason not to allow hooks to execute in > > parallel. run_processes_parallel() is well-suited - it's a task queue > > that runs its housekeeping in series, which means users don't > > need to worry about thread safety on their callback data. True > > multithreaded execution with the async_* functions isn't necessary here. > > Synchronous hook execution can be achieved by only allowing 1 job to run > > at a time. > > > > Teach run_hooks() to use that function for simple hooks which don't > > require stdin or capture of stderr. > > Since run_hooks() has been using run_processes_parallel_tr2() > already in the ab/config-based-hooks-base topic, the above > description puzzled me quite a bit. I think you meant to say with > this step you update the callers to pass either .jobs=1 or .jobs=0 > in the hooks_opt, so that hooks _can_ run in parallel (as opposed > to using hardcoded jobs=1 in run_hooks() when calling the underlying > run_processes_parallel_tr2() function). I think you are right, and this commit message is from a much older version of the series. Ok; I will reword it. I think it can be much simpler. > > I do not think SYNC and ASYNC are great adjectives for what you are > doing in this step. Wouldn't ASYNC mean "the caller tells the hooks > to run, continues without waiting for them to finish"? In order to > let more than one hooks to run at the same time, the caller has to > continue without waiting for the first one it started so that it can > start the second one before the first one finishes (otherwise these > two hooks will not run at the same time), but ASYNC implys a lot > more than that. After starting all of these hooks, the caller may > continue doing things that are not even related to these spawned > hooks if a hook is run asynchronously. > > But I do not think that is what is happening here. After all, > run_processes_parallel_tr2() will not return until all of the > subprocesses are culled. > > Perhaps the distinction you are trying to express is easier to > convey to readers if you instead used the verb TO RUN with the > adverb SERIALLY vs IN PARALLEL (as opposed to SYNCHRONOUSLY vs > ASYNCHRONOUSLY)? Good point. I think you are right and I'll change the init macros to SERIAL/PARALLEL instead. > > > diff --git a/builtin/hook.c b/builtin/hook.c > > index 4d39c9e75e..12c9126032 100644 > > --- a/builtin/hook.c > > +++ b/builtin/hook.c > > @@ -22,7 +22,7 @@ static const char * const builtin_hook_run_usage[] = { > > static int run(int argc, const char **argv, const char *prefix) > > { > > int i; > > - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; > > + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_SYNC; > > int ignore_missing = 0; > > const char *hook_name; > > struct list_head *hooks; > > @@ -32,6 +32,8 @@ static int run(int argc, const char **argv, const char *prefix) > > N_("exit quietly with a zero exit code if the requested hook cannot be found")), > > OPT_STRING(0, "to-stdin", &opt.path_to_stdin, N_("path"), > > N_("file to read into hooks' stdin")), > > + OPT_INTEGER('j', "jobs", &opt.jobs, > > + N_("run up to <n> hooks simultaneously")), > > OPT_END(), > > }; > > int ret; > > OK, so by default "git hook" runs 1 at a time but we can instruct to > run the optimal number of jobs via "git hook -j0" etc. Is it surprising for an explicitly provided "-j0" to still be overridden by a config if one was provided? That is, "-j0" doesn't mean "-j$(nproc)" as it does in many other Unixy tools, here. It means "-j(hook.jobs OR $(nproc))". I guess you could also say that "if you configured hook.jobs, it is because you decided nproc was less optimal than the value you put into hook.jobs" - so maybe it is fine? > > > diff --git a/hook.c b/hook.c > > index 80e150548c..37f682c6d8 100644 > > --- a/hook.c > > +++ b/hook.c > > @@ -228,6 +228,28 @@ static int notify_hook_finished(int result, > > return 0; > > } > > > > +/* > > + * Determines how many jobs to use after we know we want to parallelize. First > > + * priority is the config 'hook.jobs' and second priority is the number of CPUs. > > + */ > > +static int configured_hook_jobs(void) > > +{ > > + /* > > + * The config and the CPU count probably won't change during the process > > + * lifetime, so cache the result in case we invoke multiple hooks during > > + * one process. > > + */ > > + static int jobs = 0; > > + if (jobs) > > + return jobs; > > + > > + if (git_config_get_int("hook.jobs", &jobs)) > > + /* if the config isn't set, fall back to CPU count. */ > > + jobs = online_cpus(); > > + > > + return jobs; > > +} > > Not a suggestion to make this improvement as a part of this series, > but there already are more than several codepaths doing essentially > the same thing as above, taking their own configuration or > environment variables and falling back to online_cpus(). > > It may be worth introducing a shared helper function so that this > can become > > static int configured_hook_jobs(void) > { > static int jobs; /* no need for "= 0" */ > > if (!jobs) > jobs = default_parallelism("hook.jobs", NULL); > return jobs; > } > > where the new helper takes the configuration and environment > variable names. Sounds handy. - Emily
diff --git a/Documentation/config/hook.txt b/Documentation/config/hook.txt new file mode 100644 index 0000000000..96d3d6572c --- /dev/null +++ b/Documentation/config/hook.txt @@ -0,0 +1,4 @@ +hook.jobs:: + Specifies how many hooks can be run simultaneously during parallelized + hook execution. If unspecified, defaults to the number of processors on + the current system. diff --git a/Documentation/git-hook.txt b/Documentation/git-hook.txt index fa68c1f391..8bf82b5dd4 100644 --- a/Documentation/git-hook.txt +++ b/Documentation/git-hook.txt @@ -8,7 +8,8 @@ git-hook - run git hooks SYNOPSIS -------- [verse] -'git hook' run [--to-stdin=<path>] [--ignore-missing] <hook-name> [-- <hook-args>] +'git hook' run [--to-stdin=<path>] [--ignore-missing] [(-j|--jobs) <n>] + <hook-name> [-- <hook-args>] DESCRIPTION ----------- @@ -42,6 +43,20 @@ OPTIONS tools that want to do a blind one-shot run of a hook that may or may not be present. +-j:: +--jobs:: + Only valid for `run`. ++ +Specify how many hooks to run simultaneously. If this flag is not specified, use +the value of the `hook.jobs` config. If the config is not specified, use the +number of CPUs on the current system. Some hooks may be ineligible for +parallelization: for example, 'commit-msg' intends hooks modify the commit +message body and cannot be parallelized. + +CONFIGURATION +------------- +include::config/hook.txt[] + SEE ALSO -------- linkgit:githooks[5] diff --git a/builtin/am.c b/builtin/am.c index 9e3d4d9ab4..c24a27d6a1 100644 --- a/builtin/am.c +++ b/builtin/am.c @@ -446,7 +446,7 @@ static void am_destroy(const struct am_state *state) static int run_applypatch_msg_hook(struct am_state *state) { int ret; - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_SYNC; assert(state->msg); strvec_push(&opt.args, am_path(state, "final-commit")); @@ -467,7 +467,7 @@ static int run_applypatch_msg_hook(struct am_state *state) */ static int run_post_rewrite_hook(const struct am_state *state) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_ASYNC; strvec_push(&opt.args, "rebase"); opt.path_to_stdin = am_path(state, "rewritten"); diff --git a/builtin/checkout.c b/builtin/checkout.c index 6d69b4c011..27166c0bb8 100644 --- a/builtin/checkout.c +++ b/builtin/checkout.c @@ -107,7 +107,7 @@ struct branch_info { static int post_checkout_hook(struct commit *old_commit, struct commit *new_commit, int changed) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_SYNC; /* "new_commit" can be NULL when checking out from the index before a commit exists. */ diff --git a/builtin/clone.c b/builtin/clone.c index 27fc05ee51..599e7a7936 100644 --- a/builtin/clone.c +++ b/builtin/clone.c @@ -776,7 +776,7 @@ static int checkout(int submodule_progress) struct tree *tree; struct tree_desc t; int err = 0; - struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT_SYNC; if (option_no_checkout) return 0; diff --git a/builtin/hook.c b/builtin/hook.c index 4d39c9e75e..12c9126032 100644 --- a/builtin/hook.c +++ b/builtin/hook.c @@ -22,7 +22,7 @@ static const char * const builtin_hook_run_usage[] = { static int run(int argc, const char **argv, const char *prefix) { int i; - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_SYNC; int ignore_missing = 0; const char *hook_name; struct list_head *hooks; @@ -32,6 +32,8 @@ static int run(int argc, const char **argv, const char *prefix) N_("exit quietly with a zero exit code if the requested hook cannot be found")), OPT_STRING(0, "to-stdin", &opt.path_to_stdin, N_("path"), N_("file to read into hooks' stdin")), + OPT_INTEGER('j', "jobs", &opt.jobs, + N_("run up to <n> hooks simultaneously")), OPT_END(), }; int ret; diff --git a/builtin/merge.c b/builtin/merge.c index 9bd4a2532c..c749c382c3 100644 --- a/builtin/merge.c +++ b/builtin/merge.c @@ -448,7 +448,7 @@ static void finish(struct commit *head_commit, const struct object_id *new_head, const char *msg) { struct strbuf reflog_message = STRBUF_INIT; - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_ASYNC; const struct object_id *head = &head_commit->object.oid; if (!msg) diff --git a/builtin/rebase.c b/builtin/rebase.c index e7c668c99b..fecf248ed9 100644 --- a/builtin/rebase.c +++ b/builtin/rebase.c @@ -1314,7 +1314,7 @@ int cmd_rebase(int argc, const char **argv, const char *prefix) char *squash_onto_name = NULL; int reschedule_failed_exec = -1; int allow_preemptive_ff = 1; - struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT_ASYNC; struct option builtin_rebase_options[] = { OPT_STRING(0, "onto", &options.onto_name, N_("revision"), diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c index ebec6f3bb1..b32dcc9000 100644 --- a/builtin/receive-pack.c +++ b/builtin/receive-pack.c @@ -909,7 +909,7 @@ static int run_receive_hook(struct command *commands, int skip_broken, const struct string_list *push_options) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_ASYNC; struct receive_hook_feed_context ctx; struct command *iter = commands; @@ -948,7 +948,7 @@ static int run_receive_hook(struct command *commands, static int run_update_hook(struct command *cmd) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_ASYNC; strvec_pushl(&opt.args, cmd->ref_name, @@ -1432,7 +1432,8 @@ static const char *push_to_checkout(unsigned char *hash, struct strvec *env, const char *work_tree) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_SYNC; + opt.invoked_hook = invoked_hook; strvec_pushf(env, "GIT_WORK_TREE=%s", absolute_path(work_tree)); @@ -1628,7 +1629,7 @@ static const char *update(struct command *cmd, struct shallow_info *si) static void run_update_post_hook(struct command *commands) { struct command *cmd; - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_ASYNC; for (cmd = commands; cmd; cmd = cmd->next) { if (cmd->error_string || cmd->did_not_exist) diff --git a/builtin/worktree.c b/builtin/worktree.c index 330867c19b..efead564c1 100644 --- a/builtin/worktree.c +++ b/builtin/worktree.c @@ -382,7 +382,7 @@ static int add_worktree(const char *path, const char *refname, * is_junk is cleared, but do return appropriate code when hook fails. */ if (!ret && opts->checkout) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_SYNC; strvec_pushl(&opt.env, "GIT_DIR", "GIT_WORK_TREE", NULL); strvec_pushl(&opt.args, diff --git a/commit.c b/commit.c index 842e47beae..0e6e5a5b27 100644 --- a/commit.c +++ b/commit.c @@ -1700,7 +1700,7 @@ int run_commit_hook(int editor_is_used, const char *index_file, int *invoked_hook, const char *name, ...) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_SYNC; va_list args; const char *arg; diff --git a/hook.c b/hook.c index 80e150548c..37f682c6d8 100644 --- a/hook.c +++ b/hook.c @@ -228,6 +228,28 @@ static int notify_hook_finished(int result, return 0; } +/* + * Determines how many jobs to use after we know we want to parallelize. First + * priority is the config 'hook.jobs' and second priority is the number of CPUs. + */ +static int configured_hook_jobs(void) +{ + /* + * The config and the CPU count probably won't change during the process + * lifetime, so cache the result in case we invoke multiple hooks during + * one process. + */ + static int jobs = 0; + if (jobs) + return jobs; + + if (git_config_get_int("hook.jobs", &jobs)) + /* if the config isn't set, fall back to CPU count. */ + jobs = online_cpus(); + + return jobs; +} + int run_hooks(const char *hook_name, struct list_head *hooks, struct run_hooks_opt *options) { @@ -237,16 +259,18 @@ int run_hooks(const char *hook_name, struct list_head *hooks, .options = options, .invoked_hook = options->invoked_hook, }; - int jobs = 1; if (!options) BUG("a struct run_hooks_opt must be provided to run_hooks"); - cb_data.head = hooks; cb_data.run_me = list_first_entry(hooks, struct hook, list); - run_processes_parallel_tr2(jobs, + /* INIT_ASYNC sets jobs to 0, so go look up how many to use. */ + if (!options->jobs) + options->jobs = configured_hook_jobs(); + + run_processes_parallel_tr2(options->jobs, pick_next_hook, notify_start_failure, options->feed_pipe, @@ -265,7 +289,11 @@ int run_hooks_oneshot(const char *hook_name, struct run_hooks_opt *options) { struct list_head *hooks; int ret = 0; - struct run_hooks_opt hook_opt_scratch = RUN_HOOKS_OPT_INIT; + /* + * Turn on parallelism by default. Hooks which don't want it should + * specify their options accordingly. + */ + struct run_hooks_opt hook_opt_scratch = RUN_HOOKS_OPT_INIT_ASYNC; if (!options) options = &hook_opt_scratch; diff --git a/hook.h b/hook.h index 7705e6a529..4f90228a0c 100644 --- a/hook.h +++ b/hook.h @@ -43,6 +43,13 @@ struct run_hooks_opt /* Args to be passed to each hook */ struct strvec args; + /* + * Number of threads to parallelize across. Set to 0 to use the + * 'hook.jobs' config or, if that config is unset, the number of cores + * on the system. + */ + int jobs; + /* Resolve and run the "absolute_path(hook)" instead of * "hook". Used for "git worktree" hooks */ @@ -85,11 +92,6 @@ struct run_hooks_opt int *invoked_hook; }; -#define RUN_HOOKS_OPT_INIT { \ - .env = STRVEC_INIT, \ - .args = STRVEC_INIT, \ -} - /* * To specify a 'struct string_list', set 'run_hooks_opt.feed_pipe_ctx' to the * string_list and set 'run_hooks_opt.feed_pipe' to 'pipe_from_string_list()'. @@ -111,6 +113,18 @@ struct hook_cb_data { int *invoked_hook; }; +#define RUN_HOOKS_OPT_INIT_SYNC { \ + .jobs = 1, \ + .env = STRVEC_INIT, \ + .args = STRVEC_INIT, \ +} + +#define RUN_HOOKS_OPT_INIT_ASYNC { \ + .jobs = 0, \ + .env = STRVEC_INIT, \ + .args = STRVEC_INIT, \ +} + void run_hooks_opt_clear(struct run_hooks_opt *o); /** diff --git a/read-cache.c b/read-cache.c index 90099ca14d..fd2bc67667 100644 --- a/read-cache.c +++ b/read-cache.c @@ -3068,7 +3068,7 @@ static int do_write_locked_index(struct index_state *istate, struct lock_file *l { int ret; int was_full = !istate->sparse_index; - struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT_ASYNC; ret = convert_to_sparse(istate); diff --git a/refs.c b/refs.c index 73d4a93926..305a075746 100644 --- a/refs.c +++ b/refs.c @@ -2062,7 +2062,7 @@ int ref_update_reject_duplicates(struct string_list *refnames, static int run_transaction_hook(struct ref_transaction *transaction, const char *state) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_ASYNC; struct string_list to_stdin = STRING_LIST_INIT_NODUP; int ret = 0, i; diff --git a/reset.c b/reset.c index 6499bc5127..b93fe6a783 100644 --- a/reset.c +++ b/reset.c @@ -128,7 +128,8 @@ int reset_head(struct repository *r, struct object_id *oid, const char *action, reflog_head); } if (run_hook) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_ASYNC; + strvec_pushl(&opt.args, oid_to_hex(orig ? orig : null_oid()), oid_to_hex(oid), diff --git a/sequencer.c b/sequencer.c index f451e23d0c..f13a0cbfbe 100644 --- a/sequencer.c +++ b/sequencer.c @@ -1148,7 +1148,7 @@ int update_head_with_reflog(const struct commit *old_head, static int run_rewrite_hook(const struct object_id *oldoid, const struct object_id *newoid) { - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_ASYNC; struct strbuf tmp = STRBUF_INIT; struct string_list to_stdin = STRING_LIST_INIT_DUP; int code; @@ -4522,7 +4522,7 @@ static int pick_commits(struct repository *r, if (!stat(rebase_path_rewritten_list(), &st) && st.st_size > 0) { struct child_process notes_cp = CHILD_PROCESS_INIT; - struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt hook_opt = RUN_HOOKS_OPT_INIT_ASYNC; notes_cp.in = open(rebase_path_rewritten_list(), O_RDONLY); notes_cp.git_cmd = 1; diff --git a/transport.c b/transport.c index 4ca8fc0391..abf8785885 100644 --- a/transport.c +++ b/transport.c @@ -1204,7 +1204,7 @@ static int run_pre_push_hook(struct transport *transport, struct ref *remote_refs) { int ret = 0; - struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; + struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT_ASYNC; struct ref *r; struct string_list to_stdin = STRING_LIST_INIT_NODUP;
In many cases, there's no reason not to allow hooks to execute in parallel. run_processes_parallel() is well-suited - it's a task queue that runs its housekeeping in series, which means users don't need to worry about thread safety on their callback data. True multithreaded execution with the async_* functions isn't necessary here. Synchronous hook execution can be achieved by only allowing 1 job to run at a time. Teach run_hooks() to use that function for simple hooks which don't require stdin or capture of stderr. Signed-off-by: Emily Shaffer <emilyshaffer@google.com> Helped-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com> --- Documentation/config/hook.txt | 4 ++++ Documentation/git-hook.txt | 17 ++++++++++++++++- builtin/am.c | 4 ++-- builtin/checkout.c | 2 +- builtin/clone.c | 2 +- builtin/hook.c | 4 +++- builtin/merge.c | 2 +- builtin/rebase.c | 2 +- builtin/receive-pack.c | 9 +++++---- builtin/worktree.c | 2 +- commit.c | 2 +- hook.c | 36 +++++++++++++++++++++++++++++++---- hook.h | 24 ++++++++++++++++++----- read-cache.c | 2 +- refs.c | 2 +- reset.c | 3 ++- sequencer.c | 4 ++-- transport.c | 2 +- 18 files changed, 94 insertions(+), 29 deletions(-) create mode 100644 Documentation/config/hook.txt