Inverse Coupled Simulated Annealing for Enhanced OSPF Convergence in IoT Networks

Abstract

The current Internet of Things (IoT) network structure is evolving from small-scale distributed systems to a large-scale hierarchical collaboration between backbone and access networks. In this context, the dynamic changes in backbone node connections and the surge in service demands, coupled with sluggish fault detection speeds, significantly shorten effective service transmission time. To address this issue, this paper proposes an inverse coupled simulated annealing for enhanced OSPF route convergence in IoT networks (OSPF-ICSA). Initially, the link state is derived from the statistical characteristics of Hello packets, while the aggregated characteristics of the link state are employed to characterize the node state, providing data support for the reverse coupled simulated annealing algorithm. Subsequently, the Hello packet is refined, and a mechanism is designed to synchronize OSPF intervals and transmit node states. This ensures that nodes within the same subnet synchronize their sending intervals and fault detection times while sharing their node states. Finally, building upon this foundation, the reverse coupled simulated annealing algorithm is introduced to jointly optimize the Hello packet sending interval and fault detection time. Compared to the traditional AODV protocol, OSPF-ICSA reduces the average fault detection time by over 37.38%, improves the average fault detection accuracy by more than 3.1%, decreases the average routing overhead by over 20%, and increases the average packet delivery rate by over 5.1%.

1. Introduction

With the rapid development of the Internet of Things (IoT), the interconnectivity of smart devices through the internet has experienced explosive growth, resulting in an unprecedented scale of networks [1,2,3]. Correspondingly, the IoT network structure has gradually evolved from small-scale distributed systems to a large-scale hierarchical layout characterized by tight collaboration between backbone and access networks, showcasing strong cross-domain communication potential [4,5,6]. In this context, the dynamic characteristic of backbone node connections and the surge in service demands pose a pressing challenge: how to achieve rapid fault detection of backbone node links and real-time awareness of topological changes, thereby increasing the effective transmission time of services.

In the process of service transmission, the role of routing protocols becomes increasingly critical, especially in the Internet of Things (IoT), where the on-demand routing protocol AODV is widely used [7,8]. However, the path selection of AODV is often relatively singular, which can lead to route contention and result in network congestion issues. Furthermore, the delays associated with AODV’s path discovery process conflict with the real-time awareness requirements of backbone network nodes regarding topological changes, thereby limiting the application of AODV within backbone networks. To optimize the issue of routing contention in the Internet of Things, Elappila et al. proposed a congestion- and interference-aware energy efficient routing technique for the IoT. This approach is based on the signal-to-noise ratio and noise ratio of links. By evaluating the survivability factor of the path from the next-hop node to the destination and its current congestion level, it effectively meets the data routing demands in high-load network environments [9]. Guo et al. introduced a routing algorithm based on reinforcement learning, which constructs a reward function using remaining energy and hop count, optimizing routing in wireless sensor networks (WSNs), extending network lifespan, and ensuring a good data flow transmission rate [10]. Younus et al. utilized reinforcement learning to optimize routing in software-defined networking (SDN) wireless sensor networks, proposing a reward function based on energy utilization and QoS requirements, significantly improving data flow transmission efficiency [11]. Although these algorithms have reduced routing contention and improved data transmission efficiency to some extent, they primarily avoid routing contention by optimizing paths. When link failures occur between nodes and fault detection is not timely, even the best routing algorithms struggle to mitigate the impact of faulty links, leading to packet loss and reduced transmission efficiency.

