Efficient Broadcasting in Mobile

Ad Hoc Networks
Majid Khabbazian, Student Member, IEEE, and Vijay K. Bhargava, Fellow, IEEE
AbstractThis paper presents two efficient broadcasting algorithms based on 1-hop neighbor information. In the first part of the
paper, we consider sender-based broadcasting algorithms, specifically the algorithm proposed by Liu et al. In their paper,
Liu et al. proposed a sender-based broadcasting algorithm that can achieve local optimality by selecting the minimum number of
forwarding nodes in the lowest computational time complexity Oilog i, where i is the number of neighbors. We show that this
optimality only holds for a subclass of sender-based algorithms. We propose an efficient sender-based broadcasting algorithm based
on 1-hop neighbor information that reduces the time complexity of computing forwarding nodes to Oi. In Liu et al.s algorithm,
i nodes are selected to forward the message in the worst case, whereas in our proposed algorithm, the number of forwarding nodes in
the worst case is 11. In the second part of the paper, we propose a simple and highly efficient receiver-based broadcasting algorithm.
When nodes are uniformly distributed, we prove that the probability of two neighbor nodes broadcasting the same message
exponentially decreases when the distance between them decreases or when the node density increases. Using simulation, we
confirm these results and show that the number of broadcasts in our proposed receiver-based broadcasting algorithm can be even less
than one of the best known approximations for the minimum number of required broadcasts.
Index TermsWireless ad hoc networks, flooding, broadcasting, localized algorithms.

1 INTRODUCTION
B
ROADCASTINGis a fundamental communication operation
in which one node sends a message to all other nodes in
the network. Broadcasting is widely used as a basic
mechanism in many ad hoc network protocols. For
example, ad hoc on-demand routing protocols such as
AODV [1] and DSR [2] typically use broadcasting in their
route discovery phase. Broadcasting is also used for
topology updates, for network maintenance, or simply for
sending a control or warning message. The simplest
broadcasting algorithm is flooding, in which every node
broadcasts the message when it receives it for the first time.
Using flooding, each node receives the message from all its
neighbors in a collision-free network. Therefore, the broad-
cast redundancy significantly increases as the average
number of neighbors increases. High broadcast redundancy
can result in high power and bandwidth consumption in
the network. Moreover, it increases packet collisions, which
can lead to additional transmissions. This can cause severe
network congestion or significant performance degradation,
a phenomenon called the broadcast storm problem [3].
Consequently, it is crucial to design efficient broadcasting
algorithms to reduce the number of required transmissions
in the network.
A set of nodes is called a Dominating Set (DS) if any node
in the network either belongs to the set or is a 1-hop
neighbor of a node in the set. The set of broadcasting nodes
forms a Connected DS (CDS). Therefore, the minimum
number of required broadcasts is not less than the size of
the minimum CDS. Unfortunately, finding the minimum
CDS is NP-hard, even for the unit disk graphs [4], [5].
However, there are some distributed algorithms that can
find a CDS whose size is smaller than a constant factor of
the size of the minimum CDS [6], [7]. These algorithms can
be employed to find a small-sized CDS that can be used as a
virtual backbone for broadcasting in ad hoc networks.
However, this approach is not efficient in networks with
frequent topology changes, as maintaining a CDS is often
costly [8].
The main objective of efficient broadcasting algorithms is
to reduce the number of broadcasts while keeping the
bandwidth and computational overhead as low as possible.
One approach to classify broadcasting algorithms is based
on the neighbor information they use. Some broadcasting
algorithms such as flooding and probabilistic broadcasting
algorithms [9], [10] do not rely on neighborhood knowl-
edge. These algorithms cannot typically guarantee full
delivery and/or effectively reduce the number of broad-
casts. Moreover, to decide whether or not to broadcast, they
may use a threshold (such as probability of broadcast),
which may not be easy to find for different network
situations. In the second category, broadcasting algorithms
require having 2-hop or more neighbor information. The
broadcasting algorithms in this category can reduce the
number of broadcasts in the network and guarantee full
delivery [11], [12], [13]. However, they may induce high
overhead in highly dynamic networks as they need to
maintain 2-hop network connectivity.
In this paper, we propose two broadcasting algorithms
based on 1-hop neighbor information. The first proposed
IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 8, NO. 2, FEBRUARY 2009 231
. M. Khabbazian is with the Department of Electrical and Computer
Engineering, University of British Columbia, 2523 Pearkes Lane,
Vancouver, BC V6T 2C3, Canada. E-mail: [email protected].
. V.K. Bhargava is with the Department of Electrical and Computer
Engineering, University of British Columbia, 2356 Main Mall, Vancouver,
BC V6T 1Z4, Canada. E-mail: [email protected].
Manuscript received 3 Jan. 2007; revised 25 Aug. 2007; accepted 9 Apr. 2008;
published online 19 June 2008.
For information on obtaining reprints of this article, please send e-mail to:
[email protected], and reference IEEECS Log Number TMC-0002-0107.
Digital Object Identifier no. 10.1109/TMC.2008.94.
2009 IEEE Published by the IEEE CS, CASS, ComSoc, IES, & SPS
algorithm is a sender-based algorithm. In sender-based
algorithms, the broadcasting nodes select a subset of their
neighbors to forward the message. We compare our
proposed broadcasting algorithm to one of the best
sender-based broadcasting algorithms that use 1-hop
information [8]. In [8], Liu et al. propose a broadcasting
algorithm that reduces the number of broadcasts and
achieves local optimality by selecting the minimum number
of forwarding nodes with minimum time complexity
Oilog i, where i is the number of neighbors. We show
that this optimality only holds for a subclass of sender-
based broadcasting algorithms employing 1-hop informa-
tion and prove that our proposed sender-based algorithm
can achieve full delivery with time complexity Oi.
Moreover, Liu et al.s algorithm selects i forwarding nodes
in the worst case, while our proposed algorithm selects
11 nodes in the worst case. Based on our simulation results,
our sender-based algorithm results in fewer broadcasts than
does Liu et al.s algorithm. All these interesting properties
are achieved at the cost of a slight increase in end-to-end
delay. Thus, our first proposed algorithm is preferred to
Liu et al.s algorithm when the value of i is typically large,
and it is important to bound the packet size.
We also propose a receiver-based broadcasting algorithm
in this paper. In receiver-based algorithms, the receiver
decides whether or not to broadcast the message. The
proposed receiver-based algorithm is a novel broadcasting
algorithm that can significantly reduce the number of
broadcasts in the network. We show that using our
proposed receiver-based algorithm, two close neighbors
are not likely to broadcast the same message. In other
words, we prove that the probability of broadcast for a node
`

exponentially decreases when the distance between `

and its broadcasting neighbor decreases or when the

