@@ -1556,11 +1556,12 @@ static void handle_children_on_signal(int signo)
}
static void pp_init(struct parallel_processes *pp,
- get_next_task_fn get_next_task,
- start_failure_fn start_failure,
- task_finished_fn task_finished)
+ const struct run_process_parallel_opts *opts)
{
- const size_t n = pp->max_processes;
+ const size_t n = opts->processes;
+ get_next_task_fn get_next_task = opts->get_next_task;
+ start_failure_fn start_failure = opts->start_failure;
+ task_finished_fn task_finished = opts->task_finished;
if (!n)
BUG("you must provide a non-zero number of processes!");
@@ -1765,7 +1766,7 @@ static int pp_collect_finished(struct parallel_processes *pp)
return result;
}
-void run_processes_parallel(size_t n,
+void run_processes_parallel(size_t processes,
get_next_task_fn get_next_task,
start_failure_fn start_failure,
task_finished_fn task_finished,
@@ -1774,18 +1775,27 @@ void run_processes_parallel(size_t n,
int code;
int output_timeout = 100;
int spawn_cap = 4;
- int ungroup = run_processes_parallel_ungroup;
struct parallel_processes pp = {
- .max_processes = n,
+ .max_processes = processes,
.data = pp_cb,
.buffered_output = STRBUF_INIT,
- .ungroup = ungroup,
+ .ungroup = run_processes_parallel_ungroup,
+ };
+ const struct run_process_parallel_opts opts = {
+ .processes = processes,
+
+ .get_next_task = get_next_task,
+ .start_failure = start_failure,
+ .task_finished = task_finished,
+
+ .ungroup = run_processes_parallel_ungroup,
};
/* unset for the next API user */
run_processes_parallel_ungroup = 0;
- pp_init(&pp, get_next_task, start_failure, task_finished);
+ pp_init(&pp, &opts);
+
while (1) {
for (int i = 0;
i < spawn_cap && !pp.shutdown &&
@@ -1802,7 +1812,7 @@ void run_processes_parallel(size_t n,
}
if (!pp.nr_processes)
break;
- if (ungroup) {
+ if (opts.ungroup) {
for (size_t i = 0; i < pp.max_processes; i++)
pp.children[i].state = GIT_CP_WAIT_CLEANUP;
} else {
@@ -459,7 +459,42 @@ typedef int (*task_finished_fn)(int result,
void *pp_task_cb);
/**
- * Runs up to n processes at the same time. Whenever a process can be
+ * Option used by run_processes_parallel(), { 0 }-initialized means no
+ * options.
+ */
+struct run_process_parallel_opts
+{
+ /**
+ * processes: see 'processes' in run_processes_parallel() below.
+ */
+ size_t processes;
+
+ /**
+ * ungroup: see 'ungroup' in run_processes_parallel() below.
+ */
+ unsigned int ungroup:1;
+
+ /**
+ * get_next_task: See get_next_task_fn() above. This must be
+ * specified.
+ */
+ get_next_task_fn get_next_task;
+
+ /**
+ * start_failure: See start_failure_fn() above. This can be
+ * NULL to omit any special handling.
+ */
+ start_failure_fn start_failure;
+
+ /**
+ * task_finished: See task_finished_fn() above. This can be
+ * NULL to omit any special handling.
+ */
+ task_finished_fn task_finished;
+};
+
+/**
+ * Runs N 'processes' at the same time. Whenever a process can be
* started, the callback get_next_task_fn is called to obtain the data
* required to start another child process.
*
@@ -467,9 +502,6 @@ typedef int (*task_finished_fn)(int result,
* (both stdout and stderr) is routed to stderr in a manner that output
* from different tasks does not interleave (but see "ungroup" below).
*
- * start_failure_fn and task_finished_fn can be NULL to omit any
- * special handling.
- *
* If the "ungroup" option isn't specified, the API will set the
* "stdout_to_stderr" parameter in "struct child_process" and provide
* the callbacks with a "struct strbuf *out" parameter to write output
@@ -485,13 +517,13 @@ typedef int (*task_finished_fn)(int result,
* API reads that setting.
*/
extern int run_processes_parallel_ungroup;
-void run_processes_parallel(size_t n,
+void run_processes_parallel(size_t processes,
get_next_task_fn,
start_failure_fn,
task_finished_fn,
void *pp_cb);
-void run_processes_parallel_tr2(size_t n, get_next_task_fn, start_failure_fn,
- task_finished_fn, void *pp_cb,
+void run_processes_parallel_tr2(size_t processes, get_next_task_fn,
+ start_failure_fn, task_finished_fn, void *pp_cb,
const char *tr2_category, const char *tr2_label);
/**
As noted in fd3aaf53f71 (run-command: add an "ungroup" option to run_process_parallel(), 2022-06-07) which added the "ungroup" passing it to "run_process_parallel()" via the global "run_processes_parallel_ungroup" variable was a compromise to get the smallest possible regression fix for "maint" at the time. This follow-up to that is a start at passing that parameter and others via a new "struct run_process_parallel_opts", as the earlier version[1] of what became fd3aaf53f71 did. For now we're only changing how data is passed internally to "run-command.c", i.e. from "run_process_parallel()" to pp_init(). Subsequent commits will change "run_processes_parallel()" itself, as well as the "run_processes_parallel_tr2()" wrapper function. Since we need to change all of the occurrences of "n" to "opt->SOMETHING" let's take the opportunity and rename the terse "n" to "processes". We could also have picked "max_processes", "jobs", "threads" etc., but as the API is named "run_processes_parallel()" let's go with "processes". 1. https://lore.kernel.org/git/cover-v2-0.8-00000000000-20220518T195858Z-avarab@gmail.com/ Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com> --- run-command.c | 30 ++++++++++++++++++++---------- run-command.h | 46 +++++++++++++++++++++++++++++++++++++++------- 2 files changed, 59 insertions(+), 17 deletions(-)