Layer-Based Data Aggregation and Performance Analysis in Wireless Sensor Networks

Abstract

Due to the similarity and correlation among sensed data in wireless sensor network, it is an important way to reduce the number of packets transmitted with data aggregation technology so as to prolong the network lifetime. However, data aggregation is still a challenging issue since quality-of-service, such as end-to-end delay, is generally considered as a severe criterion required in many applications. We focus on the minimum-latency data aggregation problem and proposed a new efficient scheme for it. The basic idea is that we first build an aggregation tree by ordering nodes into layers, and then we proposed a scheduling algorithm on the basis of the aggregation tree to determine the transmission time slots for all nodes in the network with collision avoiding. We have proved that the upper bound for data aggregation with our proposed scheme is bounded by (15𝑅+Δ−15) for wireless sensor networks in two-dimensional space. Extensive simulation results have demonstrated that the proposed scheme has better practical performance compared with related works.

1. Introduction

Recent advances in microelectronics, low-power embedded modulators, and wireless networking have led to the emergence of the wireless sensor network [1]. All these sensor nodes are self-organized and cooperated in similar way as the ad hoc network. Such characteristics make it possible to deploy sensor network to obtain information about the covered area in an inaccessible location. It is expected that sensor networks open new vistas for many potential applications. Data aggregation [2] is generally considered as an important method in the sensor networks by aggregating and forwarding the raw data which is originated from multiple sources. In this way, the data collection from all nodes in the network is in fact done with the aggregation tree, in which the sink serves as the root and the nonleaf nodes will aggregate all raw data from their children and forward the result to their parents. This helps to minimize the traffic in the network, reduce the energy consumption, and increase the network lifetime accordingly.

Quality-of-Service (QoS), such as end-to-end delay, is generally considered as a severe criterion required in many applications. When data is collected by local nodes in the network, the sensed data is generally required to reach the root within a given time delay. To provide end-to-end delay guarantee is pioneering and challenging with the data aggregation problem in wireless sensor networks due to two separate observations. Firstly, the nonleaf nodes on the aggregation tree cannot forward to their parents until they have gathered all data from their descendants, which is possible to increase end-to-end delay especially in case that the aggregation tree is rather high. Secondly, due to the broadcasting characteristic of wireless communication, the exposed/hidden problem is the main factor which not only reduces capacity of the wireless network but also increases one-hop transmission delay. A careful scheduling algorithm concerned with the transmission time slots for all nodes in the network is rather necessary and important for data aggregation problem aiming at providing minimum end-to-end delay while utilizing the data aggregation scheme and eliminating the above collision problem.

The minimum-latency data aggregation problem in two-dimensional wireless sensor networks is well studied and proved to be NP hard [3]. Chen et al. had designed a Δ—approximation algorithm for this problem, where Δ denotes the maximum node degree in the network [3]. Huang et al. introduced a constant approximation algorithm with the latency bounded by (23𝑅+Δ−18) [4] by building the aggregation tree with the help of maximum independent set (MIS), where 𝑅 denotes the network radius. Wang et al. improved the idea of Huang and proposed a scheduling algorithm with the latency bound as (15𝑅+Δ−15) [5]. In this work, we have proved that the theoretic bound for data aggregation with our proposed scheme is also (15𝑅+Δ−15) for wireless sensor networks in two-dimensional space However, the proposed scheme has better performance compared with the previously mentioned related works [4, 5] especially in dense networks.

With the rapid development of applications in three-dimensional networks, such as underwater acoustic monitoring [6, 7], underground tunnels [8], space sensor network [9], and aerosphere pollution monitoring [10], it is interesting and challenging to study the minimum-latency data aggregation problem with three-dimensional wireless sensor networks too. Most of the current works in three-dimensional sensor networks aimed at providing connectivity, coverage, or location solutions [11]. In this work, we have also extended our efficient scheme to the case in three-dimensional network. We also demonstrated its practical performance compared with works originated from the two-dimensional networks.

The rest of this paper is organized as follows. we introduce the related works in Section 2 and present preliminary in Section 3. Section 4 introduces a new minimum-latency data aggregation (MDA) scheme. Section 5 has analyzed the correctness and performance of MDA scheme. In Sections 6 and 7, we present simulation results and conclusion.

2. Related Works

Data aggregation is considered as an important solution for the wireless sensor networks. The main goal of data-aggregation algorithms is to gather and aggregate data in an energy-efficient manner so that network lifetime is enhanced [2]. Krishnamachari et al. illustrated the impact of data aggregation by comparing its performance with traditional end-to-end routing schemes [12]. The optimal data aggregation problem was proven to be NP hard, and heuristic algorithms were proposed to gather data from multiple sources to the sink.

The process of aggregating data could reduce the transmission of data in the network, hence to reduce energy consumption. Most previous works have mainly focused on energy-saving issue and it has been investigated in [12, 13]. Wireless sensor networks often use tree topologies. This is not only because tree’s structure is suitable for a network with one sink node, but also their simplicity is very attractive when network resources are limited. There are some papers that build a data aggregation tree to control the delay [3–5, 14–22].

