A scheduling algorithm will be proposed for wireless ring topology networks, utilizing time division multiple access (TDMA) with possible simultaneous operation of nodes. The proposed algorithm finds the optimal schedule to minimize the turnaround time for messages in the network. The properties of the algorithm are mathematically analyzed and proven, and practical test results are also provided.

1. Introduction

Sensor networks consist of sensor nodes which can measure various parameters of their environment, make computations, and communicate with each other. Sensor nodes are resource constrained devices, but despite the simplicity of a single device the whole network can solve various tasks efficiently, where the use of other kind of systems is inefficient or impossible [1].

Data dissemination is a common service in wireless sensor networks. Communication patterns may differ greatly in networks depending on the application. The most common tasks are as follows:(i)convergecast, where information from network nodes is directed to a sink node; this is a typical task in data collection applications;(ii)broadcast, where information from a source node is transmitted to all network nodes, used mainly to send commands into the network;(iii)peer-to-peer, where any node can send information to any other node; used in distributed computing, where local communication is required.

A special kind of broadcast is when any node can serve as source; thus the communication pattern is any-to-all. This pattern was used for example in decentralized security systems, when all nodes were able to make decisions, based upon all the available information in the network. A possible solution is the ring topology, where information flows along a circle in the network [2]. This paper focuses on this communication pattern.

Communication networks use either contention based or contention free channel access mechanisms. The advantage of contention based protocols is their dynamism and simplicity. Nodes can compete for channel access when communication is required; thus channel bandwidth is allocated on demand. However, when channel demand is high, frequent collisions may severely decrease network efficiency [3]. Due to the inherently asynchronous nature of contention based communication, in many implementations nodes are continuously switched on, which has a negative impact on power efficiency. To decrease the effect of idle listening, many sophisticated MAC protocols have been developed, for example, RAW [4], S-MAC [5], and μ-MAC [6].

Contention free or schedule based protocols use preallocation schemes (e.g., time division multiple access, TDMA); thus the communication can be performed in the preallocated slots, avoiding collisions. However, systems with fixed assignments may be inefficient, when the preassigned slots are poorly utilized. This problem can be handled by on-demand assignment at the price of network overhead [7].

Efficient TDMA schedules provide optimal performance, where optimality may be defined by various design objectives, depending on the application requirements. Design objectives can be short schedule length, minimal latency, or minimal power consumption, just to name few (see [8] for a comprehensive list). To achieve the desired design objectives, time slices may be used by multiple nodes to transmit messages, if these transmissions do not interfere with each other. Such reuse of time slots will be referred to as multi-TDMA schedule, which is an NP-complete problem in general [9]. Various heuristics were proposed to calculate multi-TDMA schedules, most of them providing solutions, which are suboptimal, but still acceptable in practice. A review on TDMA protocols in wireless sensor networks can be found in [9]. The most widely studied topology is tree topology [8], but other topologies (e.g., line and star) were also examined [10]. TDMA scheduling in ring topology, to our best knowledge, was not specifically studied.

TDMA scheduling in ring networks, when only one node can transmit in a time slot, is a trivial task in itself. In this case consecutive nodes in the network are assigned to consecutive time slots in the schedule. We will refer to this simple case as linear scheduling. The problem, however, becomes much more complicated, when network characteristics allow multi-TDMA schedule. In this paper, we provide algorithms that are able to efficiently solve the multi-TDMA scheduling problem in ring topology, with minimal worst-case message turnaround time, as design objective.

Note that message turnaround time, in our approach, includes not only the time the message spends in the network (usually used as design objective) but also the delay from the appearance of the information (e.g., measurement by a sensor) to the injection of the message into the network. We call this approach Minimum Worst Case Turnaround Time (MWCTT) problem. Since both delay components in worst case depend on the parameters of TDMA schedule, the schedule may be optimized to include both components, providing more realistic objective for time-critical systems.

