JOURNAL OF INFORMATION SCIENCE AND ENGINEERING 23, 1155-1170 (2007)

Hypercube-based Data Gathering

in Wireless Sensor Networks*

PO-JEN CHUANG, BO-YI LI AND TUN-HAO CHAO

Department of Electrical Engineering
Tamkang University
Tamsui, Taipei County, 251 Taiwan
E-mail: pjchuang@ee.tku.edu.tw

Sensor nodes, charged with battery power and capable of wireless communications,
are distributed around to survey the environments and to send the needed data to the base
station. The limited energy resources of sensor nodes are consumed in computation and
especially in communication. To reduce power consumption for the sensor network, this
paper presents a new data gathering scheme based on the hypercube topology. The hy-
percube-based data gathering scheme collects data from all sensor nodes to the base sta-
tion through the communication tree of the constructed hypercube. It shortens commu-
nication delay by parallel transmission and replaces dead nodes through reconfiguration.
Data gathering by the distributed hypercube and binary tree is also provided.

Keywords: wireless sensor networks, data gathering, base stations, hypercubes, binary
trees, centralized and distributed approaches, simulation and performance evaluation

1. INTRODUCTION

With advances in micro electrical-mechanical technology [1], cheap and wireless

sensor nodes are now available. Charged with battery power and capable of wireless
communications, sensor nodes are distributed around to survey the environments and to
send the needed data to the base station. The limited energy resources of sensor nodes are
consumed in computation and especially in communication [2]. To reduce power con-
sumption, researchers have come up with various schemes in recent years. Some use
data-centric algorithms to collect and transmit data to the base station (BS); others adopt
power control mechanics to reach the intended recipients with minimum required energy.
Data gathering schemes are indeed critical for efficient utilization of sensor networks. In
designing data gathering schemes, one needs to take into account such factors as network
lifetime, transmission latency, node loads and system scalability.
As sensor nodes are likely to be deployed in harsh or dangerous environments, re-
charging becomes impossible. An out-of-power node is considered a dead node and a
system with no living nodes is a dead system. To prolong network lifetime, energy con-
sumption during data gathering must be reduced. A desirable data gathering scheme
should be able to reduce transmission latency as the data collected from a sensor network
are often time-critical for end users. To reduce transmission latency, a scheme may adopt
parallel data-gathering operations or divide the environment into certain sub-regions for

Received September 15, 2006; accepted February 6, 2007.

Communicated by Ten H. Lai, Chung-Ta King and Jehn-Ruey Jiang.
*
This work was supported in part by the National Science Council of Taiwan, R.O.C., under grant No. NSC
93-2213- E-032-032. A preliminary version of this paper was presented at the 2005 International Conference
on Mobile Ad-Hoc and Sensor Networks, Dec. 2005.
1155
1156 PO-JEN CHUANG, BO-YI LI AND TUN-HAO CHAO

concurrent functioning. Balancing node loads is also important. When a sensor node un-
dertaking extreme workloads dies prematurely, its neighbor nodes must consume more
energy to make up for the broken link. Besides, a good data gathering scheme should
work under all possible environments to increase system scalability.
Based on the observation, this paper presents a hypercube-based new data gathering
scheme for sensor networks. The new scheme collects data from sensor nodes to the BS
through the communication tree of a hypercube. It shortens communication delay by par-
allel transmission and replaces dead nodes through reconfiguration. Simulation results
show the new scheme outperforms other schemes in terms of transmission delay, energy
loads, network lifetime and system scalability. To complete our investigation, data gath-
ering by the distributed hypercube and binary tree is also provided.

2. BACKGROUND STUDY

2.1 Previous Schemes

The Low-Energy Adaptive Clustering Hierarchy (LEACH) [3] is a cluster hierarchy