Open Shortest Path First (OSPF) is a proactive routing protocol that possesses a comprehensive network topology view of all nodes within the area [12,13,14]. In the event of a link failure, it can swiftly disseminate information to all nodes and update routing, ensuring rapid route convergence across all nodes simultaneously. This mechanism is particularly suitable for backbone nodes in the Internet of Things, as it avoids the delays associated with path discovery in AODV. However, its fault detection process is mechanical and slow, making it difficult to quickly identify failures, which severely impacts service transmission in the IoT and hinders its deployment. To accelerate fault detection speed, the literature [15,16,17] has introduced the BFD protocol. BFD establishes independent sessions between OSPF neighbors to send probe messages at millisecond intervals, allowing for real-time monitoring of link status and rapid detection of link failures. However, this high-frequency probing also results in increased routing overhead. Particularly in cases of link congestion or interference, BFD is prone to false alarms, leading to unnecessary route convergence and further exacerbating routing overhead in the network [18]. To reduce routing overhead, Manousakis et al. developed a tool based on an enhanced simulated annealing algorithm, aimed at automatically optimizing OSPF area partitioning to balance multi-objective performance requirements. This tool effectively reduces routing overhead, convergence time, and latency while improving bandwidth utilization [19]. However, its applicability is limited, primarily targeting network environments with minimal topological changes. Considering the dynamic characteristics of network topology in the IoT, this limitation affects the tool’s feasibility in practical deployment. In response to time-varying network topologies, the IETF has introduced the OSPF-MPR [20,21], OSPF-MDR [22], and OSPF-OR [23] protocols to address topological changes in MANETs. These protocols introduce specific mechanisms to meet the demand for routing convergence in MANET topologies; however, their effectiveness in improving convergence speed is not significant. To address this gap, researchers have introduced centrality into the routing convergence process to enhance convergence speed while optimizing routing overhead to some extent. References [24,25] discuss the placement problem of Designated Routers (DRs) and propose optimizing DR layouts using betweenness centrality, closeness centrality, and degree centrality to shorten routing convergence time. References [26,27] adjust the sending frequency of Hello packets based on betweenness centrality, increasing the frequency for nodes with higher intermediary centrality to expedite fault detection and reduce routing overhead. References [28,29,30] optimize the sending of Hello packets based on load centrality, running the load centrality algorithm directly in distributed routers to reduce computational complexity, significantly improving routing convergence efficiency. Although centrality-based algorithms have achieved success in accelerating fault detection and controlling routing overhead, nodes with lower centrality can still become critical routing nodes. Their failures can delay link fault detection and convergence, leading to data loss. Furthermore, nodes with higher centrality may waste network resources due to the frequent sending of Hello messages.

To address this, this paper proposes an inverse coupled simulated annealing for enhanced OSPF route convergence (OSPF-ICSA), aimed at resolving the issues of time-varying topology in IoT backbone nodes, slow fault detection, and inadequate topological awareness, which result in shorter effective transmission times for services. This method integrates the OSPF protocol into the Internet of Things and improves upon the traditional OSPF protocol. This method first utilizes the statistical characteristics of Hello packets to assess the link state and characterizes the node state through aggregated link state features, dynamically reflecting the topological changes of nodes in the IoT. This process effectively captures the dynamic characteristics of connection relationships, providing real-time network state data support for the inverse coupled annealing algorithm. Secondly, based on the improvement of Hello packets, a mechanism for OSPF interval synchronization and node state transmission is designed to ensure that the sending intervals and fault detection times of all nodes within the same subnet are synchronized, facilitating the effective transmission of node status messages and laying the foundation for the efficient application of the inverse coupled annealing algorithm. Finally, based on this foundation, the inverse coupled annealing algorithm is introduced to collaboratively optimize the sending intervals of Hello packets and fault detection times through two coupled annealing algorithms, dynamically adjusting the sending frequency of Hello packets and fault detection times. In poor link states, this accelerates fault detection so that nodes can more swiftly and flexibly identify and respond to link failures, thus shortening overall routing convergence time. In good link states, it reduces the sending frequency of Hello packets to lower routing overhead.

2. Main Contribution

2.1. Design Overview

OSPF routing convergence refers to the process by which nodes in a network reach a consensus to update routing information following the detection of changes in links or nodes [12,13,14]. This process is illustrated in Figure 1.

The process begins with fault detection. Node R periodically sends Hello packets via the Hello protocol to monitor the status of neighboring nodes. The sending interval for Hello packets is denoted as $T_h$, which is controlled by the Hello Interval parameter, typically set to a default value of 10 s. Additionally, the link fault detection time $T_d$ is usually set to four times $T_h$. If no response to the Hello packets from the neighbors is received within $T_d$ (governed by the Dead Interval parameter), the neighbor is considered unreachable, triggering link fault handling. Assuming that the occurrence of a fault is a random event, the time difference X from the occurrence of the link fault to when R detects the fault is uniformly distributed within the interval (30, 40). The probability density function for this distribution is given by:

