Stable Desynchronization for Wireless Sensor Networks: (II) Performance Evaluation

TL;DR

This paper evaluates the performance of the M-DWARF desynchronization algorithm in wireless sensor networks through experiments and simulations, comparing it with other algorithms and proposing improvements.

Contribution

It provides a comprehensive performance evaluation of M-DWARF, validating its functionality and comparing it with existing algorithms across various scenarios.

Findings

M-DWARF performs effectively on TelosB motes.

It outperforms EXT-DESYNC and LIGHTWEIGHT in certain metrics.

A method to reduce desynchronization overhead is proposed.

Abstract

In this paper, we evaluate M-DWARF performance by experimentation and simulation. We validate its functionalities on TelosB motes and compare its performance with EXT-DESYNC, and LIGHTWEIGHT on TOSSIM. On simulation, we test the algorithms on several multihop topologies and discuss both the average and problematic cases. In addition, we investigate the impacts of period length (T) and compare channel utilization fairness among the desynchronization algorithms. Finally, we propose a method to reduce desynchronization overhead. (This paper is the second part of the series Stable Desynchronization for Wireless Sensor Networks - (I) Concepts and Algorithms (II) Performance Evaluation (III) Stability Analysis)

Tables

Table 1. TABLE I: Simulation Parameters

Parameter	Value
Header	2-byte sender node ID, and 2-byte neighbor ID (for all the algorithms) and additional 2-byte relative phase (for M-DWARF and EXT-DESYNC)
Radio header	11-byte CC2420 header
Time period	1000 (default), 2000, or 3000 milliseconds
Step size	0.95 (only for EXT-DESYNC and as originally implemented in the paper)
Topology	Single-hop and Multi-hop (see Figure 6)
Number of nodes	Varying (see Figure 6)
Initial phase	Randomized between 0 and the time period

Table 2. TABLE II: Average-Case Comparison of Desynchronization Algorithms on Various Multihop Topologies

Topology	NetworkSize	Matrix	Algorithms
			M-DWARF	EXT-DESYNC	LIGHTWEIGHT
Star	6 nodes (Figure 6a)	Convergence	Fast	Fast	Fast
		Stability	High	Low	High
		Fairness	Yes	Yes	No
	20 nodes (Figure 6b)	Convergence	Fast	Medium	Fast
		Stability	High	Low	High
		Fairness	Yes	Yes	No
Chain	3 nodes (Figure 6c)	Convergence	Fast	Fast	Fast
		Stability	High	High	High
		Fairness	Yes	Yes	No
	10 nodes (Figure 6d)	Convergence	Medium	Fast	Fast
		Stability	High	Medium	High
		Fairness	Yes	Yes	No
Cycle	4 nodes (Figure 6e)	Convergence	Fast	Fast	Fast
		Stability	High	Medium	High
		Fairness	Yes	Yes	No
	10 nodes (Figure 6f)	Convergence	Medium	Fast	Fast
		Stability	High	Medium	High
		Fairness	Yes	Yes	No
Dumbbell	6 nodes (Figure 6g)	Convergence	Fast	Fast	Fast
		Stability	High	Low	High
		Fairness	Yes	Yes	No
	20 nodes (Figure 6h)	Convergence	Medium	Medium	Fast
		Stability	High	Low	High
		Fairness	Yes	Yes	No
Mesh	10 nodes (Figure 6i)	Convergence	Fast	Fast	Fast
		Stability	High	Low	High
		Fairness	Yes	Yes	No

Equations

$$ER{R}_i=\Delta {\varphi }_{i,j}-T/n$$

$$RMSE=\sqrt{\frac{{\sum }_{i=1}^{n}ER{R}_i^2}{n}}$$

$$NRMSE=\frac{RMSE}{T/n}$$

$$\frac{(\frac{T}{s_o}-\frac{T}{s_d})}{\frac{T}{s_o}}\times 100=\frac{s_d-s_o}{s_d}\times 100$$

Full text

I Experimental Results on TelosB Motes

In a sense of TDMA, we assume communication models as follows. First, all nodes have an identical unit circle of communication ranges on the same frequency spectrum. Second, transmission and reception ranges are equal; that is, if node A can receive node B’s packets, node A’s transmission will interfere with node B’s.

We implement M-DWARF into TelosB motes [1] using TinyOS [5] and record a set of video to demonstrate its functionalities. All the motes are pre-installed with our M-DWARF implementation code and LED is on when a mote is firing a message and off when receiving a message. A state of desynchrony can be observed with nodes taking turn blinking the LEDs with equal intervals.