protocol in which every node in the network will be selected as the cluster head with a
probability p at each turn. After the heads are decided, each of the non-cluster-head
nodes selects his own head according to the distance. The cluster head collects data from
its cluster and transmits them to the BS. LEACH reduces node loads by prohibiting
nodes from becoming a cluster head again within 1/p rounds.
The Power-Efficient GAthering in Sensor Information Systems (PEGASIS) [4] is a
chain-based protocol in which sensors are formed into a chain by the greed algorithm.
The chain has a leader that changes at each turn. Starting from the two ends of the chain,
transmission moves along hop by hop. A node will fuse the received data with its own
data and pass on. The chain leader collects data passed from the two ends of the chain,
fuses them and then transmits them to the BS. The binary approach in PEGASIS uses the
same chain in a binary way to make all nodes receivers or transmitters.

2.2 The Radio Model and Energy Cost

The proposed data gathering scheme adopts the first order radio model in [3, 4]. In
this model, a radio dissipates Eelec = 50nJ/bit to run the transmitter or receiver circuitry
and εamp = 100pJ/bit/m2 for the transmitter amplifier. For a k-bit message and a distance d,
the needed transmission energy is

ETx (l, d) = ETx-elec(l) + ETx-amp(l, p) = Eelec * k + εamp * k * d2

and the receiving cost will be ERx(k) = ERx-elec(k) = Eelec * k.

Note that data fusion requires an extra cost of 5nJ/bit/message.

2.3 The Advantages of the Hypercube Topology

An m-cube is an undirected graph consisting of 2m vertices, labeled from 0 to 2m − 1,

in which there is an edge between any two vertices if and only if the binary representa-
 HYPERCUBE-BASED DATA GATHERING 1157

tion of their labels differs in one bit position k. Such two nodes are called dimension-k
neighbors of each other and the link between them is their dimension-k link. The advan-
tages of the hypercube topology are as follows.

• It takes only m = log2 (N) delay time to collect data from a network of N nodes.
• At each turn, each node transmits data only once.
• Nodes are selected as heads with the same probability, ensuring more balanced energy
(load) distribution.

3. THE HYPERCUBE-BASED DATA GATHERING SCHEME

3.1 The Hypercube-Based Transmission Scheme

Our hypercube-based data gathering scheme forms the total system into a log2N-
cube, N being the number of nodes. A node will be the root by turns at each round. After
data are transmitted to the root through the communication tree embedded in the hyper-
cube, the root will transmit the gathered data to the BS. The hypercube is constructed by
the bottom-up approach: Every two separate nodes are formed into a 1-cube, two 1-cubes
into a 2-cube and two 2-cubes into a 3-cube until all nodes are included in the con-
structed cube. Assume that all nodes transmit their locations to the BS after deployment
and the BS takes the following steps to build links between two nodes:

• Compute all links between any two nodes in the network.

• Recurrently delete the longest of these links until a node, say a, retains only one link to
another node, say b. Connect nodes a and b.
• Delete all other links of b until there remains only a link between the two nodes.

All 1-cubes are thus constructed, and the connected node pairs are dimension-0
neighbors of each other. Constructing dimension-1 links involves a similar process ex-
cept that the square of distance between two nodes is now computed to form two 1-cubes
into a 2-cube − the needed transmission energy grows according to the square of the
transmission distance. Two values (sums of squares) will result from two possible con-
nections: Take the connection with the smaller value as the dimension-1 link.
The following notations are needed for further discussion.

Ci: a set of i-cubes.

Ei: a set of connections between all pairs of i-cubes. Each element of Ei represents the
selected connection, including necessary dimension-i links, of a pair of i-cubes. (Of
all possible connections between a pair of i-cubes, the selected connection is the one
with the minimum weight, i.e., the minimum sum of squares of the link lengths.)
d(c): the degree of cube c (the number of connections relevant to c in Ei).

An i-cube has 2i nodes, denoted by X0X1X2…X2i-1 in which each Xi is a node labeled

as i. Two nodes will be connected if and only if the binary representation of their labels
differs in one bit position.
1158 PO-JEN CHUANG, BO-YI LI AND TUN-HAO CHAO

3.2 Constructing the Hypercube