density of nodes increases. Based on our experimental
results, the number of broadcasts using our receiver-based
algorithm is less than one of the best known approxima-
tions for the minimum number of required broadcasts.
The rest of this paper is organized as follows: In Section 2,
we describe the system model and network assumptions. In
Section 3, we discuss our proposed sender-based broad-
casting algorithm and its characteristics. We propose a
simple and highly efficient receiver-based broadcasting
algorithm in Section 4 and prove an interesting property of
the algorithm. We also relax some system model assump-
tion in this section. In Section 5, we verify the theoretical
results using simulation and compare the number of
forwarding nodes of our proposed broadcasting algorithms
with that of one of the best existing broadcasting algorithms
and an approximated lower bound of the optimal solution.
Finally, we provide conclusions in Section 6.
2 SYSTEM MODEL
Our systemmodel is very similar to that used by Liu et al. [8].
We assume that all nodes are located in a 2D plane and have
a transmission range of 1. Therefore, the topology of the
network can be represented by a unit disk graph. We assume
that the network is connected. Two nodes are considered
neighbors if they are in the transmission range of each other.
We suppose that each node knows its location via a
localization technique such as Global Positioning System
(GPS) or the lightweight techniques summarized in [14].
Each node periodically broadcasts a very short Hello
message, which includes its ID and position. Thus, each
node gets the position of its neighbors as well. In the medium
access control (MAC) layer, we assume that scheduling is
done according to the j-persistent CSMA/CA protocol,
which is based on IEEE 802.11 in the broadcast mode. In
the j-persistent CSMA/CA protocol, when a node has a
message to transmit, it initiates a defer timer by a random
number and starts listening to the channel. If the channel is
busy, it continues to listen until the channel becomes idle.
When the channel is idle, it starts decrementing the defer
timer at the end of each time unit. The message is broadcast
when the timer expires.
3 AN EFFICIENT SENDER-BASED BROADCASTING
ALGORITHM
3.1 Algorithm Structure
Our first proposed broadcasting algorithm is a sender-
based algorithm, i.e., each sender selects a subset of nodes
to forward the message. Each message can be identified by
its source ID and a sequence number incremented for each
message at the source node. Algorithm 1 is a general
sender-based broadcasting algorithm and indicates the
structure of our proposed sender-based broadcasting
algorithm. Upon expiration of the timer, the algorithm
requests the MAC layer to schedule a broadcast. The
message scheduled in the MAC layer is buffered and then
broadcast with a probability j. This adds another delay (i.e.,
the MAC-layer delay) in broadcasting the message. The
MAC-layer delay in IEEE 802.11 is a function of several
factors including the network traffic. Note that there is a
chance that a node changes its decision (regarding the
selected nodes or regarding whether to broadcast) during
the MAC-layer delay due to receiving other copies of the
message. This chance is not negligible when the delay in the
MAC layer is comparable to the average value of the timer
set in the broadcasting algorithm. As stated in [15], one
solution to this problem is a cross-layer design in which the
network layer is given the ability to modify or remove
packets that are present in the MAC-layer queue. This
solution allows the broadcasting algorithms to perform
close to their ideal performance even for very small average
timer values [15]. In the entire paper, we assume that either
the MAC-layer delay is negligible compared to the average
delay set by the algorithm or the network layer (hence, the
algorithm) is able to modify or remove packets buffered in
the MAC-layer queue (in this case, the algorithm does not
require to set a defer timer).
The sender-based broadcasting algorithms can be di-
vided into two subclasses. In the first subclass, each node
decides whether or not to broadcast solely based on the first
received message and drops the rest of the same messages
that it receives later. Liu et al.s algorithm falls in this
subclass and achieves local optimality by selecting the
minimum number of forwarding nodes in the lowest
computational time complexity.
232 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 8, NO. 2, FEBRUARY 2009
In the second subclass of sender-based broadcasting
algorithms, each node can decide whether or not to
broadcast after each message reception. However, if a node
broadcasts a message, it will drop the rest of the same
messages that it receives in the future. Therefore, each
message is broadcast once at most by a node using the
broadcasting algorithms in both subclasses. Our first
proposed broadcasting algorithm falls in this subclass of
sender-based broadcasting algorithms. We show that the
proposed algorithm can reduce both the computational
complexity of selecting the forwarding nodes and the
maximum number of selected nodes in the worst case.
Algorithm 1 shows the basic structure of our proposed
sender-based broadcasting algorithm. As shown in
Algorithm 1, each node schedules a broadcast for a
received message if the node is selected by the sender
and if it has not scheduled the same message before.
Clearly, each message is broadcast once at most by a
node, which is similar to Liu et al.s algorithm. However,
in Liu et al.s algorithm, each node may only schedule a
broadcast when it receives a message for the first time.
In contrast, in Algorithm 1, a broadcast schedule can be
set at any time. For example, a message can be dropped
after the first reception but scheduled for broadcast
the second time. Clearly, the main design issue in
Algorithm 1 is how to select the forwarding nodes.
Algorithm 1. A general sender-based algorithm
1: Extract information from the received message `
2: if ` has been scheduled for broadcast or does not
contain nodes ID then
3: drop the message
4: else
5: set a defer timer
6: end if
7: When defer timer expires
8: Select a subset of neighbors to forward the message
9: Attach the list of forwarding node to the message
10: Schedule a broadcast
3.2 Forwarding-Node Selection Algorithm
Let us consider point as the node `

and a circle C
.1
centered at with a radius 1 as the transmission range
of `

. We use 1 to denote the distance between two

points and 1. Before delving into the algorithm
description and proofs, we need to define the following
terms:
Definition 1 (bulged slice). As illustrated in Fig. 1, we define a
bulged slice around as the intersection area of three circles
with radius 1 and centers , `, and `, where ` 1,
` 1, and `` 1. Note that in any bulged slice ``,
we have ``

3
.
Definition 2 (right/left bulged slice). As shown in Fig. 2, let
and 1 be two points such that 0 < 1 1 and `` be a
bulged slice around . Suppose that the point 1 is on one of
the arcs `

or `

of the bulged slice ``. In this case,

`` is called the right bulged slice of 1 around if it
contains the

3
clockwise rotation of point 1 around and is
called its left bulged slice around otherwise.
Definition 3 (bulged angle). Let B
1
and B
2
be two bulged
slices around . The bulged angle

B
1
. B
2
is defined to be
equal to 0 c < 2 if B
2
is an c counterclockwise rotation of
B
1
around .
Definition 4 (B-coverage set). A subset of neighbors of `

is
called a B-coverage set of `

if any nonempty bulged slice

around contains at least one node from the set. A bulged
slice is empty if there is no node inside it.
Definition5 (slice-based selectionalgorithm). Aforwarding-
node selection algorithm is called a slice-based selection
algorithm (or slice-based algorithm) if for any node `

, it
selects a B-coverage set of it.
A node can have several different B-coverage sets. There-
fore, there is more than one slice-based selection algorithm.
For example, a trivial slice-based selection algorithm would
be one that selects all of the neighbors as the B-coverage set.
Clearly, this algorithm will result in flooding if it is used as
the forwarding-node selection scheme in Algorithm 1. In
this section, we first show that Algorithm 1 can achieve full
delivery if it uses any slice-based algorithm to select the
forwarding nodes. We then present an efficient slice-based
KHABBAZIAN AND BHARGAVA: EFFICIENT BROADCASTING IN MOBILE AD HOC NETWORKS 233
Fig. 1. A bulged slice around .
Fig. 2. Left bulged slice of 1 and right bulged slice of C around .
algorithm that selects 11 nodes in the worst case and has
computational complexity Oi, where i is the number of
neighbors.
Lemma 1. For any two points 1
1
and 1
2
inside a bulged slice,
we have
1
1
1
2
1.
Proof. As shown in Fig. 3, the line passing through 1
1
and
1
2
intersects the bulged slice `` at 1
0
1
and 1
0
2
. Clearly,
1
1
1
2
1
0
1
1
0
2
. Therefore, to prove the lemma, it is
sufficient to show that 1
0
1
1
0
2
1. This is easy to show
if both 1
0
1
and 1
0
2
are on the same arc of the bulged slice.
Thus, without loss of generality, we can assume that 1
0
1
and 1
0
2
are on the arcs `

and `

, respectively. Let us
consider the perpendicular bisector of the line segment
1
0
1
` (line 1). Line 1 passes through ` because
`` `1
0
1
1. Since the point 1
0
2
is on the arc `

,
the line segment `1
0
2
will cross the line 1 at a point Q.
Using triangle inequality, we have
1
0
1
1
0
2
Q1
0
2
Q1
0
1
_ _
Q1
0
2
Q`
_ _
1
0
2
` 1.
Note that Q is on the line 1; hence, Q1
0
1
Q`. tu
Consider two points and 1 such that 1 < 1 21. As
shown in Fig. 4, the line segment 1 intersects the circle
C
.1
at point Q. Let Q` and Q` be the left and right
bulged slices of Q around , respectively. The following
lemmas hold:
Lemma 2. A point 1 is inside the bulged slice Q` or Q` if
1 1 and 11 1.
Proof. It is easy to show that for any triangle 41C,
` 1 or ` C, where ` is a point on the line
segment 1C. Consequently, in the triangle 411
(shown in Fig. 4), we have
1Q 1 1 or 1Q 11 1.
Therefore, 1Q 1. Thus, based on the bulged slice
definition, the point 1 is inside the bulged slice Q`
or Q`. tu
Lemma 3. For any point 1 6 inside the bulged slice Q` or
Q`, we have
11 < 1.
Proof. Using triangle inequality, we get
11 1QQ1 1Q1 1.
Note that this equality holds only when 11 1QQ1
and Q1 1 or simply when 1 . tu
Theorem 1. In a collision-free network, Algorithm 1 can achieve
full delivery if it uses a slice-based selection algorithm to select
the forwarding nodes.
Proof. Using Algorithm 1, each node broadcasts the
message at most once. Therefore, broadcasting will
eventually terminate. By contradiction, suppose there is
at least one node that has not received the message after
the broadcasting termination. Let us consider the
following set:
f`
A
. `
Y
. `
7
j`
A
has broadcast the message.
`
7
has not received the message. and
`
Y
is the neighbor of both `
A
and `
7
g.
Suppose `
o
is the node that initiated broadcasting, and
`
T
is a node that has not received the message. The
network is connected; thus, there is a pathbetween`
o
and
`
T
. Clearly, we can find two neighbor nodes `
C
and `
1
along the path from `
T
to `
o
such that `
C
has not
received the message, while `
1
has received it. Suppose
that `
1
has received the message from`

