Parallel Communicating GTSPs (PCG)

• Parallel Communicating GTSPs (PCG) is a parallel algorithm that distributes GTSP solving across processes, enhancing convergence in moving target TSP scenarios.
• It leverages independent random sampling and shared incumbent solutions to overcome computational bottlenecks in large-scale interception problems.
• Empirical studies show near-linear speedup and robust performance across variants, highlighting effective trade-offs between exploration and exploitation.

Parallel Communicating GTSPs (PCG) is a parallel algorithm introduced within the Iterated Random Generalized (IRG) TSP framework for the Moving Target Traveling Salesman Problem (MT-TSP), where an agent must intercept several moving targets within prescribed time windows despite generic nonlinear target trajectories or kinematic constraints (Bhat et al., 10 Sep 2025). In PCG, multiple processes solve generalized traveling salesman problems (GTSPs) on different sample-point graphs generated from different random seeds, while sharing the points visited by the current best global tour. The method is designed to accelerate convergence relative to solving a single large GTSP by exploiting both parallelism across random realizations of the sample graph and communication of good sample-points among processes (Bhat et al., 10 Sep 2025).

1. Position within the IRG framework

The IRG framework alternates between two operations: randomly sampling a finite set of agent configuration-time points corresponding to interceptions of targets, and finding a sequence of interception points by solving a GTSP (Bhat et al., 10 Sep 2025). In each iteration, the sampled interception points are grouped into clusters, with one cluster per target, and a sparse graph is built whose nodes are the samples and whose edges represent kinematically feasible transitions. A minimum-cost tour on that graph yields a candidate interception sequence. By resampling and including incumbent tour points in subsequent iterations, IRG is provably asymptotically optimal (Bhat et al., 10 Sep 2025).

Within this framework, PCG addresses a specific bottleneck: solving a single large GTSP can become computationally expensive when the number of targets or the number of samples per target grows (Bhat et al., 10 Sep 2025). PCG responds by distributing the GTSP work across several processes, each operating on its own sample-point graph. These graphs are not independent in the strict sense, because every process is seeded with the current best sample for each target, so information found by one process can influence the search performed by all others in the next synchronized update (Bhat et al., 10 Sep 2025).

PCG differs structurally from IRG-PGLNS, the other parallel algorithm introduced in the same work. IRG-PGLNS uses one sample-point graph per iteration but parallelizes within the GTSP solver through PGLNS, a parallelized extension of GLNS. PCG instead uses multiple sample-point graphs and solves them with the serial solver GLNS, while communicating best solutions among the processes (Bhat et al., 10 Sep 2025). This division clarifies that the essential distinction is not merely implementation-level parallelism, but whether parallel resources are spent on one GTSP instance or on several distinct GTSP instances.

2. Formal problem model and graph construction

The underlying MT-TSP formulation considers $n$ moving targets indexed by $i=1,\dots,n$. Each target $i$ has a smooth trajectory

$$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$

and a time window $[\underline t_i,\overline t_i]$ (Bhat et al., 10 Sep 2025). The agent operates in a configuration space $\mathcal Q$, and its kinematic constraints are encoded by the feasibility predicate

$\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$

A sample for target $i$ is a pair $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$ such that $q$ intercepts target $i=1,\dots,n$0 at time $i=1,\dots,n$1. The current cluster of samples for target $i=1,\dots,n$2 is denoted

$i=1,\dots,n$3

From these clusters, a sample-point graph

$i=1,\dots,n$4

is defined by

$i=1,\dots,n$5

and

$i=1,\dots,n$6

Each edge $i=1,\dots,n$7 carries a cost

$i=1,\dots,n$8

A GTSP instance is therefore given by the clusters $i=1,\dots,n$9 and the cost function $i$0, and a GTSP solution is a cycle in $i$1 that visits exactly one node in each cluster (Bhat et al., 10 Sep 2025).

The IRG sampling step independently draws, for each target $i$2, $i$3 random times

$i$4

and random configurations $i$5, thereby forming new samples $i$6. In PCG, each process generates its own fresh random samples but always includes the current best sample for each target (Bhat et al., 10 Sep 2025). This suggests that PCG couples exploration through independent randomization with exploitation through globally shared incumbent interception points.

3. Parallel communicating architecture

PCG is organized as a main process and multiple child processes. The main process maintains a global incumbent tour $i$7 and a set of globally informed samples, while the child processes independently generate sample graphs, solve GTSPs, and return new candidate interception points (Bhat et al., 10 Sep 2025).

The main process, denoted $i$8, begins by initializing $i$9 to a feasible tour via a randomized initial-tour routine. For each target $$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$0, it creates a global informed set

$$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$1

It then repeats the following cycle until the time limit is reached: launch $$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$2 child processes in parallel, pass each process the current informed sets $$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$3 and $$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$4, wait for all children to return their tours $$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$5 and informed lists $$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$6, update each $$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$7 to