The novelties of the paper are the following.(i)The Minimum Worst Case Turnaround Time problem is defined.(ii)A novel scheduling algorithm will be proposed which supports multi-TDMA scheduling in ring topology networks. The proposed algorithm guarantees optimal scheduling for the MWCTT problem and still has polynomial computational complexity. The correctness, complexity, and performance of the proposed algorithm will be mathematically analyzed and proven.(iii)An accelerated version of the optimal scheduling algorithm will also be introduced. The accelerated version also provides optimal solution but requires much shorter computational time in most practical cases.(iv)The performances of the proposed algorithms are compared to a reference naive breadth first search algorithm.(v)The properties of the generated optimal schedules are also analyzed in terms of speed and power consumption.(vi)The performance of the generated schedules are compared, using the proposed algorithm and a reference method.

In Section 2 related work is reviewed. In Section 3 a mathematical formalization will be given, including the definition of the MWCTT problem, followed by the definition of the new scheduling algorithms for multi-TDMA rings, and finally the properties of the algorithms (optimality and complexity) will be proven. In Section 4 further analytical properties (delivery time and power consumption) will be discussed, along with a performance comparison. Section 5 provides test results, and the performance of the proposed algorithms is analyzed using real implementation. Section 6 concludes the paper.

Most TDMA scheduling algorithms use the high level protocol model, where a connectivity graph represents the network, the vertices, and edges corresponding to nodes and communication links, respectively. In this model the goal is to create a schedule where two constraints are satisfied: () a node cannot receive and transmit at the same time slot, and () two transmissions are not allowed to interfere with each other; that is, if more transmitters are scheduled in the same time slot, no link can be present from a transmitter to the receiver of another transmitter [11]. Some algorithms use the physical model, where the communication links and potential collisions are more accurately modelled by the signal-to-interference-plus-noise-ratio, resulting in potentially more accurate, but usually more complicated, models. In general, protocol-based models provide more pessimistic results, where as much as 30 percent of the network capacity may be lost, compared to accurate physical model-based scheduling [12].

Depending on the application requirements, TDMA design objectives may be very different. In applications, where message latency is important, TDMA schedulers use latency-related metrics, for example, schedule length, or average message latency [9, 10, 13]. In networks, where large amount of data must be delivered, throughput capacity [14] and fairness [15] may be maximized. In many applications energy utilization and thus network lifetime is a key design factor; in these cases energy efficiency is the main design objective [16, 17]. Some solutions address multiobjective scheduling [8, 13, 18].

The most widely studied network topology is tree topology (e.g., [8, 19]), but also line [10] and arbitrary topologies [11] were investigated. Scheduling algorithms also consider various data models. Most networks are designed to primarily perform data collection (convergecast) or data dissemination (broadcast) tasks [10], but other objectives, for example, small round trip delays, were addressed as well [20]. Some algorithms take into consideration varying data intensity as well [10, 21].

The TDMA scheduling problem is known to be NP-complete, since it is equivalent to the graph coloring problem [8, 9]. Since the problem is hard to solve in general, several approximate solutions were proposed to provide computable schedules, even if they are suboptimal. The scheduling problem in most cases may be transformed to coloring of the conflict graph, the nodes of which are edges of the connectivity graph, and its edges represent conflicting links, according to constraints and [11]. Since the coloring problem is NP-complete in general, various heuristics were proposed. For tree topologies, in [9] two heuristics were proposed, the effectiveness of which was shown to depend on packet generation density in the network. In [22] the conflict graph was expanded to represent the size of the subtree, connected to a parent node, and the coloring was done on the expanded conflict graph, using an approximate coloring algorithm.

In [19] the Minimum Information Gathering Time Problem was solved, providing shortest time schedule for data collection applications, where each node sends one message in every period towards a sink node. The optimal solution was provided for line and tree topologies, for general networks heuristics were proposed. A similar problem was solved in [21], using Integer Linear Programming formulation.

A unified approach was proposed in [11] for a wide class of channel assignment problems, including TDMA. In this framework the search for the solution is aided by a heuristic labelling step, which is followed by the graph coloring step, where the order of the coloring is determined by the labels. The scheduler is simple and fast but the optimum is not guaranteed.

Ring topology networks are special type of a broadcast networks, where every node can send information to every other node (all to all) [23]. A ring is selected from the communication graph (Hamiltonian cycle), along which is a linear TDMA schedule is generated.

