Topology-Dependent Performance of Scheduling-Aware Multipath Routing Under Capacity Constraints

1. Introduction

Efficient routing in capacitated networks is a foundational problem in the design of communication systems, transportation networks, and distributed computing infrastructures [1,2]. Traditional routing approaches prioritise path optimality under static assumptions, directing flow along shortest or lowest-cost paths. In networks operating near capacity, however, congestion dynamics introduced by competing flows render shortest-path strategies suboptimal: flow concentration on minimal-distance routes creates bottlenecks that propagate across the network, increasing delivery latency and reducing effective throughput [3,4].

Multipath routing addresses this by distributing flow across alternative routes, reducing load concentration. K-shortest-path strategies [5,6] and vertex-disjoint routing [7] provide principled approaches to path diversification, offering robustness to both congestion and link failure. Scheduling-aware approaches extend multipath routing by coordinating flow allocation over time, pre-empting simultaneous bottleneck formation [8,9]. Despite their intuitive appeal, it remains unclear under which structural conditions these strategies provide consistent benefits over simpler baselines.

A critical but underexplored dimension of routing performance is the interaction between algorithm design and network topology. Scale-free networks, characterised by heavy-tailed degree distributions and hub nodes [10], exhibit radically different failure profiles from regular lattice or spatially embedded networks [2,11]. Small-world networks combine high clustering with short path lengths [12], creating routing environments distinct from both random and structured topologies. Existing evaluations of routing strategies are commonly conducted on a single topology class, leaving systematic cross-topology comparative assessments largely absent from the literature.

This paper addresses that gap through a large-scale controlled simulation study. We evaluate four routing strategies across five canonical synthetic topologies and four stress scenarios, using a discrete-time flow simulation with node throughput and spillback constraints. Our goal is to characterise the structural conditions under which scheduling-aware routing provides measurable advantages, and those under which simpler approaches remain competitive. This characterisation enables topology-aware routing strategy selection without exhaustive empirical benchmarking.

Our main contributions are:

1.

We demonstrate that VDSched reduces peak blocked mass by 36.5 to 87.0% relative to SP across all five topology classes and all four scenarios (all corrected $p_{\mathrm{Holm}}<0.001$, $|d_z|\ge 2.06$), establishing spillback-aware dispatch as a robust and topology independent congestion suppression mechanism.

2.

We show that VDSched’s delivery-time benefit is strongly topology-dependent. Large improvements occur in random (18.9–23.6%) and spatial random networks (31.6–36.7%); VDSched is consistently slower than SP in grid networks (1.5–3.4%, $d_z$: 1.01–2.17, all large effects), despite reducing congestion in those same instances.

3.

We identify the congestion latency decoupling: VDSched can simultaneously reduce peak blocked mass and increase mean delivery time when alternative routes are geometrically inefficient, demonstrating that congestion reduction and latency reduction are independent effects that cannot be assumed to occur together.

4.

We confirm the structural fragility prediction of Albert, Jeong and Barabási [11] in a flow-simulation context: VDSched loses its delivery-time advantage in scale-free networks under targeted removal of structurally important edges ($d_z=0.12$, negligible effect, $p_{\mathrm{Holm}}=1.0$), while retaining a meaningful advantage under diffuse failure.

2. Related Work

2.1. Routing in Capacitated Networks

The routing of flows in networks with finite edge or node capacity traces to the foundational work of Ford and Fulkerson on maximum flow [13] and Menger’s theorem on vertex-disjoint paths [14]. Shortest-path routing, implemented via Dijkstra’s algorithm [15], remains the dominant operational baseline in link-state routing protocols such as OSPF and IS-IS [16]. However, shortest-path routing concentrates traffic on minimal-cost routes, creating bottlenecks under heterogeneous or heavy demand [3].

Multipath extensions distribute flow across several routes simultaneously. Yen’s k-shortest-paths algorithm [5] and Eppstein’s more efficient variant [6] enable traffic splitting across near-optimal paths. Vertex-disjoint routing [7], derived from max-flow decomposition, selects routes that share no intermediate nodes, increasing structural independence and robustness to individual component failures. Oblivious routing [17] provides worst-case competitive bounds for load balancing without demand knowledge, a result relevant to the fixed-demand setting used in this study. Traffic engineering formulations cast routing as a multi-commodity flow optimisation problem [18]; Fortz and Thorup [3] demonstrated that OSPF weights can be tuned to approximate optimal solutions but remain sensitive to demand fluctuations.

2.2. Congestion-Aware and Scheduling-Aware Routing

Congestion-aware strategies extend static multipath approaches by incorporating real-time or predictive load information. In data-centre networks, equal-cost multipath (ECMP) hashing distributes flows across parallel paths but suffers from hash collisions under heavy traffic [19]. Hedera [20] addresses this through centralised elephant-flow detection and rerouting; CONGA [8] achieves per-flowlet load balancing using distributed congestion feedback; and HULA [21] extends this to probe-free path quality inference in programmable data planes. Wang and Crowcroft [22] introduced early formulations of multipath routing with load-sensitive path selection, establishing the principle that path diversity provides congestion relief only when path selection is responsive to observed load.

Scheduling-aware routing, as studied in this paper, connects to the broader network control literature. Tassiulas and Ephremides [9] established that MaxWeight scheduling is throughput-optimal under adversarial arrivals; subsequent work extended this to wireline networks [23]. The VDSched heuristic evaluated here shares the motivation of these policies — coordinating flow over time in response to queue state — but operates as a local greedy heuristic rather than a provably optimal scheduler. In the transport simulation literature, spillback-aware flow propagation has been studied extensively under the cell transmission model [24] and its extensions [25], providing the conceptual framework for the node throughput and storage constraints used in our simulator.

2.3. Topology Effects on Routing Performance and Resilience