Broadcast and data aggregation are the most fundamental and useful applications in wireless sensor networks. Data aggregation is sometimes referred to converge cast. Annamalai et al. designed a heuristic algorithm [14] which constructs a tree for both broadcast and converge cast. Simulation results show that latency of this algorithm is very high, and this algorithm has high requirements for hardware of wireless sensor. Upadhyayula et al. [15] designed a heuristic algorithm for converge cast alone and purposed to reduce the latency and energy consumption. This algorithm constructs a tree using a greedy approach where new nodes are added to the tree so that weight on the branch to which it is added is less.

Chen et al. first proved that the minimum data aggregation time problem is NP hard and designed a Δ—approximation algorithm for this problem [3], where Δ denotes the maximum node degree in the network. This algorithm is centralized and has a high latency, which makes this algorithm impractical. In paper [16], the authors focused on the latency performance of data aggregation and considered applications for which the total delay of the sensed data is important instead of the maximum delay. Wan et al. [17] designed a distributed algorithm to construct a dominating tree. The algorithm is to construct a maximal independent set and then select connected nodes to construct a dominating tree. Wan et al. [18] constructed three aggregation schedules of latency (15𝑅+Δ−4), (2𝑅+𝑂(log𝑅)+Δ), and ((1+𝑂(log𝑅/√³𝑅))𝑅+Δ).

Huang et al. proposed a scheduling algorithm with the latency bound (23𝑅+Δ−18) [4], where 𝑅 is the network radius and Δ is the maximum node degree. However, this algorithm has obvious errors in the first-fit algorithm so that the schedules are not collision-free in many cases. We will modify this algorithm and compare with it in simulation. Yu et al. proposed a distributed scheduling algorithm, named DAS, the latency bound (24𝐷+6Δ+16) [19], where 𝐷 is the network diameter. Xu et al. [20, 21] constructed a data aggregation tree using an existing approach with a small modification. Then, they presented an efficiently centralized algorithm and a distributed scheduling implementation. They proved that the latency bound is at most (16𝑅+Δ−14). They focused on data aggregation scheduling problem and proved that the lower latency bound under any interference model is max{log𝑛,𝑅} in paper [20], where 𝑛 is the network size. Wang et al. designed a scheduling algorithm, Peony-tree-based data aggregation (PDA), and proved the latency bound is (15𝑅+Δ−15) [5].

Some works [22–27] concerned with the delay control. Yuan et al. designed a Multi-level Fusion Synchronization Protocol to achieve the desired trade-offs between the credibility and the aggregation latency [22]. Some works have investigated the energy latency tradeoff [23–25]. Given a deadline, they minimized the amount of missed data [23], minimized overall energy dissipation of sensor nodes [24], or minimized the maximum energy consumption [25]. Many applications of sensor networks require real-time data aggregation. Chipara et al. proposed dynamic conflict-free query scheduling [26], a novel scheduling technology based on TDMA, which is a natural choice for real-time sensor network applications.

Event-triggered data aggregation refers to no node need to send data until a relevant, unpredicted event occurs in the network. A distributed TDMA scheduling protocol for data aggregation is proposed in paper [27], which is called DATP. The sensor nodes send dummy packets in order to determine whether they are interfered with each other, if not, they are assigned the same time slot.

In this paper, we aimed at the minimum latency data aggregation problem with the data aggregation tree. We designed a novel approach to build the aggregation tree, which selects the maximum independent set in even layers. We have proved that the upper bound for data aggregation with our proposed scheme is bounded by (15𝑅+Δ−15) for wireless sensor networks in two-dimensional space. We also simulated the case in three-dimensional wireless sensor networks. The results have demonstrated that the proposed scheme has better performance compared with related works.

3. Preliminary

In this section, we will describe the system model, related terms and give a detailed problem definition.

3.1. Network Model

We consider a wireless sensor network with a sink node 𝑠 and 𝑁 sensor nodes. Each node is equipped with a wireless radio by which a node can receive/transmit data packet. Assume that all nodes have the same transmission range 𝑟_𝑐; the topology of wireless sensor network can be represented as an undirected graph 𝐺=(𝑉,𝐸), where 𝑉 is the set of all nodes and 𝐸⊆𝑉² is the set of undirected links. 𝐸 is defined as 𝐸={(𝑢,𝑣)∈𝑉²∣𝑑_𝑢𝑣≤𝑟_𝑐}, in which 𝑑_𝑢𝑣 is the Euclidean distance between node 𝑢 and 𝑣, 𝑟_𝑐 is the transmission radius.

3.2. Interference Model

Here, we use the symbol time slot to denote the period that one node is used to send or receive data packet. The radio generally works in half-duplex mode and thus one node cannot transmit and receive packet simultaneously due to broadcast characteristic of wireless communication, which is generally named as the hidden/exposed terminal problems. Here, we assume that the interference range is identical to the transmission range [28].

3.3. Related Terms

3.3.1. Data Aggregation

We assume that the network is designed with simple data aggregation function, such as max, min, and average. In this way, the final result after aggregation generally has the same property as the incoming originally data, such as packet length and prior. And all these results can be sent or received during one single time slot operation.

