Tree-Forming Schemes for Overload Control in

Wireless Sensor Networks

Charalambos Sergiou and Vasos VassiliouNetworks Research Laboratory

Department of Computer Science

University of Cyprus

Nicosia, Cyprus

Email: {sergiou,vasosv}@cs.ucy.ac.cy

Abstract—Node placement in Wireless Sensor Networks(WSNs) is frequently redundant and massive. Massive and densedeployments require efficient and effective, topology controlalgorithms in order to reduce the number of active nodes and easethe transportation of data from sources to sinks. Tree-forming

is a common strategy in topology control algorithms that canbe employed for such purpose. The most common tree-formingscheme, is shared, core-based tree, which initiates from the sink.In this work, we study how tree-forming schemes that initiatefrom sources can affect the performance of congestion/overloadcontrol algorithms. Specifically, we study source-based routingtrees in comparison with shared-, core-based trees, under trafficand resource congestion control algorithms.

Index Terms—Wireless Sensor Networks, Congestion Control,Source Based Trees, Sink Based Trees

I. INTRODUCTION

A Wireless Sensor Network (WSN) is a network com-

posed of wireless sensor nodes, capable of sensing some

phenomenon, transforming this analog data into digital and

transmitting the information to destination nodes (usually

called sinks). Due to severe power limitations their computa-

tion capability, as well as their transmission range, is limited.

A WSN comprises of a potential large set of nodes that may

be distributed over a wide geographical area indoor or outdoor.

Thus, for the transmission of data from a source (the node that

sensed the phenomenon) to a sink, the wireless sensor nodes

that lie between them, form a ”path” and data are transmitted

through it in a hop-by-hop fashion. Frequently, sensor nodes

are densely deployed near the event sources and sinks in a

redundant manner [1]. Traffic patterns in WSNs can be derived

from the physical processes that they sense. Wireless Sensor

Networks typically operate under light load and they suddenly

become active in response to a detected or monitored event.

Depending on the application this can result in the generation

of large, sudden and correlated- synchronized impulses of data

that must be delivered to a small number of sinks without

significantly disrupting the performance (i.e fidelity) of the

sensing application. This high generation of data packets is

usually uncontrolled and often leads to congestion (overflowed

buffers or packet collisions in the medium). There are a

number of protocols proposed in literature for congestion

control in Wireless Sensor Networks. A detailed analysis of a

number of them can be found in [2] and [3].

Coverage and reliability issues render massive and dense

placement of Wireless Sensor Nodes compulsory for many

applications. Massive and dense placement creates a number

of critical issues that, if not addressed correctly, are possible

to ruin completely the network’s task. Interference between

neighbor nodes, overload, and routing problems, are certain to

arise, if all nodes are allowed to transmit data each time they

sense an event. Thus, effective and efficient topology control

algorithms must be employed in order to reduce the number

of active nodes and ease the routing process [4].

Tree-forming schemes, is a common category of topology

control algorithms, that are usually employed when dense

and massive placements of sensor nodes exist. The most

common type of tree topologies, is the shared, core-based

tree, which has the sink node as the root. Networks that

employ this specific type of topology control scheme, create

a spanning tree that initiates from the sink and as a result the

initial placement and redundant connections between nodes

are severely reduced. Shared, core-based trees, also known as

sink-based trees in WSNs, are proven to be an efficient and

effective topology control solution. Sink-based trees is the term

that we will use for the rest of the paper.

In this work, we focus on congestion control algorithms and

we study whether specific tree-forming schemes can improve

the performance of congestion control algorithms when the

network faces an overload condition. In particular, we focus

on source based trees. Source-based trees are created by each

node that becomes source node (its analog part senses an

event). These trees have not been widely adopted in WSNs

since they incur excessive overhead to the network. In this

paper we study whether and how source-based trees can

improve, under specific circumstances, the performance of

congestion control algorithms. This work complements and

extents the work presented in [5].

The rest of the paper is organized as follows. In section II

we present a brief description of congestion control methods

