TMEA using a Dynamic Holdoff Time Design

To solve the inter-node scheduling conflicts, each TMEA-S of the same node’s TD has to use an eligible node list derived from all nbr(im), ∀ m on the same node, and the TD-based conservative eligibility determination rule. However, these two designs of TMEA-S may make the MEAIs of the same node derive nearly the same eligible node list. In this condition, the diversity of the inputs of MEAori, which chooses a winning node of a given TxOpp using a pseudo-random hash function, is very limited. Thus, the winning TxOpp of each MEAI on the same node is likely to be the same at the first k iterations (which continuously results in intra-node scheduling conflicts), where k is the number of TDs on a node.

This is because in this condition each MEAI’s eligible node list for the same TxOpp may have many common nodes (worse yet, their eligible node lists may be the same for many TxOpps due to the conservative TD-based eligibility determination rule), MEAIs on the same node may, therefore, find that in MEAori the winning nodes on each TxOpp calculated by them (generating the largest hash values) are the same. As a result, they will win the same next TxOpp when executing MEAori, which generates many intra-node scheduling conflicts, until some of them increase their contention start txopp values to enough large values. We call this problem the “continuous intra-node scheduling conflict”

problem, which will increase the interval of each MEAI’s transmission cycle and there-fore increase the required time to negotiate a data transmission. In this condition, the utilization of the link bandwidth will be decreased due to this problem.

To prevent this problem from occurring, we propose a version of TMEA that uses a

Table 3.1: The computation cost of TMEA-S and TMEA-D

Contention Time Contending Node List Size Computation Complexity TMEA-S N T D(NT D+1)

2 ∗ nbr2(x) nbr2(x) O(N T D²∗ nbr2(x)) TMEA-D N T D∗ nbr2(x) nbr2(x) O(N T D ∗ nbr2(x))

dynamic holdoff time design (denoted as TMEA-D) to increase the diversity of the in-puts fed into MEAori. TMEA-D has four advantages: First, it provides more scheduling flexibility for MEAIs to avoid continuous intra-node scheduling conflicts by allowing each MEAI on the same node uses distinct holdoff time values. Second, TMEA-D can gener-ate fair TxOpp scheduling for MEAIs on the same node. Thirdly, TMEA-D can assign active MEAIs (those that have data to send) smaller holdoff time exponent values and idle MEAIs larger holdoff time exponent values. Thus, using TMEA-D the time required for a transmitting node to handshake a minislot allocation can be reduced, which allows nodes to more efficiently utilize link bandwidth. Finally, because TMEA-D can avoid con-tinuous intra-node scheduling conflicts, it can greatly reduce the number of computation operations, as compared with TMEA-S.

We show the computation cost of these two schemes in Tab. 3.1, where NT D denotes the number of TDs used by a node. As can be seen, the computation complexity of TMEA-D is linear to NT D while that of TMEA-S is proportional to NT D², which shows the TMEA-D is more computation-efficient than TMEA-S.

The operation of TMEA-D is shown in Algorithm 2. In the initialization phase, an MEAI first sets its smallest tmp txopp and reference start txopp to the current TxOpp and constructs its Lij. It then empties the set Scalc, which is used to store the TxOpp numbers that are chosen by this MEAI when executing Algorithm 2 but have been used by other MEAIs. If the node has data to send in the TD, the MEAI of this TD randomly chooses a holdoff time exponent value exp from Sactive. Sactive is composed of smaller exp values from 0 to the number of TDs where this node has data to send. We call such a TD an active TD and denote the number of active TDs as Num of ActTDs in Algorithm 2. The chosen exp value is stored in the tmp exp variable and used to derive the contention start txopp, which is the reference start txopp plus 2^{tmp exp}. Then, an MEAI calculates the next TxOpp that it can win (stored in tmp txopp) using the same hash function used by MEAori with the chosen contention start txopp value and Lij.

If the chosen next TxOpp is not used by other MEAIs on the same node, it first

Figure 3.14: An example of the iterations of TMEA-D

calculates proper exp and offset values for this chosen TxOpp number and then return the 3-tuple (tmp txopp, proper exp, proper offset) as its output. Otherwise, it adds the chosen next TxOpp number into Scalc, removes the used tmp exp value from Sactive, and repeats the above process until it wins a TxOpp that has not been used by other MEAIs on the same node. (Note that, for brevity, the calculation for the proper exp proper offset values shown here does not show the details for processing the tmp txopp value wrapping problem, which has been properly solved in our implementation.)

In case that Sactive becomes empty, it means that this MEAI cannot find a tmp txopp value that has not been won by other MEAIs on the same node using the contention start txopp values derived from the current smallest tmp txopp value and the tmp exp values in Sactive. To address this problem, the MEAI advances its smallest tmp txopp to the minimum Tx-Opp stored in the Scalc (which is the smallest TxOpp that it wins in the iterations of the while loop) and then re-performs the above process. By doing so, this MEAI can have a chance to win a TxOpp that has not been won by other MEAIs belonging to the same node. Such an iterative process repeats until the MEAI finally wins an unused TxOpp that has not been chosen by other MEAIs on the same node.