3.3.2. Independent Set (IS)

Given an undirected graph 𝐺=(𝑉,𝐸) and 𝐼⊆𝑉, 𝐼 is called an independent set if any two nodes in 𝐼 are not adjacent. It is obvious that two nodes 𝑢,𝑣∈IS denotes that both 𝑢 and 𝑣 are not within the transmission range of each other. A maximum independent set is used to represent the independent set with maximum number of nodes for a given graph 𝐺.

3.3.3. Connected Dominating Set (CDS)

Given an undirected graph 𝐺=(𝑉,𝐸) and 𝐷⊆𝑉, 𝐷 is called a dominating set if 𝐷 induces a connected subgraph of 𝐺 and every node in 𝐺 either belongs to 𝐷 or is adjacent to a node in 𝐷.

3.3.4. Concurrent Set (CS)

The concurrent set denotes a set of nodes, in which each node can transmit without conflict with the transmission of other nodes.

3.4. Data Aggregation Scheduling

With the terms mentioned previously, the data aggregation scheduling problem in the wireless sensor networks is defined to find a sequence of concurrent set 𝑆₁,𝑆₂,…,𝑆_𝑇 so that the latency is minimized, where ⋃^𝑇_𝑖=1𝑆_𝑖=𝑉−{𝑠}. For any 𝑖≠𝑗, 𝑆_𝑖∩𝑆_𝑗=∅. This problem has been proved to be NP hard [14].

4. Proposed Scheme

In this section, we give the detailed description of our proposed scheme for the minimum-latency data aggregation (MDA) problem. The basic idea is that we firstly construct a data aggregation tree by dividing the nodes into layers and then design a scheduling scheme in which each node is assigned with one time slot for transmission while collision is avoided. The notations used in the algorithm are summarized in Notations.

4.1. Data Aggregation Tree Construction

4.1.1. Initialization

For a given network graph, initially we can divide all nodes into 𝑅 layers with the breadth-first searching algorithm which starts from the sink. The sink node 𝑠 is in the layer 0. 𝐿_𝑖 denotes the set of the nodes that are 𝑖-hop away from the sink 𝑠. Here we use 𝐿_𝑖 to denote the set of nodes which are 𝑖-hop away from the sink 𝑠. The sink node 𝑠 is in the layer 0.

4.1.2. Independent Set Construction for Each Layer

Here, we use the independent set to construct the data aggregation tree. The idea is described as follows. Initially, we add the sink node 𝑠 to the independent set in layer 0. Obviously, there is only node in layer 0, and no conflict occurs. Let 𝐷₀={𝑠}, in which 𝐷₀ denotes the independent set of layer 0. Generally, we select independent set 𝐷_𝑖 in layer 𝑖 if 𝑖 is an even, and the process starts from layer 0. In layer 𝑖, we check each node in sequence to find whether it conflicts with nodes in set 𝐷_𝑗(𝑗=0,2,…,𝑖−2). If not, the node is added to 𝐷_𝑖; otherwise, we will move it to layer (𝑖+1). The corresponding pseudocode is given in Algorithm 1. After the independent sets 𝐷_𝑖(𝑖=0,2,4,…) have been selected, we can obtain the total independent set as 𝐷=∪𝐷_𝑖(𝑖=0,2,4,…).

Input: Graph 𝐺, 𝐿1, 𝐿2, …, 𝐿𝑅, layer number 𝑖; Output: Maximum Independent set 𝐷𝑖, 𝐷, and 𝐿𝑖. (1) 𝐷𝑖=∅; (2) for each node 𝑢∈𝐿𝑖; (3)  if 𝑢∉{𝑥∣(𝑥,𝑣)∈𝐸,𝑣∈𝐷}, then (4)   𝐷𝑖=𝐷𝑖∪{𝑢}; (5)  else 𝐿𝑖=𝐿𝑖−{𝑢}; 𝐿𝑖+1=𝐿𝑖+1∪{𝑢}; (6)  end if (7) end for

Algorithm 1 

Layer independent set construction.

4.1.3. Construct the Aggregation Tree

The basic idea is that we construct a connected dominating set as the aggregation tree based on the previous independent set. Obviously, sink node 𝑠 in layer 0 is the root of data aggregation tree. We add 𝑠 to 𝐷₀. We find that 𝐷₂ with Algorithm 1 and the nonindependent nodes are moved to layer 3. Each node 𝑢 in layer 𝑖, 𝑖>2 can check its neighbors in upper layer and adds them to the set 𝑢𝑝𝑝𝑒𝑟(𝑢). Node 𝑢 is moved to layer (𝑖+1) in case that |𝑢𝑝𝑝𝑒𝑟(𝑢)|=0. In each even layer, we build the layer maximum independent set and move other nodes down to the next layer. The next step is to build the children list for each node. Firstly, node 𝑢 in layer (𝑖−1) checks the neighbors in layer 𝑖 and adds the neighbor to the set 𝑙𝑜𝑤𝑒𝑟(𝑢). Repeat the previous process and the data aggregation tree can be built finally.