$$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$8

and set $$\tau_i:[\underline t_i,\overline t_i]\to\mathbb R^d$$9 to the least-cost tour among $[\underline t_i,\overline t_i]$0. The final output is the continuous trajectory realized by $[\underline t_i,\overline t_i]$1 (Bhat et al., 10 Sep 2025).

Each child process $[\underline t_i,\overline t_i]$2, denoted $[\underline t_i,\overline t_i]$3, receives $[\underline t_i,\overline t_i]$4 and $[\underline t_i,\overline t_i]$5. For every target $[\underline t_i,\overline t_i]$6, it forms

$[\underline t_i,\overline t_i]$7

It then builds the GTSP graph $[\underline t_i,\overline t_i]$8 on $[\underline t_i,\overline t_i]$9, solves the resulting GTSP via GLNS while seeding the solver with $\mathcal Q$0, and records, for each $\mathcal Q$1, the point $\mathcal Q$2 intercepting target $\mathcal Q$3 in $\mathcal Q$4. The child returns both $\mathcal Q$5 and $\mathcal Q$6 (Bhat et al., 10 Sep 2025).

The communication pattern is synchronous: all $\mathcal Q$7 children must finish before the main process updates the informed sets $\mathcal Q$8 (Bhat et al., 10 Sep 2025). An asynchronous variant can update the informed sets whenever any solver finishes, but the reported experiments found little added benefit (Bhat et al., 10 Sep 2025). A common misconception would be to treat PCG merely as embarrassingly parallel multi-start search; the algorithm is more structured than that because the child processes exchange information through the informed sets and through seeding by the current best global tour.

4. Complexity, runtime model, and guarantees

The complexity discussion in the source uses the following notation: $\mathcal Q$9 is the number of parallel processes, $\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$0 is the total number of samples per child, $\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$1 is the number of clusters including the depot cluster, and $\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$2 is the average cluster size so that $\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$3 (Bhat et al., 10 Sep 2025). Per iteration, each child performs sampling in $\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$4, graph construction and edge-feasibility checks in $\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$5 worst-case, and a GTSP solve via GLNS whose empirical time is

$\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$6

per run, with observed sub-quadratic scaling (Bhat et al., 10 Sep 2025).

Because the children run in parallel, iteration time is dominated by

$\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$7

where

$\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$8

is the cost to broadcast $\mathsf{TrajExists}(q,t,q',t')\in\{0,1\}.$9 and gather the informed lists $i$0. After $i$1 iterations, the total runtime is approximated by

$i$2

This model makes explicit that the parallel speed of PCG is constrained not only by solver performance but also by the slowest child in each synchronous round (Bhat et al., 10 Sep 2025).

PCG inherits the asymptotic guarantees of IRG. Under the same mild assumptions as IRG, it is probabilistically complete, meaning that it finds a feasible tour with probability approaching $i$3 as $i$4, and asymptotically optimal, meaning that the cost of $i$5 converges to the true MT-TSP optimum with probability $i$6 (Bhat et al., 10 Sep 2025). The paper states the following theorem: suppose there exists an open neighborhood in sample-space around an optimal interception list. Then, as the number of PCG iterations $i$7,

$i$8

where $i$9 is the optimal MT-TSP cost (Bhat et al., 10 Sep 2025).

These guarantees are notable because the abstract states that, in the presence of generic nonlinear target trajectories or kinematic constraints on the agent, no prior algorithm guarantees convergence to an optimal MT-TSP solution (Bhat et al., 10 Sep 2025). A plausible implication is that the role of PCG is not solely practical acceleration; it also preserves the theoretical convergence properties established for the broader IRG construction.

5. Implementation and systems considerations

The reported implementation uses C++ with MPI for inter-process spawning and messaging, with each child assigned to a separate MPI rank (Bhat et al., 10 Sep 2025). Shared memory operations, specifically sampling and graph building, use OpenMP within each process (Bhat et al., 10 Sep 2025). This yields a hybrid parallelization scheme in which message passing manages the communication between GTSP solves, while thread-level parallelism accelerates local preprocessing inside each solver process.

The tour data structure is a std::vector<NodeID> of length $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$0, where NodeID encodes the sample index and cluster (Bhat et al., 10 Sep 2025). Communication buffers are fixed-size arrays of length $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$1 used to gather $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$2, and MPI_Allgather is used to collect the $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$3 informed lists (Bhat et al., 10 Sep 2025). Per iteration, message passing consists of one collective all-gather for the $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$4 informed points and one broadcast of $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$5 (Bhat et al., 10 Sep 2025).