in WSNs. In section III we describe the source and sink based

trees, while in section IV we present the evaluation and results.

Finally, we close with discussion and conclusions.

2012 The 11th Annual Mediterranean Ad Hoc Networking Workshop (Med-Hoc-Net)

978-1-4673-2039-9/12/$31.00 ©2012 IEEE 61

II. CONGESTION CONTROL METHODS IN WSNS

Congestion in WSNs happens when the offered load is

temporarily higher than the load the network resources can

process. Congestion happens either in the medium or in node

buffers. In the first case (medium) many nodes within range

of one another attempt to transmit simultaneously, resulting

in packet losses due to interference and thereby reducing

the throughput of all nodes in the area. In the other case

(buffer), node receives packets with a higher data rate than

the maximum data rate that it can transmit and the buffer of

this particular node overflows.

Currently, congestion control algorithms employ two dif-

ferent methods in order to face overload conditions: “Traffic

Control” and “Resource Control” [6]. Algorithms that employ

the“Traffic Control” method attempt to adjust the data rate of

the sources in order not to exceed the capacity of data that

nodes can store and process. This method has been employed

by the vast majority of congestion control algorithms [7], [8],

[9], [10], [11], [12], [13], [14] and it is similar to the approach

that is applied for congestion control in traditional networks.

On the other hand, algorithms that apply the “Resource

Control” method, attempt to take advantage of the dense and

massive placements of wireless sensor nodes. In this case,

when a node senses that is becoming overloaded, it informs,

through a backpressure message, the nodes that are forwarding

data through itself, to search for another forwarding node,

since it will soon be unable to accept any more packets. Thus,

algorithms that apply the resource control method, employ

nodes that are not in the initial path from the source to the

sink, in order to forward the excess data through them. The

data rate of the sources is not affected in this scheme.

III. TREE-FORMING SCHEMES

Tree-forming is an efficient and effective solution for topol-

ogy control in WSNs. The tree-forming scheme that has been

widely employed in WSNs is sink-based trees.

A. Sink-based Trees

Sink-based trees use the sink as the core node. This is

optimum in WSNs, since the sink is usually a robust node

that does not suffer from power or processing limitation issues.

Thus, sink-based trees defeat the main disadvantage of share-

core based trees which is the fact that the core node can

become a single point of failure.

In Fig. 1 the initial connectivity of the network is presented

while in Fig. 2 a sink-based tree, that resulted from the initial

topology (Fig. 1) is presented.

It is clear that creating a level-based, shared tree, leads to

a ”relaxed” topology (with a lower degree of connectivity).

This leads to fewer connections between the nodes, less

interference, and less probability of congestion occurrence.

The process for the creation of sink-based trees is analyti-

cally described in [5].

Fig. 1. Initial Network Connectivity (before topology control algorithmapplies)

Fig. 2. Sink Based Tree

B. Source-based Trees

Source-based trees introduce a completely different routing

approach in comparison with sink-based trees. The major

difference lies on the fact that source based trees, are built on

demand and only when a node becomes a source node. Thus,

each time a node becomes a source node it creates its own

routing tree from itself to sink. As stated in [5] the creation

of a properly constructed and well tuned source based trees

is not a straightforward procedure as with sink-based trees. If

the procedure is not monitored carefully it is easy to result

in a ”naive” tree, which it is not acceptable in many cases.

62

Figure 3, presents a “naive” tree.

Fig. 3. A “naive” source based tree

A “naive” tree presents several drawbacks which can be

proven fatal for network operation especially when resource

control-based algorithms apply. Resource control algorithms

base their operation, on the creation of alternative paths to

sink, in order to avoid an overloaded node. If the routing tree

is not properly constructed, the appearance of routing circles

is possible.

To construct source-based trees, which can fulfill their

purpose, we must consider a small set of “critical” parameters:

Location Awareness - Each node must be aware of its loca-

tion and the location of the sink. Localization and positioning

is a subject that attracted a lot of attention and solutions exist

in literature [15]. Location awareness is important for each