From the process of aggregation tree construction, we can clearly see that the children of nodes in IS are either leaf nodes or connecting nodes, while the children of the connecting node are nodes in IS. The pseudocode of the data aggregation tree construction process is presented in Algorithm 2.

Input: Graph 𝐺=(𝑉,𝐸); Output: Data aggregation tree 𝑇=(𝑉′,𝐸′), the dominated set 𝐷𝑖,𝑖=2,4,…, the set of connective nodes 𝐶𝑖, 𝑖=1,3,… (1) 𝑉′=𝑉,   𝐸′=∅; (2) Breadth first search graph 𝐺 with the root as 𝑠; (3) Divide all node of 𝑉′ into layers 𝐿0,𝐿1,…,𝐿𝑅; (4) 𝐷1={𝑠}; (5) for each node 𝑥∈𝐿1, par(𝑥) = 𝑠; 𝐸′=𝐸′∪{(𝑥,𝑠)}; (6) for 𝑖 = 2 to 𝑅 do (7)  calculate upper(𝑢), 𝑢∈𝐿𝑖 (8)  if 𝑢𝑝𝑝𝑒𝑟(𝑢)=0 and 𝑢∈𝐿𝑖, then 𝐿𝑖=𝐿𝑖/𝑢, 𝐿𝑖+1=𝐿𝑖+1∪{𝑢}; (9)  if 𝑖 is even, construct the layer independent set 𝐷𝑖, and sequence the lower(𝑦) with decreasing order of the set size as      𝑦1,𝑦2,…,𝑦∈𝐿𝑖−1, and the set size as 𝑦1,𝑦2,…,𝑦∈𝐿𝑖−1; (10)  𝑗=1; (11)  while 𝐿𝑖 != empty do (12)   for each node 𝑢∈ lower(𝑦𝑗) (13)     par(𝑢) = 𝑦𝑗, 𝐸′=𝐸′∪𝑢,𝑦𝑗, 𝐿𝑖=𝐿𝑖/𝑢; (14)    if 𝑖 is even then 𝐶𝑖=𝐶𝑖∪𝑦𝑗; (15)   end for (16)   𝑗=𝑗+1; (17)  end while (18) end for

Algorithm 2 

Data aggregation tree construction.

4.2. Data Aggregation Scheduling

Nodes are scheduled according to their roles on the tree. We firstly schedule leaf nodes and then the nodes in connected dominating set.

4.2.1. Aggregation of Leaf Nodes

In this process, we are to assign time slots for each leaf nodes on the data aggregation tree, and the leaf nodes can send data packet to their parent during the assigned time slots. In order to avoid interference and minimize the latency at this phase, leaf nodes are divided into 𝑘 concurrent sets and nodes in each set can transmit data simultaneously with interference avoided, which is denoted as 𝑆₁,𝑆₂,…,𝑆_𝑘, where 𝑘 is the number of the concurrent sets. Nodes in 𝑆_𝑖 are scheduled to transmit data in the 𝑖th time slot. In the following, we will introduce that the process leaf nodes are separated into different concurrent sets. Firstly, there is no concurrent sets and 𝑘=0. Then, we choose a node 𝑥 from 𝐿_𝑅 and try to insert 𝑥 inserted into one concurrent set. Obviously, we need to create a new set and let 𝑘=1, and we can insert 𝑥 into 𝑆₁. Then, we pick another node 𝑦 in layer 𝑅 and determine whether it conflicts with any node in current concurrent set 𝑆_𝑖(𝑖=1,2,…,𝑘) or not. If 𝑆_𝑖 is found, 𝑦 is inserted into it; otherwise, a new concurrent set is necessary, and we have 𝑘 increased by one and insert 𝑦 into the new set. This process continues until all leaf nodes are assigned to a set.

The pseudocode of concurrent set construction is presented in Algorithm 3.

Input: Data aggregation tree 𝑇, 𝐺; Output: Concurrent Set 𝑆1, 𝑆2, …, 𝑆𝑘. (1) initialize 𝑆𝑖=∅, 𝑖 = 0, 1, …; (2) for each layer 𝑖 from 𝑅 to 1; (3)  select one leaf node 𝑢 from layer 𝑖; (4)  𝑗=1; (5)  if 𝑆𝑗=∅, then 𝑆𝑗=𝑆𝑘∪{𝑢}, go to step 3; (6)  for each 𝑣∈𝑆𝑗, (7)   if 𝑢,𝑝𝑎𝑟(𝑣)∉𝐸 and par(𝑢) ≠ par(𝑣), then 𝑆𝑗=𝑆𝑗∪{𝑢}, break; (8)  end for (9)  if 𝑢∉𝑆𝑗, then 𝑗 = 𝑗+ 1, go to step 5; (10) end for

Algorithm 3 

Concurrent set construction.

4.2.2. Aggregation of Connected Dominating Nodes