The structural properties of a network fundamentally determine routing efficiency and failure resilience. Watts and Strogatz [12] showed that many real-world networks lie in a small-world regime — high clustering combined with short average paths — which concentrates inter-cluster traffic on bridge edges. Barabási and Albert [10] demonstrated that preferential attachment produces scale-free degree distributions with a small number of high-degree hub nodes that serve as routing concentrators.

Albert, Jeong and Barabási [11] established the asymmetry that is directly replicated in our results: scale-free networks are robust to random component failures but acutely vulnerable to targeted attacks on hub nodes. Newman [1] reviews the broader landscape of complex network structure and dynamic processes. Barthélemy [2] demonstrates that spatial constraints reduce redundancy and increase vulnerability to localised failures, motivating our inclusion of the spatial random topology. In transport, Berdica [26] formalised road network vulnerability as susceptibility to serviceability-reducing incidents, and Jenelius, Petersen and Mattsson [27] developed systematic importance and exposure metrics for network vulnerability assessment. Reggiani, Nijkamp and Lanzi [28] demonstrate that path diversity and structural redundancy are the primary determinants of transport network resilience under demand stress — a proposition our results empirically validate across five topology classes.

3. Methods

3.1. Problem Setting

We model a capacitated network as a directed graph

$$G=(V,E,c,H,S),$$

where:

V is a finite set of nodes,

$E\subseteq V\times V$ is the set of directed edges, and

$c:E\to {\mathbb{Z}}^{+}$ assigns a positive integer capacity to each edge.

$H:V\to {\mathbb{Z}}^{+}$ defines the maximum flow volume a node may process per timestep (node throughput), and

$S:V\to {\mathbb{Z}}^{+}$ defines the maximum queue length at each node (node storage).

Node throughput is defined as

$$H\left(v\right)=\mathrm{clip}\left(4+\mathrm{outdeg}\left(v\right),4,12\right),$$

and node storage is given by

$$S\left(v\right)=\eta H\left(v\right),$$

with

$$\eta =5.$$

A set of origin-destination pairs

$$\mathcal{D}={\left\{(s_i,t_i,d_i)\right\}}_{i=1}^{\left|\mathcal{D}\right|}$$

defines the routing demand. Each pair is assigned demand

$$d_i=100$$

flow units, with

$$\left|\mathcal{D}\right|=50$$

pairs per instance.

Discrete-time flow propagation.

Simulation proceeds in discrete timesteps

$$\tau =1,2,\dots ,T,$$

with maximum horizon

$$T=50000.$$

At each step, each node processes up to $H\left(v\right)$ units of queued flow, forwarding it along selected outgoing edges subject to edge capacity $c\left(e\right)$. Flow that cannot proceed due to insufficient downstream storage or node throughput is queued at the sending node, up to storage limit $S\left(v\right)$.

When a node’s queue reaches $S\left(v\right)$, no further incoming flow is accepted. A spillback condition in which downstream congestion prevents upstream movement.

Edge travel time is defined as

$${\tau }_e=\max \left(1,⌈{\displaystyle \frac{{\ell }_e}{s_e}}⌉\right),$$

where:

${\ell }_e$ is edge length, and,

$s_e\sim \mathcal{U}[15,25]$.

Edge capacity is drawn independently from

$$c\left(e\right)\sim \mathcal{U}\{10,25\}.$$

The objective is to minimise total delivery time

$$T_{\mathrm{total}}^{*}=\sum _i{T}_i^{*},$$

where:

$T_i^{*}$ is the timestep at which the final unit of demand $d_i$ reaches destination node $t_i$.

3.2. Routing Strategies

We compare four routing strategies under identical demand, capacity, and topology conditions.

Shortest Path (SP).

Each OD pair $(s_i,t_i)$ is routed along a single minimum-cost path computed by Dijkstra’s algorithm [15]. All demand is injected simultaneously at timestep $\tau =1$. No load balancing or congestion response is performed.

K-Shortest Paths (KSP).

Up to $k=5$ loopless shortest paths are enumerated via Yen’s algorithm [5], and demand is distributed proportionally across them. This provides limited path diversity without structural disjointness guarantees.

Vertex-Disjoint Routing (VD).

A set of vertex-disjoint paths is computed via maximum-flow decomposition [7,13]. Demand is injected simultaneously. Vertex-disjoint path selection maximises route independence, reducing contention and improving failure robustness.

Scheduling-Aware Routing (VDSched).

VDSched is a spillback-aware dispatch heuristic that uses the same vertex-disjoint candidate paths as VD but coordinates the timing of flow injection across timesteps. At each timestep, queued flow is prioritised by downstream storage availability, outgoing edge capacity, existing blocked flow, and remaining travel time.

Flow is held at the source when the downstream node’s storage is exhausted and the outgoing edge contains blocked flow. VDSched introduces local congestion awareness without solving a global time-expanded minimum-cost flow optimisation; it is a scalable greedy heuristic rather than an optimal scheduler.

VDSched differs from VD only during simulation dispatch. Both methods use the same vertex-disjoint candidate path set, but VDSched changes the order in which queued units are released from nodes. Rather than dispatching queued units in arrival order, VDSched prioritises movements that have downstream storage available, sufficient edge capacity, shorter remaining travel time, and lower blocked-exit pressure. It also prevents dispatch into a downstream node that is already full when the corresponding edge has blocked exit flow. Thus, VDSched is a local spillback-aware scheduling heuristic, not a global time-expanded optimisation method.

For each queued unit q, VDSched computes a local priority score for its next movement. If the next edge is $e=(v,w)$, the score is:

$$\mathrm{score}\left(q\right)={\displaystyle \frac{\min (c_e,\max (1,F_w))}{\max (1,R_q+B_e)}},$$

where $c_e$ is the capacity of the next edge, $F_w$ is the currently available storage at the downstream node w, $R_q$ is the remaining travel time along the assigned path, and $B_e$ is the number of units currently blocked at the exit of edge e. Units with higher scores are dispatched first.