$$f\left(x\right)=\left\{\begin{array}{cc}{\displaystyle \frac{1}{40-30}}=0.1& \mathrm{if}30\le x\le 40\\ 0& \mathrm{otherwise}\end{array}\right.$$

(1)

At this point, the expected value $E\left(X\right)$ is 35. Therefore, the average fault detection time $T_D$ is 35 s.

When a fault occurs, R generates a new Link State Advertisement (LSA) to reflect the topological change. Upon receiving the new LSA, neighboring nodes store it in their Link State Databases (LSDBs) and subsequently flood the LSA to all neighbors, achieving complete LSA flooding. To optimize LSA flooding, OSPF employs the mechanisms of Designated node (DR) and Backup Designated node (BDR). The DR is responsible for receiving and broadcasting LSAs within the network, which reduces redundant transmissions and minimizes bandwidth consumption. The BDR acts as a backup for the DR, ensuring continuity in LSA flooding. The cooperative operation of the DR and BDR enables OSPF to efficiently flood LSAs while alleviating routing overhead and network load. Consequently, the flooding time of an LSA within a broadcast segment can be expressed as:

$$T_l=\left\{\begin{array}{cc}{T}_c^{DR}+{\displaystyle \frac{s}{\beta }}& \mathrm{if}R=DR\\ T_c^{BDR/Others}+T_{\mathrm{m}}^{DR}+T_c^{DR}+2·{\displaystyle \frac{s}{\beta }}& \mathrm{if}R=BDR/Others\end{array}\right.$$

(2)

where $T_c^{DR}$ and $T_c^{BDR/Others}$ represent the time taken by the DR and BDR/Others to generate the LSA, respectively, s is the size of the LSA packet in bytes, $\beta$ is the interface transmission rate, and $T_{\mathrm{m}}^{DR}$ is the time taken by the DR to process the LSA. Therefore, the total time for LSA dissemination within the entire segment can be expressed as:

$${\mathrm{T}}_{lsa}=\sum _{i=1}^n{T}_l^i$$

(3)

where n represents the maximum number of broadcast segments for flooding the LSA to all nodes, and $T_l^i$ is the time required for the i-th broadcast segment that is traversed.

Once the LSA flooding is complete, the node recalculates the Shortest Path Tree (SPT) using Dijkstra’s algorithm based on the updated LSDB and updates the routing table. Let the time taken for this process be denoted as $T_m$. Therefore, the total routing convergence time can be expressed as:

$${\mathrm{T}}_{total}=T_{\mathrm{D}}+T_{lsa}+T_m$$

(4)

In $T_{\mathrm{total}}$, the fault detection phase is typically the most time-consuming part. This is primarily because confirming a link failure depends on not receiving a response to the Hello packets within the time $T_d$, which is set to 40 s by default. During this period, the average $T_D$ requires 35 s. In contrast, the LSA flooding process, which involves the generation and flooding of LSAs, generally consumes less time than the fault detection phase, although the time required may increase with network size. Additionally, the routing table calculation phase, based on Dijkstra’s algorithm for shortest path computation, also operates within a limited time frame. Therefore, this paper restructures the protocol based on the traditional OSPF protocol, dynamically optimizing the Hello packet transmission frequency and fault detection time, aiming to accelerate fault detection speed, thereby enhancing routing convergence speed and, to some extent, reducing routing overhead, as illustrated in Figure 2.

The specific improvements are as follows:

Utilize the statistical characteristics of Hello packets to obtain the link status, and characterize the node state based on the aggregated features of the link state, thereby assessing the state of links and nodes in the network and providing data support for the reverse coupled annealing algorithm.

Design an OSPF interval synchronization and node state propagation mechanism (OSPF-IS-NSP) to synchronize the sending intervals of Hello packets and fault detection times of nodes within the same subnet and propagate the node state of the local node.

Propose a reverse coupled annealing algorithm, which consists of two coupled annealing algorithms: the upward optimization annealing algorithm and the downward optimization annealing algorithm. When one annealing algorithm is executed, the temperature of the other gradually rises, and vice versa. Through this mechanism of alternating heating and cooling, and based on the link and node status, the two algorithms collaboratively optimize the Hello packet transmission interval and fault detection time.

2.2. Link and Node State Monitoring

In the OSPF protocol, the instability of links or nodes can trigger excessive LSA flooding and frequent routing updates, leading to routing oscillations. This situation not only results in a significant increase in routing overhead but also places a greater burden on the node’s CPU. In severe cases, it may even lead to network storms, resulting in network failures. To address this issue, this section introduces link and node states to monitor the statuses of links and nodes in real time, thereby providing data support for subsequent algorithms.

A network topology can be represented as $G(N,E)$, where N is the set of network node nodes and E is the set of communication links. Assume there exists a link $l(l\in E)$ between nodes $u\in N$ and $v\in N$, which can be denoted as: $l=uv$. In this case, the link state is evaluated based on the absence of Hello packets in link l during the assessment period, as expressed in the following formula:

$$\eta \left(uv\right)={\displaystyle \frac{T-t_d}{T}}$$

(5)

where $\eta \left(uv\right)$ is the link state evaluation function, T is the assessment period, and $t_d$ represents the time segment formed by the absence of Hello packets during the assessment period. This is defined as the difference between the expected time of receiving the next Hello packet and the actual last received time, as illustrated in Figure 3.

Additionally, based on the aggregated average link state of all interfaces on node v, the node state is assessed using the following formula:

$$\gamma \left(v\right)={\displaystyle \frac{{\sum }_{uv\in E}\eta \left(uv\right)}{\left|E\right|}}$$

(6)

where $\gamma \left(v\right)$ is the node state assessment function, and $\left|E\right|$ represents the cardinality of E, which is the number of links associated with node v.

Building on this, this paper introduces weight parameters $\alpha$ and $\beta$ for a comprehensive assessment of link and node states. The specific evaluation formula is:

$$\phi \left(u\right)=\alpha \ast \eta \left(vu\right)+\beta \ast \gamma \left(u\right)$$

(7)

where $\phi \left(u\right)$ is the comprehensive assessment function used to evaluate the overall state of the link between node v and its neighboring node u. The link state is denoted by $\eta \left(vu\right)$, indicating the condition of the link between nodes v and u, while $\gamma \left(u\right)$ represents the state of node u. The parameters $\alpha$ and $\beta$ are weight coefficients for link and node states, respectively, which adjust their influence on $\phi \left(u\right)$.

2.3. OSPF Interval Synchronization and Node State Propagation Mechanism

In the OSPF protocol, unifying the configuration of the Hello Interval ($T_h$) and Dead Interval ($T_d$) parameters for all nodes within the same segment is essential for ensuring the stable establishment and continuous maintenance of neighbor relationships. Hello packets primarily facilitate neighbor discovery and fault monitoring. Inconsistent parameter configurations can lead to asymmetries in neighbor state perception, adversely affecting the correct establishment of adjacency relations and timely fault detection. Additionally, parameter consistency synchronizes the time window for fault detection, preventing delays or misjudgments due to variations in $T_d$. This unification also enables the synchronous propagation of topological state information within the segment, minimizing delays in topology updates. Consequently, this section introduces the OSPF interval synchronization mechanism to ensure parameter consistency among all nodes, providing foundational support for the deployment of the reverse coupled annealing algorithm, as illustrated in Figure 4.

The specific steps of the OSPF interval synchronization mechanism are as follows:

• When the Designated Router (DR) calculates the new parameters for $T_h$ and $T_d$ (assumed to be 10 s and 40 s, respectively), the DR appends its $T_h$ and $T_d$ parameters to the Hello message and broadcasts it to all neighbors in the subnet.
• The Backup Designated Router (BDR) and other non-DR routers have their previous $T_h$ and $T_d$ values assumed to be 7 s and 28 s, respectively.
• Once the BDR or other routers receive the Hello message from the DR containing $T_h$ and $T_d$, they will immediately update their $T_h$ and $T_d$ to 10 s and 40 s, respectively. At the same time, the nodes will adjust their Hello message sending timers and failure detection timers accordingly. As shown in Figure 4, due to the timer adjustments, the sending of Hello messages is delayed by 3 s compared to before. When the next Hello message sending cycle begins, the node will send a Hello message containing the new parameters.
• When the DR receives the Hello messages sent by the BDR or other routers, it can detect that these nodes’ $T_h$ and $T_d$ have been updated to 10 s and 40 s, thereby achieving global synchronization of $T_h$ and $T_d$ across the entire subnet.

Additionally, this section designs a node state propagation mechanism, which transmits the node state by mapping it to the Priority field in the Hello message. This approach not only optimizes the DR election process based on the Priority field—allowing nodes with higher node state to be prioritized as DR or BDR—but also ensures that nodes with superior states take on critical roles within the network, enhancing stability and routing efficiency. Furthermore, since the OSPF protocol lacks a native mechanism for propagating node state, this mechanism enables nodes to share node state information in real-time among neighbors.

2.4. Reverse Coupled Annealing Algorithm Design

To address the dynamic characteristic of link relationships and the frequent link failures in IoT networks, it is essential to dynamically adjust the sending frequency of Hello messages and the fault detection time based on the characteristics of link and node states in real time. The annealing algorithm can explore and approximate the optimal Hello interval and fault detection time through multiple iterations based on the network environment, allowing for a broader search space in the initial stages to prevent the algorithm from getting trapped in local optima [31,32,33,34]. As the algorithm’s temperature gradually decreases, the search range converges, accelerating convergence while maintaining solution diversity. The algorithm begins by randomly generating an initial solution $x_0$ and searches for solutions within its neighborhood. In each iteration, based on the Metropolis criterion, the algorithm decides whether to accept a worse solution according to the acceptance probability formula:

$$P(\Delta E)=\left\{\begin{array}{cc}1& \mathrm{if}\Delta E<0\\ e^{-{\displaystyle \frac{\Delta E}{T_k}}}& \mathrm{if}\Delta E\ge 0\end{array}\right.$$

(8)

where $\Delta E=f\left(x_{\mathrm{new}}\right)-f\left(x_{\mathrm{current}}\right)$ is the difference in objective function values between the current and new solutions.

As the internal “temperature” of the algorithm gradually decreases, the temperature change can be expressed by the formula:

$$T_k=T_0·{\alpha }^k$$

(9)

where $T_0$ is the initial temperature and $\alpha$ is a decay factor less than 1. As the temperature decreases, the probability of accepting inferior solutions also diminishes. After each iteration, the algorithm updates the current solution:

$$x_{k+1}=\left\{\begin{array}{cc}{x}_{\mathrm{new}}& \mathrm{if}\mathrm{new}\mathrm{solution}\mathrm{accepted}\\ x_k& \mathrm{if}\mathrm{new}\mathrm{solution}\mathrm{rejected}\end{array}\right.$$

(10)

The optimization process gradually stabilizes, ultimately converging to the global optimum $x^{\ast }$, thereby minimizing $f\left(x^{\ast }\right)$.

However, traditional annealing algorithms primarily focus on unidirectional optimization, gradually reducing the temperature to minimize perturbation and slowly approaching the optimal solution. Once the temperature reaches its lowest point, the algorithm loses its effectiveness. This unidirectional cooling strategy gradually diminishes the algorithm’s perception of the network environment during execution, leading to a decrease in adaptability to dynamic changes. Particularly when faced with failures, the algorithm may not respond promptly, thereby affecting the overall fault detection and recovery speed. Therefore, this paper proposes the reverse coupled annealing algorithm, which consists of two coupled annealing algorithms: Algorithms 1 and 2. These algorithms collaborate to optimize link and node states based on $\phi \left(u\right)$ and implement dynamic fault detection through the OSPF interval synchronization mechanism. When a node assesses the overall state of node v, neighboring node u, and the link between them through the comprehensive evaluation function $\phi \left(u\right)$, it triggers DOSA if $\phi \left(u\right)$ falls below the preset threshold $\epsilon$, executing downward optimization to reduce the values of $T_h$ and $T_d$; otherwise, it triggers UOSA. Through this alternating operation of heating and cooling, the two annealing algorithms dynamically couple and interact, thereby adjusting the parameters $T_h$ and $T_d$ based on the network environment. The details are as follows.

Algorithm 1: Upward optimization simulated annealing algorithm (UOSA)

Input: UOSA current temperature: $T_0^u$; UOSA termination temperature: $T_k^u$; UOSA annealing weight: ${\delta }^u$; DOSA current temperature: $T_0^d$; UOSA heating weight: ${\beta }^u$; DOSA maximum temperature: $T_m^d$; UOSA inner loop iterations: $M_1^u$; UOSA current optimal sending interval: $s_{cb}^u$ Current Hello packet sending interval: $T_h$; Current fault detection time: $T_d$; Output: next Hello packet sending interval: $s_{nh}$; next fault detection time: $s_{nd}$; UOSA optimal sending interval: $s_b^u$; DOSA next temperature: $T_n^d$ 1:    Initialize: $s_{nh}=T_0^u$, $s_b^u=s_{cb}^u$, $s_{nd}=T_d$ 2:    if $T_0^u>T_k^u$ then 3:       Initialize: $k=0$ 4:       while $k<M_1^u$ do 5:          $s_{nh}=f_u\left(s_{nh}\right)$ 6:          difference value: $\Delta s=s_{nh}-T_h$ 7:          if $\Delta s\ge 0$ then 8:             $s_{nh}=min\{30,s_{nh}\}$ 9:          else if $e^{(\Delta s/T_0^u)}>random(0,1)$ then 10:             $s_{nh}=min\{30,s_{nh}\}$ 11:          end if 12:          if $s_{nh}>s_b^u$ then 13:             $s_b^u=s_{nh}$ 14:          end if 15:          $k=k+1$ 16:       end while 17:       $T_n^u={\delta }^u\ast T_0^u$ 18:       $s_{nd}=min\{40,s_{nh}\ast 40\}$ 19:    end if 20:    $T_0^d=min({\beta }^u\ast T_0^d,T_m^d)$

Algorithm 2: Downward optimization simulated annealing algorithm (DOSA)

Input: DOSA current temperature: $T_0^d$; DOSA termination temperature: $T_k^d$; DOSA annealing weight: ${\delta }^d$; UOSA current temperature: $T_0^u$; DOSA heating weight: ${\beta }^d$; UOSA maximum temperature: $T_m^u$; DOSA inner loop count: $M_1^d$; DOSA current optimal sending interval: $s_{cb}^d$; Current hello Packet transmission interval: $T_h$; Current fault detection time: $T_d$ Output: next Hello packet transmission interval: $s_{nh}$; next fault detection time: $s_{nd}$; DOSA optimal sending interval: $s_b^d$; UOSA next temperature: $T_n^u$ 1:    Initialize: $s_{nh}=T_0^{\mathrm{d}}$, $s_b^d=s_{cb}^d$ 2:    if $T_0^d>T_k^d$ then 3:       Initialize: $k=0$ 4:       while $k<M_1^d$ do 5:          $s_{nh}=f_d\left(s_{nh}\right)$ 6:          difference value: $\Delta s=s_{nh}-T_h$ 7:          if $\Delta s\le 0$ then 8:             $s_{nh}=max\{1,s_{nh}\}$ 9:          else if $e^{(-\Delta s/T_0^u)}>random(0,1)$ then 10:             $s_{nh}=max\{1,s_{nh}\}$ 11:          end if 12:          if $s_{nh}<s_b^d$ then 13:             $s_b^u=s_{nh}$ 14:          end if 15:          $k=k+1$ 16:       end while 17:       $T_n^d={\delta }^d\ast T_0^d$ 18:       $s_{nd}=min\{40,s_{nh}\ast 40\}$ 19:    end if 20:    $T_0^u=min({\beta }^d\ast T_0^u,T_m^u)$

The objective of the upward optimization simulated annealing (UOSA) algorithm is to optimize the Hello packet transmission interval $T_h$ and the fault detection time $T_d$, gradually increasing both parameters to their maximum values. In line 2 of the pseudocode, it first checks whether the initial temperature $T_0^u$ has reached the termination temperature $T_k^u$; if not, it enters the inner loop. Lines 4 to 16 describe the inner loop process of the simulated annealing algorithm. The algorithm generates a random number in the range of −2 to 4 using the random seed generation function $f_u\left(s_{nh}\right)$ and adds it to $s_{nh}$ to obtain a new $s_{nh}$. Subsequently, it assesses whether the generated difference $\Delta s$ meets the Metropolis criterion, ultimately updating $s_{nh}$ and the current optimal state $s_b^u$. Line 17 implements the cooling operation of the annealing process, and line 18 calculates the new fault detection time $s_{nd}$ based on the updated $s_{nh}$. Line 20 executes the heating operation for the downward optimization simulated annealing (DOSA); each time UOSA is completed, the initial temperature $T_0^d$ for DOSA is increased. In summary, the code structure of this algorithm consists of only one outer loop, with the number of iterations being $M_1^u$. The algorithm’s complexity is $O\left(M_1^u\right)$.

The downward optimization simulated annealing algorithm (DOSA) also targets the Hello message transmission interval $T_h$ and the fault detection time $T_d$, but its optimization direction is opposite to that of UOSA, aiming to gradually reduce these two parameters to their minimum values. The process is similar to UOSA, so it will not be elaborated here.

3. Simulation and Evaluation

3.1. Evaluation Metrics

The experiment primarily evaluates routing convergence performance through four metrics: fault detection time (FDT), fault detection accuracy (FDA), routing overhead (RO), and packet delivery rate (PDR). The definitions and formulas for these metrics are as follows:

(1) Fault detection rime (FDT): The fault detection time is defined as the average difference between the time $\tau$ when all OSPF nodes detect a fault during network simulation and the actual time t when the link fails [35,36]. A shorter time indicates faster routing convergence under the same conditions, reflecting the efficiency of the fault detection mechanism’s impact on overall routing convergence speed.

$$FDT={\displaystyle \frac{1}{n}}\sum _{i=1}^n({\tau }_i-t_i)$$

(11)

(2) Fault detection accuracy (FDA): The fault detection accuracy is defined as the ratio of the number of successful link fault detections $F_n$ by all OSPF nodes during network simulation to the total number of actual link failures $F_l$. A higher accuracy indicates better detection precision in the face of link failures, reflecting the responsiveness of the detection mechanism to actual fault events.

$$FDA={\displaystyle \frac{F_n}{F_l}}\times 100\%$$

(12)

(3) Routing overhead (RO): Routing overhead is expressed as the ratio of the total number of bytes in control packets $B_r$ to the total number of bytes in successfully transmitted packets $B_s$ [37,38]. A smaller routing overhead indicates lower costs associated with protocol routing convergence.

$$RO={\displaystyle \frac{B_r}{B_s}}\times 100\%$$

(13)

(4) Packet delivery rate (PDR): The packet delivery rate is defined as the proportion of successfully transmitted packets $P_r$ to the total packets sent $P_s$ by a node [39,40]. A higher packet delivery rate indicates greater reliability of the routing convergence method.

$$PDR={\displaystyle \frac{P_r}{P_s}}\times 100\%$$

(14)

3.2. Results, Analysis, and Discussion

The simulation platform for this experiment is based on the Ubuntu 16.04 operating system, running on hardware equipped with a 12th Gen Intel(R) Core(TM) i7-12700H processor and 16 GB of RAM. The experiment utilizes the NS3.33 network simulation software to conduct the simulations. Through these simulations, performance evaluations were carried out on four key metrics: fault detection time (FDT), fault detection accuracy (FDA), routing overhead (RO), and packet delivery rate (PDR). The experiment compared the performance of the OSPF-ICSA algorithm, the AODV protocol [7,8], the OSPF protocol, the BFD protocol [15,16], and the routing convergence algorithm based on load centrality (LC) [28,30]. The experiments set up two network topologies based on the literature [1,2,4,5,12]. The algorithm and topology parameters are shown in

Table 1. Algorithm and topology parameter configuration table.

Parameter Name	Topology 1	Topology 2
UOSA Maximum Temperature $T_m^u$	100	100
UOSA Termination Temperature $T_k^u$	0	0
UOSA Heating Weight ${\beta }^u$	1.2	1.2
UOSA Annealing Weight ${\delta }^u$	0.8	0.8
UOSA Inner Loop Iterations $M_1^u$	1	1
DOSA Maximum Temperature $T_m^d$	100	100
DOSA Termination Temperature $T_k^d$	0	0
DOSA Heating Weight ${\beta }^d$	1.2	1.2
DOSA Annealing Weight ${\delta }^d$	0.8	0.8
DOSA Inner Loop Iterations $M_1^d$	1	1
Threshold $\epsilon$	0.8	0.8
Number of Backbone Nodes	40	80
Number of Access Networks	13	19
Number of Flows	16	26

.

Testing was conducted under two fault scenarios, randomly introducing between 1 and 20 link failures, and 1 and 5 node failures. The experimental results are as follows.

Figure 5 and Figure 6 present a comparative experimental analysis of fault detection times under link failure and node failure scenarios for two different scales of topologies. As shown in the figures, the BFD algorithm demonstrates the best performance in terms of fault detection time, with the shortest detection time. However, the detection speed of OSPF-ICSA is also impressive, with an average fault detection time of approximately 4 s. Compared to the AODV protocol, OSPF-ICSA reduces fault detection time by an average of 74% and 37.38% in the two scenarios, respectively. In comparison to the traditional OSPF protocol, OSPF-ICSA achieves reductions of 86.24% and 87.37%, respectively. Additionally, compared to the load centrality (LC) algorithm, fault detection time is reduced by an average of 34.73% and 40.14%, respectively. These results indicate that OSFP-ICSA significantly enhances fault detection efficiency, second only to the BFD algorithm. Its lower fault detection time is attributed to the OSFP-ICSA algorithm’s ability to respond flexibly and rapidly in the network environment. When network conditions deteriorate, OSFP-ICSA minimizes fault detection time through the reverse coupled annealing algorithm, significantly reducing the detection duration. Topology 1 in Figure 5 shows that, with one link failure, the detection time is 12 s. This occurs because both annealing algorithms reach a dynamic equilibrium at the 12 s mark. Subsequently, as the number of link failures increases, the fault detection time continues to decrease until it reaches its minimum value.

Figure 7 and Figure 8 display the fault detection accuracy of five algorithms under link failure and node failure scenarios for two different scales of topologies. It can be observed that the accuracy of the OSPF-ICSA algorithm is nearly identical to that of the BFD algorithm in both scenarios, with both approaching 100%. Compared to the AODV protocol, OSPF-ICSA improves the fault detection accuracy by an average of over 20.19% and 3.1% in the link failure and node failure scenarios, respectively. When compared to the traditional OSPF protocol, the accuracy is increased by an average of over 10.54% and 27.68% in the two scenarios. Additionally, compared to the load centrality (LC) algorithm, OSPF-ICSA’s detection accuracy is improved by an average of over 3.56% and 1.14% in the respective scenarios. These results indicate that OSPF-ICSA significantly enhances fault detection accuracy, performing comparably to the BFD algorithm, which achieves faster detection by increasing routing overhead. The advantage of OSPF-ICSA lies in its ability to dynamically adjust the frequency of Hello message transmissions and fault detection times based on real-time feedback from link and node states, thus enabling efficient and flexible fault detection that achieves the same level of precision as the BFD algorithm.

Figure 9 and Figure 10 present a comparative analysis of routing overhead for five algorithms under link failure and node failure scenarios across two different network scales. It is evident that the routing overhead of OSPF-ICSA is generally lower than that of other algorithms. In both link failure and node failure scenarios, OSPF-ICSA achieves lower overhead than the AODV protocol under most conditions, with the exception of the larger topology in the node failure scenario, where it is slightly higher than AODV. Compared to the traditional OSPF protocol, OSPF-ICSA reduces overhead by an average of 21.66% and 44.44%, respectively. When compared to the BFD algorithm, OSPF-ICSA decreases overhead by an average of 63.77%. Additionally, it reduces overhead compared to the load centrality (LC) algorithm by an average of 28.14% and 20.47% in the respective scenarios. This can be attributed to two main factors: first, OSPF-ICSA significantly shortens fault detection time, enabling nodes in the network topology to quickly sense changes, thus increasing the total amount of successfully transmitted packets compared to traditional OSPF and LC algorithms. Second, OSPF-ICSA dynamically adjusts the frequency of Hello message transmissions, reducing the frequency of Hello messages on normal links and, consequently, lowering the overhead of control messages. In contrast, the BFD algorithm incurs higher routing overhead, partly due to its high frequency of probe message transmissions and partly due to false alarms caused by link jitter and congestion, which further increases routing overhead.

Figure 11 and Figure 12 illustrate the comparison of packet delivery rates for five algorithms under link failure and node failure scenarios across two different network scales. It is evident that OSPF-ICSA improves packet delivery rates by an average of 14.04% and 5.1% compared to the AODV protocol in these two scenarios, respectively. When compared to the traditional OSPF protocol, packet delivery rates increase by an average of 34.03% and 153.93%. Furthermore, it is noticeable that the traditional OSPF protocol exhibits poor packet delivery rates during multiple node failures. Additionally, OSPF-ICSA outperforms the load centrality (LC) algorithm, with average increases in packet delivery rates of 15.78% and 28.09% under link failure and node failure scenarios, respectively. However, compared to the BFD algorithm, OSPF-ICSA shows a slight decrease, with reductions of 3.46% and 7.72%. The advantage of OSPF-ICSA in packet delivery rates primarily stems from its ability to perceive changes in network topology and dynamically adjust fault detection times, leading to faster fault diagnosis and LSA flooding. This enables the entire network to detect link failures more swiftly. Although the LC algorithm has optimized fault detection, its response speed remains inferior to that of OSPF-ICSA. The slight disadvantage of OSPF-ICSA compared to BFD is due to BFD’s ability to adjust fault detection times to extremely low frequencies, significantly lower than the detection frequency of OSPF-ICSA, placing them in different magnitudes. However, under non-extreme conditions, these slightly reduced packet delivery rates remain acceptable.

4. Conclusions

In the context of the current evolution of IoT network structures from small-scale distributed systems to large-scale hierarchical collaboration between backbone and access networks, the dynamic changes in backbone node connections and the surge in service demands pose significant challenges. The sluggish fault detection speed leads to a substantial reduction in the effective service transmission time. This paper proposes an OSPF dynamic routing convergence method based on reverse coupled simulated annealing (OSPF-ICSA). This method utilizes the statistical characteristics of Hello packets to acquire the link status and characterizes the node state based on the aggregated features of the link status, providing data support for the reverse coupled simulated annealing algorithm regarding the network conditions. Furthermore, the Hello packet is improved and an OSPF interval synchronization and node state transmission mechanism is designed to synchronize the sending intervals and fault detection times of nodes within the same subnet, while sharing the node state of nodes. Building on this foundation, the reverse coupled simulated annealing algorithm is introduced to collaboratively optimize the Hello packet sending interval and fault detection time. Experimental results demonstrate that OSPF-ICSA exhibits outstanding performance across various fault scenarios, particularly in four key indicators: fault detection time, detection accuracy, routing overhead, and packet delivery rate. This algorithm effectively addresses the trade-off between routing convergence time and routing overhead, achieving an optimized convergence speed while significantly reducing resource consumption. The aim is for OSPF-ICSA to provide a new perspective on routing convergence in large-scale hierarchical IoT network topologies. In future research, we plan to integrate machine learning, large models, and other cutting-edge algorithms to achieve more efficient and rapid routing convergence, ushering in a new era of network optimization.