Efficient cross-layer protocol for bandwidth-satisfied multicast in multi-rate MANETs

Abstract

Since the multi-rate enhancements have been implemented in 802.11 wireless networks, QoS-constrained multicast protocols for multimedia communication should be adapted to exploit them fully. This work proposes a multicast protocol for data rate selection and bandwidth-satisfied multicast tree determination with an efficient cross-layer design based on the integration of PHY and MAC layers into the network layer. To use bandwidth efficiently and increase network capacity (which is the number of multicast flows supported by the network), we aim to select the combination of data rates and a multicast tree whose total amount of bandwidth consumption to the network is minimal in order to maximize the network capacity. The performance of the proposed protocol is compared with two existing protocols. Simulation results indicate that the proposed protocol has the ability to admit more multicast flows.

Appendices

Appendix 1: Minimum_B_Tree

Minimum_B_Tree is executed by a repeat-until loop. Without loss of generality, assume $D = \{ v_{{d_{1} }} ,v_{{d_{2} }} , \ldots ,v_{{d_{c} }} \}$, where c = |D| and $v_{{d_{i} }}$ is the ith client in D. The execution of the repeat-until loop consists of multiple iterations and terminates when D becomes empty. At each iteration of the repeat-until loop, a for-next loop is executed to determine a route (i.e., P _i ), a set (i.e., X _i ) of data rates, and the weight (w _i ) of the combination (i.e., X _i and P _i ) for the ith client $v_{{d_{i} }}$ in D by invoking Minimum_B_Routes. After the for-next loop has been executed, v_y ∈ D is obtained so that its determined combination with the smallest weight, i.e., $w_{y} = \min \{ w_{k} \left| {v_{k} } \right. \in D\}$. Then v _y is connected to the server v _s and deleted from D.

Initially, set Δ = {} and F = {v _s }. The execution of the for-next loop consists of |D| iterations. At the first iteration of the repeat-until loop, all bandwidth-satisfied routes from v _s to all clients are obtained as a consequence by the execution of the for-next loop. The client with the route, whose weight is the smallest among the routes to v _s , is selected as v _y . Then, X/F/Δ are replaced by X ∪ X _y /F ∪ P_y/Δ ∪ {v _y }, and v _y is removed from D. Notably, P _y is a bandwidth-satisfied route from v _s to v _y .

At the second iteration of the repeat-until loop, a bandwidth-satisfied multicast tree is constructed. For each client $v_{{d_{i} }}$ in D, the for-next loop is executed to find the bandwidth-satisfied routes P _i s from some forwarders ∈ F to $v_{{d_{i} }}$. After the execution of the for-next loop, the client, say $v_{{d_{l} }}$ (1 ≤ l ≤ c), is selected as v _y . Then, X/F/Δ are updated accordingly, and v _y is removed from D. The resulting multicast tree, which can be represented by F, connects v _s to two clients. Notably, the multicast tree is bandwidth-satisfied and HMRP can be avoided, as a consequence by executing Minimum_B_Routes (The input parameters X/F/Δ are updated at the first iteration of the repeat-until loop).

Similarly, a bandwidth-satisfied multicast tree (represented by X and F) that connects v _s to three clients is obtained at the third iteration of the repeat-until loop. When the execution of the repeat-until loop at the tth iteration of the outer for-next loop terminates, X and F represent a bandwidth-satisfied multicast tree that connects v _s to $v_{{d_{1} }} ,v_{{d_{2} }} , \ldots v_{{d_{c} }}$. The algorithm Minimum_B_Tree is detailed below.

Appendix 2: Minimum_B_Routes

Minimum_B_Routes has five input parameters—v _d , b_req, X, F and Δ. It also has three output parameters—X _d , P _d and w _d . Let P_i,d be the set of forwarders along the v _i  − d _i route, X_i,d be the set of determined data rates used by the forwarders in P_i,d, and w_i,d is the total blocked time induced by the forwarders in P_i,d, where $w_{i,d} = \sum\nolimits_{{j \in P_{i,d} }} {w_{j} }$. Here, w _j is the blocked time induced by forwarder v _j . With v _j ’s data rate r _j recorded in X_i,d, we define $w_{j} = {\frac{{|I_{{j,r_{j} }} \cup II_{{j,r_{j} }} \cup \{ v_{j} \} |}}{{r_{j} }}}$, where $I_{{j,r_{j} }} (II_{{j,r_{j} }} )$ is the set of r _j -one-hop (r _j -two-hop) neighboring hosts of v _j . The execution of Minimum_B_Routes invokes another procedure, B_Violation, which returns true if a bandwidth violation happens and false otherwise.

Initially In the first for-next loop of Minimum_B_Routes, set r _i to the maximum available data rate between v _i and v _d in order to minimize w _i,d for every $v_{i} \in N$. The maximum available data rate between v _i and v _d can be obtained by comparing the “Receiving SINR” column of one-hop neighbor table of v _d with the SINR thresholds of each data rate, and select the maximum SINR threshold which is not larger than the “Receiving SINR” column of one-hop neighbor table of v _d . Recall that in the multi-rate MANETs, if the SINR value from a transmitter to a receiver exceeds the threshold θ _t , then the transmitter can transmit data packets to the receiver successfully by using r _t .