Algorithm 1 describes the dispatch-ordering substep used by VDSched at each node queue. This substep replaces the default arrival-order dispatch rule in the common simulation update described in Appendix C1. All other simulation steps, including edge-pipeline advancement, node storage checks, edge-capacity constraints, blocked-exit discharge, and metric updates, are shared across all routing strategies.

Algorithm 1 VDSched dispatch-ordering substep

Require:  Node v; queued units $Q_v$; node throughput $H\left(v\right)$; edge capacities $c_e$; downstream storage $S\left(w\right)$; current downstream occupancy $O\left(w\right)$; blocked-exit mass $B_e$; assigned paths for all queued units Ensure:  Ordered dispatch list for node v  1: Initialise an empty candidate list $C_v$  2: Set dispatch budget $B_v\leftarrow \min (H\left(v\right),|Q_v\left|\right)$  3: for each queued unit $q\in Q_v$ do  4:     Let $e=(v,w)$ be the next edge on the assigned path of q  5:     if q has no remaining edge on its assigned path then  6:         Exclude q from dispatch consideration  7:         continue  8:     end if  9:     if edge e has no remaining timestep capacity then 10:         Exclude q from dispatch consideration 11:         continue 12:     end if 13:     Compute downstream free storage $F_w\leftarrow \max (0,S\left(w\right)-O\left(w\right))$ 14:     Let $R_q$ be the remaining path travel time of q after edge e 15:     if w is not the destination of q and $F_w=0$ and $B_e>0$ then 16:         Exclude q from dispatch consideration 17:         continue 18:     end if 19:     Compute priority score $$\pi \left(q\right)={\displaystyle \frac{\min (c_e,\max (1,F_w))}{\max (1,R_q+B_e)}}.$$ 20:     Add $(q,\pi (q\left)\right)$ to $C_v$ 21: end for 22: Rank candidates in $C_v$ in descending order of $\pi \left(q\right)$ 23: Dispatch the first $B_v$ ranked candidates, subject to remaining edge-capacity checks 24: Keep all non-dispatched units queued at node v

Algorithm 1 presents the VDSched dispatch-ordering substep used during node-level queue dispatch.

3.3. Network Topologies

We evaluate five canonical synthetic topology classes. Each was generated with target size

$$n=400$$

and converted to a directed graph by bidirecting all undirected edges. The largest strongly connected component was retained.

Grid.

A directed $20\times 20$ regular lattice (400 nodes, $1520$ directed edges, mean out-degree $3.80$), generated as nx.grid_2d_graph(20, 20). The regular structure and near-uniform degree distribution provide minimal path diversity: any vertex-disjoint alternative path requires a Manhattan-distance detour.

Random.

Erdős-Rényi random graphs with

$$p=\min \left(0.05,{\displaystyle \frac{4}{n-1}}\right)\approx 0.0100$$

for $n=400$ [1]. A representative processed instance retains 391 nodes ($1572$ directed edges, mean out-degree $4.02$) after connectivity filtering.

Scale-free.

Barabási-Albert preferential attachment graphs with

$$m=\max \left(2,\min \left(6,\mathrm{round}\left({\displaystyle \frac{\sqrt{n}}{4}}\right)\right)\right)=5$$

for $n=400$ [10]. Representative statistics: 400 nodes, $3950$ directed edges, mean out-degree $9.88$.

The heavy-tailed degree distribution produces a small number of high-degree hub nodes that serve as routing concentrators.

Small-world.

Watts-Strogatz graphs with

$$k=6$$

and rewiring probability

$$\beta =0.15$$

[12]. Representative statistics: 400 nodes, $2400$ directed edges, mean out-degree $6.00$.

Small-world networks combine high local clustering with short average path lengths.

Spatial random.

Random geometric graphs with connection radius

$$r=\min \left(0.25,\max \left(0.08,{\displaystyle \frac{2.2}{\sqrt{n}}}\right)\right)=0.11$$

for $n=400$ [2].

If the generated graph was disconnected, the radius was increased to

$$\min (0.35,1.5r)$$

and the graph regenerated.

The mean out-degree spans 3.80 (grid) to 13.32 (spatial random), providing a structural range from low-redundancy to high-redundancy routing environments. Representative processed graph statistics are reported in Table 1.

3.4. Failure and Stress Scenarios

Baseline.

No failures; all edges operate at assigned capacities.

Random edge failure.

A fraction $f=0.05$ of directed edges is removed uniformly at random. Five independent failure realisations per seed-instance combination (seeds 2026–2030) were evaluated to account for stochastic variation in failed-edge selection.

Targeted edge failure.

The same fraction $f=0.05$ of edges is removed by ranking edges according to an approximate shortest-path edge betweenness score.

For each source node, shortest paths to reachable targets are computed, and each traversed edge accumulates one unit of score. The top-ranked $5\%$ of edges are removed.

This operationalises the targeted attack regime studied by Albert et al. [11], concentrating disruption on structurally important routing infrastructure.

Capacity degradation.

All directed edge capacities are multiplied by $\alpha =0.5$, with capacities constrained to remain at least one unit. No edges are removed.

3.5. Experimental Design

For each of four graph-generation seeds (42, 123, 999, 2024), 20 instances were generated per topology class, yielding 80 seed-instance realisations per topology.

Deterministic scenarios (baseline, capacity degradation, targeted edge failure) were evaluated once per realisation, giving 80 simulation runs per topology-algorithm-scenario cell.

Random edge failure was evaluated over five independently sampled failure realisations per realisation, giving 400 runs per cell for that scenario.

The merged dataset contains 12,800 simulation rows computed as:

$$5\times 4\times \left(3\times 80+1\times 400\right)=12,800.$$

Repeating the full suite for $\eta =3$ and $\eta =8$ adds a further $25600$ runs, for $38400$ simulation rows in total across the three storage conditions $\eta \in \{3,5,8\}$.

Due to connectivity filtering, not all OD pairs had a connecting path in every instance. Planned demand was 5,000 units per run, and reachable demand ranged from $4600$ to $5000$. All delivered fraction metrics are normalised by reachable demand. Statistical comparisons for the sensitivity runs follow the same paired Wilcoxon procedure described in Section 3.7, using the same explicit failure seed pairing convention as the primary analysis.