In [6], we incrementally add new nodes by inserting AA batteries into each TelosB mote until the single-hop network contains 10 nodes. At the beginning, nodes converge to a state of desynchrony within a few time periods ($T$). As the number of nodes increases, the convergence is a little bit slower with a few more periods. We physically arrange all the motes on the table into a circular form for succinct demonstation and a final state of 10-node desynchrony can be observed by LEDs running smoothly and circularly. From the desynchronized 10-node network, we also demonstrate leaving nodes in [7]; that is, we take off the nodes’ batteries one-by-one and observe that within a few periods, the network can turn back to a state of desynchrony as each node leaves.

We also demonstrate our M-DWARF for multi-hop desynchronization. In [8], a simple three-node two-hop network (as in Figure 1) is used to show that M-DWARF successfully solves the hidden terminal problem. In the video, the first and last nodes are in two-hop communication via the middle node, all of which must avoid using the same time phase. M-DWARF successfully forces the first and last nodes not to blink at the same time; therefore, collision at the middle node is evaded. Moreover, in [9], we demonstrate, in a four-node-three-hop network, that nodes which are beyond two-hop communication can occupy the same time phase not only without interference but also with increased channel utilization. This can be achieved by employing our Force Absorption technique. In the video, the first and third nodes are in two-hop communication via the second one and so are the second and last nodes via the third one. Therefore, the first and last nodes can share the same time phase without interference, so their LEDs can blink at the same time.

These experiments show that M-DWARF can be implemented into TelosB, an off-the-shelf mote platform, and that it fast converges the network to a state of desynchrony. They also validate M-DWARF functionalities. With Relative Time Relaying, the desynchronized network can avoid the hidden terminal problem, and with Force Absorption, nodes that are beyond two-hop can share the same time phase, allowing the channel utilization to be improved. In the next section, we further evaluate M-DWARF on TOSSIM [4] and compare it with the other state-of-the-art desynchronization algorithms.

II Simulation Results on TOSSIM

We implement M-DWARF, EXT-DESYNC [2], and LIGHTWEIGHT [3] on TinyOS 2.1.2 and evaluate them on the TOSSIM simulator and have concluded simulation parameters in the Table I.

II-A Simulation on Single-Hop Topologies

We begin the experiments by evaluating M-DWARF on single-hop networks. In both the M-DWARF and EXT-DESYNC, each firing message contains relative phases of one-hop neighbors. Therefore, to limit the size of a message, we vary the one-hop network size from 4 to 32 nodes.

Desynchronization Error

We run the simulation for 300 time periods to measure the desynchronization error. In each network size, we run the simulation for 30 times. Then, we measure the average root mean square error (RMSE) and normalized root mean square error.

[TABLE]

[TABLE]

[TABLE]

where node $j$ is the next phase neighbor of node $i$. $\Delta\phi_{i,j}$ is the phase difference between node $i$ and node $j$ on the time period $T$. Given that $n$ is a total number of nodes, $T/n$ is the perfect phase difference. Figure 2a illustrates the result of absolute desynchronization error and Figure 2b illustrates the result of the normalized desynchronization error in each network size after 300 time periods.

The result indicates that, in all network sizes (4 - 32 nodes), M-DWARF achieves significantly better desynchrony states than EXT-DESYNC and LIGHT-WEIGHT do. EXT-DESYNC faces the same predicament of direct and continuing error propagation from phase neighbors, as DESYNC does, because they are based on the same mechanism. This results in a large error even after convergence. In contrast, both DWARF and M-DWARF are robust to this error propagation because they use the total received forces from all neighbors. An erroneous force from one neighbor does not directly impact the phase adjustment of a node; as a result, M-DWARF maintains the lowest level of desynchronization errrors, compared to those of the other two algorithms. For LIGHTWEIGHT, the desynchronization errors of small networks are extremely large because the algorithm randomly chooses a free time slot without considering the equitable separation or fairness. However, when the network size becomes larger, the error becomes lower because the perfect phase interval length is reduced.

Convergence Time

In this section, we measure the absolute root mean square error and normalized root mean square error for each time period to investigate the convergence time. Figure 3a and 4a show the results of sparse networks, and Figure 3b and 4b show the results of dense networks.

In all network sizes, the convergence speed of M-DWARF is comparable to that of EXT-DESYNC. However, M-DWARF converges with the lowest desynchronization error. For LIGHTWEIGHT, the algorithm converges fast and stable. However, due to the random slot selection process, the desynchronization errors in all network sizes are large.