If v _i is a forwarder in the routes to the other destinations, i.e., $v_{i} \in F$, and will not cause delay violation when invoking B_Violation, Minimum_B_Routes terminates since v _d can receive the packets from the forwarder v _i . If v _i is not a forwarder and will not cause delay violation by using r _i when invoking B_Violation, set $w_{i,d} = {\frac{{|I_{{i,r_{i} }} \cup II_{{i,r_{i} }} \cup \{ v_{i} \} |}}{{r_{i} }}},P_{i,d} = \{ v_{i} \} ;$ $R_{i,d} = \{ r_{i} \}$. In the two cases of causing delay violation or the case of $v_{d} \notin I_{{i,\gamma_{i} }}$, set $P_{i,d} \leftarrow \{ \} ,X_{i,d} \leftarrow \{ \} \,{\text{and}}\,w_{i,d} \leftarrow \infty$.

The routes are established iteratively by a repeat-until loop. In each iteration, a host v _x with minimum w _x,d that has not already been selected is determined. Then, for each r ₁-one-hop neighbor v _j of v _x , the v _j  − v _d route (i.e., P _j,d) is replaced with the v _x  − v _d route that is augmented with the v _j −v _x hop (i.e., $P_{j,d} \cup \{ v_{x} \}$), and the set of determined data rates (i.e., X _j,d) is replaced with $\{ r_{j} \} \cup X_{x,d}$, if the new v _j  − v _d route has smaller w _j,d than the old v _j  − v _d route and does not cause a bandwidth violation. After the execution of the repeat-until loop, all bandwidth-satisfied routes (i.e., P _1,d , P _2,d ,…, P _|N| ) from all hosts to v _d are obtained as a consequence of executing the for-next loop. A forwarder v _y  ∈ F is selected, where $w_{y,d} = { \min }\left\{ {\left. {w_{k,d} } \right|v_{k} \in F} \right\}$. Minimum_B_Routes is detailed below.

Appendix 3: B_Violation

B_Violation has four input parameters—b_req, X, F, and Δ, which are inherited from Minimum_B_Routes. Let $M = \Updelta \cup F \cup \bigcup\limits_{{v_{j} \in F,r_{j} \in X}} {(I_{{j,\gamma_{j} }} \cup II_{{j,\gamma_{j} }} )}$. B_Violation checks whether the forwarders in F cause a bandwidth violation to the hosts in M. Checking the hosts in $\bigcup\limits_{{v_{j} \in F,r_{j} \in X}} {(I_{{j,\gamma_{j} }} \cup II_{{j,\gamma_{j} }} )}$ can avoid HRP happened to the ongoing flows. Bandwidth violation happens at a host v _i in M if the total increment of blocked time that is induced by the forwarders in F exceeds the idle time of v _i , i.e., i_time _i . If a bandwidth violation happens, then B_Violation returns true. Finally, B_Violation returns false, if no bandwidth violation happens. B_Violation is detailed below.

Appendix 4: Information collection

Initially, set Ň _i  = {N _i } and I_time _i  = {i_time _i }. Upon receiving a b_join_reply from a host, say v _β , Ň _i (I_time _i ) is replaced with Ň _i ∪ Ň _β , (I_time _i ∪ I_time _β ). The algorithm is elaborated below.

• (1) The server v _s performs the following.

  • (1.1) Set hopcount = 0.

  • (1.2) Transmit a b_join_query(hopcount) to its neighbors.

  • (1.3) Wait for b_join_replys from its neighbors for a period of 2 × (maxhopcount − 1) × t.

• (2) Upon receiving a non-redundant b_join_query(hopcount) from a host, say v _α , a host v _i performs the following.

  • (2.1) Set Ň _i  = {N _i } and I_time _i  = {i_time _i }.

  • (2.2) If hopcount < maxhopcount − 1, perform the following.

    • (2.2.1) Set hopcount = hopcount + 1.

    • (2.2.2) Transmit b_join_query(hopcount) to its neighbors.

    • (2.2.3) Wait for b_join_replys from its neighbors for a period of 2 × (maxhopcount − 1 − hopcount) × t.

  • (2.3) If hopcount = maxhopcount − 1, reply a b_join_reply(Ň _i , I_time _i ) to v _α .

• (3) Upon receiving a b_join_reply(Ň _β , I_time _β ) from a host, say v _β , a host v _i performs the following.

  • (3.1) Set Ň _i  = Ň _i  ∪ Ň _β and I_time _i  = I_time _i  ∪ I_time _β .

When a timeout occurs at step (2.2.3), v _i replies with a b_join_reply(Ň _i , I_time _i ) to v _α. Finally, the algorithm terminates when a timeout occurs at step (1.3), and v _s can obtain all t_snr _i,j and i_time _i s from Ň _s and I_time _s , respectively.