3.6. Evaluation Metrics

Five metrics are recorded per simulation run. Lower values are better for all metrics except delivered fraction.

• Mean delivery time: mean timesteps required to deliver each demand unit.
• Delivered fraction: proportion of reachable demand delivered by the end of the simulation.
• Peak blocked mass: maximum total flow blocked at any timestep.
• Peak queue: maximum queue length at any single node.
• Peak saturated nodes: maximum number of nodes simultaneously operating at storage capacity.

Table 2. Experimental design and simulation parameters. The primary results are reported for $\eta =5$; storage-sensitivity analyses repeat the full design for $\eta \in \{3,5,8\}$.

Parameter	Value
Topology classes	Grid, Erdos-Rényi random, scale-free, small-world, spatial random
Target graph size	$n=400$ nodes
Graph-generation seeds	42, 123, 999, 2024
Instances per topology-seed pair	20
Seed-instance realisations	400
Origin-destination pairs per instance	50
Demand per OD pair	100 flow units
Total demand per instance	5,000 flow units
Routing strategies	SP, KSP, VD, VDSched
Candidate path limit	$k=5$
Stress scenarios	Baseline, random edge failure, targeted edge failure, capacity degradation
Random edge-failure fraction	5% of directed edges
Random edge-failure seeds	2026, 2027, 2028, 2029, 2030
Targeted edge-failure fraction	5% of directed edges
Capacity-degradation factor	0.5
Primary node-storage multiplier	$\eta =5$
Primary node storage	$S\left(v\right)=5H\left(v\right)$
Storage-sensitivity multipliers	$\eta \in \{3,5,8\}$
Primary simulation rows	12,800
Total rows including storage sensitivity	38,400
Run-level files in explicit merge	9,600

Table 2. Experimental design and simulation parameters. The primary results are reported for $\eta =5$; storage-sensitivity analyses repeat the full design for $\eta \in \{3,5,8\}$.

Parameter	Value
Topology classes	Grid, Erdos-Rényi random, scale-free, small-world, spatial random
Target graph size	$n=400$ nodes
Graph-generation seeds	42, 123, 999, 2024
Instances per topology-seed pair	20
Seed-instance realisations	400
Origin-destination pairs per instance	50
Demand per OD pair	100 flow units
Total demand per instance	5,000 flow units
Routing strategies	SP, KSP, VD, VDSched
Candidate path limit	$k=5$
Stress scenarios	Baseline, random edge failure, targeted edge failure, capacity degradation
Random edge-failure fraction	5% of directed edges
Random edge-failure seeds	2026, 2027, 2028, 2029, 2030
Targeted edge-failure fraction	5% of directed edges
Capacity-degradation factor	0.5
Primary node-storage multiplier	$\eta =5$
Primary node storage	$S\left(v\right)=5H\left(v\right)$
Storage-sensitivity multipliers	$\eta \in \{3,5,8\}$
Primary simulation rows	12,800
Total rows including storage sensitivity	38,400
Run-level files in explicit merge	9,600

3.7. Statistical Analysis

Because all algorithms were evaluated on matched seed-instance-scenario units, algorithm comparisons were treated as paired comparisons.

$$D_i=x_{i,\mathrm{VDSched}}-x_{i,\mathrm{SP}}$$

The primary inferential comparison is VDSched versus SP, because SP represents the operational shortest-path baseline and VDSched is the proposed spillback-aware scheduling heuristic. The primary lower-is-better outcomes are mean delivery time and peak blocked mass. Peak queue and peak saturated-node counts are reported as secondary diagnostics.

$$d_z={\displaystyle \frac{\overline{D}}{\mathrm{SD}\left(D\right)}}$$

[29]. Effect magnitudes are classified as negligible ($|d_z|<0.2$), small ($0.2--0.5$), medium ($0.5--0.8$), or large ($>0.8$) following Cohen [29].

For the random edge-failure scenario, five stochastic failure realisations were evaluated per seed-instance combination using failure seeds 2026–2030. During result merging, the failure seed was extracted from the run-level filename and retained as an explicit pairing identifier. Paired tests were therefore conducted on matched graph-seed, instance, topology, scenario, and failure-seed units, ensuring that SP, KSP, VD, and VDSched were compared under the same graph realisation, OD set, and disruption draw. Deterministic scenarios were assigned a single failure identifier. The final explicit-pairing dataset contains 38,400 simulation rows, 9,600 run files, and complete paired units across $\eta \in \{3,5,8\}$, with no incomplete algorithm sets.

For the primary $\eta =5$ suite, paired differences were computed for each topology–scenario cell. Statistical significance was assessed using two-sided Wilcoxon signed-rank tests, and Holm correction was applied across the primary test family.

4. Results

4.1. Overall Performance: Dominant Algorithm by Topology and Scenario

Figure 1 presents the dominant routing algorithm across all topology-scenario combinations. VDSched dominates in random, scale-free (except targeted failure), and spatial random topologies across all scenarios. SP dominates in grid networks across all four scenarios and in scale-free networks under targeted edge failure. Small-world networks show mixed dominance: SP is competitive under baseline and targeted-failure conditions, while VDSched is significantly better only under capacity degradation. These patterns motivate the pairwise analysis in the following subsections.

4.2. Congestion Suppression: A Universal and Robust Finding

VDSched reduces peak blocked mass relative to SP in every topology-scenario combination tested. All 20 pairwise comparisons yield $p_{\mathrm{Holm}}<0.001$ with large effect sizes ($|d_z|\ge 1.78$). Table A1 in the appendix reports the complete results; key values are summarised here and illustrated in Figure 2.