Constructing 1-dimensional cubes: To form 0-cubes into 1-cubes, first put all nodes in
C0 and all links between any two nodes in E0. Each link takes the square of its length as
the weight, to reflect the required transmission energy. Repeatedly delete the maximum
weight of links until a node, say a, with d(a) = 1 is found. Remove node a and the node
connecting to it, say b. Combine the two 0-cubes into a 1-cube and put it in C1. The link
between a and b is marked as the dimension-0 link. Delete all other links relevant to a
and b. If two or more node pairs have the degree of 1, choose the node pair with the least
weight. Repeat the process until C0 is null (i.e., the construction of 1-cubes is completed).

The algorithm for constructing the hypercube

1 i=0
2 while (the number of cubes in Ci is greater than 1) {
3 for (each pair of cubes in Ci) {
4 select the connection with the minimum weight (i.e., sum of squares);
5 put the selected connection into Ei;
6 }
7 while (Ci is not empty) {
8 if (there is only one cube in Ci) {
9 increase the dimension number of the cube’s links;
10 let the dimension-0 neighbor of each node in the cube to be itself;
11 remove it from Ci and add it to Ci+1;
12 }
13 if (a cube has no related connection in Ei) {
14 re-compute connections between it and each cube in Ci;
15 put all such connections into Ei;
16 }
17 while (a cube c in Ci has only one related connection in Ei with another cube c’ in Ci) {
18 connect c and c’ to form and (i + 1)-cube by the related connection;
19 delete all other related connections of c’;
20 remove c and c’ from Ci and add the formed (i + 1)-cube to Ci+1;
21 }
22 delete the connection with the maximum weight in Ei;
23 }
24 i++;
25 }

Constructing 2-dimensional cubes: An example

• Fig. 1 (a): Put all nodes to C0 and all links between any two nodes in C0 to E0 (lines 3-6
of the above algorithm).
• Fig. 1 (b): After deleting the maximum links in E0 (line 22 of the algorithm), node d
has only one link which connects to c. Combine c and d, and delete all links relevant to
c. Put cd to C1 (lines 17-21 of the algorithm).
• Fig. 1 (c): As node a retains only one link to b, remove a and b from C0, put ab to C1,
and delete all links relevant to node b. By now all nodes find their dimension-0
neighbors (lines 17-21 of the algorithm).
 HYPERCUBE-BASED DATA GATHERING 1159

Fig. 1. Constructing a 2-dimensional cube.

Fig. 2. The four possible connections to combine two 2-cubes into a 3-cube.

• Fig. 1 (d): The two ways to form ab and cd into a 2-cube.

• Fig. 1 (e): Dimension-1 links are decided based on the values of ad2 + bc2 and bd2 +
ac2 (choose the one with the smaller value). Put abdc to C2. (The 2-cube is abdc, not
abcd, because a and d, not a and c, are connected through a dimension-1 link.)
• Fig. 1 (f): When a is labeled 00, b will be 01; c and d will be 11 and 10.

Constructing a 3-dimensional cube: There are 2i ways to form two i-cubes into an (i +
1)-cube. Fig. 2 shows the four (22) possible connections to combine two 2-cubes into a
3-cube. Each of the 2-cubes (abdc and efgh) needs four more links to form the 3-cube.
Put the selected connection between abdc and efgh (i.e., the connection with the mini-
mum weight among the four connections) to E2.

Two special situations: Lines 8-12 and 13-16 in the above algorithm deal with two spe-
cial situations.

1. Lines 8-12: In finding the dimension-(i + 1) neighbor for each i-cube, if there remains
only one i-cube in Ci, increase the dimension number of the cube’s links by 1, let each
node be its own dimension-0 neighbor, and put it into Ci+1. (Note that links of higher
dimensions are less likely to be used. In such a pseudo-complete hypercube, each node
may have more than one label and yet transmit only once at each stage.)
2. Lines 13-16: When a cube c in Ci with d(c) = 0, i.e., c has no related connections with
other cubes in Ci, re-compute the links between c and the other cubes in Ci. For exam-
ple, when three cubes connect with one another like a triangle, deleting any one con-
nection will isolate one of the cubes.
1160 PO-JEN CHUANG, BO-YI LI AND TUN-HAO CHAO

