RRO: A Regularized Routing Optimization Algorithm for Enhanced Throughput and Low Latency with Efficient Complexity

Solving the shortest-path problem is a prevalent approach for data routing in contemporary communication networks [13, 14, 15]. This method aims to find the shortest path between a source and a destination node in a network, reducing the transmission delay and improving network performance. Shortest-path routing algorithms are widely used in various network protocols, such as OSPF and RIP. These protocols rely on the shortest-path algorithm to determine the most efficient routes for data transmission across the network. By selecting paths with the least number of hops or the lowest accumulated cost, these protocols aim to achieve efficient data routing and network operation. For example, the widely adopted OSPF routing protocol employs this principle to route data flows efficiently across the network, where the computation of the shortest paths is often facilitated by the Dijkstra algorithm [16, 14, 15]. More recent studies focus on online learning algorithms for shortest path computations under unknown link states that need to be inferred [17, 18, 19].

However, while shortest path-based routing is effective under various circumstances, it presents a significant drawback: It tends to increase congestion along the shortest routes, especially in networks experiencing high traffic loads. This congestion can, in turn, degrade overall network performance, as the most direct routes become highly congested with excessive data flow.

To address this limitation, backpressure routing emerges as an alternative routing aproach [20]. Backpressure routing, derived from network utility maximization principles, dynamically adjusts data routes based on real-time congestion levels, contrasting sharply with traditional methods that focus on minimizing path cost [21]. This strategy reduces congestion by maximizing differential queue backlog between nodes. It is known to achieve maximal throughput theoretically in a non-interference environment [14]. Related studies on backpressure routing can be found in [22, 23, 24, 25, 26, 14, 27, 28, 19] and references therein.

Despite the efficiency of backpressure routing in terms of achievable throughput, it suffers from several main drawbacks. Firstly, backpressure routing tends to reduce congestion by transmitting packets through less congested nodes. While this approach is beneficial when congestion levels are high, it is inefficient when congestion is low. In such cases, packets travel along longer paths when shorter paths could have been used, leading to a significant increase in delay. Secondly, in an interference environment where links interfere with each other, transmitting data through longer paths increases the interference levels across the network, thereby reducing its overall capacity. Thirdly, from a practical implementation perspective, backpressure routing requires frequent message exchanges between neighboring nodes regarding their instantaneous queue states to make routing decisions. This necessity for constant updates for each transmission creates significant overhead for the communication protocol. These drawbacks have so far prevented the operational implementation of backpressure routing in real-world systems.

To address the limitation of increased delay in low congestion levels by backpressure routing, while incorporating the benefits of traditional shortest path routing, recent studies have suggested the development of hybrid routing algorithms. These approaches leverage the strengths of both methods, using shorter paths when congestion is low to avoid the delays characteristic of backpressure routing, and longer paths during high congestion to prevent the issues associated with shortest path routing [29, 19]. This balance aims to optimize network performance across varying congestion levels, thereby increasing throughput while limiting path costs and adapting to dynamic network conditions. However, these methods still suffer from high implementation complexity, as they require frequent message exchanges between neighboring nodes regarding their instantaneous queue states to make backpressure-type routing decisions. Additionally, they necessitate storing a large number of buffers for each flow to optimize the route for each packet. Consequently, these methods are not practically appealing for a variety of network applications.

In this paper, inspired by the hybrid approach as in [29, 19], we aim to strike a balance between increasing throughput and limiting path costs. However, a significant advantage of our approach is that we reduce congestion by seeking routes with high capacity, resulting in increased throughput without relying on backpressure. This avoids the drawbacks of backpressure-based routing discussed earlier. Additionally, our method maintains a complexity level compatible with OSPF.

Moreover, inspired by the recent success of deep learning and AI in solving complex decision-making tasks, deep learning methods have been proposed to solve related spectrum access [30, 31, 32, 33, 34], scheduling [35, 36, 37, 38, 39], and routing [40, 41, 42, 43, 44, 45] problems. Specifically, recent studies developed deep learning based methods to compute flow routes in communication networks to increase throughput with low latency [40, 41, 42, 43, 44, 45]. However, these methods demand high computational resources that exceed the capabilities of networks with limited hardware devices, making them unsuitable in many cases. Therefore, a key challenge in communication network research is to devise algorithms that achieve enhanced throughput with low latency while maintaining a complexity level compatible with OSPF.

Furthermore, combining low-complexity algorithms with deep-learning techniques could offer a versatile solution for future networks. This hybrid approach would allow for the flexibility to use deep learning when higher processing time is permissible and low-complexity algorithms when quick decisions are needed. Thus, these solutions do not compete but rather complement each other, offering a balanced and adaptive strategy to meet varying network demands.