node that is going to participate in a source based tree, since

forwarding of nodes must be in the direction of the sink. Thus

each node must select as neighbor nodes, nodes that are closer

to sink than itself.

Higher Level Connection Availability - A node must be

kept on the source-based tree, only if it can communicate with

at least one node that is closer to sink than itself. In case that

higher level connection availability is not possible, then this

node cannot be part of the tree.

Number of nodes kept in neighbor table - The number of

nodes that must be kept in the neighbor table must be optimal.

In dense placements is possible to allow a large number of

nodes as neighbors. According to [16] a value of six neighbors

seems to be optimal for most topologies.

Employing these parameters in Fig. 3, the initial source

based tree transforms to the one in Fig. 4

IV. EVALUATION

To compare the performance of source-based against sink-

based trees, when resource and traffic control algorithms for

Fig. 4. A properly constructed source based tree

congestion control in WSNs are employed, we performed a

series of simulations.

A. Network Model

We assume that there is a WSN, where nodes are initially

deployed uniformly. One sink is located at a specific point

in the network. Each node is considered to be aware of its

position in relation to the sink. In our network deployment

we consider that all nodes (except the sink) are identical

and “carrier sense multiple access with collision avoidance”

(CSMA/CA) is employed as MAC protocol.

Moreover, in order to compare the performance of source-

and sink-based trees when the network faces congestion, we

employed as a resource control reaction mechanism, the alter-

native path creation scheme of Hierarchical Tree Alternative

Path (HTAP) algorithm [17].

Also, we employed as a “traffic control” mechanism, a

simple mechanism, which in case of congestion informs with a

backpressure message the sources, to reduce the data rate. By

using the “additive increase multiplicative decrease” (AIMD)

method, this algorithm attempts to adapt the data rate to the

capacity of the network. When the “traffic control” algorithm

is employed the packets are always routed through the shortest

path from each source to the sink.

B. Simulator Setup

For our simulations we employed the Prowler simulator

[18]. The radio propagation and transmission models we used

are given by:

Prec,ideal(d)← Ptransmit

1

1 + dγ(1)

where, 2 ≤ γ ≤ 4 and

63

Prec(i, j)← Prec,ideal(di,j)(1 + a(i, j))(1 + β(t)) (2)

where Ptransmit is the signal strength at the transmitter and

Prec,ideal(d) is the ideal received signal strength at distance

d, a and β are random variables with normal distributions

N(0, σa) and N(0, σβ), respectively. A node j can receive

packets from node i if Prec(i, j) > ∆ where ∆ is the

threshold.

In our simulations we used the following default simulator

parameters:

• sigmaa = 0.5• sigmaβ = 0.03• perror = 0.05• ∆ = 0.1

The rest of the parameters reflect Mica-Z node specifica-

tions, the most important of which are presented in Table I.

TABLE ISIMULATION PARAMETERS

Max Data Rate (kbps) 128Transmission Power (dbm) 2Receive Threshold (dbm) -74Transmission Current (mA) 17.4Receive Current (mA) 19.7Fragment Size (bit) 1024Buffer Size(Bytes) 512KMAC layer CSMA/CA

C. Scenarios and Results

For each of the performance metrics presented below, the

results are the average of 20 runs for 10s for each measurement

point (except for the cases that it is otherwise stated). Nodes

are uniformly placed on a square grid. All nodes communicate

only with the nodes that are one hop away. We employed

12 sources and every source is programmed to transmit at

maximum 128 packets/s, while we increase the number of

nodes on the grid.

The first metric we examine is sink throughput. Sink

throughput indicates the ability of any congestion control

algorithm, to control congestion and transmit a maximum

number of packets to the sink.

Fig. 5 presents the results when the resource control method

applies.

Results show that, when resource control is used along with

a source based tree, the sink throughput increases. This result

indicates the ability of source-based trees to provide more

alternative paths, in comparison with sink-based trees. Thus,

algorithms that employ resource control methods are favored

by the employment of source-based trees and as a result they