When all leaf nodes are assigned time slots to transmit data packet to their parents, we are to schedule the time slots for nonleaf nodes on the aggregation tree. Starting from the bottom of the tree, the algorithm assigns the sending time to all connected dominating nodes. According to the tree construction process, the dominating nodes are located in even layers and connecting nodes in odd layer. Hence, the algorithm will construct concurrent set in every layer. That is, the dominating nodes in layer 𝑑 are divided into 𝑚_𝑑 sets if 𝑑 is even. Similarly, the connected nodes in odd layer 𝑐 are also divided into 𝑛_𝑐 sets. Due to the fact that the latency of the aggregation of leaf nodes is 𝑘, we schedule all connected dominating nodes from the tree bottom to the root. Generally, for each node 𝑢∈𝐿_𝑖, if 𝑢 is assigned to the 𝑗th set in layer 𝑖, the scheduled time slot for 𝑢 is (𝑘+𝑗+∑^𝑖−2_𝑑=𝐻𝑚_𝑑+∑^𝑖−1_𝑐=𝐻𝑛_𝑐) in case that 𝑖 is even, where 𝐻 denotes the depth of the data aggregation tree. And the result is (𝑘+𝑗+∑^𝑖−2_𝑐=𝐻𝑛_𝑐+∑^𝑖−1_𝑑=𝐻𝑚_𝑑) in case that 𝑖 is odd.

4.2.3. Data Aggregation Scheduling Algorithm

After the previous two steps, the sending time of all nodes in the network are assigned. The pseudocode of the data aggregation scheduling is presented in Algorithm 4. As we can observe from the algorithm details, the time of the sink 𝑠 received is latency=𝑘+∑^𝑖=1_𝑖=𝐻(𝑚_𝑖+𝑛_𝑖)+1. Particularly, we have 𝑛_𝑖=0 in case that mod(𝑖,2)=1, and otherwise 𝑚_𝑖=0.

Input: Data aggregation tree 𝑇= (𝑉′, 𝐸′), depth of the data aggregation tree 𝐻; Output: Sending time 𝑡(𝑢) for each node 𝑢, and latency. (1) for each node 𝑢∉𝐶𝐷𝑆, run Algorithm 3 to construct the concurrent set 𝑆1, 𝑆2, …, 𝑆𝑘; (2) if 𝑢∈𝑆𝑗 then 𝑡(𝑢) = 𝑗; (3) 𝑙𝑎𝑡𝑒𝑛𝑐𝑦=𝑘; (4) for 𝑖=𝐻 to 1 (5)  if 𝑖 is even, then (6)   all nodes 𝑢∈𝐿𝑖, construct the concurrent set 𝑆𝐷1, 𝑆𝐷2, …, 𝑆𝐷𝑚; (7)   if 𝑢∈𝑆𝐷𝑗, then 𝑡(𝑢)=𝑙𝑎𝑡𝑒𝑛𝑐𝑦+𝑗, 𝑙𝑎𝑡𝑒𝑛𝑐𝑦=𝑙𝑎𝑡𝑒𝑛𝑐𝑦+𝑚; (8)  else (9)   all nodes 𝑢∈𝐿𝑖, construct the concurrent set 𝑆𝐶1, 𝑆𝐶2, …, 𝑆𝐶𝑛; (10)   if 𝑣∈𝑆𝐶𝑗, then 𝑡(𝑣) = latency + 𝑗, latency = latency + 𝑛; (11)  end if (12) end for

Algorithm 4 

Minimum-latency data aggregation.

4.3. Example Demonstration

In this section, we use an example to demonstrate the process of data aggregation tree construction in detail. Figure 1(a) shows the topology of a random network with 20 nodes, in which each node is represented by a cycle, and the node identification is marked below the cycle. There is a link/edge between two nodes if they are within the transmission range of each other. Here, we assume that the sink node; that is, 𝑠 is located at the center of the network.

(a)   Network topology

(b) Former three layers

(c) Former four layers

(d) Data aggregation tree

Figure 1 

An example to demonstrate the process of MDA algorithm.

Initially, we can organize the network topology into layers, Algorithm 1, and nodes in each layer can be observed in Figure 1(b). For example, there are only one node, that is, 𝑠, in layer 0, and five nodes, that is, 1, 2, 3, 4, and 5 in layer 2. There are totally 5 layers in this example with the network radius as 4. It is obvious that the layer number for each node denotes the distance from the node to the sink.