. Consequently,
`

. `
1
. `
C
2 ; thus, 6 ;. As a result, we have
9`

0 . `
1
0 . `
C
0 2 s.t.8`
A
. `
Y
. `
7
2:
0
C
0
A7. 1
Obviously, `

0 and `
C
0 are not neighbors, because `
C
0
has not received the message. Thus,
0
C
0
1. Using
Lemma 2, 1
0
is inside the bulged slice
0
1
1
1
2
or
0
1
1
1
3
,
where 1
1
is the intersection of line segment
0
C
0
and the
circle C

0
.1
, and
0
1
1
1
2
and
0
1
1
1
3
are the left and the
right bulged slices of 1
1
around
0
, respectively. Without
loss of generality, assume that 1
0
is inside the bulged
234 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 8, NO. 2, FEBRUARY 2009
Fig. 3. Upper bound on the distance between nodes inside a bulged
slice.
Fig. 4. Other properties of bulge slice from Lemmas 2 and 3.
slice
0
1
1
1
2
. Since `

0 has at least one neighbor (i.e., `

1
0 )
in this slice, there must be a selected node `
1
in the slice
that has forwarded the message. Using Lemma 1, we get
1
0
1 1; hence, nodes `
1
and `
1
0 are neighbors.
Therefore, `
1
. `
1
0 . `
C
0 2 . However, this contradicts
(1) because using Lemma 3, we have
1C
0
<
0
C
0
.
tu
Algorithm 2 shows our proposed slice-based selection
algorithm. Suppose that node `

uses the proposed

algorithm to select the forwarding nodes from its neighbors.
Let us assume that `

stores all of its neighbors IDs and

locations in an array of length i, where i is the number of
neighbors. The algorithm selects the first node `
o1
randomly from the array. The first node can also be selected
deterministically by, for example, selecting the node that is
the farthest away from `

. Let LB

1 and RB

1 denote
the left bulged slice and right bulged slice of 1 around ,
respectively. Suppose that `
o
i
is the last node selected by
the algorithm. To select the next node, the algorithm iterates
through the array and selects the node `
oi1
such that it is
inside the slice LB

o
i
,

LB

o
i
. LB

o
i1
6 0, and
8`
1
inside LB

o
i
:

LB

o
i
. LB

LB

o
i
. LB

o
i1
.
2
If there is no such node, the algorithm selects `
oi1
such that
8`
1
inside C
.1
:

LB

o
i
. RB

o
i1

LB

o
i
. RB

1 .
3
The algorithm terminates by selecting the last node `
oi
if
`
o
i
is inside LB

o
1
or `
o
1
is inside LB

o
i
or
o
i1
o
1
.
Algorithm 2 A slice-based selection algorithm
Input: 1i:t

1 . . . i: List of all neighbors of `

Output: A B-coverage set of `

: f`
oi
g
1: iid 1; i 0
2: repeat
3: oiq ior 0; oiq iii 2
4: i i 1
5: `
oi
1i:t

iid
6: c// )o|:c
7: for , 1; , length1i:t

; ,++ do
8: if 1i:t

, is in LB

o
i
then
9: if

LB

o
i
. LB

1i:t

, oiq ior
then
10: c// tinc
11: iid ior ,
12: oiq ior

LB

o
i
. LB

1i:t

,
13: end if
14: else
15: if

LB

o
i
. RB

1i:t

, < oiq iii

then
16: iid iii ,
17: oiq iii

LB

o
i
. RB

1i:t

,
18: end if
19: end if
20: end for
21: if c// then
22: iid iid ior
23: else
24: iid iid iii
25: end if
26: until o
1
is in LB

1i:t

iid OR 1i:t

iid is in
LB

o
1

27: if iid 6 1 then

28: `
o
i1
1i:t

iid
29: end if
Lemma 4. Suppose the proposed algorithm selects i nodes
f`
o1
. `
o2
. . . . . `
oi
g. For any 1 i < i2, we have

LB

o
i
. LB

o
i2


3
.
Proof. Based on (2), (3), and the algorithm termination
condition, we can show that

LB

o
i
. LB

o
i2

LB

o
i
. LB

o
i1

for any 1 i < i2. By contradiction, assume that

LB

o
i
. LB

o
i2


3
.
Therefore, o
i2
is inside LB

o
i
. Thus, using (2), we
have

LB

o
i
. LB

o
i2

LB

o
i
. LB

o
i1
.
which is a contradiction. tu
Theorem 2. The proposed slice-based selection algorithm will
select at most 11 nodes.
Proof. By contradiction, assume that the algorithm selects
more than 11 nodes. Therefore, o
11
is not in LB

o
1
.
Using Lemma 4, we get

LB

o
1
. LB

o
11

5
i1

LB

o
2i1
. LB

o
2i1
5

3
.
Ther ef or e,

LB

o
11
. LB

o
1
< 2 5

3


3
.
Consequently, o
1
is inside LB

o
11
; thus, the proposed
slice-based algorithm will terminate after selecting o
11
.tu
The above theorem gives an upper bound on the number of
nodes selected by the proposed selection algorithm. In
Section 5, using simulation, we show that the average
number of selected nodes (when the nodes are distributed
uniformly) is less than six.
Theorem 3. Time complexity of the proposed slice-based selection
algorithm is Oi, where i is the number of neighbors.
Proof. The algorithm selects the first node in O1. To select
each of the other nodes, the algorithm performs Oi
operations by checking all the neighbors in the array.
Therefore, the complexity of the algorithm is Oii,
where i is the number of selected nodes. Using
Theorem 2, we have i 11; thus, the time complexity
of algorithm is Oi. tu
KHABBAZIAN AND BHARGAVA: EFFICIENT BROADCASTING IN MOBILE AD HOC NETWORKS 235
3.3 Reducing the Number of Forwarding Nodes
In the sender-based broadcasting algorithms, each broad-
casting node attaches a list of its selected forwarding nodes
to the message before broadcasting it. This procedure will
increase the bandwidth and power required to broadcast
the message. As shown earlier, our proposed slice-based
selection algorithm reduces the number of selected for-
warding nodes to 11 in the worst case. In this section, we
show how to further reduce the number of selected nodes.
Recall that the proposed slice-based algorithm selects a
subset of `

s neighbors such that there is at least one

selected node in any nonempty bulged slice around .
Suppose `

extracts the list of the forwarding nodes from

each message it receives. Let L

be a subset of `

s
neighbors that has broadcast the message or been selected
by other nodes to forward it. Since all of the selected
forwarding nodes are required to broadcast the message, it
is sufficient for `

to find a subset of its neighbors S

such
that any nonempty bulged slice around contains at least
one node from S