In this paper, we concentrate on developing low-complexity algorithms that are compatible with OSPF. Our aim is to enhance network performance by achieving higher throughput and lower latency without increasing computational demands. These algorithms are designed to be efficient and scalable, ensuring they can be implemented in real-world networks with limited hardware resources. By aligning with the principles of OSPF, our approach maintains compatibility with existing network infrastructure, facilitating easy integration and adoption. Through this research, we seek to provide practical solutions that address the pressing challenges in modern communication networks.

Our motivation to balance enhanced throughput with low latency shares similarities with the approaches in [29, 19]. However, our algorithmic solution is fundamentally different and has significant advancements compared to [29, 19]. Firstly, it does not use backpressure for data transmission. Instead, it computes the balanced path to enhance capacity with low path cost at the source node and routes the packet through the computed path. This avoids the need for frequent message exchanges between neighboring nodes regarding their instantaneous queue states, as required by backpressure transmissions. By leveraging the advantages of 5G and beyond technologies, our method enables both distributed and centralized path computation, similar to current OSPF implementations. Consequently, no changes to the communication protocol are needed compared to current deployments. Secondly, the implementation complexity of our approach is much simpler as it does not require storing a large amount of packet buffers when making decisions, unlike [29, 19]. Thirdly, the computational complexity of our approach is very low and is compatible with OSPF, as we will describe later.

Specifically, in terms of algorithm development, we present a novel algorithm called Regularized Routing Optimization (RRO). The RRO algorithm offers both distributed and centralized implementations with low complexity, making it suitable for integration into 5G and beyond technologies with centralized node deployments. The RRO optimization process is implemented on a computation unit, either a source node of the flow in a distributed implementation or a centralized unit in a centralized implementation. This process utilizes the topology, link weights (such as link capacity), and an interference map, similar to the OSPF protocol used in 5G networks. The innovative design of the regularized optimization strikes a balance between the interference level over a route and the path length to yield the corresponding path allocation for each flow. It achieves this by searching for paths with high throughput while ensuring that latency remains sufficiently low.

Secondly, in terms of complexity analysis, we prove that RRO requires a low-complexity running time of $O(N\cdot|{\mathcal{E}}|+N\cdot|{\mathcal{V}}|\log|{\mathcal{V}}|)$, where $\mathcal{E}$, and $\mathcal{V}$ denote the numbers of edges and nodes, respectively. This maintains the same complexity order as OSPF, as required.

Finally, we extensively evaluated RRO’s performance through simulations across various network topologies, including random deployments, NSFNET, and GEANT2 networks. The results consistently demonstrated that RRO significantly outperforms existing methods with compatible complexity. These simulations showcased RRO’s ability to handle diverse and complex network conditions efficiently. The improvements were evident in terms of both throughput and latency, proving RRO’s robustness and adaptability. Additionally, the algorithm’s performance was stable across different scenarios, underscoring its potential for real-world applications in 5G and beyond technologies. This comprehensive evaluation highlights RRO as a superior routing solution that is very well-suited for modern network environments.

In the distributed implementation, each flow updates its route distributedly from time to time, as currently employed by OSPF mechanism, given the current path allocation vector of all other flows. Once a flow selects a path it broadcasts this information to all other source nodes in the network, to have each source node holds the updated path allocation vector of all other flows.

We now describe the basic steps of RRO with respect to flow $f_{n}$, computed by its corresponding source node $s_{n}$. In the description below, we often omit the subscript $n$ when the notations become cumbersome, to simplify the presentation. Assume that $N-1$ paths were selected for flows $\mathcal{F}\setminus f_{n}$, given by path vector $\Pi_{-n}$.
Initial computation step at source node $\boldsymbol{n}$: Based on the interference map, and the current path allocation vector $\Pi_{-n}$ of all other flows, the source node $s_{n}$ computes the achievable rates of all links in the network: $\tilde{R}_{l},\forall l\in\mathcal{E}$, assuming it selects link $l$ in its updated path. Specifically, the achievable rate over link $l$, $\tilde{R}_{l}(\Pi)$, is computed as follows:

where $B_{l}$ is the bandwidth of link $l$, and

denotes the Signal to Interference plus Noise Ratio (SINR) at the reciever of link $l$. Here, $P_{l}$ is the received power of the signal, $\sigma^{2}$ is the power spectrum density (PSD) of the additive white Gaussian noise (AWGN), and