Creating a ring in an ad hoc wireless network is not a trivial problem; it is equivalent to finding a Hamiltonian cycle in the connectivity graph of the network, which is not only NP-hard in general, but not constant approximable even in special cases like cubic Hamiltonian graphs [24]. Based on Pósa’s seminal rotational algorithm [25], several heuristics have been proposed to enhance the efficiency of the search method, for example, by applying precheck mechanisms to increase the probability of the right choices during the search [26], or by avoiding backtracking [27]. Fiedler vectors can be used to find pseudo-Hamiltonian cycles [28]. A semiautomatic heuristic approach, especially the one designed for connectivity graphs of sensor networks, was proposed in [29].

TDMA in ring topology was addressed in [30], where the clocks of the nodes were automatically and evenly distributed to create a stable TDMA ring network. Extended ring topologies were used in [23] to represent network hierarchy. A heuristic TDMA scheduling algorithm for such extended ring topologies was proposed in [31]. The heuristic approaches provide in most cases practically acceptable results, but they cannot guarantee optimal scheduling.

In this paper multi-TDMA scheduling in ring topology networks is addressed, where multiple nodes are allowed to transmit in the same time slot, if network topology allows collision-free communication. The goal is to find optimal schedule with shortest turnaround time, as design objective. We will prove that optimal multi-TDMA scheduling is possible in polynomial time, and two scheduling algorithms will be proposed and analyzed.

3. Linear and Multi-TDMA Scheduling

3.1. Basic Principles

The TDMA approach uses dedicated time slices for the transmitter nodes to avoid collisions. The linear round-robin TDMA operates with a predefined periodic schedule. The periods are divided into time slices and each time slice is assigned to one transmitter-receiver pair. The nodes are arranged in a cycle. In the first time slice the first transmitter node transmits a packet to its neighbor, and in every later time slice the node that has just received the message in the previous time slice transmits a packet to its neighbor. In the last time slice the last node will transmit to the first one and this period is repeated, as shown in the example with 16 nodes in Figure 1. The figure indicates time instants when nodes are transmitting. In linear round-robin TDMA the number of time slices in a period is equal to the number of nodes.

Multi-TDMA allows more nodes to transmit at the same time, provided the transmitters do not disturb the messages of each other. Figures 2 and 3 show two possible multi-TDMA schedules for 16 nodes. In Figure 2 the length of the period is 6 and the period must be repeated 3 times in order that a message reaches all nodes in the network and arrives back to node 1. In Figure 3 the period length is 7 and 4 periods are required to deliver a message to all of the nodes and return it back to node 1. In both examples maximum 3 nodes transmit at the same time. (Naturally nodes scheduled for the same time slices must not interfere with each other.)

Utilization of multi-TDMA networks can be advantageous if short message delay is required. Suppose that a node detects an event and sends a message about it to the network. For the linear TDMA schedule in Figure 1, the worst case turnaround time from the detection until all nodes receive the message and it gets back to the source node is 32 time slots; the source node must wait at most 16 time slots from the detection until its scheduled transmission time slot and then 16 time slots are required to propagate the message to all other nodes and get it back. In Figure 2, where multi-TDMA schedule is used, the worst case turnaround time is only 24 time slots (6 time slices to start the transmission and to propagate the message). Note that inappropriate multi-TDMA schedules may give larger propagation delay than the linear schedule, as in the example of Figure 3, where the worst case delay is 35 time slots.

3.2. Design Objective

The multi-TDMA scheduling to be proposed implements a data dissemination service, where the information, originating at any node, is disseminated to every other node in the network, along the path defined by the ring topology.

The design objective is to minimize the worst case turnaround time, introducing the Minimum Worst Case Turnaround Time (MWCTT) problem. The MWCTT is measured from the time point when the information (e.g., measurement or alert) to be disseminated appears asynchronously in the initiator node, to the time point when messages in the ring topology network reach the initiator node again. This scenario models the real-life situation when a node sends an alert to the network and waits for the reactions of other nodes.