[ L

. Algorithm 2 can be simply

extended to achieve this in Oi. Note that the extended
algorithm can start with a node from L

and select any

node in L

as soon as it appears in the left bulged slice of

the previously selected node. Finally, the extended algo-
rithm removes all of the nodes in L

from the set of

selected nodes.
3.4 Maximizing the Minimum Node Weight of
B-Coverage Set
Suppose node `

assigns a weight to each of its neighbors.

The weight can represent the neighbors battery lifetime, its
distance to `

, the average delay of the node, the level of

trust, or a combination of them. In some scenarios, we may
desire to find a B-coverage set such that its minimum node
weight is the maximum or its maximum node weight is the
minimum among that of all B-coverage sets. For example,
assume that the weight of each node represents its battery
lifetime in a wireless network. It may be desirable to select
the nodes with a higher battery lifetime to forward the
message in order to keep the nodes with a lower battery
lifetime alive. Algorithm 3 shows how to find a B-coverage
set such that its minimum node weight is the maximum
among that of all B-coverage sets. A similar approach can be
used to find a B-coverage set such that its maximum node
weight is the minimum.
Algorithm 3. Maximizing the minimum node weight
Input: 1i:t

1 . . . i: List of all neighbors of `

Output: A B-coverage set of `

with highest minimum

node weight
1: o1i:t

:oit1i:t

{Sort the neighbor nodes by

their weights} fo1i:ti ! o1i:t, , i ,g
2: H i; T 1; i b
i
2
e
3: ot |qoiit/i 2o1i:t1
4: if ot is a B-coverage set for `

then
5: return SList[1]
6: end if
7: while H T 1 do
8: ot |qoiit/i 2o1i:t1 . . . i {Pass i nodes
with the highest weights to Algorithm 2 as the input}
9: if ot is a B-coverage set for `

then
10: H i
11: i d
Ti
2
e
12: else
13: T i
14: i d
Hi
2
e
15: end if
16: end while
17: return Algorithm 2o1i:t1 . . . H
Algorithm 3 first sorts the nodes by their weights in
decreasing order. Then, in each step, it passes i nodes with
the highest weights to Algorithm 2 as input and gets a set of
(at most 11) nodes as output, where 1 i i is an integer
initially set to d
i
2
e. If the output set is a B-coverage set,
Algorithm 3 sets H to i and decreases i to d
Ti
2
e, where T
and H are variables initially set to 1 and i, respectively.
Otherwise, it sets T to i and increases i to d
Hi
2
e. After a
finite number of steps, we get H T 1. Algorithm 3 then
returns the output of Algorithm 2o1i:t1 . . . H.
Corollary 1. Algorithm 3 will select at most 11 nodes.
Proof. The proof is clear, as Algorithm 3 returns an output
of Algorithm 2 (Line 17). tu
Theorem 4. The time complexity of Algorithm 3 is Oilog i.
Proof. Algorithm 3 requires Oilog i operations to sort the
list of neighbors 1i:t

1 . . . i. The computational com-

plexity of Algorithm 2 is Oi. Therefore, Algorithm 3
performs Oi operations in each iteration of the while
loop. The while loop terminates after Olog i iterations
because it uses a binary search approach to find the
minimum value of H. Consequently, the order of
Algorithm 3 is Oilog i log i i. tu
Theorem 5. The minimum weight of nodes of the B-coverage
set selected by Algorithm 3 is the maximum among that of
all B-coverage sets.
Proof. Suppose that ot
iii
is a B-coverage set such that the
minimum weight of nodes in ot
iii
is greater than or
equal to that of other B-coverage sets. Let `
A
2 ot
iii
be
the node with the minimum weight in ot
iii
. Assume
that `

has 1 neighbors with weights greater than or

equal to the weight of `
A
. Therefore, the output of
Algorithm 2o1i:t1 . . . 1 is a B-coverage set. Note that
Algorithm 3 finds the minimum H such that the output
of Algorithm 2o1i:t1 . . . H is a B-coverage set for `

.
Therefore, H 1, and thus, the minimum weight of
nodes of the B-coverage set selected by Algorithm 3 is
greater than or equal to the weight of `
A
. tu
3.5 Similarity with a Topology Control Algorithm
In [16] and [17], the authors proposed a cone-based
topology control algorithm, where each node makes local
decisions about its transmission power. The objective of the
algorithm is to minimize the transmission power of each
node without violating the network connectivity. In order to
do that, each node `

transmits with the minimum power

1
c
such that in every nonempty cone of degree c around
`

, there is some node that `

can reach with power 1

c
. A
cone is nonempty if there is at least a node in the cone that
`

can reach using its maximum power. For c

2
3
, they
236 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 8, NO. 2, FEBRUARY 2009
proved that the network remains connected if the cone-
based algorithm is employed.
Suppose that we use cones instead of bulged slices in the
proposed forwarding-node selection algorithm. Therefore,
the algorithm will select the forwarding node set such that
any nonempty cone of degree c around `

contains at least
one node from the forwarding node set. Surprisingly, this
algorithm will not guarantee full delivery. Fig. 5 shows a
counterexample for the case where c
2
3
. Fig. 6 shows that
even for c

3
, full delivery cannot be guaranteed. In both
Figs. 5 and 6, the node `

initiates broadcasting and selects

only `
1
and `
C
to forward the message. Suppose that `
1
is
close enough to the point ` such that it is the only node
that can reach `
1
. In this case, `
1
will not receive the
message because `
1
is not selected by neither `
1
nor `
C
to
forward the message. Note that the cone-based and the
forwarding-node selection algorithms use different ap-
proaches. In the cone-based algorithm, a node `

increases
its power from zero until there is a node in each nonempty
cone around `

. However, in the forwarding-node selec-

tion algorithm, a node `

selects some nodes (the forward-

ing nodes) until there is a selected node in each nonempty
bulged slice around `

.
4 A HIGHLY EFFICIENT RECEIVER-BASED
BROADCASTING ALGORITHM
In this section, we propose a novel receiver-based broad-
casting algorithm that can significantly reduce redundant
broadcasts in the network. As mentioned earlier, in
receiver-based broadcasting algorithms, the receiver of the
message decides whether or not to broadcast the message.
Therefore, a potential advantage of receiver-based broad-
casting algorithms over sender-based ones is that they do
not increase the size of the message by adding a list of
forwarding nodes.
4.1 Algorithm Structure
Algorithm 4 shows a general approach used in several
receiver-based broadcasting algorithms [13], [18]. Our
proposed receiver-based broadcasting algorithm employs
this approach. Clearly, the main design challenge of
Algorithm 4 is to determine whether or not to broadcast a
received message. A trivial algorithm is to refrain broad-
casting if and only if all the neighbors have received the
message during the defer period. Although this algorithm is
simple to implement, it has limited effect in reducing the
number of redundant broadcasts. Suppose `

s defer time
expires at t
0
. Using the above strategy, node `

will
broadcast if some of its neighbors (at least one) have not
received the message by t
0
. However, this broadcast is
redundant if all such neighbors receive the message from
other nodes after time t
0
. This scenario typically occurs
when t
0
is small compared to the maximum defer time. In
the next section, we introduce a responsibility-based
scheme (RBS) that further reduces the redundant broadcasts
without any changes in the MAC-layer defer-time design.
Algorithm 4. A general receiver-based algorithm
1: Extract information from the received message `
2: if ` has been received before then
3: drop the message
4: else
5: set a defer timer
6: end if
7: When defer timer expires
8: decide whether or not to schedule a broadcast
4.2 Responsibility-Based Scheme
Algorithm 5 shows the proposed RBS. The main idea of
Algorithm 5 is that a node avoids broadcasting if it is not
responsible for any of its neighbors. A node `

is not
responsible for a neighbor `
1
if `
1
has received the
message or if there is another neighbor `
C
such that `
C
has
received the message and `
1
is closer to `
C
than it is to `

.
Suppose `

stores IDs of all its neighbors that have

broadcast the message during the defer period. When
executed by a node `

, Algorithm 5 first uses this

information to determine which neighbors have not
received the message (Lines 1-9 of Algorithm 5). It then
returns false if and only if it finds a neighbor `
1
that has not
received the message and
1 1C
KHABBAZIAN AND BHARGAVA: EFFICIENT BROADCASTING IN MOBILE AD HOC NETWORKS 237
Fig. 5. A counterexample for c
2
3
.
Fig. 6. A counterexample for c

3
.
for any `

s neighbor `
C
that has received the message.
The output of RBS determines whether or not the broadcast
is redundant.
Algorithm 5. RBS
Input: 1i:t

: List of all neighbors of `

, and 1i:t
1
: List of
broadcasting neighbors
Output: true or false
1: 1i:t
C
1i:t

2: for i 1; i length1i:t
C
; i++ do
3: for , 1; , length1i:t
1
; ,++ do
4: if dist1i:t
C
i. 1i:t
1
, 1 then
5: removeElement1i:t
C
i. 1i:t
C

6: break
7: end if
8: end for
9: end for
10: 1i:t
1
1i:t

1i:t
C
11: for i 1; i length1i:t
C
; i++ do
12: c/cc/ tinc
13: for , 1; , length1i:t
1
; ,++ do
14: if dist1i:t
C
i. 1i:t
1
, < dist1i:t
C
i. `

then
15: c/cc/ )o|:c
16: break
17: end if
18: end for
19: if check then
20: return (false)
21: end if
22: end for
23: return (true)
Example 1. As shown in Fig. 7, `

has five neighbors.

Suppose that `

has received a message from `

1
. Note
that `

has the position of all its neighbors. Therefore, it

can find that `
1
and `
1
have received the message but
`
1
and `
C
have not. As shown in Fig. 7, `

is not
required to broadcast because
11 < 1 and C1 < C.
Theorem 6. In a collision-free network, Algorithm 4 can achieve
full delivery if it uses the proposed RBS to determine whether
or not to broadcast.
Proof. Using Algorithm 5, each node broadcasts a message
at most once. Therefore, broadcasting will eventually
terminate. By contradiction, suppose there is at least one
node that has not received the message after the
broadcasting termination. Let us consider the set
f`
A
. `
Y
j`
A
and `
Y
are neighbors.
`
A
has received the message. and
`
Y
has not received the messageg.
Suppose `
o
is the node that initiated broadcasting,
and `
T
is a node that has not received the message. The
network is connected; thus, there is a path between `
o
and `
T
. Clearly, we can find two neighbor nodes `
1
and
`

along the path from `

T
to `
o
such that `
1
has not
received the message, while `

has. Consequently,
`

. `
1
2 ; thus, 6 ;. As a result, we have
9`

0 . `
1
0 2 s.t. 8`
A
. `
Y
2 :
0
1
0
AY . 4
Clearly, `

0 has not broadcast since `

1
0 has not
received the message. Therefore, there must be a node
`
C
0 such that `
C
0 has received the message and C
0
1
0
<

0
1
0
1. This result contradicts (4), since`
C
0 . `
1
0 2 .tu
Theorem 7. The time complexity of the proposed RBS is Oi
2
,
where i is the number of neighbors.
Proof. Algorithm 5 consists of two parts. In the first part
(Lines 1-9), the algorithm generates a list of neighbors
that have not received the message 1i:t
C
. Clearly, the
time complexity of this part is O/i, where 1 < / i is
the number of broadcasting neighbors. In the second
part, the algorithm checks whether there is a node `
1
such that `
1
has not received the message and 1 1C
for any neighbor `
C
2 1i:t
1
. The time complexity of this
part is O|i, where 0 | i is the number of neighbors
that have not received the message, and 1 i i is the
number of neighbors that have received it. Therefore, the
complexity of the algorithm is O|i/i. tu
4.3 A Property of the Proposed RBS
In the simulation section (Section 5), we show that the
proposed RBS can significantly reduce the number of
broadcasts in the network. In particular, our simulation
shows that using RBS, the average number of broadcasts is
less than one of the best known approximations for the
minimum number of required broadcasts. To justify this,
we prove a property of the proposed RBS.
Assume that nodes are placed randomly inside a square
area of size 1 1 using a homogeneous planar Poisson
distribution. Therefore, nodes are independently and
uniformly distributed in the area. Moreover, we have
1io/number of nodes in area t /
ct
/
c
ct
/!
.
where c is the density of nodes [19], [20]. Suppose node `
1
receives the message from `

for the first time. For

simplicity, assume that circle C
.21
is completely inside
238 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 8, NO. 2, FEBRUARY 2009
Fig. 7. An example of an RBS decision.
the square area. Corollary 2 shows that the probability that
`
1
broadcasts the message exponentially decreases when
the distance 1 decreases or when the node density c
increases. This result is further confirmed by simulation in
Section 5.
Example 2. Suppose 1250 m, 11. 000 m, and c1
2
300
(i.e., there are about 300 nodes in the network). Let
1i/1id
1
be the probability that `
1
broadcasts the
message after receiving it from `

. Using Theorem 8, we
get 1i/1id
1
1.26 10
2
, 1i/1id
1
1.4 10
3
,
and 1i/1id
1
10
4
when 1 100 m, 1 80 m,
and 1 60 m, respectively.
Let R
1
. R
2
. . . . R
/
be / nonoverlapping regions inside the
network. Suppose that
R
is the event

R
fThe region R contains at least one nodeg.
Since the nodes are placed by homogeneous planar Poisson
distribution, the events
R
i
are independent [20]. Conse-
quently, we have
1i/
R
1
.
R
2
. . . . .
R
/
1i/
R
1
1i/
R
2
. . . 1i/
R
/
. 5
Lemma 5 generalizes (5) to the case where the regions may
overlap each other.
Lemma 5. Let R
1
. R
2
. . . . R
/
be / regions inside the network. We
have
1i/
R1
.
R2
. . . . .
R/
! 1i/
R1
1i/
R2
. . . 1i/
R/
.
Proof. The proof is by induction on the number of regions.
The lemma is true if the number of regions is one (i.e.,
/ 1). Suppose that the inequality holds for / d
regions. We have
1i/
R
1
.
R
2
. . . . .
R
d
j
"

R
d1
_ _
1i/
R
1
R
d1
.
R
2
R
d1
. . . . .
R
d
R
d1
_ _
.
6
where
"

R
i
is the complement of
R
i
, and 1
i
1
,
is the
collection of all points inside 1
i
and outside 1
,
. Note that
1i/
R
1
.
R
2
. . . . .
R
d
j
R
1
R
d1
.
R
2
R
d1
. . . . .
R
d
R
d1
_ _
1.
Thus,
1i/
R
1
.
R
2
. . . . .
R
d

! 1i/
R1Rd1
.
R2Rd1
. . . . .
RdRd1
_ _
.
7
It follows from (6) and (7) that
1i/
R1
.
R2
. . . . .
Rd
! 1i/
R1
.
R2
. . . . .
Rd
j
"

Rd1
_ _
. 8
We have
1i/
R1
.
R2
. . . . .
Rd

1i/
R
d1
_ _
1i/
R
1
.
R
2
. . . . .
R
d
j
R
d1
_ _
1i/
"

Rd1
_ _
1i/
R1
.
R2
. . . . .
Rd
j
"

Rd1
_ _
.
Therefore, using (8), we get
1i/
Rd1
_ _
1i/
R1
.
R2
. . . . .
Rd
j
Rd1
_ _
! 1 1i/
"

R
d1

_ _
1i/
R
1
.
R
2
. . . . .
R
d
.
Thus, using an induction hypothesis, we get
1i/
R1
.
R2
. . . . .
Rd
.
Rd1
_ _
! 1i/
R
d1
_ _
1i/
R
1
.
R
2
. . . . .
R
d

! 1i/
R
1
1i/
R
2
. . . 1i/
R
d
1i/
R
d1
_ _
.
tu
Lemma 6. Let D
.1
and D
1.1
be two disks with radius 1 and
centers and 1, respectively. Suppose 1 1. As shown in
Fig. 8, consider a point Q such that 1 < Q and Q1 1.
Let D
Q.Q1
be a disk with radius Q1. We have
ID
.1
. D
1.1
. D
Q.Q1

_ _
!
11
2
3
.
where ID
.1
. D
1.1
. D
Q.Q1
is the intersection of disks D
.1
,
D
1.1
, and D
Q.Q1
, and 1 is the area of region 1.
Proof. For any point 1 on the circle C
.1
, we have
11 1 1 11.
Therefore, as shown in Fig. 8, the disk D
1.11
is inside
ID
.1
. D
1.1
. Consequently, we have
1D
.1
. D
1.1
. D
Q.Q1

_ _
! 1D
1.11
. D
Q.Q1

_ _
.
Since Q ! 1, using triangle inequality, we get
Q1 ! Q1 ! 1 1.
Therefore, we have
Q1C !

3
and Q11 !

3
.
and hence, C11 !
2
3
. Therefore,
1D
1.11
. D
Q.Q1

_ _
!
D
1.11
_ _
3

1 1
2
3
.
tu
KHABBAZIAN AND BHARGAVA: EFFICIENT BROADCASTING IN MOBILE AD HOC NETWORKS 239
Fig. 8. Finding a lower bound for 1D
.1
. D
1.1
. D
Q.Q1
.
Theorem 8. Suppose d 1 is the distance between two nodes
`

and `
1
. We have
1i/1id 1 c
cc
c
1d
2
3
.
where 1i/1id is the probability that `
1
broadcasts the
message after receiving it from `

, and
D
1.1
ID
.1
. D
1.1

_ _
is the area of the hatched crescent shown in Fig. 8.
Proof. Node `
1
is not required to broadcast if and only if

: 8`
Q
2 : 9`
1
inside 1D
.1
. D
1.1
. D
Q.Q1
.
where
f`
A
jA 1 and 1A 1g.
Note that the nodes positions have a Poisson distribu-
tion. Therefore, using Lemma 6, we get
1i/ 9`
1
inside 1D
.1
. D
1.1
. D
Q.Q1

_ _
1 c
c 1D
.1
.D
1.1
.D
Q.Q1

_ _
! 1 c
c
1d
2
3
.
9
Thus,
1i/1id 1 1i/

1
/0
1io/ jj / 1i/

j jj / .
where jj is the cardinality of the set . Therefore, using
(9) and Lemma 5, we get
1i/1id 1

1
/0
c
/
c
c
/!
1 c
c
1d
2
3
_ _
/
1 c
cc
c
1d
2
3
.
where is the area of the hatched crescent in Fig. 8
(collection of all points Q, Q 1, and Q1 1):
D
1.1
ID
.1
. D
1.1

_ _
1
2
2 arccos
d
21
_ _ _ _
d

1
2

d
2
_ _
2

.
tu
Corollary 2. Using Theorem 8, we get
1i/1id cc
c
11
2
3
.
Proof. Consider the function
)r r c
r
1.
It is easy to show that )r has a global minimum at
r 0. Therefore, we have
1 c
r
r
for any real number r. As a result, we get
1i/1id 1 c
cc
c
1d
2
3
cc
c
1d
2
3
.
tu
It is also possible that node `
1
receives the message from
more than one neighbor in its defer period. In this case, the
number of `
1
s neighbors that have received the message
increases, and the number of that have not received the
message decreases. Consequently, the probability that `
1
is
required to broadcast the message further decreases
compared to the case where `
1
receives the message from
only one neighbor. It is worth mentioning that RBS can
guarantee that the number of forwarding nodes is within a
constant factor of the optimal solution (minimum CDS) if it
is provided with 2-hop neighbor information [21].
4.4 Relaxing Some System Model Assumptions
We assumed in Section 2 that the nodes are placed in a 2D
plane. However, this assumption is not used in the proof of
Theorem 6. Therefore, the proposed receiver-based algo-
rithm can also achieve full delivery when the nodes are
distributed in a 3D space. Note that in this case, RBS uses
3D node positions.
We can also relax the assumption that all the nodes have
the same transmission range 1. When the nodes transmis-
sion ranges are different, the topology graph should be
defined as a directed graph for which there is a link from
`

to `
1
if `
1
is in the transmission range of `

. Suppose
G is an undirected graph obtained by removing unidirec-
tional links of the topology graph. We assume that G is
connected and define two nodes as neighbors if there is a
link between them in G (i.e., they are in the transmission
range of each other). Note that many wireless MAC
protocols such as IEEE 802.11 require bidirectional links.
Let us assume that nodes put not only their ID and position
but also their transmission range into the hello messages
that they periodically broadcast. Therefore, the neighbors of
a node know both its position and transmission range. In
this case, nodes can use Algorithm 6 to decide whether or
not to broadcast.
Algorithm 6 is a modified version of RBS. When
executed by a node `

, Algorithm 6 uses the position and

transmission range of the broadcasting nodes to determine
which neighbors have not received the message. It then
returns false if and only if it finds a neighbor `
1
that has not
received the message and
1 1C or 1C transmission range of `
C
for any `

s neighbor `
C
that has received the message.
Algorithm 6. Modified RBS
Input: 1i:t

: List of all neighbors of `

, and 1i:t
1
: List of
broadcasting neighbors
Output: true or false
1: 1i:t
C
1i:t

2: for i 1; i length1i:t
C
; i++ do
3: for , 1; , length1i:t
1
; ,++ do
4: if dist1i:t
C
i. 1i:t
1
, 1
1i:t
1
,
then
5: {1
1i:t
1
,
: Transmission range of node 1i:t
1
,}
6: removeElement1i:t
C
i. 1i:t
C

7: break
8: end if
240 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 8, NO. 2, FEBRUARY 2009
9: end for
10: end for
11: 1i:t
1
1i:t

1i:t
C
12: for i 1; i length1i:t
C
; i++ do
13: c/cc/ tinc
14: for , 1; , length1i:t
1
; ,++ do
15: if dist1i:t
C
i. 1i:t
1
, < dist1i:t
C
i. `

then
16: if dist1i:t
C
i. 1i:t
1
, 1
1i:t
1
,
then
17: c/cc/ )o|:c
18: break
19: end if
20: end if
21: end for
22: if check then
23: return (false)
24: end if
25: end for
26: return (true)
Corollary 3. In a collision-free network, Algorithm 4 can achieve
full delivery if it uses the modified RBS to determine whether
or not to broadcast.
Proof. The proof is similar to the proof of Theorem 6. By
contradiction, suppose there is at least one node that has
not received the message after the broadcasting termina-
tion. Let us consider the set