The second process is to build the MIS for each even layer. The process is carried out in increasing order of the layers. Firstly, there is only one node in layer 0, and the node 𝑠 is added to the independent set for layer 0, that is, 𝐷₀={𝑠}, which is marked as black in Figure 1(b). Note that nodes in layer 1 are one hop away from node 𝑠, and thus they are not possible to be included into the IS, and they are added into the aggregation tree with their parent as 𝑠. The next step is to select IS for layer 2. With Algorithm 2, we can obtain 𝐷₂={6,8,9,11,12,13} which is also marked black in the figure; 7, 10, and 14 are dependent nodes and they are moved down to layer 3 (the process is simulated via dash line in Figure 1; then we can select parent nodes form nodes in 𝐷₂, which are marked as gray in Figure 1(b). In this way, the tree construction process for previous three layers is finished.

Now, consider nodes in layer 3. Note that 7, 10, and 14 are moved from previous layer to layer 3, and it is possible that some nodes in layer 3 cannot find their parents in upper layer, that is, layer 2. With Algorithm 2, we calculate the set upper for each node in layer 3, and we have |𝑢𝑝𝑝𝑒𝑟(17)|=0, |𝑢𝑝𝑝𝑒𝑟(22)|=0, |𝑢𝑝𝑝𝑒𝑟(23)|=0. As we can observe from Figure 1(b), 17 can connect to sink 𝑠 via 7; however, 17 cannot find proper parent in layer 2 since 7 is moved to layer 3. The case is similar to 22 and 23, and all these three nodes are moved down to layer 4, which is marked with dash line in Figure 1(b). After these processes are done, we can select parent for nodes in layer 3 and add them into the tree.

There are five nodes, that is, 17, 22, 23, 24, and 25 in layer 4. We firstly check whether they can find their parents in upper layers before building the independent set. It can be seen that set upper is not empty for all nodes in layer 4; secondarily, we build the MIS for layer 4, and 𝐷₄={17,22,24,25} which is marked black; 23 is moved down to layer 5; finally, we choose parent for nodes in layer 4, and 7, 14, 19, and 20 are selected accordingly and included in set 𝐶₃ which is marked gray. In this way, the tree construction for former four layers is finished which is illustrated in Figure 1(c).

Note that there is only 23 in layer 5 with parent 22 in layer 4, and it can be inserted into the tree directly. So far, all nodes in the network are included in the aggregation tree with the height as 5. The final result is demonstrated in Figure 1(d).

The last process is to schedule the aggregation process on the tree with Algorithms 3 and 4. Following the idea of our scheduling scheme, the leaf nodes on the tree are scheduled firstly. It starts from the final layer, and all leaf nodes are scheduled into collision-free time slots. As we can see from Figures 1(a) and 1(d), these leaf nodes can be divided into two separate sets, {23,15,10,21,5} and {16,18}. Nodes in the first set are assigned to the first time slot, and nodes in the second set are assigned to second time slot. In this way, we use only 2 time slots to ensure that all leaf nodes can send to their parents while collision is avoided. Then, we are to schedule the nonleaf nodes on the tree. It can be seen that nodes in 𝐷₄={17,24,22,25} can be scheduled with one time slot, that is, slot 3. The process is carried out in the same way until all nodes are scheduled. And we can see that in time slot 11 the sink node can collect all data from all nodes in the network.

5. Performance Analysis

Lemma 1. Given the original network radius R, the depth of the data aggregation tree by our MDA algorithm does not exceed (2𝑅−1).

Proof. As shown in the process of the tree construction, nodes in layer 0 and layer 1 are not moved down.
In layer 2, we select the layer maximum independent set 𝐷₂ and move the nonindependent nodes to layer 3. 𝐿^′₂ denotes the set of the nodes which moved from layer 2 to layer 3. Since each node in 𝐿^′₂ is adjacent to at least one node in 𝐷₂, it finds its parent in 𝐷₂. Layer 3 is the base for nodes in original layer 2.
In layer 3, some nodes may not find their neighbors in 𝐷₂. Their neighbors have been moved to the set 𝐿^′₂ in the same layer with them. Nodes in layer 3 cannot find their neighbors as their parent in upper layer, which should be moved to layer 4. 𝐿^′₃ denotes the set of nodes which move from layer 3 to layer 4. Hence, each node in 𝐿^′₃ can find its neighbor as its parent in 𝐿^′₂. We should select the layer maximum independent set 𝐷₄ in layer 4, so some nodes in 𝐿^′₃ may be as the nonindependent nodes moved to layer 5. 𝐿₃^′′ denotes the set of nodes which move from layer 3 to layer 5. Since each node in 𝐿₃^′′ is adjacent to one node in 𝐷₄ at least, it finds its parent in 𝐷₄. Layer 5 is the lowest layer the nodes in original layer 3 can be moved.
In layer 4, because there may be some nodes whose neighbors are all in the set 𝐿₃^′′, they should be moved to layer 6 with the nodes in 𝐿₃^′′ moving to layer 5. 𝐿^′₄ denotes the set of nodes which moves from layer 4 to layer 6. We should select the layer maximum independent set 𝐷₆ in layer 6, so some nodes in 𝐿^′₄ may be as the nonindependent nodes moved to layer 7. 𝐿₄^′′ denotes the set of nodes which moves from layer 4 to layer 7. Because each node in 𝐿₄^′′ is adjacent to at least one node in 𝐷₆, it finds its parent in 𝐷₆. Layer 7 is the base layer that nodes in original layer 4 can be moved.
After analyzing the nodes moving cases in the four layers, we can get the number of layers each node is displaced from its original position depending on its neighbor in upper layer. When a node was moved to an even layer, the layer independent set should be selected in this even layer, so the node may be as a nonindependent node moved to the next layer. Then, the node in the odd layer can find its neighbor in the maximum independent set; the node will no longer be moved. In this way, it would move into its final position in an odd layer. Therefore, in the worst case, a node’s moving layer is the moving layer of its neighbor in upper layer plus 2. For a node 𝑢 in layer 𝑘, if all its neighbors in layer (𝑘−1) have been moved to layer (2(𝑘−1)−1), at worst, they have to be moved to layer (2𝑘−3). We can infer that the final layer which 𝑢 moved to is equal to the sum of the layer (2𝑘−3) which neighbors of 𝑢 moved to plus 2, that is, layer 2(𝑘−1). Given the original network radius 𝑅, in the worst case, the nodes in layer 𝑅 may be moved to layer (2𝑅−1).

Lemma 2. The latency of aggregation from leaf nodes is Δ−1.

Proof. Given the maximum node degree Δ, the latency of aggregation from leaf nodes is (Δ−1) [4, 5].

Theorem 3. The latency bound of the connected dominating nodes aggregation is 15𝑅−14.

Proof. Now, we will estimate the data aggregation of connected dominating nodes. According to Lemma 1, the depth of data aggregation tree is at most (2𝑅−1). In the tree, the number of layers of the dominative nodes except the sink 𝑠 is (𝑅−1). The number of layers of the connective nodes is (𝑅−1), because connective nodes cannot be in layer 𝑅. According to [4, 5], the latency bound of data aggregation from dominative nodes to connective nodes is 4, and the latency bound of data aggregation from connective nodes to dominative nodes is 11. Particulary, the sink node 𝑠 is the root of the tree. Thus, connective nodes in layer 1 are its children and it takes at most 12 time slots to finish the transmission.
Based on the previous analysis, the latency bound of the connected dominating nodes aggregation is 4(𝑅−1)+11(𝑅−2)+12=15𝑅−14.

Theorem 4. The total latency bound of data aggregation is 15𝑅+Δ−15.

Proof. According to the MDA, the total latency is the sum of latencies of leaf nodes aggregation and connected dominating nodes aggregation. The total latency bound of data aggregation is (Δ−1)+(15𝑅−14)=15𝑅+Δ−15.

Theorem 5. The time complexity with the MDA algorithm is 𝑂(𝑅𝑛²+𝑛Δ), in which n is the node number, 𝑅 is the network radius, and Δ is the maximum node degree.

Proof. Initially, we use the breadth search algorithm to construct the layer structure for a given network, and the complexity with Algorithm 1 is 𝑂(𝑛²).
During the tree construction process of Algorithm 2, we check each node whether they can find their parent, and the time complexity is 𝑂(𝑛²). Secondarily, we select independent set for even layers with the rest nodes excluded in the IS moved down, and the time complexity for this operation is 𝑂(𝑛). Finally, each node will select its parent and be added into the aggregation tree; the time complexity is 𝑂(𝑛²). Assume the network radius as 𝑅, the time complexity for the tree construction is 𝑂(𝑅𝑛²).
During the scheduling process, we first schedule the leaf nodes and then nonleaf nodes. Note that we schedule these nodes from layers far away from the sink, and the collision conflict occurs only in case that the transmission is carried out simultaneously by neighbors of its parent, and thus the scheduling time complexity is 𝑂(𝑛Δ).
In this way, the time complexity with our MDA algorithm is 𝑂(𝑛²)+𝑂(𝑛²)+𝑂(𝑅𝑛²)+𝑂(𝑛Δ)=𝑂(𝑅𝑛²).
Based on the previous analysis, we could know that the total latency bound of data aggregation obtained by MDA is the same as [5] in two-dimensional space, which is the best result we have ever known. Besides, our proposed algorithm could achieve better performance by reducing the height of the aggregation tree without increasing the time complexity. The later experimental results also validate the efficiency of the method.

6. Simulation Results

Our simulation is accomplished by generating a random wireless sensor network in MATLAB software. We evaluate the performance of the proposed MDA and related in two- and three-dimensional networks.

6.1. Simulation Results in Two-Dimensional Networks

In this simulation part, the network topology is randomly generated by placing nodes in a fixed region of size 100m×100m. We compare our MDA with the algorithm proposed by Huang et al. in [15] (denoted as HUANG in short in the figures) and PDA proposed by Wang in [19].

6.1.1. Impact of Network Size

The first group of simulations estimates the impact of network size. The transmission range of each sensor is fixed to 10 m. The aggregation latency is measured when the network size varies from 300 to 800. We compare its average performance by building 11 different network topologies.

Figure 2(a) compares the network radius after constructing the data aggregation tree by using these algorithms. As mentioned in the previous section, the worst case for the tree height with the MDA algorithm is 2𝑅−1. However, it can be seen that the upper bound is seldom met in the simulations. This is because nodes are not always moved during the tree construction process with our MDA algorithm, which leads to the reduction of tree height. However, the results with HUANG and PDA are almost always 2𝑅−1. It is seen that the network radius of HUANG and PDA is approximately twice as much as MDA. Our algorithm shows great improvement on the tree height as we can observe from Figure 2(a).

(a) The network radius

(b) Aggregation latency of leaf nodes

(c) Aggregation latency of nodes in CDS

(d) Total aggregation latency

Figure 2 

Simulation results in two-dimensional networks with different network sizes.

Figure 2(b) shows the simulation result of aggregation latency of leaf nodes. Due to the fact that independent set is selected only in even layers with our MDA, the number of connected dominating nodes is less than the other two algorithms, and thus the number of leaf nodes is larger than the other two algorithms. So, it is reasonable that, in some case, the delay for leaf nodes scheduling costs more time slots with our MDA algorithm, which can be seen in case that network size is 850.

Figure 2(c) compares the aggregation latency of nodes in the connected dominating sets. As mentioned previously, the MDA algorithm only selects dominating nodes in even layers, and thus it leads to less number of dominating nodes compared with the other two algorithms. And accordingly, the required number of time slots for aggregation is generally smaller.

The total latency for the data aggregation process is calculated with the previous two parts. As we can see from Figure 2(d), our MDA algorithm runs better than HUANG and PDA, which is more significant in case that the network size is very large.

6.1.2. Impact of Communication Range

The second group of simulations estimates the impact of communication range. The network size is fixed to 1000 while the communication range varies from 6 m to 15 m. Figure 3(a) shows the network radius after constructing the data aggregation tree by using HUANG, PDA, and MDA. With the communication range becoming larger, the node degree increases, and accordingly the radius decreases. Figure 3(c) compares the latency of aggregation from leaf nodes. The latency of aggregation from leaf nodes decreases when the communication range becomes larger. The total latency is the sum of latencies of leaf nodes aggregation and connected dominating nodes aggregation. The smaller the transmission range, the more independent nodes, the more connected dominating nodes accordingly. Hence, the total latency is mainly determined by the latency of aggregation from connected dominating nodes. When the transmission range becomes larger, the node degree increases; thus, the number of leaf nodes increases. Now, the total latency depends on latency of aggregation from leaf nodes. The latency is large at both ends of curves and relative small in middle, as shown in Figure 3(d).

(a)   The network radius

(b) Aggregation latency of leaf nodes

(c) Aggregation latency of nodes in CDS

(d) Total aggregation latency

Figure 3 

Simulation results in two-dimensional networks with different communication ranges.

6.2. Simulation Results in Three-Dimensional Networks

In the part, the network topology is randomly generated by placing nodes in a 100×100×100m³ cube. We compare our MDA with HUANG and PDA when applied to the three-dimensional networks.

6.2.1. Impact of Network Size

The third group of simulations estimates the impact of network size in three-dimensional networks. Similar to the first group of simulations, the results of this group are shown in Figure 4.

(a) The network radius

(b) Aggregation latency of leaf nodes

(c) Aggregation latency of nodes in CDS

(d) Total aggregation latency

Figure 4 

Simulation results in three-dimensional networks with different network sizes.

6.2.2. Impact of Communication Range

The last group of simulations estimates the impact of communication range in three-dimensional networks. Similar to the first group of simulations, the results of this group are shown in Figure 5.

(a) The network radius

(b) Aggregation latency of leaf nodes

(c) Aggregation latency of nodes in CDS

(d) Total aggregation latency

Figure 5 

Simulation results in two-dimensional networks with different communication ranges.

7. Conclusions

Data aggregation is an import technology used to reduce the energy consumption in the wireless sensor networks. In this paper, we focused on the minimum latency data aggregation problem in wireless sensor networks and proposed a novel minimum-latency data aggregation (MDA) algorithm to build the aggregation tree as well as scheduling scheme for the node transmission in the network. We proved that the theoretical latency bound for MDA in the plane is (15𝑅+Δ−15). We have also simulated the case in three-dimensional wireless sensor networks. Extensive simulation results have demonstrated that our algorithm has good performance compared with the related algorithms. In the future work, we are to develop a distributed version of the proposed MDA algorithm with energy considered by constructing a load balance aggregation tree. Furthermore, we will extend our work to the multisink wireless sensor networks.

Notations

𝑑𝑖𝑠𝑡(𝑢,𝑣):	Euclidean distance between 𝑢 and 𝑣
𝑁(𝑢):	The set of neighbors for node 𝑢
𝑅:	The network radius
𝐻:	Depth of the data aggregation tree
Δ:	Maximum node degree
𝐿𝑖:	The set of nodes that are 𝑖-hop away from the sink 𝑠
𝑢𝑝𝑝𝑒𝑟(𝑢):	The set of neighbors in upper layer of node 𝑢
𝑙𝑜𝑤𝑒𝑟(𝑢):	The set of neighbors in lower layer of node 𝑢
𝑡𝑎𝑔(𝑢):	The tag whether 𝑢’s sending time is determined
𝑝𝑎𝑟(𝑢):	The parent node of node 𝑢 on the data aggregation tree.

Acknowledgments

This work is supported by the National Science Foundation of China under Grants nos. 61370210, 61103175, the Fujian Provincial Natural Science Foundation of China under Grants nos. 2011J01345, 2013J01232, and the Development Foundation of Educational Committee of Fujian Province under Grant no. 2012JA12027.