We note that the errors of EXT-DESYNC for 8-node and 16-node networks fluctuate. The reason is that, in our 30 EXT-DESYNC simulations, there are some cases in 8-node and 16-node networks that the phases of some nodes highly fluctuate as depicted in Figure 5. These cases affect the average value. This fluctuating behaviour is caused by the mechanism of EXT-DESYNC (and DESYNC) that relies on only two phase neighbor information.

The result of single-hop networks indicates that M-DWARF, which augments DWARF with the two mechanisms, still performs very well on single-hop networks without loss of generality.

II-B Simulation on Multi-Hop Topologies

For multi-hop networks, we evaluate M-DWARF on several topologies including star, chain, cycle, dumbbell, and mesh topologies (Figure 6). In each topology, we simulate for 30 times and show the relative phase graph results. We show the relative phase graphs that plot relative phases and simulation rounds and represent the average cases and the problematic cases of each algorithm. For each topology, we provide relative phase graphs to visualize the performance of the three desynchronization algorithms. At the end of this section, we qualify the algorithms and compare their performance using a matrix of Convergence, Stability, and Fairness in Table II.

Star Topology

The star topology is the simplest case for multi-hop desynchronization. There is one center node that can transmit and receive messages with all other nodes in the network. In contrast, other nodes can transmit and receive only with the center node. Figure 6a and 6b illustrate 6-node and 20-node star topologies that we use for performance evaluation. In the star topology, every node is connected to each other within two-hop communication; as a result, all nodes must desynchronize to use different time slots.

Figure 7 and 8 shows the simulation results of three algorithms on 6-node and 20-node star topologies respectively. Due to the relative phase relaying mechanism, both M-DWARF and EXT-DESYNC perceive relative phases of neighbors within two hops, which are all other nodes in the star topologies. Consequently, both algorithms can separate 6 nodes into almost equivalent 6 time slots. However, M-DWARF achieves almost perfect desynchony whereas EXT-DESYNC slightly fluctuates in the sparse 6-node network and highly fluctuates in the dense 20-node network.

Figure 9 and 10 shows the problematic cases. For M-DWARF, there is no problem in the sparse networks, but, in the dense networks, nodes take more time to become stable. The reason is that, when the network is dense, the usable time interval gap for each node is shortened. Therefore, if several nodes start closely to each other at the initial configuration, their colliding packets make them initially become unaware of each other and their highly absorbed forces demand more time to separate away from each other and desynchronize. In the case of EXT-DESYNC, because each node relies on only information of two phase neighbors, the error from one node can propagate throughout the networks and cause all the nodes’ phases to fluctuate all the time.

Chain Topology

The chain topology is one of the simplest multi-hop topologies. Every node is lined up without a loop. The 3-node and 10-node chain topologies are depicted in Figure 6c and 6d.

The case of 3-node chain topologies is simple because all three nodes simply cannot share the same phase. From the simulation results shown in Figure 11, both M-DWARF and EXT-DESYNC perform very well in terms of fairness because all nodes’ phases are equivalently separated. However, the nodes’ phases in M-DWARF is slightly more stable than those in EXT-DESYNC.

For 10-node topologies, some nodes that are farther than two hops are able to occupy the same phase position. There are several optimal solutions. For example, the first optimal solution is that there are four groups of nodes that use different phases. Each node within the same group can use the same phase. These four groups are $\{0,3,6,9\},\{1,4,7\},\{2,5,8\}$, and $\{6\}$. Another optimal solution is $\{0,4,9\},\{1,5,8\},\{3,6\},$ and $\{2,7\}$. We note that, in our 30 simulations, M-DWARF could achieve the perfect desynchrony state with 4 slots as in Figure 12a, but EXTENDED-DEESYNC never achieve the perfect desynchrony state (there are 5 slots in Figure 12b because node 0 is at phase 0).

In some problematic cases, the phases of the EXT-DESYNC slightly fluctuate in the sparse networks (Figure 13b) and highly fluctuate in the dense networks (Figure 14b). Additionally, for both EXT-DESYNC and M-DWARF, each node attempts to gradually adjust its phase in the range between previous and next phase neighbors. Therefore, if the nodes’ initial phrases are not proper, they may be not able to adjust their phases over the range of such neighbors and the networks cannot get into the perfect desynchrony state.

Cycle Topology