As shown in Section 3.1, MWCTT consists of two components. First the initiator node has to wait for its transmission time slice, which requires time slices in worst case, where is the lenght of a period, for example, in Figure 2, , while in Figure 3, . Note that the worst case scenario is when the information to be disseminated appears at the initiator node just after it has begun its transmission. After the initiator node transmitted the message into the network, the message must reach all the other nodes and arrive back to the initiator node, which requires time slices, where is the necessary number of the repetitions of the periods (e.g., in Figure 2, , while in Figure 3, ). Thus the worst case dissemination time is equal to time slices. The goal of the scheduling is to minimize WCTT.

3.3. Mathematical Formalization

The network is represented by a connectivity graph , where denotes the set of vertices corresponding to the sensor nodes and denotes the set of edges representing the links between nodes. The cardinality of is denoted by .

The link quality function shows the quality of the links according to a predefined metric. Only the links with link quality greater than a threshold should be used for communication. denotes the set of possible communication links: and the communication graph is defined as follows:

Note that the weaker links also have to be considered in multi-TDMA scheduling, because even weaker signal strength levels may cause collisions when a receiver hears multiple transmitters at the same time.

Figure 4 shows a 16-node example, where continuous lines denote good links (with ), while dashed lines denote weaker links (with ).

In the discussed communication model each node transmits to the next node; therefore, a Hamiltonian cycle must exist in . Without loss of generality it can be assumed that and the edges of the Hamiltonian cycle are , as shown in Figure 4 for .

3.4. Definitions

Definition 1. Each node transmits to its receiver node, denoted by :

Definition 2. The transmission-interference graph (or constraint graph) represents transmitter interferences. There is an edge between two nodes if they should not transmit in the same time slice, because of and ; that is,

Definition 3. A set of nodes in is polite if all nodes in the set can transmit in the same time slice without collision. POL is the set of the polite transmitter-sets; that is,

Definition 4. A schedule is a sequence of node-sets , where and is the length of the schedule, such that contains the transmitting nodes for the th time slice of the schedule. Each node transmits exactly once in the sequence to its receiver node; that is,
Figure 5 shows the schedule shown in Figure 3, where , , , , , , and .
Note that the schedule describes the operation of the network for exactly one period; such periods are repeated periodically and in each period the nodes are operated according to the schedule.

Definition 5. To a given schedule , a schedule connection graph is defined, where
The meaning of edge is that node can retransmit the message received from node , in a subsequent time slice in the same period. Figure 5 shows the schedule connection graph as well, for the schedule shown in Figure 3. There is an edge between node 2 and node 3, because the message received from node 2 in time slice 2 can be retransmitted by node 3 to node 4 in time slice 3, in the same period. Similarly, node 4 can transmit to node 5 in the same period; therefore, there is an edge between node 3 and node 4. But node 5 cannot retransmit the message, received from node 4, in the same period: node 5 can transmit only in time slice 2 of the next period. Therefore, there is no edge between node 4 and node 5.

Definition 6. The width of schedule is the number of independent components in the schedule connection graph .

In Figure 5 the width of the schedule is 4. Note that the width has an important practical meaning. If the width of the schedule is then the schedule must be repeated times in order to deliver a packet from any node to all other nodes.

Definition 7. Assuming that the Hamiltonian cycle has been partitioned into connected parts (i.e., subpaths), a segment is the node-set of any of those parts.

Note that the independent paths in the schedule connection graph are (independent) segments. In Figure 5 red, blue, green, and brown paths correspond to independent segments. Thus the following definition naturally follows.

Definition 8. For any -wide schedule a segmentation can be defined on the Hamiltonian cycle, where is a segment such that , where the length of the th segment is and the vertices of are denoted with .
Note that a -wide schedule contains independent segments, such that the union of the segments is .
In Figure 6 the segmentation for the schedule of Figure 5 is shown.

Definition 9. Given a segmentation , the state is a list of nodes where node , is the node which transmitted for the last time in segment . If in segment there was no transmission yet then notation is used. The state representing that no transmission has occurred yet is denoted by . The th element of state , corresponding to segment , is denoted by .

For the construction of a -wide schedule the directed graph is used. The vertices in denote the states of the schedule. The edges of the graph define possible sequences of states representing valid schedules.

Notice that state transition means that the set of actual transmitters is