In random networks, VDSched reduces peak blocked mass by 79.3 to 81.9% across all four scenarios, with ($|d_z|=4.33$–$4.64$). In small-world and spatial random networks, reductions are 85.3 to 87.0% and 84.7 to 86.0% respectively, with ($|d_z|=2.06$–$6.06$). Even in grid networks, where VDSched provides no delivery time advantage, it reduces peak blocked mass by 68.4 to 77.6%, with ($|d_z|=2.63$–$2.87$). The smallest reductions occur in scale free networks, ranging from 36.5% under capacity degradation to 50.8% under targeted edge failure, with ($|d_z|=2.06$–$2.91$).

The relatively smaller congestion reduction in scale free networks reflects the hub concentrated topology. With fewer but higher capacity paths, spillback events are less frequent but individually larger.

These results establish that the primary and most reliable effect of VDSched is congestion suppression. Whether this congestion reduction translates into reduced delivery time depends on topology, as the following subsection shows.

4.3. Delivery Time: A Topology-Dependent Finding

Figure 3 presents the paired mean delivery-time difference (VDSched - SP) with 95% confidence intervals across all topology-scenario cells. Negative values indicate VDSched reduces delivery time; positive values indicate SP is faster. Table 3 reports the complete pairwise statistics.

Spatial random networks: strongest VDSched advantage.

The largest delivery-time improvements occur in spatial random networks. VDSched reduces mean delivery time by 32.6% under baseline conditions (SP: 19.74 timesteps, VDSched: 13.30; $d_z=-3.71$), 32.1% under random edge failure the improvement is 31.6% (SP: 19.81, VDSched: 13.56; $d_z=-3.51$). Under targeted edge failure the improvement is also 31.6% (SP: 21.51, VDSched: 14.72; $d_z=-3.25$). Under capacity degradation the improvement reaches 36.7% (SP: 20.78, VDSched: 13.15; $d_z=-3.76$). All four comparisons are highly significant ($p_{\mathrm{Holm}}<0.001$) with large effect sizes.

The spatial embedding of these networks with nodes connected only to geographic neighbours creates dense local routing alternatives without systematic route-length penalties, providing the structural conditions under which spillback-aware scheduling most efficiently reduces latency.

Erdős–Rényi networks deliver consistent gains regardless of scenario.

In Erdos Renyi random networks, VDSched delivers consistent delivery time reductions across all scenarios. The improvement is 20.1% under baseline, (SP: 12.84, VDSched: 10.26, $d_z=-2.17$). Under capacity degradation the improvement reaches 23.6%, (SP: 13.51, VDSched: 10.32, $d_z=-2.45$). Under random edge failure the improvement is 19.6%, $d_z=-2.14$, and under targeted edge failure it is 18.9%, $d_z=-2.17$. All four comparisons are significant at $p_{\mathrm{Holm}}<0.001$ with large effect sizes.

The moderate, uniform path diversity of Erdős-Rényi graphs allows spillback avoidance to reduce queuing without forcing geometrically costly detours.

Scale-free networks: scenario-dependent, medium effects.