The cycle topology is simlar to the chain topology. All nodes are lined up but the first and last nodes are connected together to form a closed loop. Figure 6e and 6f depict 4-node and 10-node cycle topologies.

For 4-node cycle networks, all nodes are within two hops from each other. Therefore, every node has known phases of other nodes and no node can share the same phase. On average, both the algorithms, M-DWARF and EXT-DESYNC, achieve the perfect desynchrony state as shown in Figure 15a and 15b. We note that, for 10-node networks, the optimal solution in the cycle topology is different from the optimal solution in the chain topology because node 0 and 9 cannot share the same phase in the cycle topology. Both M-DWARF and EXT-DESYNCE can achieve the perfect desynchrony state in this case (see Figure 16a and 16b). However, repeatedly, the phases of EXT-DESYNC are not stable.

In some problematic cases, the result is similar to the problematic result of the chain topology with the same reason that the initial configuration affects how nodes adjust theirs phases to the proper phases. Figure 17a, 17b, 18a, and 18b illustrate the problem.

Dumbbell Topology

Dumbbell is a network topology commonly found in practice. It is one form of transit-stub networks. In a dumbbell network, there are a number of nodes connected to a single relay node which is connected to another relay node at another side to which another group of nodes are connected, to create a dumbbell topology. Figure 6g and 6h depict 6-node and 20-node dumbbell networks.

Obviously, a node at one side can share the same phase with another node at the other because they are far from each other beyond two hops. Therefore, for 6-node networks, the optimal solution requires 4 slots. Each slot interval is $T/4$. For 20-node networks, the optimal solution requires 11 slots. Each slot interval is $T/11$. In Figure 19a and 19b, both M-DWARF and EXT-DESYNC achieve the optimal solution for 6-node dumbbell networks. However, M-DWARF is again more stable than EXT-DESYNC.

When the network is dense, EXT-DESYNC highly fluctuates (Figure 20b). In problematic cases, if one node adapts their phase too fast, several nodes are affected because there are many two-hop neighbors in the dumbbell networks as illustrated in Figure 22b. In contrast, in M-DWARF, the fast adaptation of one node does not highly impact to the other nodes because they do not rely on only their two phase neighbors but use all information from neighbors within two hops as the force function.

Mesh Topology

We use the same 10-node mesh topology as evaluated in [10]; Figure 6i depicts such a topology. A solid line represents one-hop connectivity whereas a dash line represents two-hop connectivity. In [10], they state the optimal solution of this topology requires eight slots. However, in our simulation, we discover a better solution that requires only six slots, as illustrated in Figure 23a for M-DWARF and Figure 23b for EXT-DESYNC. The problematic case for both M-DWARF and EXT-DESYNC is that the initial configuration is not proper, which will be explained in Problematic Cases below. However, the results show that while the phases of nodes in EXT-DESYNC are highly affected from high fluctuation (Figure 23b and 24b), those in M-DWARF are comparatively much more stable (Figure 23a and 24a).

A Summary Result of Average Cases

From Table II, for small network sizes ($n<=6$), we can observe that all the algorithms easily achieve fast convergence rates. However, on medium-sized networks ($n>6$), M-DWARF and EXT-DESYNC alternate to have medium and fast convergence because nodes are more likely to have collision at the beginning. In average cases of all topologies, LIGHTWEIGHT produces quite similar results. For LIGHTWEIGHT, each node randomly chooses the beginning of a time slot by avoiding the collision with one-hop neighbors. Therefore, on average, LIGHTWEIGHT brings about several inequivalent interval gaps between two consecutive phase neighbor nodes, while M-DWARF and EXT-DESYNC attempt to equalize phase intervals. Therefore, LIGHTWEIGHT fails at channel utilization fairness. On the other hand, EXT-DESYNC suffers from poor phase stability because of its initial design to use phase information only from previous and next phase neighbors. In contrast, because M-DWARF uses phase information from all the phase neighbors, it has much better stability, which leads nodes to acquiring firmer time slots with smaller time guards and causing less message interference and collision. In conclusion, of the three algorithms, M-DWARF is the only one that produces fast convergence, attains high stability and maintains channel utilization fairness.

A Note on Problematic Cases

In addition to the average cases reported, problematic cases are also shown in order to spot anomalies during our experimentation. We have found that these two main problems result from initial, random configuration of some simulation runs. Therefore, they are outliers that are separated from our average cases.