The highlighted part of Figure 7 shows the states and state transitions corresponding to the schedule in Figure 5. The state graph starts from state . After the time slice corresponding to , nodes 1 and 11 are the nodes which transmitted for the last time from their segments (from the other two segments no transmission has happened yet); thus the corresponding state is . After the time slice of nodes 2, 5, and 12 were the last transmitters in their segments, resulting state . After the time slice of nodes 3, 6, 12, and 14 are the last transmitters, with the corresponding state of . Note that no node transmitted from the segment of node 12 (along the green path in Figure 5) in the actual time slice; therefore, in this case node 12 remains in the state.

The formal definition of is as the follows.

Definition 10. For a segmentation , is called the state graph of segmentation . The nodes in the node set of represent the states which may occur in a schedule compatible with . The edges of the state graph are defined as follows.
if(TR1); that is, in any segment the first node () will transmit for the first time;(TR2). It expresses the trivial requirement that if once a node has transmitted in a segment, any later time there is one node in that segment, which transmitted for the last time;(TR3), where , ; that is, after a node transmits in the segment, its receiver node will transmit either in the next time slice (condition ), or in a later time slice, in which case the currently latest transmitter node remains unchanged (condition );(TR4); that is, only a polite transmitter-set is allowed to transmit in one time slice.
Rules (TR1)–(TR4) are the tracing rules.

3.5. The FSS Algorithm

In this section first the fixed-segmentation-scheduler (FSS) then the optimal-multi-TDMA-scheduler (OMTS) algorithm will be introduced.

The pseudocode of the FSS algorithm is shown in Pseudocode 1. Notes on notations are the following.(i) removes the first element of list , while adds to the end of list , see lines , , and .(ii) returns reverse of list .(iii) represents the state from which state was traced; see lines and .

(1) input
(2)  : connectivity graph
(3)  : communication graph
(4)  : set of segments
(5) variables
(6)  : set of traced nodes in
(7)  : list of open nodes in
(8)  : the currently traced node
(9)  : a possible combination of transmitting segments
(10) : set of possible nodes with directed arc from node
(11) : mapping from nodes to nodes
(12) begin
(15) while  
(17)  foreach    in  
(19)   if   satisfies the tracing rules  and  :
(25) while  
(29) return  
(30) end

The input of the algorithm consists of the connectivity graph , the communication graph , and the segmentation . The algorithm builds a graph , where , , and is represented by the mapping; see lines of the FSS algorithm.

During the iterations contains states which are reached by breadth-first search (traced nodes), and contains states, already in , from which breadth-first search was not continued yet (open nodes).

In the beginning the list of open nodes contains only the empty set (line (14)) and in each iteration the algorithm traces all possible combinations of transmitting nodes (line (18)) that satisfy the tracing rules (lines ). The schedule is reconstructed from the series of states in from endstate to start-state in a backwards manner (lines ).

Note that the FSS algorithm calculates the optimum schedule for a given segmentation. The OMTS algorithm enumerates all the possible segmentations and calls the FSS algorithm for each segmentation.

The pseudocode of the OMTS algorithm is shown in Pseudocode 2. Lines without asterisks give the basic OMTS algorithm. With all lines, including those with asterisk, an accelerated version is given with early cuts (OMTS-A).

(1) input
(2)  : connectivity graph
(3)  : communication graph
(4)  : maximum width of the schedule
(5) variables
(6)  : the length of the shortest known schedule
(4)  : the actually considered width
(5)  : list of starting -tuples of the traced segmentations
(6)  : length of the longest segment in a segmentation
(7)  : a starting -tuple of a segmentation
(8)  : a segmentation
(9)  : an optimal schedule for
(10) : an optimal schedule
(11) begin
(13) for    downto  1
(15)  foreach    in  
(19)*  sort    by    increasing  order
(20)  foreach    in  
(21)*   if  
(23)      FSS
(24)    if  
(27)*   else
(28)*    break  (foreach)
(29) return  
(30) end