enhance their performance in terms of sink throughput. Sink-

based trees cannot provide as many alternative paths as source-

based trees and normally throughput is reduced. A “naive”

tree is the worst option, since routing circles and uncontrolled

number of alternative paths enhance may congestion problem

instead of relieving it.

50 100 150 200 250 300 3500

200

400

600

800

1000

1200

1400

1600

1800

Number of Nodes

Sin

k T

hro

ug

hp

ut

(pkts

/s)

Source Based Tree

Sink Based Tree

"Naive" Source Based Tree

Fig. 5. Resource Control Method: Sink Throughput (pkts/s)

Also, we notice that as the number of nodes in the network

increases, throughput also increases since more alternative

paths can be provided.

When “traffic control” method is employed, the situation is

different (Fig. 6).

50 100 150 200 250 300 350350

400

450

500

550

600

650

700

750

800

Number of Nodes

Sin

k T

hro

ug

hp

ut

(pkts

/s

Source Based Tree

Sink Based Tree

"Naive" Source Based Tree

Fig. 6. Traffic Control Method: Sink Throughput (pkts/s)

In this case, the sink throughput is significantly reduced

in comparison with the resource-control method. When a

traffic-control method applies, the network attempts to adjust

the traffic to the available network resources. Thus, since

algorithms that employ traffic control do not alter their routing

path and always use the shortest path, the sink throughput is

affected by the number of flows that cross each other. It is

notable that in this scenario the sink-based tree provides the

worst results in comparison with the other two trees. This is

normal, since when a sink-based tree is employed data flows

from each source share the same topology. On the other hand,

when source and “naive” trees are employed, each source

node creates its own routing tree from the beginning. Hence,

more nodes are employed as part of the tree and a lower

64

number of data flows cross between them. “Naive” trees, give

acceptable results concerning sink throughput, since after the

tree creation, each source finds the shortest path to the sink.

The results are worse than source-based trees, since a naive

trees create longer paths to the sink and flows cross in more

nodes in comparison.

The next parameter we study is the average delay of

successfully received packets from the sources to the sink.

Fig. 7 presents the results for the resource control method.

50 100 150 200 250 300 35020

30

40

50

60

70

80

90

100

Number of Nodes

Av

era

ge

So

urc

e t

o S

ink

De

lay

(m

S)

Source Based Tree

Sink Based Tree

"Naive" Source Based Tree

Fig. 7. Resource Control Method: Average Delay from Sources to Sink (ms)

Sink-based trees, provides less delay in comparison with

the other trees. This is normal since a sink-based tree is a

spanning tree and the position from each node to the sink is

the minimum. Between the other two trees, the average delay

when source-based tree is employed is less than that of the

“naive tree”. Source-based trees provide more routing paths in

case of congestion while “naive” trees provide longer routes

and in some cases routing circles, that increase the delay.

Fig. 8 presents the results when traffic control is employed.

50 100 150 200 250 300 35022

24

26

28

30

32

34

36

38

Number of Nodes

Av

era

ge

So

urc

e t

o S

ink

De

lay

(m

s)

Source Based Tree

Sink Based Tree

"Naive" Source Based Tree

Fig. 8. Traffic Control Method: Average Delay from Sources to Sink (ms)

In this case the overall delay is less, in all three topologies,

in comparison with the case that the resource control method

applies. This result is expected, since algorithms that employ

traffic control, always use the shortest path from source to sink

and do not re-route any packets. Between the three topologies,

sink-based trees present much better results in comparison

with the other two trees. The reason lies in the fact that sink-

based trees create a spanning tree using a shared topology. On

the other hand, source-based trees, present an increased initial

overhead, in order to create each tree from each source, while

the “naive tree”solution provides longer routes, which results

in increased delay.

Finally, we study the average energy consumption of the

network. Each energy unit is equal to 1000mW in 1 second.

Fig. 9 presents the results when resource control is used.

As it is expected, the “naive” tree presents the worst results

while the sink-based tree, the best.

50 100 150 200 250 300 3502

2.5

3

3.5

4

4.5

5

5.5

6

Number of Nodes

En

erg

y C

on

su

mp

tio

n (

un

its

)

Source Based Tree

Sink Based Tree

"Naive" Source Based Tree

Fig. 9. Resource Control Method: Average Energy Consumption (units)

This is normal, since sink-based tree creates a shared

topology and nodes follow the shortest paths in order to reach

sink. On the other hand, source-based trees create a big number

of paths and in some cases nodes follow longer routes in order

to reach sink.

Concerning the “traffic control” algorithm, the situation is

as follows.

In this case, also sink-based trees provide the best results,

but the reason is different. According to Fig. 6, when the traffic

control method applies, sink-based trees provide the sink with

the fewer packets, since the sources’ data rate is reduced.

Less packets leads to fewer transmissions and less energy

consumption. Moreover, the average delay is also smaller,

which translates into fewer hop counts.

V. DISCUSSION

Studying the results we notice that source-based trees can

provide a proper topology control solution in WSNs when

overload conditions exist. Source-based trees provide better

results in terms of sink throughput when either traffic or

65

50 100 150 200 250 300 3501

1.2

1.4

1.6

1.8

2

2.2

2.4

2.6

Number of Nodes

En

erg

y C

on

su

mp

tio

n (

un

its

)

Source Based Tree

Sink Based Tree

"Naive" Source Based Tree

Fig. 10. Traffic Control Method: Average Energy Consumption

resource congestion control algorithms apply. The drawback

is the longer delay and the higher energy consumption they

present, in comparison with sink-based trees. Therefore, we

consider that source-based trees can provide a significant

topology control solution when the application demands the

vast majority of packets to reach sink. In this case, source-

based trees can be combined with resource-control algorithms.

However, source-based trees must be carefully tuned since the

creation of a “naive” tree, can prove extremely disadvanta-

geous in the operation of the network.

Moreover, results show that when sink-based trees are

combined with resource control algorithms they can also

provide very good results, in terms of delay and energy

consumption. We believe that this solution can present a

notable overall behavior, if carefully tuned. Finally, sink-based

trees, if combined with traffic-control algorithms can provide

excellent results in terms of delay and energy consumption.

This combination has already been proposed in literature

and can be used effectively for transient congestion control

situations.

VI. CONCLUSION

In this paper, we discuss how different tree structures can

be used for overload control in WSNs. Specifically, we present

source-based trees, shared-, core-based trees (sink-based trees)

and a naive source-based tree structure and evaluate them

under resource and traffic congestion control methods. Sim-

ulation results show that not only sink-based trees, but also

source-based trees can provide efficient and effective topology

control solutions, which are, of course, application specific.

ACKNOWLEDGMENTS.

This work has been partly conducted under the European

Union Project GINSENG funded under the FP7 Program

(FP7/2007-2013) grant agreement no 224282.

REFERENCES

[1] S. Toumpis and L. Tassiulas, “Optimal Deployment of Large WirelessSensor Networks,” IEEE Transactions on Information Theory, vol. 52,no. 7, pp. 2935–2953, 2006.

[2] C. Wang, M. Daneshmand, B. Li, and K. Sohraby, “A Survey ofTransport Protocols for Wireless Sensor Networks,” IEEE Network,May/June, vol. 20, pp. 34–40, 2006.

[3] C. Wang, K. Sohraby, B. Li, and W. Tang, “Issues of TransportControl Protocols for Wireless Sensor Networks,” in Proceedings ofInternational Conference on Communications, Circuits and Systems(ICCCAS), 2005.

[4] J. N. Al-karaki and A. E. Kamal, “Routing Techniques in WirelessSensor Networks: A Survey,” IEEE Wireless Communications, vol. 11,pp. 6–28, 2004.

[5] C. Sergiou and V. Vassiliou, “Source-based Routing Trees for Effi-cient Congestion Control in Wireless Sensor Networks,” in DistributedComputing in Sensor Systems and Workshops (DCOSS), InternationalConference on (PWSN2012 Workshop), May 2012.

[6] J. Kang, Y. Zhang, and B. Nath, “TARA: Topology-Aware ResourceAdaptation to Alleviate Congestion in Sensor Networks,” IEEE Trans-actions on Parallel and Distributed Systems, vol. 18, no. 7, pp. 919–931,2007.

[7] C. Wang, K. Sohraby, and B. Li, “SenTCP: A Hop-by-Hop CongestionControl Protocol for Wireless Sensor Networks,” IEEE INFOCOM(Poster Paper), March 2005.

[8] Y. Sankarasubramaniam, O. Akan, and I. Akyildiz, “ESRT: Event-to-Sink Reliable Transport in Wireless Sensor Networks,” in MobiHoc ’03:Proceedings of the 4th ACM International Symposium on Mobile AdHoc Networking & Computing. New York, NY, USA: ACM, 2003, pp.177–188. [Online]. Available: http://dx.doi.org/10.1145/778415.778437

[9] C. T. Ee and R. Bajcsy, “Congestion Control and Fairness for Many-to-One Routing in Sensor Networks,” in SenSys ’04: Proceedings of the2nd international conference on Embedded networked sensor systems.New York, NY, USA: ACM, 2004, pp. 148–161.

[10] B. Hull, K. Jamieson, and H. Balakrishnan, “Mitigating Congestion inWireless Sensor Networks,” in SenSys ’04: Proceedings of the 2ndInternational Conference on Embedded Networked Sensor Systems.New York, NY, USA: ACM, 2004, pp. 134–147.

[11] C.-Y. Wan, S. B. Eisenman, and A. T. Campbell, “CODA:Congestion Detection and Avoidance in Sensor Networks,” inSenSys ’03: Proceedings of the 1st international Conferenceon Embedded Networked Sensor Systems. New York, NY,USA: ACM Press, 2003, pp. 266–279. [Online]. Available:http://portal.acm.org/citation.cfm?id=958523

[12] K. Sundaresan, V. Anantharaman, H.-Y. Hsieh, and R. Sivakumar,“ATP: A Reliable Transport Protocol for Ad Hoc Networks,” IEEETransactions on Mobile Computing, vol. 4, pp. 588–603, 2005.

[13] F. Stann and J. Heidemann, “RMST: Reliable Data Transportin Sensor Networks,” in Proceedings of the First InternationalWorkshop on Sensor Net Protocols and Applications. Anchorage,Alaska, USA: IEEE, April 2003, pp. 102–112. [Online]. Available:http://www.isi.edu/ johnh/PAPERS/Stann03a.html

[14] C.-Y. Wan, A. T. Campbell, and L. Krishnamurthy, “P.S.F.Q: A ReliableTransport Protocol for Wireless Sensor Networks,” in WSNA ’02:Proceedings of the 1st ACM international workshop on Wireless SensorNetworks and Applications. New York, NY, USA: ACM Press, 2002,pp. 1–11. [Online]. Available: http://dx.doi.org/10.1145/570738.570740

[15] J. Hightower and G. Borriello, “Location Systems for UbiquitousComputing,” Computer, vol. 34, pp. 57–66, August 2001. [Online].Available: http://dx.doi.org/10.1109/2.940014

[16] N. Li, J. Hou, and L. Sha, “Design and Analysis of an MST-based Topol-ogy Control Algorithm,” in INFOCOM 2003. Twenty-Second AnnualJoint Conference of the IEEE Computer and Communications. IEEESocieties, vol. 3, 2003, pp. 1702 – 1712 vol.3.

[17] C. Sergiou, V. Vassiliou, and A. Pitsillides, “Reliable Data Transmissionin Event-Based Sensor Networks During Overload Situation,” inWICON’07: Proceedings of the 3rd International Conference on WirelessInternet, Austin, Texas, October 2007, pp. 1–8.

[18] Prowler: Probabilistic Wireless Network Simulator. [Online]. Available:http://www.isis.vanderbilt.edu/Projects/nest/prowler/

66