First, we observe phase fluctuation problems. This kind of problems likely occurs in a dense network. Because the time gaps between nodes’ phases are short and two or more randomly initialized nodes start their transmission at the same time, their packet frames will get collided. Moreover, their frames will keep colliding with each other for the next iterations because, when collision occurs, nodes are unaware of each other’s phases. For M-DWARF, this kind of problem leads to a slower convergence rate and nodes’ phases turn stable after a state of desynchrony. In contrast, for EXT-DESYNC, because of this problem, nodes’ phases are fluctuating all over the simulation period and they never reach a state of desynchrony. The main reason for this is again because EXT-DESYNC uses information only from previous and next phase neighbors and the effects of any disturbance on one node will ripple throughout the network.

We call the second problem phase suboptimality. In some problematic cases of multi-hop experiments, the number of desynchronized time slots is sub-optimal. For example, in the problematic cases of the 10-node chain topology, M-DWARF desynchronizes the network to have ten time slots rather than the optimal six time slots. Another example of sub-optimal desynchronized slots is the problematic cases of the 10-node cycle topology which result in a desynchrony state of eight time slots, not the optimal four. Similarly, the problematic cases of dumbbell and mesh topologies produce sub-optimal six and eight time slots, respectively, with their optimal numbers of four and six time slots, respectively. As a result, a node’s slot size will be reduced in percentage as in the equation.

[TABLE]

It is given that $T$ is the period length (eg. 1,000 ms), $s_{o}$ is the optimal number of time slots according to the particular topology, and $s_{d}$ is the number of slots from desynchronization. For example, in case of the 10-node chain topology, where $s_{d}=10$ and $s_{o}=6$, the slot size shrinks as much as 40%.

To figure out what causes these problematic cases, we should take a look at a simple topology of four-node chain networks in Figure 26. The initial phases of all the four nodes in the node 0’s local view are displayed in Figure 26b which differs from that of Figure 25 in that the node 2 and 3, which beyond two-hop neighbors, are not the phase neighbors in the circular desynchronization framework. With this initial phase setting, the node 2 and 3’s phases cannot be moved to be at the same position because their repulsive forces cannot be absorbed. In sum, none of the forces can be absorbed and none of the nodes’ phases can be merged into the same phase position even though node 2 and 3 are beyond two-hop neighbors. This example results in four time slots in four-node chain networks whereas three time slots are optimal. In short, if two nodes are beyond two-hop neighbors but their initial phases are not phase neighbors, the number of time slots in a desynchrony state shall be sub-optimal. However, these problematic cases also affect EXT-DESYNC with even greater phrase fluctuation as mentioned above.

However, it is shown in [11, 3] that desynchronization is reducible to graph coloring problems and is well known that k-coloring is an NP-complete problem when $k>=3$. Moreoever, based on graph coloring, Ergen et al. also proves that the TDMA scheduling problem is NP-complete [12]. As a result, it is even more challenging when one tries to solve this class of problems using distributed algorithms.

III Impacts of Period Length (T)

In previous experiments, we set the time period to 1,000 milliseconds. In this experiment, we vary the period from 1,000 to 3,000 milliseconds. To obviously see the impact of period length, we use the star topology which is a multi-hop topology in which every node is a two-hop neighbor to all the other nodes except for the central one which is the only one-hop neighbor of all the nodes (Figure 6b). We set the number of nodes to 30. With this topology and the number of nodes, the network is saturated within the 1,000-millisecond period.

Figure 27 and 28 show the phase graphs when the algorithms vary the period lengths of M-DWARF and EXT-DESYNC respectively. At the 1,000-ms period, the network is saturated for 30 nodes and both the algorithms seem not to be able to function properly but EXT-DESYNC shows more phase fluctuation. At the 2,000-ms period, M-DWARF still is able to desynchronize the network even if the convergence rate is slow. EXT-DESYNC, on the other hand, fails to desynchronize because the fluctuation rate is too high for the network to converge. When the network is relaxed with the 3,000-ms period, M-DWARF reaches a state of desynchrony within approximately 50 time periods from the total of 300. In contrast, node phases in EXT-DESYNC still fluctuate even at the end of the simulations.

We argue that desynchronization algorithms do not need to stress the network with such a small 1,000-ms period on a single-hop 30-node topology. They can easily adjust the period length according to the network size. For example, if the number of neighbor nodes is 1 to 10, desynchronization algorithms may select $T$ = 1,000 ms. Whereas, the period length of a 30-node network shall be set to be $T$ = 3,000 ms, allowing more gaps between neighbor phases.

IV Channel Utilization Fairness