Scale free networks exhibit nuanced behaviour. VDSched provides medium effect delivery time improvements under three of four scenarios. The improvement is 9.9% under baseline, (SP: 23.69, VDSched: 21.36, $d_z=-0.70$. Under random edge failure the improvement is 9.8%, $d_z=-0.71$, and under capacity degradation it is 10.4%, (SP: 23.89, VDSched: 21.40, $dz=-0.71$.

Under targeted edge failure, however, the difference reverses direction and is negligible. SP achieves 19.39 timesteps versus VDSched’s 19.60, a difference of 0.21 timesteps, $d_z=0.12$, at $p_{\mathrm{Holm}}=1.0$. This reversal is consistent with Albert, Jeong and Barabasi’s prediction that scale free networks are acutely vulnerable to targeted attack on hub nodes [11]. Removal of the top 5 percent of highest betweenness edges disproportionately destroys the hub connectivity on which VDSched’s multipath scheduling depends, collapsing its advantage.

Small-world networks: conditional and asymmetric improvements.

Small-world networks show a complex pattern. VDSched provides a significant, large effect improvement only under capacity degradation, SP at 25.67 versus VDSched at 23.58, an improvement of 8.1%, $d_z=-1.30$, $p_{\mathrm{Holm}}<0.001$. Under random edge failure, the improvement is statistically significant but small in magnitude, 1.9%, $d_z=-0.35$.

Under baseline conditions and under targeted failure, VDSched and SP are statistically indistinguishable. The baseline difference is 2.3% in VDSched’s favour but does not survive Holm correction, $d_z=-0.41$, $p_{\mathrm{Holm}}=0.129$. Targeted failure shows a difference of 0.9%, $d_z=-0.16$, at $p_{\mathrm{Holm}}=1.0$.

This pattern suggests that in small-world networks, VDSched’s scheduling benefit materialises only when network stress, whether from reduced capacity or from diffuse failure pressure under random edge loss, creates congestion sufficient for spillback aware dispatch to provide measurable latency relief, and that this benefit does not reach statistical significance under ordinary operating conditions.

Grid networks: the congestion-latency trade-off.

Grid networks produce the most unexpected finding of this study. VDSched increases mean delivery time relative to SP in all four scenarios. The penalty is 2.7% under baseline, SP at 137.46 versus VDSched at 141.18, $d_z=1.67$. Under random edge failure the penalty is 3.3%, $d_z=2.15$. Under targeted edge failure it is 3.4%, $d_z=2.17$. Under capacity degradation it is 1.5%, SP at 139.44 versus VDSched at 141.58, $d_z=1.01$.

All four differences are statistically significant at $p_{\mathrm{Holm}}<0.001$ with large effect sizes.

Despite cutting peak blocked mass by 68.4 to 77.6% in the same grid instances, VDSched still arrives later on average, which shows that congestion reduction and delivery time reduction are not co-incident effects. The mechanism is addressed in Section 5.

4.4. Delivered Fraction

Across all topology-scenario-algorithm combinations, delivered fraction was close to unity. In the parameter regime studied (planned demand 5,000 units, reachable demand 4,600–5,000 units, maximum horizon 50,000 timesteps), all algorithms eventually route all reachable demand to its destination.

Congestion manifests primarily as delivery delay rather than delivery failure, making mean delivery time and peak blocked mass the key discriminating metrics.

4.5. Sensitivity to Node Storage Capacity

The primary experiments used $\eta =5$. To test whether the topology-dependent performance regimes depend on this storage assumption, we repeated the full simulation suite for $\eta =3$ (tight storage) and $\eta =8$ (relaxed storage).

Figure 4 presents VDSched delivery-time improvement relative to SP across all three storage conditions. The qualitative topology-dependent pattern is stable. VDSched remains consistently slower than SP in grid networks for all eta, with the penalty ranging from $-0.9\%$ to $-3.7\%$ across all storage and scenario conditions). In spatial random networks, VDSched remains strongly beneficial across all $\eta$, with delivery-time improvements of approximately 29–$37\%$ regardless of storage setting. Random networks also show consistently positive gains of 19–$26\%$ across all values of $\eta$.

The scale-free targeted-failure exception persists: VDSched’s delivery-time advantage over SP remains negligible or absent under targeted removal of structurally important edges for all three storage multipliers, confirming that this is a structural rather than storage-dependent effect. Small-world networks remain mixed, with the capacity-degradation benefit ($7.0\%$ at $\eta =5$) present but varying in magnitude across storage settings.

These results demonstrate that the topology-dependent regimes are robust to variation in node storage capacity. Storage multiplier $\eta$ affects the magnitude of effects but does not change the qualitative classification of topology-dependent performance.

Figure A1 shows the blocked-mass sensitivity. VDSched reduces peak blocked mass under all topology, scenario, and storage combinations. The percentage reduction is generally largest under relaxed storage ($\eta =8$): when nodes can accumulate larger queues before saturation, SP produces substantially higher absolute blocked mass that VDSched’s spillback-aware dispatch can more effectively offset.

Under tight storage ($\eta =3$), all strategies experience stronger congestion pressure, compressing the relative reduction achievable by local scheduling, though VDSched retains its universal congestion-suppression advantage in absolute terms.

These findings qualify the storage dependence of VDSched. Its relative congestion suppression benefit is largest when storage is more relaxed rather than tighter. Spillback frequency and downstream saturation pressure both scale with storage tightness, but they pull SP and VDSched in different directions, and the net effect favors VDSched more under relaxed storage than under tight storage.

4.6. Summary of Findings

Four findings hold across all experiments. VDSched reduces peak blocked mass everywhere, from 36.5% to 87.0%, which confirms that congestion suppression is the mechanism’s main effect and that it does not depend on topology. Its delivery-time benefit, however, is topology-dependent rather than universal. That benefit only shows up where the topology offers efficient alternative routes, producing large gains in random networks, 18.9% to 23.6%, and spatial random networks, 31.6% to 36.7%, while grid networks and scale free networks under targeted failure see no real benefit at all. Congestion reduction and delivery-time reduction are separable outcomes.. Grid networks make this clearest. VDSched cuts blocked mass there while making delivery slower, so reducing peak load does not automatically mean reducing latency. Put together, these results say that how well scheduling aware routing performs depends jointly on topology and failure type, not on the algorithm by itself.

5. Discussion

5.1. The Congestion-Latency Trade-Off in Grid Networks

The simultaneous reduction of peak blocked mass (68.4–77.6%) and increase in mean delivery time (1.5–3.4%) produced by VDSched in grid networks is the most theoretically informative finding of this study. It demonstrates that congestion suppression and latency minimisation are independent effects, not co-incident consequences of scheduling-aware dispatch.

In a directed $20\times 20$ lattice (mean out-degree 3.80), vertex-disjoint alternative paths between any two nodes necessarily involve a Manhattan-distance detour: any path that avoids shared intermediate nodes must traverse additional edges. VDSched’s spillback-aware dispatch defers injection on the primary path when congestion is detected and redirects flow along these longer detours.

While this reduces the instantaneous peak of blocked flow; explaining the large congestion reduction, it increases the total path length traversed by delivered demand units. In the regular grid, the variance in alternative route lengths is low: detours offer no geometric shortcut, and the gain from spillback avoidance does not compensate for the delay penalty of the longer route. The result is that VDSched achieves peak-load reduction at the cost of latency.

The trade-off carries a direct operational implication for infrastructure resembling regular lattice topologies, urban arterial road grids, regular mesh communication fabrics, structured data-centre interconnects scheduling-aware multipath routing may be appropriate when the priority is peak-load reduction (infrastructure protection, queue management) but counterproductive when the priority is minimum delivery latency (time-sensitive logistics, interactive communication).

Notably, scale-free networks under targeted failure also exhibit a version of this decoupling: peak blocked mass is reduced by 50.8% under targeted failure (the highest scale-free reduction), while delivery time is statistically indistinguishable from SP ($d_z=0.12$). With hub edges removed, VDSched can still route flow along the surviving vertex-disjoint paths, reducing individual congestion events, but the collapse of hub connectivity prevents these paths from offering meaningfully shorter routes than SP’s single shortest path.

5.2. Scale-Free Networks and the Structural Fragility Prediction

The scenario-dependent behaviour of scale-free networks provides a clean empirical validation of the theoretical predictions of Albert, Jeong and Barabási [11]. Under baseline, random failure, and capacity-degradation conditions, the heavy-tailed degree distribution of scale-free graphs (mean out-degree 9.88) provides rich hub-mediated routing alternatives that VDSched exploits, yielding medium effect delivery time improvements of 9.8–10.4% ($|d_z|$: 0.70–0.72).

Under targeted removal of the 5% of edges with highest approximate betweenness centrality, hub connections are disproportionately removed. Hub edges carry the majority of vertex-disjoint paths between OD pairs; with these edges absent, VDSched’s candidate path sets collapse, and the heuristic degenerates toward single-path routing. The result $d_z=0.12$, $p_{\mathrm{Holm}}=1.0$ directly validates the asymmetry identified by Albert et al.: scale-free networks are robust to diffuse failure but fragile to targeted hub attack. Our results extend this prediction from node-removal robustness to routing-algorithm effectiveness, showing that the structural fragility under targeted attack also eliminates the scheduling advantage that hub redundancy normally provides.

5.3. Random and Spatial Random Networks: Efficient Alternative Routes

The strongest delivery-time gains occur in topologies where alternative routes are both vertex-disjoint and geometrically competitive with the shortest path.

In Erdős-Rényi random graphs with average degree $\approx 4$, the absence of geometric constraints means alternative paths are available in multiple directions without systematic length penalties. In spatial random networks ($r=0.11$, mean out-degree 13.32), the dense local clustering creates multiple short competing paths between nearby nodes, providing the richest supply of geometrically efficient alternatives in the dataset.

The scale of spatial random improvements, (31.6 to 36.7%), is particularly notable under stress conditions. The 36.7% delivery time reduction under capacity degradation ($d_z=-3.76$), indicates that VDSched’s advantage compounds when the base network is constrained. When edge capacities are halved, the shortest path becomes more likely to saturate, and VDSched’s ability to identify and redirect to uncongested alternatives becomes correspondingly more valuable. Dense urban wireless meshes and high utilisation freight road networks [28] are exactly this kind of spatial network operating near capacity, and the results here suggest scheduling aware routing would provide its greatest relative benefit in exactly those settings.

5.4. Small-World Networks: A Conditional and Stress-Amplified Benefit

The small-world results are asymmetric in a telling way. Improvement only reaches a large effect under capacity degradation, while the other three scenarios show negligible differences, and that gap points to a threshold effect. Small-world networks combine high local clustering with short average paths [12], creating inter-cluster bridge edges that carry concentrated traffic. Under nominal conditions, this concentration is insufficient to trigger the spillback cascade that VDSched’s defer-and-redirect logic is designed to mitigate. Under capacity degradation (edges at 50% capacity), the same concentrated traffic exceeds the reduced capacity threshold, activating the spillback mechanism and enabling VDSched to provide a 8.1% delivery-time improvement ($d_z=-1.30$). Whether scheduling-aware routing pays off in small-world infrastructure therefore depends critically on the network’s operating point relative to its capacity ceiling, not on the topology alone.

5.5. Practical Routing Strategy Selection

The experimental results support the following topology-aware decision rule:

• Prefer VDSched when the network exhibits usable path diversity and geometrically competitive alternative routes — conditions observed in Erdős–Rényi random topologies (mean out-degree ≈ 4) and spatial random topologies (mean out-degree 13.32) in this study — and when failures, if anticipated, are diffuse rather than targeted at high-centrality nodes.
• Prefer SP when the topology is regular or near-regular (grid-like, low degree variance; mean out-degree $\le 4$), or when targeted infrastructure failures are anticipated that selectively destroy hub connectivity.
• Evaluate context in small-world and scale-free networks with diffuse failure: VDSched provides medium-effect delivery improvements (7.0–9.3%), but only SP is guaranteed competitive performance under targeted attack.

This decision rule can be operationalised by computing the mean vertex-disjoint path count for a representative OD sample, a polynomial-time computation, as a proxy for the structural redundancy on which scheduling-aware routing depends. Networks where this count is consistently $\ge 2$ along geometrically competitive routes are candidates for VDSched deployment.

5.6. Limitations and Future Work

Three limitations warrant mention. First, this study used node storage multiplier $\eta =5$ as the primary setting. A storage-sensitivity analysis across $\eta \in \{3,5,8\}$ confirms that the topology-dependent performance regimes are qualitatively stable: grid networks favour SP and random or spatial random networks favour VDSched under all three storage conditions. However, the analysis reveals an asymmetry in storage sensitivity between the two main effects. VDSched’s congestion-suppression advantage in percentage terms is largest under relaxed storage ($\eta =8$), where SP can accumulate larger queues that VDSched’s local dispatch avoids. The delivery-time benefit, by contrast, is only mildly storage-sensitive and remains primarily determined by topology. The relationship between storage and scheduling benefit turns out to be more nuanced than a simple spillback frequency account would predict. Spillback frequency rises as storage tightens, but downstream saturation pressure rises with it too, and the two effects do not move VDSched’s advantage in the same direction. The result is that relaxed storage, not tight storage, produces the largest relative gain. Full storage-sensitivity results are reported in Appendix B.

Second, demand is fixed per OD pair. Variable or stochastic demand may change the congestion dynamics and alter VDSched’s advantage in intermediate topologies (small-world, scale-free), particularly under load spikes.

Third, VDSched is a local heuristic; its performance relative to a globally optimal time-expanded minimum-cost flow scheduler remains unknown. Establishing this optimality gap and assessing whether it is topology-dependent in the same way as the VDSched-SP gap would bound the headroom for improvement beyond the current heuristic.

6. Conclusions

We evaluated four routing strategies: SP, KSP, VD, and VDSched across five canonical synthetic topologies and four failure scenarios in a discrete-time capacitated flow simulation (12,800 simulation runs). Our results yield two central findings.

First, VDSched is a robust congestion suppression mechanism. It reduces peak blocked mass by 36.5 to 87.0% relative to SP in every topology and scenario tested, (all $p_{\mathrm{Holm}}<0.001$, $|d_z|\ge 2.06$). This result is not topology dependent. Even in grid networks, where VDSched provides no delivery time benefit, it substantially reduces instantaneous congestion.

Second, VDSched’s delivery time benefit is strongly topology dependent and governed by the geometric efficiency of available alternative routes. It provides large delivery time improvements in spatial random networks, 31.6–36.7%, and random networks, 18.9–23.6%, medium improvements in scale free networks under diffuse failure, 9.8–10.4%, and no significant benefit in scale free networks under targeted failure of structurally important edges or in grid networks. In grids, VDSched simultaneously reduces congestion and increases delivery time, demonstrating that these are independent effects.

These findings establish that effective routing strategy selection requires alignment between algorithm design, network topology, and anticipated failure mode. VDSched is not a universally superior routing strategy; it is a congestion-control mechanism that provides latency benefits only when the underlying topology offers efficient routing alternatives that single-path strategies fail to exploit.

Appendix C.1. Discrete-Time Capacitated Simulation Update

Algorithm A1 describes the common discrete-time simulation loop used by all routing strategies. The routing strategies differ in path assignment and, for VDSched, in the ordering of queued dispatches. SP, KSP, and VD use the same capacity, storage, pipeline, and spillback rules but do not apply the VDSched priority score during node-level dispatch.

Algorithm A1 Discrete-time capacitated simulation update

Require:  Directed graph $G=(V,E)$; flow units assigned to paths; node throughput $H\left(v\right)$; node storage $S\left(v\right)$; edge capacities $c_e$; travel times ${\tau }_e$; simulation horizon T Ensure:  Delivered fraction, mean delivery time, peak queue, peak blocked mass, and peak saturated nodes  1: Initialise edge pipelines for each edge $e\in E$ with length ${\tau }_e$  2: Initialise node queues by placing each flow unit at the origin of its assigned path  3: Initialise blocked-exit lists for all edges as empty  4: Set delivered count to zero  5: for $t=1$ to T do  5: Step 1: discharge blocked exits  6:     for each edge $e=(u,v)$ with blocked units at its exit do  7:         Let $F_v$ be the available storage at node v  8:         for each blocked unit q at the exit of e do  9:            if v is the destination of q then 10:                Mark q as delivered 11:            else if $F_v>0$ then 12:                Move q into the queue of node v 13:                Decrease $F_v$ by one 14:            else 15:                Keep q blocked at the exit of e 16:            end if 17:         end for 18:     end for 18: Step 2: advance edge pipelines 19:     for each edge $e=(u,v)$ do 20:         Advance all units in the pipeline of e by one time step 21:         Let $A_e$ be the units arriving at the exit of e 22:         Let $F_v$ be the available storage at node v 23:         for each arriving unit $q\in A_e$ do 24:            if v is the destination of q then 25:                Mark q as delivered 26:            else if $F_v>0$ then 27:                Move q into the queue of node v 28:                Decrease $F_v$ by one 29:            else 30:                Add q to the blocked-exit list of edge e 31:            end if 32:         end for 33:     end for 33: Step 3: dispatch from node queues 34:     for each node v with non-empty queue $Q_v$ do 35:         Set node dispatch budget $B_v\leftarrow \min (H\left(v\right),|Q_v\left|\right)$ 36:         Order queued units using the dispatch rule of the selected routing strategy 37:         for each queued unit $q\in Q_v$ in dispatch order do 38:            if $B_v=0$ then 39:                Keep q queued at node v 40:                continue 41:            end if 42:            Let $e=(v,w)$ be the next edge on the assigned path of q 43:            if q has no remaining edge on its path then 44:                Keep q queued at node v 45:                continue 46:            end if 47:            if edge e has reached its capacity $c_e$ for timestep t then 48:                Keep q queued at node v 49:                continue 50:            end if 51:            if the selected strategy is VDSched then 52:                if w is not the destination of q, storage at w is full, and edge e has blocked-exit flow then 53:                    Keep q queued at node v 54:                    continue 55:                end if 56:            end if 57:            Dispatch q into the pipeline of edge e 58:            Decrease $B_v$ by one 59:         end for 60:     end for 61:     Update peak queue, peak blocked mass, and peak saturated-node metrics 62:     if all flow units have been delivered then 63:         Terminate simulation 64:     end if 65: end for

Appendix C.2. Targeted Edge-Failure Selection

Algorithm A2 gives the targeted-failure procedure used in the experiments. The score $b_e$ is an approximate shortest-path edge-betweenness measure based on shortest-path traversal counts, using one shortest-path per reachable source-target pair. It is used to identify structurally important directed edges for disruption. In the final experiments, the removed fraction was $\rho =0.05$.

Algorithm A2 Targeted edge-failure selection

Require:  Directed graph $G=(V,E)$; edge-failure fraction $\rho$ Ensure:  Disrupted graph $G^{\prime }$  1: Initialize score $b_e\leftarrow 0$ for every edge $e\in E$  2: for each source node $s\in V$ do  3:     Compute shortest paths from s to all reachable target nodes  4:     for each reachable target node $t\in V$, $t\ne s$ do  5:         Let $P_{s,t}$ be one shortest-path from s to t  6:         for each directed edge $e\in P_{s,t}$ do  7:            $b_e\leftarrow b_e+1$  8:         end for  9:     end for 10: end for 11: Rank all edges in descending order of $b_e$ 12: Set $m\leftarrow \lceil \rho \left|E\right|\rceil$ 13: Let F be the set of the top m ranked edges 14: Construct $G^{\prime }$ by removing all edges in F from G 15: return $G^{\prime }$

Appendix D.1. Code and Reproducibility

All simulation code, processed inputs, run manifests, merged result files, statistical-analysis scripts, and figure-generation scripts are archived with the accompanying Zenodo release. The repository includes the explicit run-level manifest used to reconstruct the final merged dataset. In the random edge-failure scenario, the random-failure seed was extracted from each run-level filename and retained as an explicit pairing identifier, allowing paired statistical comparisons to be reproduced on matched graph-seed, instance, topology, scenario, and failure-seed units. The repository also includes the $\eta =3$, $\eta =5$, and $\eta =8$ storage-sensitivity outputs used in the appendix tables and figures.

Appendix D.2. Software Environment

Graph generation, result processing, statistical analysis, and figure generation were performed using Python 3 with standard scientific computing libraries, including pandas, NumPy, SciPy, NetworkX, and Matplotlib. Discrete-time routing simulations were implemented in Go. The archived repository includes the Go simulator source code, Python analysis scripts, and dependency specifications required to reproduce the reported results.