Fig. 3 demonstrates the two special situations.

• Fig. 3 (a): There are 6 nodes in the system. Delete the longer links until there remain
only 6 links.
• Fig. 3 (b): Delete bc in E0, choose nodes a and b, and then delete links relevant to node
a, leaving node c with d(c) = 0.
• Fig. 3 (c): Put all links relevant to c and the other nodes in E0.
• Fig. 3 (d): Dimension-0 links are thus established.
• Fig. 3 (e): Connect the two 1-cubes ab and cd into a 2-cube (abcd). C1 now has a
1-cube ef.
• Fig. 3 (f): Increase the dimension number of links for e and f, let e and f each be their
own dimension-0 neighbors. Put eeff to C2.

Fig. 3. Two special situations in constructing the cube.

Fig. 4. Constructing the cube in a wrong way.

Deciding the dimension-k neighbor of a node: The above algorithm does not decide
the dimension-k neighbor of a node by the shortest distance because when choosing the
shortest link on one side, we may be forced to choose a longer link on the other side,
producing uneven load distribution for the nodes. Fig. 4 gives an example case. In the
case, the dimension-0 link between nodes b and c is decided by the shortest distance,
which leads to the construction of the dimension-0 link between nodes a and d. Fig. 4
finally forms a 2-cube similar to the one in Fig. 1 (f) except that in Fig. 1 (f) the longest
connection is a dimension-1 link.

The hypercube transmission scheme: After the hypercube is constructed, data can be
transmitted through the embedded communication tree. The transmission scheme [5, 6]
for a 4-cube is illustrated in Fig. 5, in which the node at the start of an arrow line/at the
arrow head is a sender/receiver node. To start transmission, a head node is first chosen by
turns. Each of the other nodes compares its own label with the head’s label from LSB to
 HYPERCUBE-BASED DATA GATHERING 1161

Fig. 5. Communication-tree transmission for a 4-cube.

MSB: Among the difference bits, the smallest bit number (say k) indicates the stage at
which the node needs to transmit data to its dimension-k neighbor. For example, if the
head node is 0000, node 0101 needs to transmit data at stage 0 and the receiver will be its
dimension-0 neighbor node 0100. Similarly, if the head node is 1001, node 0101 must
transmit data at stage 2 to node 0001. Transmission completes at stage log2 N, N = the
number of nodes. (As the probability for a link to be used is 1/2k, k being the dimension
of the link, we will find the lowest dimension link first when constructing the cube.)

3.3 Hypercube Maintenance

In the proposed scheme, the BS dominates the construction of a hypercube and the
hypercube needs to be reconstructed when a node is dead. To trim down the complexity
of re-constructing a cube, we set a node replacement policy. Each node in the hypercube
will broadcast, at each round, a packet to all neighbors to notify it is alive. If a node fails
to receive such a packet from a specific neighbor node j for a certain period of time, it
will inform other nodes that j is dead. Each of j’s neighbor nodes then broadcasts a mes-
sage including its own location and the connection bit number k between itself and node j
to the network. Upon receiving the information, each node n computes C(n) − the in-
creased average cost per round when n attains the label of the dead node j − and get

d (i, n) 2
C ( n) = ∑ 2k
.
i∈N

N is the set of neighbors of node j; d(i, n) is the distance between nodes i and n. The
cost is computed by the square of distance d(i, n) times the probability of the link to be
used in a round (1/2k). After each neighbor node of j broadcasts its computed value to the
network, the node with the minimum value will take the label of the dead node.
1162 PO-JEN CHUANG, BO-YI LI AND TUN-HAO CHAO

4. THE PROPOSED DISTRIBUTED APPROACHES

The proposed hypercube transmission scheme builds a cube by the bottom-up ap-
proach conducted in a centralized way by the BS. For completeness, we also investigate
the feasibility of gathering data through a hypercube or a binary tree which is constructed
by a different approach − the top-down approach − in a distributed way.