We measure the channel utilization fairness of nodes. If we average the channel utilization per node, the result is approximately the same for M-DWARF and EXT-DESYNC but M-DWARF is insignificantly slightly better (which is the reason why the average channel utilization of M-DWARF is only slightly better). However, to measure the fairness, we are interested in the value of the average standard deviation of the channel utilization per node. If nodes fairly utilize the network, this deviation value must be low. The results of 30- and 40-node networks are shown in Figure 29 and the results of 50- and 60-node networks are shown in Figure 30. In saturated networks (i.e. 1000-millisecond period), the fairness of both M-DWARF and EXT-DESYNC is approximately the same when time passes by. However, the difference of fairness becomes significantly large when the period length is increased. The average standard deviation of the channel utilization per node of EXT-DESYNC is 30 - 400% higher than that of M-DWARF. Therefore, M-DWARF achieves better fairness. One of the main reasons that nodes in M-DWARF fairly utilize a network is that the stability of M-DWARF is better than that of EXT-DESYNC which is sensitive to neighbor phase errors leading to high fluctuation.

V Overhead Optimization

Because a firing message contains relative phase information of one-hop neighbors, if there are too many neighbors, the algorithm incurs large overhead. Therefore, in this evaluation, we attempt to reduce such overhead. We straightforwardly reduce the number of relative phases broadcastings. We only sporadically attach neighbors’ relative phases in a firing message; therefore, in most firing messages, relative phases are not included, minimizing the size of such messages. Each node keeps records of phase neighbors within two hops even it does not receive updated neighbor phase information. We set a time-to-live counter for each record to 3 periods. If a node does not receive the phase information from another node within 3 periods, it removes that node from its records. To investigate how much we can reduce the overhead, we vary a saving gain parameter $\beta$ which is the frequency to exclude relative phases from a firing message; for example, $\beta=0$ means including relative phases in every firing message, $\beta=1$ means including relative phases in every two firing messages, $\beta=2$ means including relative phases in every three firing messages, and so on.

We evaluate this optimization scheme on the 10-node star topology. We vary the saving gain $\beta$ from 0 to 20. The result is shown in Figure 31. From the figure, we find that, even we reduce the number of relative phases broadcastings, the system still converges to the perfect desynchrony state in most cases. However, if the saving gain is greater than 16, the system converges slowly or may not converge at all because the information that a node keeps is removed. This result indicates two important insights. First, by trading off with convergence speed, we can considerably reduce the overhead upto a factor of 16 in our investigated scenario. Second, even if each node does not receive relative phases for many consecutive times, the algorithm still operates to desynchronize successfully. Therefore, this implies that our proposed algorithm tolerates packet loss at a certain level. As a result, in a perspective of WSN energy consumption, wireless sensor nodes are allowed to go into a sleep mode for a period of time at the expense of slower convergence rate.

VI Conclusion and Future Work

In this paper, we propose a novel desynchronization algorithm for multi-hop networks namely M-DWARF. Our M-DWARF algorithm works without any master node, desynchronizes nodes to possess an equitable slot size, and requires nodes to occupy and de-occupy slots on-demand and on-the-fly. M-DWARF has two additional techniques, relative time relaying and force absorption, that allow it to successfully overcome hidden terminal problems and efficiently support multi-hop networks. We experiment M-DWARF on single-hop networks and various multi-hop topologies including star, chain, cycle, dumbbell, and mesh topologies, with network size variations. Our performance evaluation indicates that M-DWARF has lower desynchronization errors, converges faster, and maintains more stable than existing approaches. Moreover, we propose an overhead optimization that allows M-DWARF to reduce overhead in exchange with slower convergence rates. We also describe limitations of our work that leave room for future research and development. Finally, we provide extensive stability analysis of the single-hop and multi-hop desynchronization algorithms by applying dynamic system analysis.

The future work includes the followings. First, it is interesting to have convergence analysis for our desynchronization algorithms by using a similar model as in [13]. This kind of analysis helps quantify how much iterations the algorithms need to reach desynchronization convergence. Second, energy efficiency can be further improved by using techniques like reduced radio listening. This can be achieved by cross layer information of data lengths, packet lengths and frame lengths. Our desynchronization algorithms could correctly estimate the time-to-live of neighbors’ phases without having to turn on the radio and listen to packets all the time. Third, we plan to experiment our desynchronization algorithms on more scalable networks and implement them on other wireless network standards or platforms like Zigbee [14] or WARP [15].