^{*}

This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution license (http://creativecommons.org/licenses/by/3.0/).

Wireless sensor networks (WSNs) are promising technologies for exploring harsh environments, such as oceans, wild forests, volcanic regions and outer space. Since sensor nodes may have limited transmission range, application packets may be transmitted by multi-hop communication. Thus, connectivity is a very important issue. A bridge is a critical edge whose removal breaks the connectivity of the network. Hence, it is crucial to detect bridges and take preventions. Since sensor nodes are battery-powered, services running on nodes should consume low energy. In this paper, we propose energy-efficient and distributed bridge detection algorithms for WSNs. Our algorithms run single phase and they are integrated with the Breadth-First Search (BFS) algorithm, which is a popular routing algorithm. Our first algorithm is an extended version of Milic's algorithm, which is designed to reduce the message length. Our second algorithm is novel and uses ancestral knowledge to detect bridges. We explain the operation of the algorithms, analyze their proof of correctness, message, time, space and computational complexities. To evaluate practical importance, we provide testbed experiments and extensive simulations. We show that our proposed algorithms provide less resource consumption, and the energy savings of our algorithms are up by 5.5-times.

Wireless sensor networks (WSNs) are infrastructureless networks that consist of hundreds, even thousands, of sensor nodes that cooperate to perform sensing and communicating tasks. These nodes are low-cost, low-power multifunctional small devices. Healthcare, environmental control, military surveillance and target tracking are example application areas of WSNs [

Nowadays, WSNs are used in harsh environments, such as underground mines, oceans, tunnels and outer space [

A WSN can be modeled with a graph, _{r}_{r}

The bridge detection algorithms proposed in the literature have some important disadvantages. Some of them should be implemented as a separate service [

We propose an extended version of Milic's algorithm (E-MILIC). We propose two rules as the extension in order to reduce the message length of Milic's algorithm. We show from testbed experiments and extensive simulation results that E-MILIC consumes less resources than Milic's algorithm. Theoretical analysis and performance evaluations show that E-MILIC outperforms other bridge detection algorithms for graphs having a low cross edge count and a high diameter.

We propose an ancestral knowledge-based bridge detection algorithm (ABIDE), which is a novel approach. ABIDE is integrated with the BFS, and it completes its operation within a single phase. Theoretical and practical studies show that for random graphs, ABIDE outperforms other bridge detection algorithms.

The rest of the paper is organized as follows. The network model and bridge detection problem are given in Section 2. The related work is summarized in Section 3. The proposed algorithms are described in Section 4. The theoretical analysis is given in Section 5. Testbed experiments and simulations are presented in Section 6. Finally, Section 7 provides conclusions.

In this section, we explain the network model and the bridge detection problem.

The following assumptions are made about the network, as in [

Each node has a distinct

The nodes are stationary in the sensing area.

Links between nodes are symmetric. Thus, if there is a link from

Nodes are not equipped with a position tracker, and they do not execute a localization algorithm; thus, each node does not know its position.

All nodes have identical capabilities; they are equal in terms of processing capabilities, radio, battery and memory.

Each node can send radio multicast messages to its immediate neighbors in its transmission range.

Nodes are time-synchronized, where this can be achieved by implementing a protocol, such as proposed in [

The undirected graph model for the network is depicted in

A bridge can be a link between a leaf node and its parent or it can be a link between a whole component to lower layers. An example sensor network is given in

The bridge detection algorithm should be efficient in terms of message complexity and message size, since message transmission is the dominant factor of the energy consumption.

Routing is crucial for data delivery and data aggregation [

The bridge detection algorithm should be distributed, since the sink node may initiate the bridge detection algorithm at any time and locally.

In order to interface various medium access control (MAC) and physical layer standards [

If location information is already available, a location-based cut detection algorithm can be used. However, for many sensor network setups, accurate localization cannot be afforded, due to the economic costs of GPS receivers, environmental effects (heat, wind, obstacles,

Depth-first search (DFS) is a fundamental technique that can be used for bridge detection [_{2}(^{2}

BFS is a very important algorithm for routing in various networks, and distributed versions of BFS are proposed [

Pritchard proposed a three-phase distributed algorithm for bridge detection [

Dagdeviren proposed the ENBRIDGE algorithm for energy-efficient bridge detection [

Milic proposed a BFS-based bridge detection algorithm for wireless

In this section, we will introduce our proposed E-MILIC and ABIDE algorithms.

Although the MILIC algorithm completes its operation within a BFS execution session, the transmitted byte count can be high for energy-efficient sensor networks. In order to reduce transmitted byte count, we propose the extended-MILIC (E-MILIC) algorithm by adding two new rules to the MILIC algorithm as listed below:

_{i}_{i}

To explain these rules clearly, we give an example operation in _{2}(_{2}(_{2}(

The message size of E-MILIC depends on the count of cross edges. In the following section, we will introduce a new algorithm, whose transmitted byte count is independent from cross edge count.

In E-MILIC algorithm, nodes process and send cross edge information to detect bridges. This may cause the transmission of large packets when the cross edge count is high. In order to reduce energy consumption for this case, we propose the ABIDE algorithm, which uses ancestral knowledge for bridge detection in WSNs. The algorithm is fully integrated to the BFS, where it completes its execution by the end of a single BFS phase execution. The main idea of the proposed algorithm is that the nodes process and send their ancestor's information to detect bridges. The algorithm has two steps: forward and backward steps. In the forward step, the spanning BFS tree,

In the forward step of the algorithm, the sink node,

Obviously, the first common ancestor of all nodes is the sink, so that, in each Λ, the first element is always the sink. It is quite possible that the ancestors of two arbitrary nodes become identical, for example, in

Whenever a visited node,

Δ_{r}), where fm_{r} is a received forward message, whose source is not ρ(α). This can be defined as_{r≠ρ(α)}_{r})

In fact, if a node detects various cycles, it is sufficient to send the cycle identifier of the longest cycle to the parent, because it will cover other cycles. For example, sending

In the ABIDE algorithm, a leaf node in

The pseudocode of the ABIDE algorithm is given in Algorithm 1.

As previously mentioned, the node,

In this section, we will analyze the proof of correctness, message, time, space and computational complexities of the ABIDE algorithm. At the end of this chapter, we will give the theoretical bounds of the E-MILIC algorithm.

We know that the algorithm is started by the sink node of the BFS tree. Additionally, we know that each node sends exactly one

Let Λ_{[k]}(^{th}_{[k]}(α) = Λ_{[k]}(

Before presenting the next assertion, we define the edge set of a path between two node in a BFS tree in Definition 2.

_{α}(x) is the set of edges that create a path from α to x in τ

In _{T}_{Q}

_{α}(i) are non-bridges

According to Definition 1 and Assertion 2, there exists a cycle between _{α}_{α}

_{α}_{α}(x)

All elements in Λ(_{[i]}(_{[j]}(_{k}^{th}_{k}_{α}_{k}_{k}_{k}_{α}_{k}_{α}_{k}_{α}_{k}_{α}_{[j]} (_{α}_{[i]}(_{α}_{α}

The number of elements in Δ(

In the forward step of the ABIDE algorithm, each node divides its adjacent edges into three groups, which are: child link(s), parent link and cross link(s). A child link of node

In the ABIDE algorithm, each node exactly sends one

In this algorithm, all nodes send one

Due to the broadcast communication in wireless sensor networks, each node may multicast a message to its immediate neighbors. In the worst case, if we assume that each node has neighbor

_{2}(N)) bits

At the forward stage of ABIDE, each node multicasts its ancestor list to its neighbors. The size of the ancestor list can be at most _{2}(

The ABIDE algorithm starts when the sink multicasts a

Each node must store its ancestor list. In the worst case, a leaf node must hold a list with

The computational complexity of most functions that are presented for algorithm implementation are O(1), except ⋏ and

An analytical comparison between the TURAU algorithm, MILIC algorithm, E-MILIC algorithm and ABIDE algorithm is given in _{2}(_{2}(_{2}(^{2}_{2}(_{2}(_{2}(_{2}(^{2}E_{2}_{2}(_{2}(_{2}(_{2}(^{2}E_{2}(_{2}(_{2}(

In this section, we show extensive performance evaluations of the algorithms by giving testbed experiments and simulations.

To evaluate the performance of our algorithms, we firstly conduct experiments on our testbed. The proposed algorithms, E-MILIC and ABIDE, are implemented with their counterparts: MILIC and TURAU algorithms. The algorithms are implemented in nesC language for TinyOS platform [

Lastly, we measured the performance of the algorithms for a caterpillar-like topology. In

ABIDE performs best for random graphs, and E-MILIC performs best for caterpillar-like graphs. Although these experiments give ideas about the performance of algorithms and their efficiency, the size of the network is limited with 20 nodes. Besides, TinyOS does not provide an interface to measure energy consumption. In order to evaluate algorithms for large-scale networks, we use a simulator in the following section.

We implemented ABIDE, E-MILIC, MILIC and TURAU algorithms in a TOSSIMsimulator [

The sent byte counts of ABIDE and the sent byte counts of E-MILIC algorithms against various node counts and degrees are shown in

Comparisons between the implemented algorithms in terms of sent byte counts are given in _{2}(

Comparisons between algorithms in terms of received bytes are given in

Energy consumption measurements for the ABIDE and E-MILIC algorithms for networks with various sizes and degrees are shown in

Comparisons between the ABIDE, E-MILIC, MILIC and TURAU algorithms in terms of energy consumption are given in

The wall clock times of ABIDE and E-MILIC algorithms against various node counts and degrees are shown in _{2}(_{2}(

Lastly, we measured the sent byte counts, received byte counts, energy consumption and wall clock times on caterpillar-like graphs. The sent byte counts and the received byte counts of the algorithms against various node counts are shown in

Comparisons between the algorithms in terms of energy consumption and wall clock times are given in

In this section, we showed from the measurements taken that our analytical results given in Section 5 conform with the results taken from our testbed experiments and simulation results; E-MILIC performs better than the former MILIC algorithm. ABIDE has the best performance for random graphs and E-MILIC has the best performance for caterpillar-like graphs in terms of all metrics.

In this paper, we propose two BFS-based and single-phase bridge detection algorithms for WSNs located on challenged environments. Our first proposed algorithm, E-MILIC, is the extended version of the MILIC algorithm. In this algorithm, two rules are added to the MILIC algorithm to reduce the length of the messages. The sent message complexity of E-MILIC is Θ(_{2}(_{2}(_{2}(_{2}(

We gave the analysis for the proof of correctness and the message, time, space and computational complexities of the algorithms. Both algorithms are implemented in an experiment testbed and a simulation environment with their counterparts. Measurements conform with the theoretical analysis that the proposed algorithms outperform their counterparts, both practically and theoretically. By applying the proposed rules, E-MILIC has the best performance in terms of the received byte count, sent byte count, energy consumption and wall clock times, among other algorithms for caterpillar-like graphs. For random graphs, ABIDE has the best performance in terms of all metrics, since it uses smaller messages to detect bridges. The time savings of ABIDE are up to 28-times and energy savings up to 5.5-times for random graphs. Our proposed algorithms are significant contributions to the resource-efficient bridge detection problem in sensor networks operating in harsh environments.

The authors declare no conflict of interest.

Breadth-first search (BFS) example.

The graph model and the bridge problem.

MILIC and extended-MILIC (E-MILIC) examples.

Transmitted messages in ancestral knowledge-based bridge detection algorithm (ABIDE) algorithm.

The case in which node

(

The deployment of the sparse topology.

Snapshot of the monitoring program for the sparse topology.

The deployment of the dense topology.

Snapshot of the monitoring program for the dense topology.

Snapshot of the monitoring program and deployment for the caterpillar topology. (

Sent bytes of ABIDE and E-MILIC algorithms against node count and degree. (

Comparisons between algorithms in terms of sent bytes. (

Received bytes of ABIDE and E-MILIC algorithms against node count and degree. (

Comparisons between algorithms in terms of received bytes. (

Energy consumption of the ABIDE and E-MILIC algorithms against node count and degree. (

Comparisons between algorithms in terms of energy consumption. (

Wall clock times of ABIDE and E-MILIC algorithms against node count and degree. (

Comparisons between algorithms in terms of wall clock times. (

Comparisons between algorithms in terms of sent byte counts and received byte counts for caterpillar-like graphs. (

Comparisons between algorithms in terms of energy consumption and wall clock times for caterpillar-like graphs. (

Analytical comparison of algorithms.

Sent Messages | Θ( |
Θ( |
Θ( |
Θ( |

Received Messages | O( |
Θ( |
Θ( |
Θ( |

Message Size | O(log_{2}( |
O(ℰ log_{2}( |
O(Ψ log_{2}( |
O(_{2}( |

Transmitted Byte Count | O(^{2}_{2}( |
O(_{2}( |
O(_{2}( |
O(_{2}( |

Time | O( |
O( |
O( |
O( |

Space (per node) | O( |
O( |
O( |
O( |

Computational (per node) | O(δ) | O( |
O( |
O( |

Experiment Testbed Parameters.

Platform | TinyOS |

Transceiver | 2.4 GHz, IEEE 802.15.4 compliant |

Transmission Rate | 250 kbps |

Transmission Power | 3 dbm |

Memory | 128 kB flash, 8 kB RAM |

Node Count | 20 |

Node Degree | 3 and 7 |

Performance of algorithms in sparse topology.

MILIC | 701 | 2,189 | 41.797 |

E-MILIC | 581 | 1,778 | 41.798 |

TURAU | 990 | 2,739 | 256.63 |

ABIDE | 546 | 1,630 | 41.793 |

Performance of algorithms in dense topology.

MILIC | 816 | 6,209 | 38.361 |

E-MILIC | 579 | 4,250 | 37.967 |

TURAU | 1859 | 11,986 | 514.418 |

ABIDE | 540 | 3,853 | 37.878 |

Performance of algorithms in caterpillar-like topology.

MILIC | 1,059 | 2,539 | 73.32 |

E-MILIC | 844 | 1,891 | 73.04 |

TURAU | 936 | 2,057 | 178.50 |

ABIDE | 874 | 2,111 | 73.05 |

Simulation parameters.

Topology | Random and Caterpillar-like |

Sink Position | Randomly Placed in the Area |

Sensor Node Count | 50–250 |

MAC | TDMA |

Node Degrees | 3, 5 and 7 |