4.1 The Distributed Hypercube Approach

To build the communication tree of a hypercube in a distributed way takes log2 N

steps, N = the number of nodes. First select the node closest to the BS as the head which
then selects a nearest neighbor as its upstream. Both the head node and its upstream node
move on to take the nearest neighbor nodes as further upstream nodes. Repeat this proc-
ess until all nodes are connected to form a communication tree (as in Fig. 6).

Fig. 6. Constructing a hypercube in a distributed way.

The algorithm for constructing a distributed hypercube

1 ConstructDistributedHypercube()
2 {
3 If (I am selected ) {
4 do {
5 select the nearest unselected node;
6 send a message requesting the node to become my upstream;
7 } while (I do not find an upstream at this step and there is an unselected node in the network)
8 }
9 else
10 if (I receive a request
11 {
12 select the nearest node from the nodes that send requests;
13 I become the upstream of the node and mark myself as selected;
14 }
15 }

The algorithm shows that, at each step, every selected node will request a nearest
unselected node to be its upstream. If an unselected node receives only one such request,
it will take the sender as its downstream and mark itself “selected”; if receiving multiple
requests, it will take the nearest sender as its downstream.

Transmission for a distributed hypercube: Each node will pass the data received from
its upstream nodes. After gathering data from all upstream nodes, the head will transmit
 HYPERCUBE-BASED DATA GATHERING 1163

the fused data to the BS. To gather data by such a distributed hypercube approach takes a
total of log2 N steps. Whenever a node dies, the topology needs re-construction.

4.2 The Binary Tree Approach

To gather data by the distributed hypercube approach, each node needs to have one
immediate upstream node to conduct tree transmission. If there are no sensor nodes in the
neighboring area of a node, it needs to take farther upstreams to assist data gathering –
consuming extra energy. For improvement, we can use the distributed binary tree which
is more flexible on the number of allowed immediate upstream nodes to gather data. (The
flexibility may save a significant amount of energy in the data gathering process.) The
distributed binary tree approach allows each node to have at most two immediate up-
stream nodes. To construct a binary tree, the BS first selects the nearest node as the root.
At each round data are collected through the tree to the root which then transmits the
fused data to the BS. The topology must be re-constructed when a node dies (possibly the
root − because the dead nodes will always appear in the neighboring area of the BS).

Constructing the binary tree: The BS first picks up the nearest node as the root. The
root then takes two closest nodes to be its children and asks them to find their own chil-
dren. The offspring of all nodes are decided in this way. To avoid choosing a child of
long distance, we set a maximum distance constraint D. When the distance between two
nodes exceeds D, one can not be the child of the other. If a node is chosen as child by
more than one node, it will become the child of the nearest node. A node which fails to
find any child or receives connection tables from all of its children must return an inte-
grated table (including its connection status) to the parent. After receiving tables from all
children, the root will broadcast a query to check if any node is left out of the tree. If any,
the root will pass the information along the tree and those nodes with less than two chil-
dren now get the chance to find another child with a larger D. When all nodes are in-
cluded, tree construction is completed. Repeatedly enlarging the distance constraint to
build a complete tree is acceptable because a binary tree needs re-construction only when
a node dies. Fig. 7 gives an example of constructing the binary tree.

Fig. 7. Constructing a binary tree.

1164 PO-JEN CHUANG, BO-YI LI AND TUN-HAO CHAO

In Fig. 7, node d is first taken as the root, with D as the initial distance constraint,
for constructing the binary tree (a). Node d then selects the two nearest nodes, i.e., nodes
c and g, as its upstreams (b). The two upstream nodes move on to have their own up-
streams: Node c takes node e; node g takes nodes e and h. As node e is closer to node g,
it becomes the upstream of node g (c). Node f becomes the upstream of node h in the
same way, and tree construction stops here (d). Seeing that nodes a and b are not in-
cluded in the tree, the root passes the command along to re-find children with a larger D.
Node a is thus taken as the upstream of node c (e) and node b becomes the upstream of
node a (f).
After the root is decided, all nodes will execute the following algorithm to construct
the binary tree (the status of a node is specified by a variable S).

S = 0: the node is not in the tree.

S = 1: the node is in the tree and will later find its upstream nodes.
S = 2: the node is awaiting connection tables from its children (i.e., its upstream nodes).
S = 3: the node has transmitted its integrated table to the parent.

The algorithm for constructing the binary tree

1 Construct DistributedBinaryTree () {
2 switch(S) {
3 case 0:
4 if (I receive a request from one or more nodes) {
5 select a nearest node among these nodes;
6 send a request to become the child of the node;
7 }
8 break
9 case 1:
10 while (number of my children < 2 and there is an unselected node within D ) {
11 select a nearest node among them and request it to be my child;
12 notify my child to change S to 1 and the current D;
13 }
14 S=2
15 break
16 case 2:
17 if (I have no children or have received all connection tables from my children )
18 if (I am the root ) {
19 broadcast to check if any node is not included in the tree;
20 if (I receive ACK) {
21 increase the distance constraint D;
22 S = 1;
23 }
24 }
25 else
26 // The topology construction is completed
27 else {
28 integrate the received connection information and send it to my parent;
29 S = 3;
30 }
31 }

The algorithm does not immediately set S to 1 following “send a request to become
the child of the node” (line 6), but instead “notify my upstream to change S to 1 and the
 HYPERCUBE-BASED DATA GATHERING 1165

current D” later in case 1. The reason can be traced in the following example in which
node A (already with a child) requests node B to be its another child.

1. A sends the request to B, asking B to be its child.

2. B selects the nearest node, A, from all requesting nodes and sends back ACK.
3. As A may receive ACK from more than one node, it will select the nearest one (as
another child) and notify it to change S to 1 and the current D. (Note that B will
change S to 1 only after receiving A’s notification at this step.)

Deciding the transmission stages: After all nodes are included in the binary tree, the BS
computes the stage by the following algorithm for each node to send data in each round
and passes the schedule up the tree. Nodes then send data based on the schedule in after
rounds. The transmission stage starts from stage 0. A node will transmit data to its parent
only after receiving and fusing data from all of its children. If two children of a parent
conduct data transmission at the same stage, one has to delay to the next stage. The fol-
lowing are parameters used in the algorithm to decide the transmission stages.

WAIT: the set of nodes not yet assigned transmission stages.

WAIT[i].id: the id of the ith node in the WAIT.
NODE[i].STAGE: the stage for node i to transmit data.

A node in WAIT will be assigned a stage number and removed from WAIT when
no children are in the WAIT and no siblings carry the same stage number to be assigned
to it. The arrangement allows a parent to get a transmission stage after its children and
sibling nodes to have different stage numbers.

The algorithm to decide the transmission stages

1 for (stage = 0; WAIT is not empty, stage++)
2 for (i = 0; i < size(WAIT); i++)
3 if (no children of WAIT[i] is in the WAIT) {
4 if (node WAIT[i].id has sibling k and node[k].stage == stage)
5 continue;
6 NODE[WAIT[i].id].STAGE = stage;
7 remove WAIT[i] from WAIT;
8 }

Fig. 8 displays an example of gathering data by the binary tree transmission.

5. PERFORMANCE EVALUATION

5.1 Data Gathering Delay Time

Table 1 lists the required transmission stages (the data gathering delay time) at each
round for various schemes (n = the number of nodes). As shown here, the hypercube-
based scheme takes less stages than PEGASIS and LEACH to gather data.
1166 PO-JEN CHUANG, BO-YI LI AND TUN-HAO CHAO

Fig. 8. Transmission schemes of the binary tree topology.

Table 1. Transmission steps for various schemes.

Schemes Data gathering delay
The Cube O(log2 n)
The Binary tree O(log2 n)
Leach O(n)
Pegasis O(n)

5.2 The Simulation

The simulation evaluates the performance of the proposed Hypercube, Distributed

Hypercube (DH), Binary tree and 4 other schemes − the PEGASIS, PEGBin (the binary
approach of PEGASIS), LEACH and Direct.

The simulation model: Conducted using NS-2, our simulation adopts the same radio
model and network topology as PEGASIS [4]. The system has 100 nodes, initially
charged with 0.25J energy and randomly scattered to a 100m * 100m network. The BS is
located at (50, 250). Each node has a packet (2,000 bits) to send to the BS at each round.
The Binary tree approach sets a 10m basic distance constraint between any two
nodes. When the distance constraint fails to include all nodes in the tree, the approach
enlarges the constraint by 10m at each tree construction attempt − until the tree is com-
pleted. As the BS is located far from the sensor nodes, LEACH is set to have only one
head at each round to save energy. In PEGASIS and Hypercube, the BS performs the
task of constructing topologies. The cost for constructing topologies is negligible and is
therefore left out. All schemes will reconstruct their topologies when a node dies.

5.3 Simulation Results

• the rounds vs. the number of living nodes (Fig. 9)

Note that our simulation locates the BS at (50, 250), 200m away from the center of
the topology. Due to such a long distance, the proposed Hypercube scheme − which
transmits data in parallel instead of by shorter paths − fails to maintain as many living
 HYPERCUBE-BASED DATA GATHERING 1167

1200

1000 Hypercube

800 PEGASIS
PEGBin

Round
600 LEACH
400 Direct
Binary tree
200
DH
0
100 90 80 70 60 50 40 30 20 10 0
Number of Living Nodes

Fig. 9. Rounds vs. the number of living nodes.

100 87.76
76.49
80
Average Delay

60

40

20 14.87
6.79 6.84 6.48
0
LEACH PEGASIS PEGBin Hypercube DH Binary tree
Protocol
Fig. 10. The average delay of total inter-node transmissions per round.

nodes as the PEGASIS. By contrast, the Binary tree approach maintains the most living
nodes − partly because it is more flexible with the number of upstream nodes and partly
because it selects the node that uses the least energy to transmit data to the BS.

• the average delay of total inter-node transmissions per round before all nodes turn
dead (Fig. 10)
The DH, PEGBin and Hypercube are shown to yield the lowest average delay. The
Binary tree yields more than twice the delay because it takes double time of log2 n.

• the average energy dissipation for inter-node transmissions per round (Fig. 11)
The Binary tree, PEGASIS and Hypercube consume less energy per round. PEGBin
performs not as well because it optimizes only the first transmission step of each round.
(For clearer illustration, the result excludes the large amount of energy consumed by the
head node when sending the gathered data to the BS.)

• the average energy * delay between nodes (Fig. 12)

The average energy * delay between nodes is the required energy times the needed
delay before data are gathered to the head in each round. It is the combined evaluation of
energy dissipation and transmission delay. The Hypercube outperforms others because it
takes both time and energy into account when conducting transmission. The Binary tree,
which focuses more on energy than on time, performs slightly behind.
1168 PO-JEN CHUANG, BO-YI LI AND TUN-HAO CHAO

Average Energy Dissipation

0.06 0.05
0.05 0.041
0.04 0.035

0.03 0.021 0.024

0.018
0.02
0.01
0
LEACH PEGASIS PEGBin Hypercube DH Binary tree
Protocol

Fig. 11. The average energy dissipation for inter-node transmissions per round.

5 4.58
Average Energy*Delay

4
3
1.99
2

1 0.28 0.17 0.24 0.28

0
LEACH PEGASIS PEGBin Hypercube DH Binary tree
Protocol
Fig. 12. The average energy * delay between nodes.

800
700 re-construction
600 reconfiguration
500
Round

400
300
200
100
0
100 90 80 70 60 50 40 30 20 10 0
Number of Living Nodes
Fig. 13. The round vs. the number of living nodes for the Hypercube.

• the rounds vs. the number of living nodes for the Hypercube (Fig. 13)
The result is collected for the Hypercube under reconstruction or reconfiguration
when a node dies. “Reconfiguration” indicates the reconfiguring process to replace the
dead node rather than re-construct the hypercube itself. Reconfiguration, whose per-
formance slightly trails behind that of reconstruction, actually saves a lot of work for the
BS. When it is not desirable for the BS to reconstruct a faulty hypercube, system recon-
figuration can be an alternative.
 HYPERCUBE-BASED DATA GATHERING 1169

6. CONCLUSIONS

To save the limited energy resources of sensor nodes consumed during data trans-
mission, this paper presents a new data gathering scheme for the sensor network. Based
on hypercube transmission, the new scheme concurrently collects data from all sensor
nodes to the base station through the communication tree of the constructed hypercube.
Such a hypercube transmission scheme is desirable because it can shorten communica-
tion delay by parallel transmission and replace a dead node through topology reconfigu-
ration. Experimental evaluation shows that our hypercube-based data gathering scheme
outperforms previous schemes in terms of transmission delay, energy load distribution,
system scalability and system lifetime. To complete our investigation, data gathering by
the distributed hypercube and binary tree is also provided and discussed.

REFERENCES

1. M. Dong, K. Yung, and W. Kaiser, “Low power signal processing architectures for
network microsensors,” in Proceedings of International Symposium on Low Power
Electronics and Design, 1997, pp. 173-177.
2. I. F. Akyildiz, W. Su, Y. Sankarasubramaniam, and E. Cayirci, “A survey on sensor
networks,” IEEE Communications Magazine, Vol. 40, 2002, pp. 102-114.
3. W. Heinzelman, A. Chandrakasan, and H. Balakrishnan, “Energy-efficient communi-
cation protocol for wireless microsensor networks,” in Proceedings of the 33rd Ha-
waii International Conference on System Sciences, 2000, pp. 3005-3014.
4. S. Lindsey, C. Raghavendra, and K. Sivalingam, “Data gathering algorithms in sensor
networks using energy metrics,” IEEE Transactions on Parallel and Distributed Sys-
tems, Vol. 13, 2002, pp. 924-935.
5. Y. R. Leu and S. Y. Kuo, “A fault-tolerant tree communication scheme for hypercube
systems,” IEEE Transactions on Computers, Vol. 45, 1996, pp. 641-650.
6. P. J. Chuang, S. Y. Chen, and J. T. Chen, “Constructing fault-tolerant communication
trees in hypercubes,” Journal of Information Science and Engineering, Vol. 20, 2004,
pp. 39-55.

Po-Jen Chuang (莊博任) received the B.S. degree from

National Chiao Tung University, Taiwan, R.O.C., in 1978, the
M.S. degree in Computer Science from the University of Mis-
souri at Columbia, U.S.A., in 1988, and the Ph.D. degree in
Computer Science from the Center for Advanced Computer
Studies, University of Southwestern Louisiana, Lafayette, U.S.A.
(now the University of Louisiana at Lafayette), in 1992. Since
1992, he has been with the Department of Electrical Engineering,
Tamkang University, Taiwan, where he is currently a Professor.
He was the department chairman from 1996 to 2000. His main
areas of interest include parallel and distributed processing, fault-tolerant computing,
computer architecture, and mobile computing. Dr. Chuang is a member of the IEEE and
the IICM.
1170 PO-JEN CHUANG, BO-YI LI AND TUN-HAO CHAO

Bo-Yi Li (李柏逸) received the B.S. and M.S. degrees in

Electrical Engineering in 2003 and 2005 from Tamkang Univer-
sity, Taiwan, where he is currently pursuing the Ph.D. degree. His
research interests include parallel and distributed processing,
computer architecture, and mobile computing.

Tun-Hao Chao (趙惇豪) received the B.S. and M.S. de-

grees in Electrical Engineering in 2003 and 2005 from Tamkang
University, Taiwan. His research interests include parallel and
distributed processing, computer architecture, and mobile com-
puting.