Load balancing is handled by having each child draw exactly $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$6 samples per cluster and by assigning the same time limit per GLNS solve (Bhat et al., 10 Sep 2025). The source also gives explicit tuning guidance: $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$7 should be set to the number of physical cores, or slightly below to allow some oversubscription; the GTSP solver time limit per child should be balanced so that all children finish in roughly the same time; and $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$8 controls exploration versus exploitation (Bhat et al., 10 Sep 2025). Smaller $$s=(q,t)\in\mathcal Q\times[\underline t_i,\overline t_i]$$9 leads to more frequent communication and faster convergence in highly constrained problems, whereas larger values help in loose problems by discovering new good intercept points (Bhat et al., 10 Sep 2025).

These implementation details clarify that the performance of PCG depends not only on algorithmic structure but also on synchronization discipline and solver budget allocation. The mention of synchronous barriers causing stragglers to delay the iteration is therefore a systems-level limitation, not merely an abstract scheduling concern (Bhat et al., 10 Sep 2025).

6. Empirical behavior and comparative performance

The experimental evaluation was conducted on a 10-core Xeon with 128 GB RAM (Bhat et al., 10 Sep 2025). The reported metrics are convergence rate, defined as solution cost versus wall-clock time over 30 seconds for the close-enough variant and 1 minute for the other variants; AUC, defined as the area under the cost-versus-time curve, where lower is better; and speedup, defined as AUC decrease as the number of processes $q$0 increases (Bhat et al., 10 Sep 2025).

The paper presents numerical results for three MT-TSP variants: one in which intercepting a target only requires coming within a particular distance, one in which the agent is a variable-speed Dubins car, and one in which the agent is a redundant robot arm (Bhat et al., 10 Sep 2025). For 200 targets with random B-spline motion, the summary is as follows.

Variant	Reported AUC summary	Relative outcome
Close-Enough MT-TSP	PCG AUC $q$1 vs. IRG-PGLNS $q$2 ms·m; baseline memetic $q$3	PCG outperforms IRG-PGLNS slightly and is 20% faster than baseline memetic
Variable-Speed Dubins	IRG-PGLNS $q$4 vs. PCG $q$5 s$q$6; memetic $q$7	IRG-PGLNS marginally beats PCG; PCG outperforms memetic
Robot Arm	IRG-PGLNS $q$8 rad·s, PCG $q$9; both $i=1,\dots,n$00 memetic	IRG-PGLNS slightly better; both substantially better than memetic

Across these experiments, IRG-PGLNS and PCG both converge faster than a baseline based on prior work (Bhat et al., 10 Sep 2025). The scaling study reports that PCG sees near-linear AUC reduction up to $i=1,\dots,n$01, whereas the memetic baseline shows only 10–20% gains (Bhat et al., 10 Sep 2025). This indicates that, in the reported hardware and problem regime, inter-solve diversity combined with communication can be converted into effective parallel scaling.

The results also show that PCG is not uniformly dominant. In the close-enough MT-TSP, PCG has the best reported AUC among the compared methods, but in the variable-speed Dubins and robot arm settings IRG-PGLNS is slightly better (Bhat et al., 10 Sep 2025). Any claim that PCG is the universally superior parallel strategy would therefore be inconsistent with the reported evidence.

7. Regimes of effectiveness, limitations, and interpretation

The source identifies the conditions under which PCG tends to perform well. It excels when GTSP solves are relatively slow and when there is high variance across random sample graphs, because exploring multiple graphs per iteration allows the method to accumulate good sample-points from multiple runs (Bhat et al., 10 Sep 2025). This characterization aligns with the algorithm’s design: a larger payoff from diversity is expected when different sample realizations lead to meaningfully different local optima or solver trajectories.

The paper also states when an alternative may be preferable. For problems in which sampling and edge checks dominate, such as Dubins instances with fine curvature constraints, IRG-PGLNS may be preferable because it parallelizes within one GTSP rather than across multiple GTSP instances (Bhat et al., 10 Sep 2025). This distinction matters because the computational bottleneck shifts from combinatorial search to graph construction and feasibility testing.

Several limitations are made explicit. Synchronous barriers can cause stragglers to delay the iteration, and although an asynchronous PCG can mitigate this, it introduces more complicated sample-set management (Bhat et al., 10 Sep 2025). The experiments found little added benefit from the asynchronous variant (Bhat et al., 10 Sep 2025). This suggests that synchronization overhead was not the dominant obstacle in the reported settings, although it remains a structural concern in heterogeneous workloads.

In summary, PCG is presented as a parallel scheme for IRG MT-TSP that trades some intra-solve parallelism for inter-solve diversity and communication, yielding faster convergence in many settings (Bhat et al., 10 Sep 2025). A plausible implication is that its main conceptual contribution lies in combining asymptotically optimal sampling-based refinement with synchronized exchange of incumbent interception points, thereby making multiple randomized GTSP solves mutually informative rather than independent.