The input of the algorithm consists of the connectivity graph , communication graph , and maximal width . Variable stores the length of the shortest known schedule; it is set to at the beginning (line ). The basic algorithm iterates on widths from down to 1 (line ); every possible -tuple is generated as a starting node for the segmentations (line ). List stores the starting points of the segments (line ), while mapping stores the length of the longest segment for the corresponding -tuples (lines ). The algorithm iterates on the list (line ) and generates the actual segmentations (line ). For each segmentation the FSS algorithm is executed (line ) which returns the shortest schedule for the given segmentation.

While the OMTS algorithm evaluates all possible segmentations, the OMTS-A algorithm does not call FSS for those cases which trivially results in longer schedules than the current best schedule; since the length of the longest segment is a lower bound for the length of any schedule, during the iterations those segmentations are considered, for which (see lines , , and ). To increase the efficiency of the early cuts, the segmentations are sorted by before the iterations (lines ).

3.6. Algorithm Properties

Lemma 11. For a given segmentation, endstate gives the last state of all possible schedules, that is, the last node in all possible paths in the state graph corresponding to the given segmentation.

Proof. Each node has to transmit exactly once in the schedule; therefore, from each segment each node has to be present in at least one state. If a node from a segment is present in state , and is an edge of the state graph, then will also contain a node from that segment. From each segment nodes appear in increasing order in states belonging to a schedule. Therefore, the last state belonging to a schedule will contain the last nodes from each segment.

Lemma 12. The shortest schedule for a given segmentation corresponds to states on a shortest path in graph from to the endstate .

Proof. For a given segmentation each transition of the state graph describes a time slice of a possible schedule. Thus the length of the schedule is equal to the length of a path in the state graph from to the endstate , and any shortest path from to the endstate corresponds to one of the shortest schedules.

The next lemma guarantees the existence of at least one valid schedule.

Lemma 13. For every there exists a state where satisfies the tracing rules.

Proof. Since , there exists such that . Let and , . In this case satisfies the tracing rules since only one node () is transmitting.

Definition 14. For a given state and endstate the distance between and is defined as . Note that if and only if .

Lemma 15. For every two states and , where satisfies the tracing rules, , where .

Proof. Consider .
According to (TR3) either (case ) or (case ), for all . Since at least one value of the state changes (case ), .

Lemma 16. The FSS algorithm stops; that is, eventually and also .

Proof. Let us define and , , in each iteration.
Since the algorithm traces elements of queue after each other (see lines ), in each iteration it is true that the actual state will be traced after iterations. Thus according to Lemmas 13 and 15, after iterations will decrease.
Repeating this process results in decreasing series of integer values, thus eventually reaches 0, where necessarily (and also ; see lines ). The iteration stops in line (15) and the algorithm terminates after executing lines .

Theorem 17. The list of states, generated by algorithm FSS corresponds to a shortest schedule for the given segmentation.

Proof. Let be the schedule connection graph generated by the FSS algorithm. (Note that edges in are implicitly represented by the mapping.)
The algorithm starts with the node (see line ); therefore, contains the start-state . According to Lemma 16, also contains the endstate .
The search mechanism of the algorithm (breadth-first search) provides the shortest path from the start-state to the endstate. Since the algorithm applies the tracing rules (see line ), therefore, ; thus the component of , built by the algorithm, contains the shortest path in from to . According to Lemma 12 this path corresponds to one of the shortest paths for the given segmentation.

Theorem 18. The OMTS and OMTS-A algorithms find an optimal schedule for the MWCTT for a given node set, link set, communication link set triplet , and a maximum width .

Proof. The OMTS algorithm tries every possible segmentation for the given communication graph. According to Theorem 17 the FSS algorithm finds the shortest schedule for each given segmentation. Therefore, OMTS finds the global optimum.
The OMTS-A algorithm also enumerates every possible segmentations but skips the cases where the result would trivially be worse than the current best. Thus OMTS-A also finds an optimal solution.

Theorem 19. If the number of nodes in the communication graph is then the computational complexity of the OMTS algorithm is a polynomial function of for a given maximum width .