is the cumulative interference power at the receiver of link $l$, aggregated across all links within its interference range $\mathcal{N}_{l}$. Here, $I_{l,i}$ is the interference power at the receiver of link $l$ caused by flow $i$, greater than zero if active by strategy $\pi_{i}$. The transmission power control mechanism considered in this paper is independent, where a predetermined transmission power is assigned to each link based on factors such as geographical distance and channel state. Consequently, the search space of the optimization problem is solely determined by the selected paths that affect the throughput.
Regularized Routing Optimization step at source node $\boldsymbol{n}$: In this step, source node $s_{n}$ computes the updated path given the current path allocation vector $\Pi_{-n}$.

Note that the rate of flow $f_{n}$ transmitted through path $\pi_{n}=(s_{n},u_{1},u_{2},...,d_{n})$ is determined by the link with the lowest rate across the links in its path, say link $l^{*}$. The achievable rate of flow $n$ is thus given by:

Therefore, the RRO algorithm aims at searching path with enhanced data rate, while limiting the path length to strike a trade-off between enhanced throughput and low latency.

To allow this optimization procedure, we first apply linear transformation to transform the computed link rates into corresponding weights, where a link with higher capacity is assigned a lower weight, and vice versa. Let $\tilde{R}_{max}=\max_{e\in\mathcal{E}}\{\tilde{R}_{e}(\Pi)\}$, and $\tilde{R}_{min}=\min_{e\in\mathcal{E}}\{\tilde{R}_{e}(\Pi)\}$. Then, RRO computes:

where the values $\tilde{R}_{e}(\Pi),\;\forall e\in\mathcal{E}$ were computed in the initial computation step. As a result, $w(e)$ is a mapping function from the link rate into $[0,1]$, preserving the significance of order in the inverse direction.

Next, the congestion function is set to be:

Then, using this construction, the RRO algorithm can use $\lambda_{n}$ in (1) as a regularized parameter of flow $n$, to compute a low-complexity regularized optimization to update the selected path iteratively over the nodes. Increasing $\lambda_{n}$ increases the penalty of using long paths, with the price of increasing the congestion over the selected path. The procedure applies a Dijkstra-type update, were at each iteration, each node updates the index of its predecessor in the updated path through the network, and the updated regularized cost. The procedure starts with storing all nodes in a set $Q$, and initializing all regularized distances used in the computation to infinity, except the distance at the source node which is set to zero.

First, the source node is removed from $Q$. Then, the regularized distance of all its neighbors is updated based on the following computation:

and the index of the predecessor of $v$ is set to be $p(v)=s$. Then, RRO updates the hop counter (in units of $\lambda$) of node $u$ such that $h(v)=\lambda$ and set the maximal weight on the path from $s_{n}$ to $v$ to be $m(v)=w(s_{n},v)$. In the next iteration, the node with the smallest regularized distance in $Q$ is selected (i.e., the neighbor of $s$ with the smallest regularized distance): $\min_{v:(s_{n},v)\in\mathcal{E}}d(v)$. Assume node $u$ is selected for the next iteration. Then, it is removed from $Q$. Next, the regularized distance is computed with respect to all its neighbors:

If $\tilde{d}(v)$ is smaller than the current value of $d(v)$, then RRO updates the value of $d(v)$ to be $d(v)=\tilde{d}(v)$, and the predecessor of $v$ is set to be $p(v)=u$. The procedure continues until convergence for flow $f_{n}$ (convergence to smallest regularized cost, and complexity analysis is provided in Section IV)

Then, the updated path is generated by the stored predecessors

Note that throughout the routine RRO searches for path with minimal regularized cost, consisting of the maximal value between $d(u)$ and $w(u,v)$ plus the regularization parameter $\lambda_{n}$. Decreasing $\lambda_{n}$ assigns more weight on reducing congestion to increase throughput, determined by the link with lowest data rate. while increasing $\lambda_{n}$ assigns more weight on minimizing the path length (i.e., tending to shortest path selection).
Notification Step: In the final step, the source node must inform all other source nodes of its selected route by broadcasting a control signal containing this information. This process does not significantly complicate the system compared to the current OSPF protocol, which already requires extensive message exchanges between nodes regarding network topologies and link weights before computing the shortest path. Therefore, it does not increase the implementation complexity compared to current deployments.

The procedure continues as each source node periodically updates its selected route. The pseudocode is given in Algorithm 1

The centralized implementation of RRO follows similar steps to the distributed implementation, with the adjustments discussed in the following section. The key difference in the centralized implementation is that a central unit receives the input information regarding the network topology and interference map, and computes all routes for all nodes. It determines the desired path for each flow one by one and notifies each flow of its updated path. This approach aligns with 5G and beyond technology, which supports central unit deployments.
Initial computation step at the centralized unit: This step is similar to that in the distributed implementation, but it is performed at the centralized unit for flow $f_{n}$.
Regularized Routing Optimization step at the centralized unit: This step is similar to that in the distributed implementation, but it is performed at the centralized unit for flow $f_{n}$.
Notification Step: The centralized node must inform only source node $s_{n}$ of its selected route $\pi_{n}$ by broadcasting a control signal containing this information.