Fig. 3.14 illustrates an example of how TMEA-D solves the above problem. Suppose that a node i has six MEAIs and its TD-1 MEAI is calculating the next MSH-DSCH TxOpp. First, the TD-1 MEAI sets its smallest tmp txopp to 0 and then performs MEAori

to find its next TxOpp number. In the first round, it finds that the TxOpp numbers that node i can win have been used by other MEAIs on node i (TxOpps 9, 18, 33, 66, and 130). As a result, it advances its smallest tmp txopp to 9 and restarts the next TxOpp finding process. In this round, it successfully wins TxOpp 14 that has not been won by other MEAIs of node i.

Algorithm 2 TMEA-D

1: Num of ActTDs := the number of TDs on the same node where there is data to send 2: Lij := {(k, Lij(k))| ∀ TxOpp k, Lij(k) is the eligible node list of node i^′s TD j, 3: constructed based on the eligibility of all nodes in ∪ nbr(im), ∀ TD m ∈ node i}

4: smallest tmp txopp := current TxOpp 5: reference start txopp := current TxOpp 6: Scalc:= ∅

12: tmp exp := random(Sactive)

13: contention start txopp := smallest tmp txopp + 2^{tmp exp} 14: tmp txopp ← MEAori(contention start txopp, Lij)

15: if tmp txopp has been used by other MEAIs on the same node then 16: Scalc← Scalc∪ {tmp txopp}

23: if found flag = false then

24: smallest tmp txopp ← min(Scalc) 25: goto line 7

32: starting exp := min( Num of ActTDs, max exp) 33: end if

34: for tmp exp ← starting exp to max exp do

35: contention start txopp := smallest tmp txopp + 2^{tmp exp} 36: tmp txopp ← MEAori(contention start txopp, Lij)

37: if tmp txopp has been used by other MEAIs on the same node then 38: Scalc← Scalc∪ {tmp txopp}

39: contention start txopp ← contention start txopp + 1 40: else

41: found flag ← true

42: break

43: end if 44: end for

45: if found flag = false then

46: smallest tmp txopp ← min(Scalc) 47: goto line 8

48: end if 49: end if

50: proper exp := floor(log₂(tmp txopp − reference start txopp)) 51: proper offset := (tmp txopp − reference start txopp) − 2^{proper exp} 52: return (tmp txopp, proper exp, proper offset)

The reason why TxOpp 14 cannot be derived in the first round but can be derived in the second round is explained here. TxOpp 14 is after TxOpp 9, which is found when the exponent value is advanced to 3 (i.e., the holdoff time becomes 2³ = 8), and before TxOpp 18, which is found when the exponent value is advanced to 4 (i.e., the holdoff time becomes 2⁴ = 16). According to the standard, when MEAori wins TxOpp 9, it should immediately return that TxOpp as the output. Later on, when MEAori finds that TxOpp 9 has been won by another MEAI and a new one should be found, it advances the exponent value from 3 to 4 and starts the searching from TxOpp 16=0+16 (where 0 is the value of smallest tmp txopp and 16 is the current holdoff time 2⁴). However, this exponential holdoff time expansion causes TxOpp 14 to be skipped in the search during the first round. At the second round, because smallest tmp txopp is moved to TxOpp 9 and the exponent value starts over from 0 again, the search can start from TxOpp 10=9+2⁰ and eventually find TxOpp 14.

For the case where there is no data to send in the TD, the MEAI need not use a small next TxOpp to transmit its next control message. Thus, it first determines the starting holdoff time exponent value (stored as starting exp) using the minimum between Num of ActTDs and max exp¹. If this value is below ⌈max exp

2 ⌉ (i.e., 4), then MEAI adjusts it to 4. The rationale behind this design is that the number of active TDs of a node may dynamically fluctuate. Because the node has no data to send in this TD, the control message dissemination of this TD is not time-critical. Thus, TMEA-D prevents the MEAI of an idle TD from using small holdoff time exponent values, which are more valuable for MEAIs of active TDs to reduce the time required for negotiating minislot allocations.

After determining the starting exp value, the MEAI of an idle TD iteratively finds its next TxOpp using holdoff time exponent values from start exp to max exp. The calculation in this iterative process is similar to that used by an MEAI of an active TD. The main difference is that an MEAI of an active TD chooses a smaller holdoff time exponent value from Sactive in a random manner while an MEAI of an idle TD chooses a larger holdoff time exponent value from [max(4, min(Num of ActTDs,max exp)), max exp] in an iterative manner. For brevity, we do not repeat the same explanation for these calculations here.

1The maximum holdoff time exponent value is defined as 7 in the standard.

As one sees, the MEAIs of active TDs on the same node share the useable smaller holdoff time values in a random manner. This design prevents some of them from monop-olizing the smallest holdoff time values and thus ensures a fair sharing of these valuable small holdoff time values among them in a long term. Thus, the average times required by the MEAIs of a node’s active TDs to negotiate minislot allocations (to transmit data) can be the same.