_
`
A
. `
Y
j`
A
and `
Y
are neighbors.
`
A
has received the message. and
`
Y
has not received the message
_
.
Suppose `
o
is the node that initiated broadcasting, and
`
T
is a node that has not received the message. There is a
path between `
o
and `
T
in G; thus, we can find two
neighbors `

and `
1
along the path from `
o
to `
T
such
that `

has received the message and `

1
has not
received it. Consequently, `

. `
1
2 ; thus, 6 ;. As
a result, we have
9`

0 . `
1
0 2 s.t. 8`
A
. `
Y
2 :
0
1
0
AY . 10
Clearly, `

0 has not broadcast, since `

1
0 has not received
the message. Therefore, there must be a node `
C
0 such
that `
C
0 has received the message and
C
0
1
0
<
0
1
0
and C
0
1
0
Transmission range of `
C
0 .
This result contradicts (10) because `
C
0 . `
1
0 2 . tu
We can relax the assumption of having precise position
information as well. The reader is referred to [21] for
more details about broadcasting under uncertain position
information.
5 SIMULATION
5.1 Average Number of Nodes Selected by the
Proposed Sliced-Based Algorithm
In Section 3, we proved that the proposed forwarding-node
selection algorithm selects 11 nodes in the worst case. In
practice, the number of selected nodes is typically less than
11. To avoid the complexity of mathematical analysis, we
used a simulation to find the average number of selected
nodes. For a given number of neighbors 1 i 160, we
randomly put i points inside a circle with radius 1. We then
ran the proposed selection algorithm and obtained the
number of selected nodes. To get the average number of
selected nodes, we ran simulation 10
6
times for each given i.
As shown in Fig. 9, the average number of selected nodes is
less than six and approaches five when i increases. Note that
the proposed sliced-based selection algorithm does not
necessarily select a B-coverage with a minimum number of
nodes. However, there is a sliced-based selection algorithm
that can find a B-coverage with a minimumnumber of nodes
in Oilog i and can consequently reduce the average
number of selected nodes. It is worth mentioning that Fig. 9
shows the average number of selected nodes by the source
node (the node that initiates the broadcasting). For the rest of
broadcasting nodes, the average number of selected nodes is
at least one less than that for the source node because of the
optimization technique introduced in Section 3.
5.2 Probability of Broadcast Using the Proposed
RBS
Suppose that the proposed receiver-based algorithm is used
for broadcasting in the network. Assume that node `
1
receives a message from `

for the first time. It has been

proven that the probability of `
1
broadcasting the message
1i/1id
1
exponentially decreases when the distance 1
decreases or when the node density c increases. We used
simulation to confirm this theoretical result. For the
simulation, we considered two nodes `

and `
1
with
distance 0 < d 1 from each other. We uniformly placed
nodes with density c inside the network and checked
whether or not `
1
was required to broadcast the message.
We ran simulation 10
6
times for a given c and 1. We then
estimated 1i/1id
1
by the ratio of the number of times `
1
was required to broadcast over the total number of runs.
Figs. 10, 11, 12, and 13 show the simulation results for
several values of c, d, and 1. As shown in these figures, the
probability of broadcast exponentially decreases when d
decreases or when c increases. For example, when 1 300 m
KHABBAZIAN AND BHARGAVA: EFFICIENT BROADCASTING IN MOBILE AD HOC NETWORKS 241
Fig. 9. Average number of nodes selected by the proposed slice-based
algorithm.
and c 4 10
4
, the probability of broadcast is 0.1 for
d 250 m and reduces to 10
4
for d 200 m. This property
can justify why the proposed receiver-based algorithm can
significantly reduce the number of broadcasts in the net-
work. Fig. 14 illustrates an instance of using RBS for the case
where 1 300 m, c 4 10
4
, and nodes are placed in a
square area of 1.000 1.000 m
2
. As shown in Fig. 14, only
nine nodes (represented by stars) among 400 nodes broad-
cast the message.
5.3 Performance of Proposed Sender-Based and
Receiver-Based Algorithms
The main objective of efficient broadcasting algorithms is to
reduce the number of broadcasts. Therefore, we considered
the ratio of broadcasting nodes over the total number of
nodes as the metric to evaluate the performance of the
proposed broadcasting algorithms. Using the ns-2 simula-
tor, we evaluated this metric against two parameters:
transmission range and node density. In each simulation
run, we uniformly distributed ` nodes in a 1.000
1.000 m
2
square area, where ` c network area. A
randomly generated topology was discarded if it led to a
disconnected network. Only one broadcasting occurred in
each simulation run by a randomly selected node. Table 1
242 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 8, NO. 2, FEBRUARY 2009
Fig. 11. Probability of broadcast for 1 400 m.
Fig. 12. Probability of broadcast for 1 500 m.
Fig. 13. Probability of broadcast for 1 600 m.
Fig. 14. Broadcasting nodes in a 1.000 1.000 m
2
square area with
400 nodes.
TABLE 1
Simulation Parameters
Fig. 10. Probability of broadcast for 1 300 m.
summarizes some of the parameters used in ns-2. As
shown in the table, the total number of nodes ` varies
within 25-1,000, and the transmission range varies within
50-300 m. As a result, the simulation covers very sparse and
very dense networks as well as the networks with large
diameters.
Figs. 15 and 16 show the average ratio of broadcasting
nodes for 100 separate runs. The performance of our
proposed algorithm is compared with the performance of
Liu et al.s algorithm [8] and the Edge Forwarding
algorithm [22]. Using the Edge Forwarding algorithm, each
node divides its transmission coverage into six equal-size
sectors and decides whether or not to broadcast based on
the existence of forwarding nodes in some overlapped
areas. In [8], Liu et al. show that the number of redundant
broadcasts using their broadcasting algorithm is signifi-
cantly lower than that of previous notable broadcasting
algorithms [22], [23]. As proved earlier, our proposed
sender-based algorithm has lower computational complex-
ity and selects fewer forwarding nodes than Liu et al.s
algorithm. The simulation results, shown in Figs. 15 and 16,
indicate two interesting facts. First, our proposed sender-
based algorithm does not require more broadcasts than
Liu et al.s proposed broadcasting algorithm. Second, the
number of broadcasts using RBS is significantly lower than
the number associated with the other implemented algo-
rithms. In fact, as shown in Figs. 15 and 16, this number is
even less than one of the best-known approximations for
the minimum number of required broadcasts [6]. Note that
in RBS, the probability that two close nodes broadcast the
same message is very low. As a result, the number of
broadcasting nodes is statistically bounded in a finite region
(e.g., the transmission range of a node). However, using the
slice-based and Liu et al.s algorithms, the chance that two
close nodes broadcast the same message is not negligible.
For example, using Liu et al.s algorithm, a node `