The procedure continues as the centralized node repeat these steps for all flows to periodically update their selected routes. The pseudocode is given in Algorithm 1.

We begin our evaluation by simulating the well-known NSFNET network topology [50], which comprises $|\mathcal{V}|=14$ nodes and $|\mathcal{E}|=21$ edges, as illustrated in Fig. 1(a). The results are presented in Figs. 1(b)-1(e). It can be seen that RRO consistently outperforms all other evaluated algorithms, with an average data rate outperforming IMA by $10\%$ to $40\%$, as presented in Fig. 1(b). It is important to highlight that the superior data rate performance of the RRO algorithm does not compromise packet delay, as depicted in Fig. 1(c). Additionally, RRO demonstrates significantly higher fairness values compared to other algorithms, as illustrated in Fig. 1(d). Finally, in Fig. 1(e) we present the maximum queue length for $N=10$, indicating that RRO’s queues stabilize quickly, unlike other methods which diverge and fail to support high loads.

Next, we simulate the well-known GEANT2 network topology [51], which comprises $|\mathcal{V}|=24$ nodes and $|\mathcal{E}|=37$ edges, as illustrated in Fig 2(a). The results are presented in Figs. 2(b)-2(e). Once again, the RRO algorithm consistently surpasses all other evaluated algorithms, achieving an average data rate significant improvement, as presented in Fig. 2(b). We observe a significant improvement in lightly loaded networks, with the performance gap gradually narrowing. Ultimately, when the network is heavily loaded ($N\approx 4\cdot|\mathcal{V}|$), the relative advantage of RRO compared to the other methods becomes less significant in terms of average data rate. In terms of average delay and fairness values, significant improvements were observed, where RRO continues to demonstrate substantial improvements even under extremely heavy loads settings, as illustrated in Fig. 2(c) and in Fig. 2(d), respectively.

Finally, Fig. 2(e) displays the maximum queue length observed in the temporal dynamics for a heavily loaded network with $N=30$ data flows The findings reveal that the queue achieves stability quickly under RRO, unlike other methods which fail to support high loads.

Finally, we conducted simulations on random large-scale network deployments. First, we present the results on a random medium-size network configuration (presented in Fig. 3(a)) which comprises $V=35$ nodes and $E=65$ random edges between nodes. The results are presented in Figs. 3(b)-3(e). Across all scenarios, RRO consistently outperforms all other algorithms, particularly in lightly and moderately loaded networks. In terms of average flow data rates (Fig. 3(b)), RRO surpasses the second-best performer, IMA, by margins ranging from $90\%$ (where $N=5$) to $5\%$ (where $N=200$). Furthermore, RRO demonstrates superior performance in reducing flow delays (Fig. 3(c)) and enhancing fairness (Fig. 3(d)), even under extreme network loads. We also evaluated the queue length for each algorithm where $N=40>|\mathcal{V}|$ (Fig. LABEL:fig:random_topologyY_buffer). The findings indicate that the maximum queue length stabilizes quickly by RRO, whereas other algorithms fail to support high loads.

To further substantiate the robustness of the RRO algorithm in accommodating diverse network configurations characterized by varying numbers of flow demands $N$, nodes $|\mathcal{V}|$, and edges $|\mathcal{V}|$, and to validate its applicability in 5G topologies, which typically comprise dense networks with numerous edges, additional experiments were conducted using randomized settings. The outcomes of these experiments are detailed in Table I. The simulation results demonstrate that our method excels in both heavily-loaded and moderately-loaded dense networks (lines 1 and 2, respectively), where $|\mathcal{E}|>N>|\mathcal{V}|$. Continuing in line 3, a scenario is presented where $|\mathcal{E}|\gg N=|\mathcal{V}|$, indicative of a highly connected dense network. Additionally, a scenario with a moderate degree of connectivity under heavy load, where $|\mathcal{E}|=N>|\mathcal{V}|$, is examined in line 4. The outcomes, detailed in Table I, confirm that RRO significantly surpasses all other algorithms in terms of average flow rate, packet delay and fairness across all tested network configurations.

These results underscore the notable superiority of RRO over alternative algorithms in all tested scenarios, showcasing its consistent performance advantage. The robustness and efficacy of RRO are evident, presenting a compelling case for its adoption in diverse network environments.