Proof. The FSS algorithm traces each state in lines . The operation can run in constant time. The cardinality of is constant for a given ; thus the number of iterations in the loop of lines is also constant. The set operations, checking of tracing rules, queue, and map updates in the body of the loop in lines have at most complexity for a given . Therefore, the complexity of tracing any state is .
Let the number of states traced by the FSS algorithm (i.e., the number of iterations performed by the loop in lines ) be denoted by . clearly cannot be more than the number of all possible states. Let us consider a -wide segmentation with segment lengths of . Then the th element of a state can be either , or or ( possibilities). Therefore the number of possible states for segmentation is Using the inequality of arithmetic and geometric means which has the complexity of . Taking into consideration the complexity of tracing one state (), the complexity of the FSS algorithm is
The number of iterations when FSS is called in the OMTS algorithm is equal to the sum of the numbers of -wide segmentations, where : Therefore, and the complexity of the OMTS algorithm can be computed from and as

4. Analytical Results

To compare the scheduling methods, measurement metrics are defined.

4.1. Turnaround Time

Turnaround time, denoted with is the time required to deliver a packet from a node to all other nodes and get it back to the source node.

In linear TDMA scheduling the worst case delivery time can easily be calculated for an -node network, as follows. In the network asynchronous events occur (e.g., measurements), for which events the network reacts by sending messages (e.g., alerts). After this event, the node first has to wait for its transmission time slice. The worst case is when the node transmitted just before the measurement event, thus it has to wait a full period ( time slices) for the next transmission time. Second, at most time slices are required for the message to turn around. Therefore, in the worst case the delivery time is

For a -wide multi-TDMA schedule a lower bound can be calculated. Let be the length of the period. In the worst case a node has to wait for time slices to transmit and time slices are required for the message to turn around; thus The length of the period must be at least the size of the largest segment in the segmentation; therefore, the following lower bound can be given for : Therefore,

Note that the maximal gain in delivery time is approximately 2, compared to linear TDMA scheduling. The lower bound is a good approximation, when(i)the segmentation contains segments with equal size,(ii)in all time slices one node transmits from each segment,(iii) is large.

4.2. Power Consumption

Power consumption can be considered in two different ways. The energy, which is necessary to deliver a packet from a node to all other nodes is denoted by for the linear TDMA and for the multi-TDMA scheduling. The average energy consumed in a time slice is denoted by and for linear and multi-TDMA, respectively.

In our model energy is necessary to transmit and to receive a packet, regardless of other parameters (e.g., link quality).

In both linear and multi-TDMA scheduling each measurement is transmitted by each node exactly once. In each time slice is required for the transmission and is required for the reception of the message containing the measurement. Thus the energy required to broadcast a measurement can be calculated with the following equation for both the linear and the multi-TDMA scheduling:

In linear TDMA scheduling in each time slice exactly one node transmits and one node receives the message; thus the average energy consumption is

In multi-TDMA scheduling each node will receive and transmit once in a period; therefore, the multi-TDMA requires the same energy amount in a period with length as the linear TDMA for a longer period with length . Thus the average energy consumption for the multi-TDMA scheduling can be calculated with the following equation:

Thus the price of faster delivery time is the increase in energy consumption. Since ,

The average energy consumption is largest when all the segments are equal and there is one transmitter from each segment in each time slice; in this case the multischeduler algorithm consumes times more energy than the linear one.

5. Test Results

5.1. Computation Time

To test the computational complexity of the scheduling algorithms, both the OMTS and OMTS-A algorithms were implemented in Perl. For reference a brute-force algorithm was also implemented, which did not use the proposed states. For test cases random graphs with controlled numbers of node () and link () were generated, as follows. nodes were placed randomly in a square-shaped area and links for the Hamiltonian cycle were added. Afterwards additional links were added iteratively between the two nodes, which had the shortest distance and no existing link yet. In the test was chosen as 15% of all the possible number of links; that is, . The value of varied from 10 to 100. For each , 10 different random topologies were generated and the average and standard deviation of the runtimes of the three algorithms were measured, where it was feasible. The test platform was a Lenovo Thinkpad T430 with an Intel Core i5-3210M CPU at 2.5 GHz and 8 GB RAM. In the tests was used. The results are shown in Table 1, where the average and standard deviation values are listed for each experiment. The results are also plotted in Figure 8 in a logarithmic scale, showing the results of all the experiments.