selects
the smallest subset of its 1-hop neighbors with the
maximum coverage area, where the coverage area of a set
of nodes is the union of their transmission coverage. As
expected, most of the nodes around the transmission
boundary of `

will be selected by `

since they often

have contributions in the maximum coverage area of `

s
1-hop neighbors. Therefore, it is likely for Liu et al.s
algorithm to select two close nodes around the transmission
boundary of a node.
We repeated the simulation to consider a few more
scenarios. In the first scenario, we changed the node
distribution from a uniform to a 2D Gaussian distribution.
Both the center and the variance of the Gaussian distribu-
tion were randomly selected for each run. The variance was
selected from the range 200-400 to avoid a very dense
population of nodes around the center of the distribution.
As shown in Fig. 17, the number of broadcasting nodes
decreases for all the broadcasting algorithms when a
Gaussian distribution is used to distribute the nodes in
the region. The simulation results indicate that the RBS
algorithm still performs significantly better than other
broadcasting algorithms considered in this work.
In the second scenario, we used a uniform distribution
to distribute the nodes and evaluated the impact of
message-reception failure on the performance of broad-
casting algorithms. We considered two networks of 100 and
400 nodes. The probability of message-reception failure was
assumed to be equal and independent for each node in the
network. For both networks, the maximum transmission
KHABBAZIAN AND BHARGAVA: EFFICIENT BROADCASTING IN MOBILE AD HOC NETWORKS 243
Fig. 15. Ratio of broadcasting nodes versus total number of nodes
(uniform distribution).
Fig. 16. Ratio of broadcasting nodes versus transmission range (uniform
distribution).
Fig. 17. Ratio of broadcasting nodes versus total number of nodes
(Gaussian distribution).
range was set to 250 m. Figs. 18 and 19 compare the
average delivery ratio of the broadcasting algorithms for
different probabilities of message-reception failure. As
shown in these figures, the Edge Forwarding algorithm is
the most robust broadcasting algorithm against message-
reception failure. This is because the impact of message loss
is less when the broadcast redundancy is high. Interest-
ingly, the robustness of the RBS algorithm significantly
improves as the node density increases. The simulation
results indicate that the slice-based algorithm is the least
robust broadcasting algorithm against message-reception
failure. This is mainly due to the fact that the slice-based
algorithm selects a small number of nodes (less than six on
the average) to forward the message. Therefore, when the
probability of message-reception failure is high, it is very
likely that most of the selected nodes fail to receive and
thus forward the message.
Finally, we simulated the broadcasting algorithms in a
mobile wireless setting. The nodes were initially distributed
using a uniform distribution. In the simulation, we used a
random walk mobility model and set the maximum velocity
to 10 m/s. We fixed the transmission range to 250 m and
varied the total number of nodes within 25-1,000. The
simulation results indicate that all the broadcasting algo-
rithms considered in this paper can achieve a high delivery
ratio (above 95 percent on the average) for ` ! 50, where `
is the total number of nodes in the network. This is mainly
because the implemented broadcasting algorithms make
broadcasting decisions on the fly. For ` 25, the
implemented algorithms failed to achieve a high delivery
ratio because the network could easily get disconnected due
to the nodes mobility. Clearly, broadcasting algorithms
cannot achieve a high delivery ratio in such scenarios. It is
worth mentioning that for ` ! 50, the ratio of broadcasting
nodes is almost the same as the case where there is no
mobility (see Fig. 15).
6 CONCLUSION AND FUTURE WORK
In the first part of this paper, we proposed a forwarding-
node selection algorithm that selects at most 11 nodes in
Oi, where i is the number of neighbors. This limited
number of nodes is an improvement over Liu et al.s
algorithm, which selects i nodes in the worst case and has
time complexity Oilog i. Moreover, we showed that our
proposed forwarding-node selection algorithm results in
fewer broadcasts in the network. In the second part of the
paper, we proposed an efficient receiver-based algorithm
and showed why it significantly reduces the number of
forwarding nodes in the network. We also relaxed some
system model assumptions that are typically used in the
broadcasting algorithms. Interestingly, the 2-hop-based
version of our proposed receiver-based algorithm can
guarantee constant approximation to the optimal solution
(minimum CDS). As far as the authors know, this is the first
broadcasting algorithm that constructs a CDS on the fly
and can guarantee both full delivery and a constant
approximation ratio to the optimal solution. As part of
our future work, we will investigate the necessary condi-
tions to guarantee both full delivery and constant approx-
imation ratio to the minimum CDS.
REFERENCES
[1] C. Perkins, Ad Hoc on Demand Distance Vector (AODV) Routing,
IETF Internet draft, work in progress, 1997.
[2] D. Johnson and D. Maltz, Dynamic Source Routing in Ad Hoc
Wireless Networks, Mobile Computing, T. Imielinski and
H.F. Korth, eds., Kluwer Academic Publishers, 1996.
[3] S. Ni, Y. Tseng, Y. Chen, and J. Sheu, The Broadcast Storm
Problem in a Mobile Ad Hoc Network, Proc. ACM MobiCom 99,
pp. 151-162, 1999.
[4] M. Garey and D. Johnson, Computers and Intractability: A Guide to
the Theory of NP-Completeness. W.H. Freeman, 1990.
[5] B. Clark, C. Colbourn, and D. Johnson, Unit Disk Graphs,
Discrete Math., vol. 86, pp. 165-177, 1990.
[6] P. Wan, K. Alzoubi, and O. Frieder, Distributed Construction of
Connected Dominating Set in Wireless Ad Hoc Networks, Proc.
IEEE INFOCOM 02, vol. 3, pp. 1597-1604, 2002.
[7] S. Funke, A. Kesselman, U. Meyer, and M. Segal, A Simple
Improved Distributed Algorithm for Minimum CDS in Unit Disk
Graphs, ACM Trans. Sensor Networks, vol. 2, no. 3, pp. 444-453,
2006.
[8] H. Liu, P. Wan, X. Jia, X. Liu, and F. Yao, Efficient Flooding
Scheme Based on 1-Hop Information in Mobile Ad Hoc Net-
works, Proc. IEEE INFOCOM, 2006.
244 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 8, NO. 2, FEBRUARY 2009
Fig. 19. Average delivery ratio versus probability of message-reception
failure ` 400.
Fig. 18. Average delivery ratio versus probability of message-reception
failure ` 100.
[9] Y. Tseng, S. Ni, and E. Shih, Adaptive Approaches to Relieving
Broadcast Storms in a Wireless Multihop Mobile Ad Hoc
Networks, Proc. 21st Intl Conf. Distributed Computing Systems
(ICDCS 01), pp. 481-488, 2001.
[10] Y. Sasson, D. Cavin, and A. Schiper, Probabilistic Broadcast for
Flooding in Wireless Mobile Ad Hoc Networks, Proc. IEEE
Wireless Comm. and Networking Conf. (WCNC 03), pp. 1124-1130,
2003.
[11] W. Lou and J. Wu, Double-Covered Broadcast (DCB): A
Simple Reliable Broadcast Algorithm in Manets, Proc. IEEE
INFOCOM 04, pp. 2084-2095, 2004.
[12] J. Wu and F. Dai, Broadcasting in Ad Hoc Networks Based on
Self-Pruning, Proc. IEEE INFOCOM 03, pp. 2240-2250, 2003.
[13] W. Peng and X. Lu, On the Reduction of Broadcast Redun-
dancy in Mobile Ad Hoc Networks, Proc. ACM MobiHoc 00,
pp. 129-130, 2000.
[14] T. He, C. Huang, B. Blum, J. Stankovic, and T. Abdelzaher,
Range-Free Localization Schemes in Large Scale Sensor Net-
works, Proc. ACM MobiCom 03, pp. 81-95, 2003.
[15] A. Keshavarz-Haddad, V. Ribeiro, and R. Riedi, DRB and DCCB:
Efficient and Robust Dynamic Broadcast for Ad Hoc and Sensor
Networks, Proc. Fourth Ann. IEEE Conf. Sensor, Mesh and Ad Hoc
Comm. and Networks (SECON 07), June 2007.
[16] R. Wattenhofer, L. Li, P. Bahl, and Y. Wang, Distributed Topology
Control for Power Efficient Operation in Multihop Wireless
Ad Hoc Networks, Proc. IEEE INFOCOM01, pp. 1388-1397, 2001.
[17] L. Li, J. Halpern, P. Bahl, Y. Wang, and R. Wattenhofer, A Cone-
Based Distributed Topology-Control Algorithm for Wireless
Multi-Hop Networks, IEEE/ACM Trans. Networking, vol. 13,
pp. 147-159, 2005.
[18] M. Sun, W. Feng, and T. Lai, Broadcasting in Ad Hoc Networks
Based on Self-Pruning, Proc. IEEE Global Telecomm. Conf.
(GLOBECOM 01), pp. 2842-2846, 2001.
[19] A. Papoulis, Probability and Statistics. Prentice Hall, 1990.
[20] R. Chang and R. Lee, On the Average Length of Delaunay
Triangulations, BIT Numerical Math., vol. 24, pp. 269-273, 1984.
[21] M. Khabbazian and V.K. Bhargava, Localized Broadcasting with
Guaranteed Delivery and Bounded Transmission Redundancy,
IEEE Trans. Computers, vol. 57, no. 8, pp. 1072-1086, Mar. 2008.
[22] Y. Cai, K. Hua, and A. Phillips, Leveraging 1-Hop Neighborhood
Knowledge for Efficient Flooding in Wireless Ad Hoc Networks,
Proc. 24th IEEE Intl Performance, Computing, and Comm. Conf.
(IPCCC 05), pp. 347-354, 2005.
[23] J. Wu and H. Li, On Calculating Connected Dominating Set for
Efficient Routing in Ad Hoc Wireless Networks, Proc. Third Intl
Workshop Discrete Algorithms and Methods for Mobile Computing and
Comm. (DIAL-M 99), pp. 7-14, 1999.
Majid Khabbazian received the BSc degree in
computer engineering from the Sharif University
of Technology, Tehran, Iran, in 2002 and the
MASc degree in electrical and computer en-
gineering from the University of Victoria, British
Columbia, Canada, in 2004. He is currently a
PhD candidate in the Department of Electrical
and Computer Engineering, University of British
Columbia, Vancouver, British Columbia, Cana-
da, where he is a university graduate fellowship
holder. He was a university graduate fellowship recipient at the
University of Victoria. His current research interests include cryptogra-
phy and wireless network security. He is a student member of the IEEE.
Vijay K. Bhargava received the BSc, MSc, and
PhD degrees from Queens University, Kingston,
Ontario, Canada in 1970, 1972, and 1974,
respectively. Currently, he is a professor and
the head of the Department of Electrical and
Computer Engineering, University of British
Columbia, Vancouver, British Columbia, Cana-
da. He was with the University of Victoria from
1984 to 2003 and with Concordia University,
Montreal, from 1976 to 1984. He is a coauthor of
the book Digital Communications by Satellite (John Wiley & Sons,
1981), a coeditor of Reed-Solomon Codes and Their Applications (IEEE,
1994), and a coeditor of Communications, Information and Network
Security (Kluwer Academic Publishers, 2003). His research interests are
in wireless communications. He is very active in the IEEE and was
nominated by the IEEE Board of Directors for the office of IEEE
President-Elect. He has served on the Board of the IEEE Information
Theory Society and the IEEE Communications Society. He is a past
president of the IEEE Information Theory Society. He is the editor-in-
chief for the IEEE Transactions on Wireless Communications. He
received the IEEE Centennial Medal in 1984, the IEEE Canadas
McNaughton Gold Medal in 1995, the IEEE Haraden Pratt Award in
1999, the IEEE Third Millennium Medal in 2000, the IEEE Graduate
Teaching Award in 2002, and the Eadie Medal of the Royal Society of
Canada in 2004. He is a fellow of the IEEE, the Engineering Institute of
Canada (EIC), the Canadian Academy of Engineering, and the Royal
Society of Canada.
> For more information on this or any other computing topic,
please visit our Digital Library at www.computer.org/publications/dlib.
KHABBAZIAN AND BHARGAVA: EFFICIENT BROADCASTING IN MOBILE AD HOC NETWORKS 245