The brute-force algorithm quickly reached the feasibility limit of one day at , the OMTS algorithm could compute schedules for , while OMTS-A was usable even for . The speed differences are clearly shown in Figure 8: the computational time of the brute-force algorithm increases with the number of nodes much faster than in the case of the proposed algorithms. The behavior of algorithms OMTS and OMTS-A are similar, but due to the early cuts, the complexity of OMTS-A is two orders of magnitude lower. Notice the higher variance of OMTS-A, which is due to the fact that the efficiency of early cuts depends largely on the actual topology.

For , used in the tests, the theoretical complexity of the OMTS and OMTS-A algorithms is , which corresponds well to the measurement results for .

5.2. Performance Comparison

The proposed method is compared to a graph coloring based reference algorithm described in [11]. An example network with 16 nodes was constructed, where 15 nodes form a cycle with symmetrical connections between the neighbors and all nodes in the cycle have symmetrical connection to the central node; see Figure 9(a). The connectivity graph with a Hamiltonian cycle is shown in Figure 9(a) with straight and dashed lines, respectively. From the connectivity graph and the Hamiltonian cycle the constraint graph is constructed for the method described in [11] with constraints and , as shown in Figure 9(b).

Although the method described in [11] contains heuristics to solve the graph coloring problem, in the example of Figure 9 the optimal coloring was found. In Figure 10(a) the constraint graph is colored with 3 colors, which is indeed the minimum, because the graph contains triangles. The sequence of the colors was chosen to be purple green blue; that is, purple nodes transmit in time slices , green nodes transmit in time slices and blue nodes transmit in time slices    ().

The optimal schedule found by the proposed OMTS algorithm for the same network is shown in Figure 10(b). The optimum was found at and the graph is colored with 4 colors, with sequence of purple green blue orange.

The timing diagrams of the reference and the proposed algorithms are shown in Figure 11. The arrows denote the transmission of the information originating from node 1; the dashed vertical lines denote the point, where this information reaches all nodes and is returned back to node 1.

In Figure 11(a) the timing diagram for the reference algorithm is shown. After the information to be disseminated first appears at node 1, the node has to wait for its transmission time slice, which requires 3 time slices in the worst case. From that point the information reaches node 1 again in the 23rd time slice. Thus the propagation of the information requires time slices.

In Figure 11(b) the timing diagram for the proposed OMTS algorithm is shown. In worst case, node 1 has to wait 4 time slices to transmit, and the information reaches the last node in the 20th time slice. Thus with this schedule time slices are required to disseminate the information originating from node 1. The example clearly illustrates the ability of the OMTS algorithm to find the optimal solution in ring topology networks, where messages must be propagated to all other nodes.

6. Conclusion

The Minimum Worst Case Turnaround Time problem was defined. A novel algorithm (OMTS) was proposed for ring-topology networks to compute multi-TDMA schedules for the MWCTT problem. The algorithm was proven to find the optimal schedule (with the shortest turnaround time), which, in worst case, provides the fastest means to distribute information from any node to all other nodes and back to the source node in the network. It was proven that the multi-TDMA scheduling can provide at most twofold acceleration with respect to linear scheduling, at a price of increased energy consumption.

An accelerated version of the algorithm (OMTS-A) was also proposed, which narrows the search space during runtime using heuristics but still guarantees the optimal solution.

In addition to the mathematical analysis of the proposed algorithms, extensive tests were performed to compare the performances of the proposed algorithms and the conventional (brute-force) search method. While the brute-force algorithm can be used for small networks only (less than 15 nodes), the proposed algorithm can solve problems with even 100 nodes in reasonable time.

The performance of the designed schedule was also compared to that of another algorithm. In case of the MWCTT problem the proposed solution was able to find better (optimal) schedule.

Conflict of Interests

The authors declare that there is no conflict of interests regarding the publication of this paper.


This research was supported by the Hungarian Government and the European Union and cofinanced by the European Social Fund under the project TÁMOP-4.2.2.C-11/1/KONV-2012-0004. Gergely Vakulya was supported by the European Union and cofinanced by the European Social Fund in the framework of TÁMOP 4.2.4. A/2-11-1-2012-0001 “National Excellence Program.”